Fix: Bump to latest tunit version

Author: AnnaSasDev

.editorconfig

@@ -1,3 +1,4 @@
+# noinspection EditorConfigKeyCorrectness
 [*]
 charset = utf-8-bom
 end_of_line = crlf
@@ -7,12 +8,15 @@ indent_style = space
 indent_size = 4
 
 # Microsoft .NET properties
+csharp_indent_braces = false
 csharp_new_line_before_members_in_object_initializers = false
 csharp_new_line_before_open_brace = none
-csharp_preferred_modifier_order = public, internal, protected, private, static, override, async, virtual, file, new, sealed, required, abstract, extern, volatile, unsafe, readonly:suggestion
+csharp_preferred_modifier_order = private, internal, protected, public, required, static, file, new, abstract, override, sealed, virtual, readonly, extern, volatile, unsafe, async:suggestion
 csharp_style_prefer_utf8_string_literals = true:suggestion
 csharp_style_var_elsewhere = false:none
 csharp_style_var_for_built_in_types = false:suggestion
+csharp_style_var_when_type_is_apparent = true:none
+csharp_using_directive_placement = outside_namespace:silent
 dotnet_naming_rule.private_constants_rule.import_to_resharper = True
 dotnet_naming_rule.private_constants_rule.resharper_description = Constant fields (private)
 dotnet_naming_rule.private_constants_rule.resharper_guid = 236f7aa5-7b06-43ca-bf2a-9b31bfcff09a
@@ -92,6 +96,7 @@ dotnet_naming_symbols.unity_serialized_field_symbols_1.applicable_kinds =
 dotnet_naming_symbols.unity_serialized_field_symbols_1.resharper_applicable_kinds = unity_serialised_field
 dotnet_naming_symbols.unity_serialized_field_symbols_1.resharper_required_modifiers = instance
 dotnet_sort_system_directives_first = false
+csharp_new_line_between_members = false
 dotnet_style_parentheses_in_arithmetic_binary_operators = never_if_unnecessary:none
 dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:none
 dotnet_style_parentheses_in_relational_binary_operators = never_if_unnecessary:none
@@ -104,8 +109,9 @@ dotnet_style_qualification_for_property = false:suggestion
 dotnet_style_require_accessibility_modifiers = for_non_interface_members:suggestion
 
 # ReSharper properties
+resharper_accessor_owner_body = expression_body
 resharper_align_multiline_binary_expressions_chain = false
-resharper_align_multiline_statement_conditions = false
+resharper_align_multiline_statement_Assertions = false
 resharper_arguments_anonymous_function = named
 resharper_arguments_skip_single = true
 resharper_autodetect_indent_settings = true
@@ -118,25 +124,30 @@ resharper_blank_lines_around_property = 0
 resharper_braces_for_for = required
 resharper_braces_for_foreach = required_for_multiline_statement
 resharper_braces_for_ifelse = not_required
-resharper_braces_for_while = required_for_multiline
+resharper_braces_for_using = required
+resharper_braces_for_while = required_for_multiline_statement
 resharper_braces_redundant = false
 resharper_cpp_insert_final_newline = true
+resharper_csharp_align_multiline_argument = false
 resharper_csharp_blank_lines_around_field = 0
 resharper_csharp_blank_lines_around_invocable = 0
 resharper_csharp_blank_lines_around_region = 0
 resharper_csharp_blank_lines_inside_region = 0
 resharper_csharp_insert_final_newline = true
 resharper_csharp_keep_blank_lines_in_declarations = 100
-resharper_csharp_max_line_length = 505
+resharper_csharp_max_line_length = 709
 resharper_csharp_remove_blank_lines_near_braces_in_code = false
 resharper_csharp_remove_blank_lines_near_braces_in_declarations = false
 resharper_csharp_space_around_alias_eq = false
+resharper_csharp_space_around_shift_op = false
 resharper_csharp_space_before_trailing_comment = false
 resharper_csharp_stick_comment = false
 resharper_csharp_wrap_after_declaration_lpar = true
 resharper_csharp_wrap_before_binary_opsign = true
 resharper_csharp_wrap_before_declaration_rpar = true
 resharper_csharp_wrap_extends_list_style = chop_if_long
+resharper_csharp_wrap_parameters_style = chop_if_long
+resharper_force_attribute_style = join
 resharper_formatter_off_tag = @formatter:off
 resharper_formatter_on_tag = @formatter:on
 resharper_formatter_tags_enabled = true
@@ -149,23 +160,32 @@ resharper_keep_existing_declaration_block_arrangement = true
 resharper_keep_existing_embedded_block_arrangement = true
 resharper_max_attribute_length_for_same_line = 70
 resharper_method_or_operator_body = expression_body
