0.6.0

[nth-commit]

New package: GalaxyCheck.Xunit.CodeAnalysis

It's installed automatically when you install GalaxyCheck.Xunit, and will be the home of Roslyn analyzers and code refactoring providers.

Add MemberGenAttribute

This new attribute mirrors MemberData in xunit, but allows parameter-level configuration of data generation. It allows you to quickly configure generators without using a custom GenFactory, or switching to LINQ-properties.

using GalaxyCheck;
using Xunit;

public class FizzBuzzTests
{
    private static IGen<int> MultipleOfThree => Gen.Int32().Select(x => x * 3);

    [Property]
    public void ItFizzes([MemberGen(nameof(MultipleOfThree))] int n)
    {
        Assert.Contains("Fizz", FizzBuzz(n));
    }
}

MemberGenAttribute is optional on parameters. If omitted, it will fall back to the default generation strategy.

Add Roslyn analyzers for statically checking the validity of a MemberGenAttribute

• GalaxyCheckXunit1000: MemberGen must reference an existing member - (the member must exist in the test class)
• GalaxyCheckXunit1001: MemberGen must reference a valid member type - (the member must be a field or a property)
• GalaxyCheckXunit1002: MemberGen must reference a member providing a suitable data type - (the member must be of type IGen<T>, where T is the parameter type the attribute is decorating)

Add Roslyn code-refactoring provider for generating MemberGenAttributes

The code refactor will interpret the type of parameter that the cursor is over, and produce a generator inside the class that'll provide a good starting point for further configuration.

Improves Property.Precondition

Property.Precondition is a quick and dirty way to filter input to a property that you can add inside it's body. It's similar to Gen.Where, but it has a few limitations. However, a lot of the time, it's just what you need.

For example, consider the property:

[Property]
public void DifferentIntegersHashDifferently(int x, int y)
{
    Assert.NotEqual(Hash(x), Hash(y));
}

This property will almost certainly fail, as early on in testing a property, GalaxyCheck has a high chance of generating the minimum value (e.g. 0), and later on, it has a reasonably chance of generating the maximum value (e.g. int.MaxValue). This makes the test pretty flakey. One way to fix that is to couple the generation of the integers together, like so:

private static IGen<(int x, int y)> TwoDistinctIntegers =>
    from x in Gen.Int32()
    from y in Gen.Int32()
    where x != y
    select (x, y);

[Property]
public void DifferentIntegersHashDifferently([MemberGen(nameof(TwoDistinctIntegers))] (int x, int y) tupleOfInts)
{
    Assert.NotEqual(Hash(tupleOfInts.x), Hash(tupleOfInts.y));
}

This is reasonably verbose. Property.Precondition allows you augment the existing test slightly to provide that filter, rather than modifying the whole generation:

[Property]
public void DifferentIntegersHashDifferently(int x, int y)
{
    Property.Precondition(x != y);

    Assert.NotEqual(Hash(x), Hash(y));
}

This release improves Property.Precondition so it behaves slightly more like Gen.Where. Whilst some of the limitations between it and Gen.Where are impossible to resolve (mostly, because GalaxyCheck has no insight into what and why the values are filtered), it improves the usability a fair bit, such that:

• GalaxyCheck will give up after a certain amount of effort trying to generate parameters that don't seem to ever fulfil the precondition.
• GalaxyCheck will try and generate "bigger" data, if smaller data is not fulfilling the precondition. That means it can retry its why out of preconditions like x > 0.

BREAKING: Simplified some of the information returned by Property.Check

This change has a very low-chance of being breaking in reality, but some of the properties on the CheckResult were trimmed down, somewhat.

---

This discussion was created from the release 0.6.0.