Property based testing

Having over 10 years of experience with
Microsoft Technologies, Miguel has many
specializations, including C#, F#, Azure, and
DevOps practices.
MSDEVMTL co-organizer
Director of engineering at Nexus Innovations
https://blog.miguelbernard.com
https://www.linkedin.com/in/miguelbernard/
@MiguelBernard88
https://github.com/mbernard

// Given
var input = 3;
// When
var result =
Calculator.Calculate(input);
// Then
Assert.Equal(0, result);

// Given
var input = 3;
// When
var result =
// Then

Problems with example-based tests (EBT)
DON’T SCALE DON’T HELP YOU TO
FIND EDGE CASES
BRITTLE
DON’T EXPLAIN
WHAT WAS THE
REQUIREMENT
OFTEN SPECIFIC TO
AN
IMPLEMENTATION

What’s Property-based testing?

What it’s not
•
•
•
•
•
•
More like

Commutativity
2+3 = 3+2 2-3 != 3-2 2*3 = 3*2

Associativity
Add(input1, input2)
Add(input2, input3)
(2+3)+4 = 2+(3+4) (2-3)-4 != 2-(3-4) (2*3)*4 = 2*(3*4)

Identity
2+0 = 2 2-0 = 2 2*0 != 2

Haaaa, so properties
are for math stuff

Execute twice
gets same
result
(Idempotence)

Hard to find,
easy to validate

PBTs advantages
General, and thus are less brittle
Provide a better and more concise description of requirements than a bunch of examples
1 PBT can replace many, many, example-based tests
Reveal overlooked edge cases
Force you to think
Ensure deep understanding of requirements
More thinking = less typing
Force you to have a clean design

Why don’t we use
PBTs already then?

no kidding it’s really hard
• EBTs are still good for a lot of things
• Test known corner cases
• Regression
• Easier to understand for newcomers

The Diamond Kata
Given a letter, print a diamond starting with ‘A’ with the
supplied letter at the widest point.

public class Diamond
{
public static IEnumerable<string> Generate(char c)
{
yield return "A";
}
}

[Property(Arbitrary = new[] { typeof(LetterGenerator) })]
public Property NotEmpty(char c)
{
return Diamond.Generate(c)
.All(s => s != string.Empty)
.ToProperty();
}

public static class LetterGenerator
{
public static Arbitrary<char> Generate() =>
Arb.Default.Char().Filter(c => c >= 'A' && c <= 'Z');
}

2. First line contains A
3. Last line contains A

public Property FirstLineContainsA(char c)
{
.First().Contains('A’)
.ToProperty();
}
public Property LastLineContainsA(char c)
{
.Last().Contains('A’)
.ToProperty();
}

public Property DiamondWidthEqualsHeight(char c)
{
var diamond = Diamond.Generate(c).ToList();
return diamond.All(row => row.Length == diamond.Count)
.ToProperty();
}

5. Outside space
padding is
symmetric on each
side of a row

public Property SpacesPerRowAreSymmetric(char c)
{
.All(row =>
CountLeadingSpaces(row) == CountTrailingSpaces(row))
.ToProperty();
}

6. Symmetric
around horizontal
axis

public Property SymmetricAroundHorizontalAxis(char c)
{
var diamond = Diamond.Generate(c).ToArray();
var half = diamond.Length / 2;
var topHalf = diamond[..half];
var bottomHalf = diamond[(half + 1)..];
return topHalf.Reverse()
.SequenceEqual(bottomHalf)
.ToProperty();
}

7. Symmetric
around vertical axis

public Property SymmetricAroundVerticalAxis(char c)
{
return Diamond.Generate(c).ToArray()
.All(row =>
{
var half = row.Length / 2;
var firstHalf = row[..half];
var secondHalf = row[(half + 1)..];
return firstHalf.Reverse().SequenceEqual(secondHalf);
}).ToProperty();
}

8. Input letter row
contains no outside
padding spaces

public Property InputLetterRowContainsNoOutsidePaddingSpaces
(char c)
{
var inputLetterRow = Diamond.Generate(c)
.ToArray()
.First(x => GetCharInRow(x) == c);
return (inputLetterRow[0] != ' ' && inputLetterRow[^1] != ' ')
.ToProperty();
}

private static IEnumerable<string> Generate(char c)
{
yield return " A ";
yield return $"{c} {c}";
yield return " A ";
}

private static IEnumerable<string> Generate3(char c)
{
if (c == 'A')
{
yield return "A";
}
else
{
yield return " A ";
yield return $"{c} {c}";
yield return " A ";
}
}

9. Rows contain
letters in ascending
then descending
order

public Property RowsContainCorrectLetterInCorrectOrder
(char c)
{
var expected = new List<char>();
for (var i = 'A'; i < c; i++) expected.Add(i);
for (var i = c; i >= 'A'; i--) expected.Add(i);
var actual = Diamond.Generate(c).ToList()
.Select(GetCharInRow);
return actual.SequenceEqual(expected).ToProperty();
}

Recap
Few simple tests (10 tests, ~4-5 lines / test)
No need to change the tests when changing the implementation
Makes it easier to do TDD

Resources
https://github.com/mbernard/property
-based-testing

Property based testing

More Related Content

What's hot (19)

Similar to Property based testing (20)

More from MSDEVMTL (20)

Recently uploaded (20)

Property based testing

Editor's Notes