+resharper_nested_ternary_style = expanded
+resharper_object_creation_when_type_evident = target_typed
 resharper_parentheses_redundancy_style = remove
-resharper_place_accessorholder_attribute_on_same_line = false
+resharper_place_accessorholder_attribute_on_same_line = true
 resharper_place_expr_accessor_on_single_line = true
 resharper_place_expr_property_on_single_line = true
+resharper_place_record_field_attribute_on_same_line = true
 resharper_place_simple_accessor_on_single_line = false
 resharper_place_simple_anonymousmethod_on_single_line = false
 resharper_place_simple_case_statement_on_same_line = true
 resharper_place_simple_embedded_statement_on_same_line = true
 resharper_place_simple_initializer_on_single_line = false
 resharper_place_simple_list_pattern_on_single_line = false
-resharper_place_type_attribute_on_same_line = if_owner_is_single_line
+resharper_place_single_method_argument_lambda_on_same_line = false
+resharper_place_type_attribute_on_same_line = false
 resharper_qualified_using_at_nested_scope = true
+resharper_space_in_singleline_anonymous_method = false
 resharper_space_within_empty_braces = false
 resharper_treat_case_statement_with_break_as_simple = false
 resharper_use_indent_from_vs = false
+resharper_wrap_array_initializer_style = chop_always
+resharper_wrap_before_primary_constructor_declaration_rpar = true
+resharper_wrap_chained_binary_expressions = wrap_if_long
 resharper_wrap_list_pattern = chop_always
 resharper_wrap_object_and_collection_initializer_style = chop_always
+resharper_wrap_ternary_expr_style = chop_if_long
 
 # ReSharper inspection severities
 resharper_arrange_redundant_parentheses_highlighting = hint
@@ -201,3 +221,7 @@ indent_size = 2
 indent_style = space
 indent_size = 4
 tab_width = 4
+
+[*.razor]
+csharp_space_after_keywords_in_control_flow_statements = true
+

src/CodeOfChaos.Testing.TUnit/Assertions/GeneratorDriverRunResultHasSourceTextEqualToAssertion.cs

@@ -0,0 +1,58 @@
+// ---------------------------------------------------------------------------------------------------------------------
+// Imports
+// ---------------------------------------------------------------------------------------------------------------------
+using Microsoft.CodeAnalysis;
+using TUnit.Assertions.Core;
+
+namespace CodeOfChaos.Testing.TUnit.Assertions;
+// ---------------------------------------------------------------------------------------------------------------------
+// Code
+// ---------------------------------------------------------------------------------------------------------------------
+public class GeneratorDriverRunResultHasSourceTextEqualToAssertion(
+    AssertionContext<GeneratorDriverRunResult> context,
+    string filename,
+    string expected,
+    StringComparison stringComparison,
+    bool ignoreWhiteSpace,
+    bool withTrimming
+)
+    : Assertion<GeneratorDriverRunResult>(context) {
+
+    // -----------------------------------------------------------------------------------------------------------------
+    // Methods
+    // -----------------------------------------------------------------------------------------------------------------
+    protected override string GetExpectation() => "to have a source with the the expected text";
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<GeneratorDriverRunResult> metadata) {
+        if (metadata.Exception is {} exception) return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().Name}"));
+        
+        GeneratorDriverRunResult? generatorResult = metadata.Value;
+
+        if (generatorResult is null) return Task.FromResult(AssertionResult.Failed("Compilation is null"));
+
+        GeneratedSourceResult? generatedSource = generatorResult.Results
+            .SelectMany(result => result.GeneratedSources)
+            .SingleOrDefault(result => result.HintName == filename);
+
+        if (generatedSource is null) return Task.FromResult(AssertionResult.Failed($"Could not find source with name '{filename}'"));
+        if (generatedSource.Value.SourceText is not {} sourceText) return Task.FromResult(AssertionResult.Failed("Source text is null"));
+
+        string actualValue = sourceText.ToString();
+        string expectedValue = expected;
+
+        // Use the TUnit Equals String so it follows the same structure
+        if (withTrimming) {
+            actualValue = actualValue.Trim();
+            expectedValue = expectedValue.Trim();
+        }
+
+        if (ignoreWhiteSpace) {
+            actualValue = string.Concat(actualValue.Where(c => !char.IsWhiteSpace(c)));
+            expectedValue = string.Concat(expectedValue.Where(c => !char.IsWhiteSpace(c)));
+        }
+
+        if (string.Equals(actualValue, expectedValue, stringComparison)) return Task.FromResult(AssertionResult.Passed);
+        return Task.FromResult(AssertionResult.Failed($"Source text does not match"));
+
+    }
+}

