Double precision

[TomW-Skyline]

On my PC, a unit test that uses VerifyTests, succeeds. But when I upload the same code to our build server, the unit test fails because one of the double values is being serialized slightly different. Is it somehow possible to specify the precision when doubles are compared?

In both cases the double is set to 1225.84:

[SimonCropp]

yeah thats not ideal. happy to accept a PR that fixes this

[aaron-manning]

This is an issue in other c# snapshot testing libraries also, eg https://github.com/theramis/Snapper

There seems to be some non-determinism in the runtime when converting decimals, doubles and floats (eg sometimes a number will be 13.0, the next test run it will be 13.00)

This frequently causes my CI tests to fail, and there's no clear solution. A re-run of the same build will deterministically exhibit the same non-determinism (aka running the same build produces consistent results, but the results change between builds), so the solution is often to completely rebuild the application (dotnet clean, dotnet build) and run CI again.

Another solution is to write a custom converter (eg map it to a DTO) for each type you want to snapshot, within which you manually set the precision for these data types (probably by converting them to a string). This is a pain honestly.

I have tried solving this by forcing a default culture in the application, eg

    public static void SetDefaultCulture(string culture = "en-US")
    {
        var cultureInfo = new CultureInfo(culture);

        Thread.CurrentThread.CurrentCulture = cultureInfo;
        Thread.CurrentThread.CurrentUICulture = cultureInfo;
        CultureInfo.CurrentCulture = cultureInfo;
        CultureInfo.CurrentUICulture = cultureInfo;
        CultureInfo.DefaultThreadCurrentCulture = cultureInfo;
        CultureInfo.DefaultThreadCurrentUICulture = cultureInfo;
    }

But it doesn't fix the issue.

Does anyone have a better solution?

[SimonCropp]

probably by converting them to a string

what logic would you use to do that?

[aaron-manning]

public class SomeInputEntity
{
    public decimal dec;
    public double dbl;
    public float flt;
    
    public object MapInputForSnapshot()
    {
        return new
        {
            dec = dec.ToString(".##"),
            dbl = dbl.ToString(".##"),
            flt = flt.ToString(".##"),
        };
    }

    public static void Example()
    {
        var x = new SomeInputEntity
        {
            dec = 1.23456m,
            dbl = 1.23456,
            flt = 1.23456f
        };

        var result = x.MapInputForSnapshot();
        
        /// dec = "1.23"
        /// dbl = "1.23"
        /// flt = "1.23"

        // you would call the snapshot on this result
    }
}

Very manual solution. Looking for a better alternative to enforce consistent precision.

[SimonCropp]

isnt that problematic if the value is .001

[aaron-manning]

absolutely. It's not a generic solution. It's something that has to be hand-crafted to fit a specific problem domain. eg if you know you only need a max of 2 decimal places.

The real problem is that the .net runtime doesn't seem to have a deterministic precision for stringified floating point numbers between builds of the application.

Sometimes a snapshot with a value of 10.123 rounded to 2dp is 10.1 on one build and the next build it's 10.10. It makes using snapshot libraries a pain as the tests keep breaking with false negatives.

I'm aware there may be no reasonable way to solve this generically in Verify, it's more of an open question if anyone knows how to stop this from happening.

[dbruning]

As an alternative to mapping properties to strings, you could tell Verify to write all floats and doubles with a specified precision.

Add these classes:

public class DoubleConverter3dp : WriteOnlyJsonConverter<double>
{
	public override void Write(VerifyJsonWriter writer, double theDouble) =>
		writer.WriteValue(theDouble.ToString("f3"));
}

public class FloatConverter3dp :WriteOnlyJsonConverter<float>
{
	public override void Write(VerifyJsonWriter writer, float theFloat) =>
		writer.WriteValue(theFloat.ToString("f3"));
}

... and then tell Verify to use them:

var settings = new VerifySettings();
settings.AddExtraSettings( _ =>
{
    _.Converters.Add(new FloatConverter3dp());
    _.Converters.Add(new DoubleConverter3dp());
});
await Verifier.Verify(yourObject, settings);