feat(assertions): add nullable value type assertions for IsDefault and IsNotDefault

[thomhurst]

Fixes #3472

[claude]

Claude finished @thomhurst's task —— View job

---

Code Review Complete ✅

Todo List:

• Read and understand the CLAUDE.md guidelines
• Review the modified assertion files and understand the changes
• Check test coverage and quality
• Verify public API snapshot updates
• Assess compliance with TUnit's dual-mode requirements
• Evaluate performance implications
• Check for potential bugs and security issues
• Provide comprehensive review feedback

---

Code Review Feedback

✅ Positive Aspects

1. Excellent Type Safety & Design: The implementation provides proper type-safe assertions for different scenarios:

   • IsDefaultAssertion<T> for value types (where T : struct)
   • IsDefaultNullableAssertion<T> for nullable value types (T? where T : struct)
   • IsDefaultReferenceAssertion<T> for reference types (where T : class)

2. Comprehensive Test Coverage: The test suite in DefaultAssertionTests.cs covers all scenarios:

   • Value types (int, DateTime) with default and non-default values
   • Reference types (string, object) with null and non-null values
   • Nullable value types (bool?, int?, DateTime?) with null and HasValue scenarios

3. Proper Public API Management: All snapshots were correctly updated across all target frameworks (.NET 4.7, 8.0, 9.0, 10.0), indicating proper API versioning.

4. Clear Documentation: Good XML documentation explains the purpose and usage of each assertion type.

5. Thread Safety Verification: The STA thread tests demonstrate that delegate assertions properly preserve thread affinity, which was important for issue Asserted Action runs on a different thread / Missing IsDefault assertion #3472.

✅ TUnit Compliance

Dual-Mode Implementation: ✅ VERIFIED

• The implementation correctly uses the [AssertionExtension] attribute system
• Source generator (AssertionExtensionGenerator) automatically creates extension methods for both source-gen and reflection modes
• No manual extension methods needed - follows TUnit's architecture perfectly

⚠️ Minor Issues & Suggestions

1. Nullable Suppression Warnings (lines 97, 130, 232, 266):

   if (EqualityComparer<TValue>.Default.Equals(value!, default!))

   The null-forgiving operators (!) suppress valid nullable warnings. Consider:

   if (EqualityComparer<TValue>.Default.Equals(value, default(TValue)))

2. Redundant Exception Handling: Lines 90-95 in IsDefaultAssertion<T> and similar patterns:

   var exception = metadata.Exception;
   if (exception != null)
   {
       return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().Name}"));
   }

   This exception handling appears in all assertion types but may be redundant since these are value assertions, not delegate assertions. The exception should typically be null unless there's an evaluation error.

3. Performance Consideration: The use of EqualityComparer<T>.Default.Equals() is appropriate and performant, but consider caching the comparer for hot paths if needed.

🔍 Security & Bugs

No Security Concerns: ✅ The code doesn't expose any sensitive information or create security vulnerabilities.

No Bugs Identified: ✅ The implementation logic is sound:

• Correctly uses !value.HasValue for nullable default checks
• Properly uses EqualityComparer<T>.Default.Equals() for type-safe equality
• Error messages are informative and consistent

📈 Performance Assessment

Performance Impact: ✅ MINIMAL

• Uses efficient EqualityComparer<T>.Default.Equals()
• No allocations in happy path beyond error message strings
• Leverages source generation for zero-reflection overhead
• Follows TUnit's performance-first design principles

🎯 Overall Assessment

This is a high-quality implementation that:

• ✅ Solves the requirements of issue Asserted Action runs on a different thread / Missing IsDefault assertion #3472
• ✅ Follows TUnit's architectural patterns perfectly
• ✅ Provides comprehensive type safety for nullable value types
• ✅ Includes thorough test coverage
• ✅ Maintains backward compatibility
• ✅ Uses efficient, allocation-friendly code

Recommendation: APPROVE with consideration of the minor nullable suppression suggestions above.

---