src/CodeOfChaos.Testing.TUnit/Conditions/Library/ContainsDiagnosticAssertCondition.cs renamed to src/CodeOfChaos.Testing.TUnit/Assertions/Library/ContainsDiagnosticAssertion.cs

@@ -1,27 +1,34 @@
-// ---------------------------------------------------------------------------------------------------------------------
-// Imports
-// ---------------------------------------------------------------------------------------------------------------------
-using Microsoft.CodeAnalysis;
-using System.Collections.Immutable;
-using TUnit.Assertions.AssertConditions;
-
-namespace CodeOfChaos.Testing.TUnit.Conditions.Library;
-// ---------------------------------------------------------------------------------------------------------------------
-// Code
-// ---------------------------------------------------------------------------------------------------------------------
-public class ContainsDiagnosticAssertCondition<T>(Func<T, ValueTask<ImmutableArray<Diagnostic>>> getDiagnosticsAction, string expectedId) : BaseAssertCondition<T> {
-    // -----------------------------------------------------------------------------------------------------------------
-    // Methods
-    // -----------------------------------------------------------------------------------------------------------------
-    protected override string GetExpectation() => $"to have a diagnostic with Id \"{expectedId}\"";
-
-    protected override async ValueTask<AssertionResult> GetResult(T? actualValue, Exception? exception, AssertionMetadata assertionMetadata) {
-        if (actualValue is null) return AssertionResult.Fail($"{nameof(T)} is null");
-
-        ImmutableArray<Diagnostic> diagnostics = await getDiagnosticsAction(actualValue);
-        if (!diagnostics.Any()) return FailWithMessage("No diagnostics");
-        if (diagnostics.Any(d => d.Id == expectedId)) return AssertionResult.Passed;
-
-        return FailWithMessage("No diagnostic with Id");
-    }
-}
+// ---------------------------------------------------------------------------------------------------------------------
+// Imports
+// ---------------------------------------------------------------------------------------------------------------------
+using Microsoft.CodeAnalysis;
+using System.Collections.Immutable;
+using TUnit.Assertions.Core;
+
+namespace CodeOfChaos.Testing.TUnit.Assertions.Library;
+// ---------------------------------------------------------------------------------------------------------------------
+// Code
+// ---------------------------------------------------------------------------------------------------------------------
+public class ContainsDiagnosticAssertion<T>(
+    AssertionContext<T> context,
+    Func<T, ValueTask<ImmutableArray<Diagnostic>>> getDiagnosticsAction,
+    string expectedId
+) : Assertion<T>(context) {
+    // -----------------------------------------------------------------------------------------------------------------
+    // Methods
+    // -----------------------------------------------------------------------------------------------------------------
+    protected override string GetExpectation() => $"to have a diagnostic with Id \"{expectedId}\"";
+
+    protected override async Task<AssertionResult> CheckAsync(EvaluationMetadata<T> metadata) {
+        if (metadata.Exception is {} exception) return AssertionResult.Failed($"threw {exception.GetType().Name}");
+        
+        T? actualValue = metadata.Value;
+        if (actualValue is null) return AssertionResult.Failed($"{nameof(T)} is null");
+
+        ImmutableArray<Diagnostic> diagnostics = await getDiagnosticsAction(actualValue);
+        if (!diagnostics.Any()) return AssertionResult.Failed("No diagnostics");
+        if (diagnostics.Any(d => d.Id == expectedId)) return AssertionResult.Passed;
+
+        return AssertionResult.Failed("No diagnostic with Id");
+    }
+}

src/CodeOfChaos.Testing.TUnit/Conditions/Library/ContainsDiagnosticsExclusivelyAssertCondition.cs renamed to src/CodeOfChaos.Testing.TUnit/Assertions/Library/ContainsDiagnosticsExclusivelyAssertion.cs

