Add DefaultConstraint

[Dreamescaper]

Sometimes it is needed to verify value type against default value.
Common use case - verify that value in rest response is not empty, e.g. Guid (not empty) or enums (not Undefined value).

Current alternative - using EqualConstraint (e.g. Is.Not.EqualTo(Guid.Empty), Is.Not.EqualTo(default(MyEnumTypeName))), which is not always convenient.

Details:

1. If actual is non-nullable value type - should pass if actual == default.

2. If actual is nullable value type - should pass if actual is equal to default value of underlying type, so the following code could be possible:

MyValueType? actual = ...;
Assert.That(actual, Is.Not.Null & Is.Not.Default);

Open question - what the expected behavior if nullable actual is null? Technically it is default value for nullable value type, but I think would make sense to fail it in this case, i.e. only account for underlying type default value.

3. Not sure about the behavior for reference types. Not sure it should be allowed at all. Another option - allow (passing when null), and provide roslyn analyzer with warning if used against reference type.

[rprouse]

I think this is a decent idea. @nunit/framework-team thoughts?

Not sure about the behavior for reference types. Not sure it should be allowed at all.

Since the default value for a reference type is null, would could just treat it the same as the null constraint.

[stevenaw]

I really like this idea.

As far as expected behaviour, if I came across an this API without documentation I'd probably think of this as syntactic sugar for a comparison to default(T). Based on that, I agree with @rprouse on point 3 about reference types being null, since default(T) == null where T is a reference type.

For point 2, I'd probably be surprised if Nullable<int> was treated as equal to 0, since default(Nullable<int>) evaluates to null. I think an uninitialized variable of type Nullable<int> also evaluates to null, so to have a 0 value it would have to be explicitly set. I can see special casing a comparison of the underlying type being convenient for some cases, but I could see it causing false negatives in others.

[jnm2]

I'd also expect Assert.That<T>(x, Is.Default) to evaluate whether x equals default(T) the way C# would, whether T is int or int?. This also matches the default value the .NET runtime assigns to fields that aren't explicitly initialized. Assert.That((int?)null, Is.Default); should succeed and Assert.That((int?)0, Is.Default); should fail.

[stevenaw]

Given the edge cases around ImmutableArray<T> in #3772 I'd like to ask if there's any further thoughts on this.
default(ImmutableArray<T>) is unfortunately neither null (it's a struct) nor empty (it's uninitialized and throws when enumerated against)

[jnm2]

I think it would be a useful constraint to add. It is synonymous with (or an extrapolation of) Is.Zero since 'default' in .NET means zeroed memory, but I would prefer to use the syntax Is.Default for anything non-numeric.

[jnm2]

I would implement it using System.Runtime.CompilerServices.RuntimeHelpers.Equals(actual, default(T)); to bypass any custom equality implementation on the struct which might legitimately throw for a default instance and which would also not as accurately answer the question "is this default memory."

[Dreamescaper]

I'll work on this one (unless someone else is planning to).