@@ -1,48 +1,56 @@
-// ---------------------------------------------------------------------------------------------------------------------
-// Imports
-// ---------------------------------------------------------------------------------------------------------------------
-using Microsoft.CodeAnalysis;
-using System.Collections.Immutable;
-using TUnit.Assertions.AssertConditions;
-
-namespace CodeOfChaos.Testing.TUnit.Conditions.Library;
-// ---------------------------------------------------------------------------------------------------------------------
-// Code
-// ---------------------------------------------------------------------------------------------------------------------
-public class ContainsDiagnosticsExclusivelyAssertCondition<T>(Func<T, ValueTask<ImmutableArray<Diagnostic>>> getDiagnosticsAction, string[] expectedIds) : BaseAssertCondition<T> {
-    private readonly HashSet<string> ExpectedValuesHashSet = expectedIds.ToHashSet();
-
-    // -----------------------------------------------------------------------------------------------------------------
-    // Methods
-    // -----------------------------------------------------------------------------------------------------------------
-    protected override string GetExpectation() => $"to have a compilation output with the following Ids \"{expectedIds}\"";
-    protected override async ValueTask<AssertionResult> GetResult(T? actualValue, Exception? exception, AssertionMetadata assertionMetadata) {
-        if (actualValue is null) return AssertionResult.Fail($"{nameof(T)} is null");
-
-        ImmutableArray<Diagnostic> diagnostics = await getDiagnosticsAction(actualValue);
-        if (!diagnostics.Any() && expectedIds.Length == 0) return AssertionResult.Passed;
-        if (!diagnostics.Any()) return FailWithMessage("No diagnostics");
-        if (expectedIds.Length != diagnostics.Length) return FailWithMessage("Wrong number of diagnostics");
-
-        HashSet<string> diagnosticsHashSet = diagnostics.Select(d => d.Id).ToHashSet();
-
-        if (diagnosticsHashSet.SetEquals(ExpectedValuesHashSet)) return AssertionResult.Passed;
-
-        // Find which diagnostics are missing or unexpected
-        string[] missingDiagnostics = ExpectedValuesHashSet.Except(diagnosticsHashSet).ToArray();
-        string[] unexpectedDiagnostics = diagnosticsHashSet.Except(ExpectedValuesHashSet).ToArray();
-
-        string errorMessage = "Diagnostics do not match:";
-
-        if (missingDiagnostics.Length != 0) {
-            errorMessage += $"\n  - Missing diagnostics: {string.Join(", ", missingDiagnostics)}";
-        }
-
-        if (unexpectedDiagnostics.Length != 0) {
-            errorMessage += $"\n  - Unexpected diagnostics: {string.Join(", ", unexpectedDiagnostics)}";
-        }
-
-        return AssertionResult.Fail(errorMessage);
-
-    }
-}
+// ---------------------------------------------------------------------------------------------------------------------
+// Imports
+// ---------------------------------------------------------------------------------------------------------------------
+using Microsoft.CodeAnalysis;
+using System.Collections.Immutable;
+using TUnit.Assertions.Core;
+
+namespace CodeOfChaos.Testing.TUnit.Assertions.Library;
+// ---------------------------------------------------------------------------------------------------------------------
+// Code
+// ---------------------------------------------------------------------------------------------------------------------
+public class ContainsDiagnosticsExclusivelyAssertion<T>(
+    AssertionContext<T> context,
+    Func<T, ValueTask<ImmutableArray<Diagnostic>>> getDiagnosticsAction,
+    string[] expectedIds
+) : Assertion<T>(context) {
+    private readonly HashSet<string> ExpectedValuesHashSet = expectedIds.ToHashSet();
+
+    // -----------------------------------------------------------------------------------------------------------------
+    // Methods
+    // -----------------------------------------------------------------------------------------------------------------
+    protected override string GetExpectation() => $"to have a compilation output with the following Ids \"{expectedIds}\"";
+
+    protected override async Task<AssertionResult> CheckAsync(EvaluationMetadata<T> metadata) {
+        if (metadata.Exception is {} exception) return AssertionResult.Failed($"threw {exception.GetType().Name}");
+        
+        T? actualValue = metadata.Value;
+        if (actualValue is null) return AssertionResult.Failed($"{nameof(T)} is null");
+
+        ImmutableArray<Diagnostic> diagnostics = await getDiagnosticsAction(actualValue);
+        if (!diagnostics.Any() && expectedIds.Length == 0) return AssertionResult.Passed;
+        if (!diagnostics.Any()) return AssertionResult.Failed("No diagnostics");
+        if (expectedIds.Length != diagnostics.Length) return AssertionResult.Failed("Wrong number of diagnostics");
+
+        HashSet<string> diagnosticsHashSet = diagnostics.Select(d => d.Id).ToHashSet();
+
+        if (diagnosticsHashSet.SetEquals(ExpectedValuesHashSet)) return AssertionResult.Passed;
+
+        // Find which diagnostics are missing or unexpected
+        string[] missingDiagnostics = ExpectedValuesHashSet.Except(diagnosticsHashSet).ToArray();
+        string[] unexpectedDiagnostics = diagnosticsHashSet.Except(ExpectedValuesHashSet).ToArray();
+
+        string errorMessage = "Diagnostics do not match:";
+
+        if (missingDiagnostics.Length != 0) {
+            errorMessage += $"\n  - Missing diagnostics: {string.Join(", ", missingDiagnostics)}";
+        }
+
+        if (unexpectedDiagnostics.Length != 0) {
+            errorMessage += $"\n  - Unexpected diagnostics: {string.Join(", ", unexpectedDiagnostics)}";
+        }
+
+        return AssertionResult.Failed(errorMessage);
+
+    }
+}