From 6d23f749c49d7437b109f6e8d0b3ebc0aadd7efd Mon Sep 17 00:00:00 2001 From: Jihoon Park Date: Tue, 4 Jun 2024 22:06:48 -0400 Subject: [PATCH 01/12] Fix #713: Make best attempt at fixing trivia --- ...qualClassicModelAssertUsageCodeFixTests.cs | 46 +++++- ...qualClassicModelAssertUsageCodeFixTests.cs | 42 ++++++ ...SameClassicModelAssertUsageCodeFixTests.cs | 62 ++++++++ ...SameClassicModelAssertUsageCodeFixTests.cs | 64 ++++++++ ...ainsClassicModelAssertUsageCodeFixTests.cs | 62 ++++++++ ...aterClassicModelAssertUsageCodeFixTests.cs | 50 +++++++ ...qualClassicModelAssertUsageCodeFixTests.cs | 50 +++++++ ...mptyClassicModelAssertUsageCodeFixTests.cs | 56 +++++++ ...alseClassicModelAssertUsageCodeFixTests.cs | 67 +++++++++ ...ceOfClassicModelAssertUsageCodeFixTests.cs | 114 +++++++++++++++ ...sNaNClassicModelAssertUsageCodeFixTests.cs | 56 +++++++ ...mptyClassicModelAssertUsageCodeFixTests.cs | 56 +++++++ ...ceOfClassicModelAssertUsageCodeFixTests.cs | 87 +++++++++++ ...NullClassicModelAssertUsageCodeFixTests.cs | 71 +++++++++ ...NullClassicModelAssertUsageCodeFixTests.cs | 71 +++++++++ ...TrueClassicModelAssertUsageCodeFixTests.cs | 67 +++++++++ ...icModelAssertUsageCondensedCodeFixTests.cs | 67 +++++++++ ...LessClassicModelAssertUsageCodeFixTests.cs | 50 +++++++ ...qualClassicModelAssertUsageCodeFixTests.cs | 50 +++++++ ...ZeroClassicModelAssertUsageCodeFixTests.cs | 56 +++++++ ...ZeroClassicModelAssertUsageCodeFixTests.cs | 56 +++++++ .../CollectionAssertUsageCodeFixTests.cs | 137 +++++++++++++++++- .../ComparisonConstraintUsageCodeFixTests.cs | 49 +++++++ .../EqualConstraintUsageCodeFixTests.cs | 43 +++++- .../SomeItemsConstraintUsageCodeFixTests.cs | 60 ++++++-- .../StringConstraintUsageCodeFixTests.cs | 33 +++++ .../AreEqualClassicModelAssertUsageCodeFix.cs | 4 +- ...eNotEqualClassicModelAssertUsageCodeFix.cs | 2 +- ...reNotSameClassicModelAssertUsageCodeFix.cs | 2 +- .../AreSameClassicModelAssertUsageCodeFix.cs | 2 +- .../ClassicModelAssertUsageCodeFix.cs | 7 + .../ContainsClassicModelAssertUsageCodeFix.cs | 2 +- .../GreaterClassicModelAssertUsageCodeFix.cs | 4 +- ...erOrEqualClassicModelAssertUsageCodeFix.cs | 4 +- .../IsEmptyClassicModelAssertUsageCodeFix.cs | 2 +- ...eAndFalseClassicModelAssertUsageCodeFix.cs | 8 +- ...nstanceOfClassicModelAssertUsageCodeFix.cs | 4 +- .../IsNaNClassicModelAssertUsageCodeFix.cs | 2 +- ...sNotEmptyClassicModelAssertUsageCodeFix.cs | 2 +- ...nstanceOfClassicModelAssertUsageCodeFix.cs | 4 +- ...ndNotNullClassicModelAssertUsageCodeFix.cs | 2 +- ...llAndNullClassicModelAssertUsageCodeFix.cs | 2 +- ...ueAndTrueClassicModelAssertUsageCodeFix.cs | 2 +- .../LessClassicModelAssertUsageCodeFix.cs | 4 +- ...ssOrEqualClassicModelAssertUsageCodeFix.cs | 4 +- .../NotZeroClassicModelAssertUsageCodeFix.cs | 2 +- .../ZeroClassicModelAssertUsageCodeFix.cs | 2 +- .../CollectionAssertUsageCodeFix.cs | 11 +- .../BaseConditionConstraintCodeFix.cs | 26 +++- .../EqualConstraintUsageCodeFix.cs | 5 +- .../SomeItemsConstraintUsageCodeFix.cs | 7 +- .../StringConstraintUsageCodeFix.cs | 5 +- .../ArgumentListSyntaxExtensions.cs | 46 +++++- 53 files changed, 1715 insertions(+), 74 deletions(-) diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs index eea3bf9c..4e86d833 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs @@ -295,15 +295,45 @@ public void Test(object actual, object expected) } [Test] - public void CodeFixPreservesLineBreakBeforeMessage() - { - var code = TestUtility.WrapInTestMethod(@" - ClassicAssert.AreEqual(2d, 3d, 0.0000001d, - ""message"");"); + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapInTestMethod($@" + ↓ClassicAssert.AreEqual( + 2d, + 3d, + 0.0000001d{commaAndMessage});"); + + var fixedCode = TestUtility.WrapInTestMethod($@" + Assert.That( + 3d, + Is.EqualTo(2d).Within(0.0000001d){commaAndMessage});"); + + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapInTestMethod($@" + ↓ClassicAssert.AreEqual( + 2d, + 3d, + 0.0000001d{commaAndMessage} + );"); - var fixedCode = TestUtility.WrapInTestMethod(@" - Assert.That(3d, Is.EqualTo(2d).Within(0.0000001d), - ""message"");"); + var fixedCode = TestUtility.WrapInTestMethod($@" + Assert.That( + 3d, + Is.EqualTo(2d).Within(0.0000001d){commaAndMessage} + );"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFixTests.cs index e49697fa..fc13672d 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFixTests.cs @@ -103,5 +103,47 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapInTestMethod($@" + ↓ClassicAssert.AreNotEqual( + 2d, + 3d{commaAndMessage});"); + + var fixedCode = TestUtility.WrapInTestMethod($@" + Assert.That( + 3d, + Is.Not.EqualTo(2d){commaAndMessage});"); + + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapInTestMethod($@" + ↓ClassicAssert.AreNotEqual( + 2d, + 3d{commaAndMessage} + );"); + + var fixedCode = TestUtility.WrapInTestMethod($@" + Assert.That( + 3d, + Is.Not.EqualTo(2d){commaAndMessage} + );"); + + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFixTests.cs index 25e26060..945846ff 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFixTests.cs @@ -133,5 +133,67 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expected = new object(); + var actual = new object(); + + ↓ClassicAssert.AreNotSame( + expected, + actual{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expected = new object(); + var actual = new object(); + + Assert.That( + actual, + Is.Not.SameAs(expected){commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expected = new object(); + var actual = new object(); + + ↓ClassicAssert.AreNotSame( + expected, + actual{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expected = new object(); + var actual = new object(); + + Assert.That( + actual, + Is.Not.SameAs(expected){commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs index ca0dc975..ec069870 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs @@ -133,5 +133,69 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expected = new object(); + var actual = new object(); + + ↓ClassicAssert.AreSame( + expected, + actual{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expected = new object(); + var actual = new object(); + + Assert.That( + actual, + Is.SameAs(expected){commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expected = new object(); + var actual = new object(); + + ↓ClassicAssert.AreSame( + expected, + actual, + ""message"" + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expected = new object(); + var actual = new object(); + + Assert.That( + actual, + Is.SameAs(expected), + ""message"" + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs index 2e137c37..acd1de81 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs @@ -133,5 +133,67 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, instanceDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var instance = new object(); + var collection = Array.Empty(); + + ↓ClassicAssert.Contains( + instance, + collection{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var instance = new object(); + var collection = Array.Empty(); + + Assert.That( + collection, + Does.Contain(instance){commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, instanceDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var instance = new object(); + var collection = Array.Empty(); + + ↓ClassicAssert.Contains( + instance, + collection{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var instance = new object(); + var collection = Array.Empty(); + + Assert.That( + collection, + Does.Contain(instance){commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, instanceDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFixTests.cs index 13c4cb2d..a9761f2d 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFixTests.cs @@ -231,5 +231,55 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.Greater( + 2d, + 3d{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + 2d, + Is.GreaterThan(3d){commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.Greater( + 2d, + 3d{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + 2d, + Is.GreaterThan(3d){commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs index b5823959..3afb230f 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs @@ -231,5 +231,55 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.GreaterOrEqual( + 2d, + 3d{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + 2d, + Is.GreaterThanOrEqualTo(3d){commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.GreaterOrEqual( + 2d, + 3d{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + 2d, + Is.GreaterThanOrEqualTo(3d){commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFixTests.cs index 756b3b47..f81d3e72 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFixTests.cs @@ -159,5 +159,61 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var collection = Array.Empty(); + + ↓ClassicAssert.IsEmpty( + collection{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var collection = Array.Empty(); + + Assert.That( + collection, + Is.Empty{commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var collection = Array.Empty(); + + ↓ClassicAssert.IsEmpty( + collection{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var collection = Array.Empty(); + + Assert.That( + collection, + Is.Empty{commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs index 65a03a34..63642ed6 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs @@ -1,9 +1,12 @@ +using System.Collections.Generic; +using System.Linq; using Gu.Roslyn.Asserts; using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.Diagnostics; using NUnit.Analyzers.ClassicModelAssertUsage; using NUnit.Analyzers.Constants; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace NUnit.Analyzers.Tests.ClassicModelAssertUsage { @@ -12,6 +15,12 @@ public sealed class IsFalseAndFalseClassicModelAssertUsageCodeFixTests { private static readonly DiagnosticAnalyzer analyzer = new ClassicModelAssertUsageAnalyzer(); private static readonly CodeFixProvider fix = new IsFalseAndFalseClassicModelAssertUsageCodeFix(); + private static readonly Dictionary diagnosticIdsToAssertions = new() + { + { AnalyzerIdentifiers.FalseUsage, nameof(ClassicAssert.False) }, + { AnalyzerIdentifiers.IsFalseUsage, nameof(ClassicAssert.IsFalse) }, + }; + private static readonly string[] diagnosticIds = diagnosticIdsToAssertions.Keys.ToArray(); [Test] public void VerifyGetFixableDiagnosticIds() @@ -155,5 +164,63 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen( + [ValueSource(nameof(diagnosticIds))] string diagnosticId, + [Values] bool hasMessage) + { + var assertion = diagnosticIdsToAssertions[diagnosticId]; + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.{assertion}( + false{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + false, + Is.False{commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen( + [ValueSource(nameof(diagnosticIds))] string diagnosticId, + [Values] bool hasMessage) + { + var assertion = diagnosticIdsToAssertions[diagnosticId]; + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.{assertion}( + false{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + false, + Is.False{commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFixTests.cs index 9c26ada2..0a63d344 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFixTests.cs @@ -301,5 +301,119 @@ public void VerifyIsInstanceOfGenericFixWithMessageAndArrayParamsInNonstandardOr Assert.That(actual, Is.InstanceOf(), $""{""first""}, {""second""}"");"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen() + { + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings(@" + public void TestMethod() + { + var expected = typeof(int); + var actual = 42; + + ↓ClassicAssert.IsInstanceOf( + expected, + actual, + ""message""); + }"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings(@" + public void TestMethod() + { + var expected = typeof(int); + var actual = 42; + + Assert.That( + actual, + Is.InstanceOf(expected), + ""message""); + }"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen() + { + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings(@" + public void TestMethod() + { + var expected = typeof(int); + var actual = 42; + + ↓ClassicAssert.IsInstanceOf( + expected, + actual, + ""message"" + ); + }"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings(@" + public void TestMethod() + { + var expected = typeof(int); + var actual = 42; + + Assert.That( + actual, + Is.InstanceOf(expected), + ""message"" + ); + }"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixForGenericMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var actual = 42; + + ↓ClassicAssert.IsInstanceOf( + actual{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var actual = 42; + + Assert.That( + actual, + Is.InstanceOf(){commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixForGenericMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var actual = 42; + + ↓ClassicAssert.IsInstanceOf( + actual{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var actual = 42; + + Assert.That( + actual, + Is.InstanceOf(){commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFixTests.cs index d474e249..9088ac71 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFixTests.cs @@ -123,5 +123,61 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = double.NaN; + + ↓ClassicAssert.IsNaN( + expr{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = double.NaN; + + Assert.That( + expr, + Is.NaN{commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = double.NaN; + + ↓ClassicAssert.IsNaN( + expr{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = double.NaN; + + Assert.That( + expr, + Is.NaN{commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFixTests.cs index b410f513..e54797a9 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFixTests.cs @@ -195,5 +195,61 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var collection = Array.Empty(); + + ↓ClassicAssert.IsNotEmpty( + collection{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var collection = Array.Empty(); + + Assert.That( + collection, + Is.Not.Empty{commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var collection = Array.Empty(); + + ↓ClassicAssert.IsNotEmpty( + collection{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var collection = Array.Empty(); + + Assert.That( + collection, + Is.Not.Empty{commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs index 259cd1bd..1136a02d 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs @@ -301,5 +301,92 @@ public void VerifyIsNotInstanceOfGenericFixWithMessageAndArrayParamsInNonstandar Assert.That(actual, Is.Not.InstanceOf(), $""{""first""}, {""second""}"");"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen() + { + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings(@" + public void TestMethod() + { + var expected = typeof(int); + var actual = 42; + + ↓ClassicAssert.IsNotInstanceOf( + expected, + actual, + ""message""); + }"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings(@" + public void TestMethod() + { + var expected = typeof(int); + var actual = 42; + + Assert.That( + actual, + Is.Not.InstanceOf(expected), + ""message""); + }"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expected = typeof(int); + var actual = 42; + + ↓ClassicAssert.IsNotInstanceOf( + expected, + actual{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expected = typeof(int); + var actual = 42; + + Assert.That( + actual, + Is.Not.InstanceOf(expected){commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixForGenericMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var actual = 42; + + ↓ClassicAssert.IsNotInstanceOf( + actual{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var actual = 42; + + Assert.That( + actual, + Is.Not.InstanceOf(){commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs index f1c37fdc..1c64e5fb 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs @@ -1,9 +1,12 @@ +using System.Collections.Generic; +using System.Linq; using Gu.Roslyn.Asserts; using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.Diagnostics; using NUnit.Analyzers.ClassicModelAssertUsage; using NUnit.Analyzers.Constants; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace NUnit.Analyzers.Tests.ClassicModelAssertUsage { @@ -12,6 +15,12 @@ public sealed class IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests { private static readonly DiagnosticAnalyzer analyzer = new ClassicModelAssertUsageAnalyzer(); private static readonly CodeFixProvider fix = new IsNotNullAndNotNullClassicModelAssertUsageCodeFix(); + private static readonly Dictionary diagnosticIdsToAssertions = new() + { + { AnalyzerIdentifiers.NotNullUsage, nameof(ClassicAssert.NotNull) }, + { AnalyzerIdentifiers.IsNotNullUsage, nameof(ClassicAssert.IsNotNull) }, + }; + private static readonly string[] diagnosticIds = diagnosticIdsToAssertions.Keys.ToArray(); [Test] public void VerifyGetFixableDiagnosticIds() @@ -126,5 +135,67 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen( + [ValueSource(nameof(diagnosticIds))] string diagnosticId, + [Values] bool hasMessage) + { + var assertion = diagnosticIdsToAssertions[diagnosticId]; + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + object? obj = null; + ↓ClassicAssert.{assertion}( + obj{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + object? obj = null; + Assert.That( + obj, + Is.Not.Null{commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen( + [ValueSource(nameof(diagnosticIds))] string diagnosticId, + [Values] bool hasMessage) + { + var assertion = diagnosticIdsToAssertions[diagnosticId]; + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + object? obj = null; + ↓ClassicAssert.{assertion}( + obj{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + object? obj = null; + Assert.That( + obj, + Is.Not.Null{commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs index 6c517696..7a0cb78b 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs @@ -1,9 +1,12 @@ +using System.Collections.Generic; +using System.Linq; using Gu.Roslyn.Asserts; using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.Diagnostics; using NUnit.Analyzers.ClassicModelAssertUsage; using NUnit.Analyzers.Constants; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace NUnit.Analyzers.Tests.ClassicModelAssertUsage { @@ -12,6 +15,12 @@ public sealed class IsNullAndNullClassicModelAssertUsageCodeFixTests { private static readonly DiagnosticAnalyzer analyzer = new ClassicModelAssertUsageAnalyzer(); private static readonly CodeFixProvider fix = new IsNullAndNullClassicModelAssertUsageCodeFix(); + private static readonly Dictionary diagnosticIdsToAssertions = new() + { + { AnalyzerIdentifiers.NullUsage, nameof(ClassicAssert.Null) }, + { AnalyzerIdentifiers.IsNullUsage, nameof(ClassicAssert.IsNull) }, + }; + private static readonly string[] diagnosticIds = diagnosticIdsToAssertions.Keys.ToArray(); [Test] public void VerifyGetFixableDiagnosticIds() @@ -126,5 +135,67 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen( + [ValueSource(nameof(diagnosticIds))] string diagnosticId, + [Values] bool hasMessage) + { + var assertion = diagnosticIdsToAssertions[diagnosticId]; + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + object? obj = null; + ↓ClassicAssert.{assertion}( + obj{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + object? obj = null; + Assert.That( + obj, + Is.Null{commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen( + [ValueSource(nameof(diagnosticIds))] string diagnosticId, + [Values] bool hasMessage) + { + var assertion = diagnosticIdsToAssertions[diagnosticId]; + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + object? obj = null; + ↓ClassicAssert.{assertion}( + obj{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + object? obj = null; + Assert.That( + obj, + Is.Null{commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs index be20d208..2dd739d0 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs @@ -1,9 +1,12 @@ +using System.Collections.Generic; +using System.Linq; using Gu.Roslyn.Asserts; using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.Diagnostics; using NUnit.Analyzers.ClassicModelAssertUsage; using NUnit.Analyzers.Constants; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace NUnit.Analyzers.Tests.ClassicModelAssertUsage { @@ -12,6 +15,12 @@ public sealed class IsTrueAndTrueClassicModelAssertUsageCodeFixTests { private static readonly DiagnosticAnalyzer analyzer = new ClassicModelAssertUsageAnalyzer(); private static readonly CodeFixProvider fix = new IsTrueAndTrueClassicModelAssertUsageCodeFix(); + private static readonly Dictionary diagnosticIdsToAssertions = new() + { + { AnalyzerIdentifiers.TrueUsage, nameof(ClassicAssert.True) }, + { AnalyzerIdentifiers.IsTrueUsage, nameof(ClassicAssert.IsTrue) }, + }; + private static readonly string[] diagnosticIds = diagnosticIdsToAssertions.Keys.ToArray(); [Test] public void VerifyGetFixableDiagnosticIds() @@ -194,5 +203,63 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen( + [ValueSource(nameof(diagnosticIds))] string diagnosticId, + [Values] bool hasMessage) + { + var assertion = diagnosticIdsToAssertions[diagnosticId]; + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.{assertion}( + true{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + true, + Is.True{commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen( + [ValueSource(nameof(diagnosticIds))] string diagnosticId, + [Values] bool hasMessage) + { + var assertion = diagnosticIdsToAssertions[diagnosticId]; + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.{assertion}( + true{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + true, + Is.True{commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs index 2f840b1d..8f655242 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs @@ -1,9 +1,12 @@ +using System.Collections.Generic; +using System.Linq; using Gu.Roslyn.Asserts; using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.Diagnostics; using NUnit.Analyzers.ClassicModelAssertUsage; using NUnit.Analyzers.Constants; using NUnit.Framework; +using NUnit.Framework.Legacy; namespace NUnit.Analyzers.Tests.ClassicModelAssertUsage { @@ -12,6 +15,12 @@ public sealed class IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests { private static readonly DiagnosticAnalyzer analyzer = new ClassicModelAssertUsageAnalyzer(); private static readonly CodeFixProvider fix = new IsTrueAndTrueClassicModelAssertUsageCondensedCodeFix(); + private static readonly Dictionary diagnosticIdsToAssertions = new() + { + { AnalyzerIdentifiers.TrueUsage, nameof(ClassicAssert.True) }, + { AnalyzerIdentifiers.IsTrueUsage, nameof(ClassicAssert.IsTrue) }, + }; + private static readonly string[] diagnosticIds = diagnosticIdsToAssertions.Keys.ToArray(); [Test] public void VerifyGetFixableDiagnosticIds() @@ -121,5 +130,63 @@ public void TestMethod() RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription + IsTrueAndTrueClassicModelAssertUsageCondensedCodeFix.Suffix); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen( + [ValueSource(nameof(diagnosticIds))] string diagnosticId, + [Values] bool hasMessage) + { + var assertion = diagnosticIdsToAssertions[diagnosticId]; + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.{assertion}( + true{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + true{commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, + fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription + IsTrueAndTrueClassicModelAssertUsageCondensedCodeFix.Suffix); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen( + [ValueSource(nameof(diagnosticIds))] string diagnosticId, + [Values] bool hasMessage) + { + var assertion = diagnosticIdsToAssertions[diagnosticId]; + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.{assertion}( + true{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + true{commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, + fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription + IsTrueAndTrueClassicModelAssertUsageCondensedCodeFix.Suffix); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFixTests.cs index f1198094..9380fff3 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFixTests.cs @@ -231,5 +231,55 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.Less( + 2d, + 3d{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + 2d, + Is.LessThan(3d){commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.Less( + 2d, + 3d{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + 2d, + Is.LessThan(3d){commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFixTests.cs index c54be504..99d1f17e 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFixTests.cs @@ -231,5 +231,55 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.LessOrEqual( + 2d, + 3d{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + 2d, + Is.LessThanOrEqualTo(3d){commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.LessOrEqual( + 2d, + 3d{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + 2d, + Is.LessThanOrEqualTo(3d){commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFixTests.cs index d05fbe00..66fb1ef5 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFixTests.cs @@ -123,5 +123,61 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = default(int); + + ↓ClassicAssert.NotZero( + expr{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = default(int); + + Assert.That( + expr, + Is.Not.Zero{commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = default(int); + + ↓ClassicAssert.NotZero( + expr{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = default(int); + + Assert.That( + expr, + Is.Not.Zero{commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFixTests.cs index 5b8fdbe2..1a4d4790 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFixTests.cs @@ -123,5 +123,61 @@ public void TestMethod() }"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = default(int); + + ↓ClassicAssert.Zero( + expr{commaAndMessage}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = default(int); + + Assert.That( + expr, + Is.Zero{commaAndMessage}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = default(int); + + ↓ClassicAssert.Zero( + expr{commaAndMessage} + ); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = default(int); + + Assert.That( + expr, + Is.Zero{commaAndMessage} + ); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageCodeFixTests.cs index 665d555e..2edbc393 100644 --- a/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageCodeFixTests.cs @@ -123,6 +123,136 @@ public void AnalyzeTwoCollectionWhenNoMessageArgumentsAreUsed(string method) RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode); } + [Test] + public void CodeFixForOneCollectionParameterAssertMaintainsReasonableTriviaWithEndOfLineClosingParen( + [ValueSource(nameof(OneCollectionParameterAsserts))] string method, + [Values] bool hasMessage) + { + var commaAndMessage = hasMessage ? @", + ""message""" : string.Empty; + var code = TestUtility.WrapInTestMethod(@$" + var collection = new[] {{ 1, 2, 3 }}; + ↓CollectionAssert.{method}( + collection{commaAndMessage});"); + var fixedCode = TestUtility.WrapInTestMethod(@$" + var collection = new[] {{ 1, 2, 3 }}; + Assert.That( + collection, + {CollectionAssertUsageAnalyzer.OneCollectionParameterAsserts[method]}{commaAndMessage});"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode); + } + + [Test] + public void CodeFixForOneCollectionParameterAssertMaintainsReasonableTriviaWithNewLineClosingParen( + [ValueSource(nameof(OneCollectionParameterAsserts))] string method, + [Values] bool hasMessage) + { + var commaAndMessage = hasMessage ? @", + ""message""" : string.Empty; + var code = TestUtility.WrapInTestMethod(@$" + var collection = new[] {{ 1, 2, 3 }}; + ↓CollectionAssert.{method}( + collection{commaAndMessage} + );"); + var fixedCode = TestUtility.WrapInTestMethod(@$" + var collection = new[] {{ 1, 2, 3 }}; + Assert.That( + collection, + {CollectionAssertUsageAnalyzer.OneCollectionParameterAsserts[method]}{commaAndMessage} + );"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode); + } + + [Test] + public void CodeFixForTwoCollectionParameterAssertMaintainsReasonableTriviaWithEndOfLineClosingParen( + [ValueSource(nameof(TwoCollectionParameterAsserts))] string method, + [Values] bool hasMessage) + { + var commaAndMessage = hasMessage ? @", + ""message""" : string.Empty; + var code = TestUtility.WrapInTestMethod(@$" + var collection1 = new[] {{ 1, 2, 3 }}; + var collection2 = new[] {{ 2, 4, 6 }}; + ↓CollectionAssert.{method}( + collection1, + collection2{commaAndMessage});"); + var fixedCode = TestUtility.WrapInTestMethod(@$" + var collection1 = new[] {{ 1, 2, 3 }}; + var collection2 = new[] {{ 2, 4, 6 }}; + Assert.That( + {GetAdjustedTwoCollectionConstraint(method, insertNewline: true)}{commaAndMessage});"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode); + } + + [Test] + public void CodeFixForTwoCollectionParameterAssertMaintainsReasonableTriviaWithNewLineClosingParen( + [ValueSource(nameof(TwoCollectionParameterAsserts))] string method, + [Values] bool hasMessage) + { + var commaAndMessage = hasMessage ? @", + ""message""" : string.Empty; + var code = TestUtility.WrapInTestMethod(@$" + var collection1 = new[] {{ 1, 2, 3 }}; + var collection2 = new[] {{ 2, 4, 6 }}; + ↓CollectionAssert.{method}( + collection1, + collection2{commaAndMessage} + );"); + var fixedCode = TestUtility.WrapInTestMethod(@$" + var collection1 = new[] {{ 1, 2, 3 }}; + var collection2 = new[] {{ 2, 4, 6 }}; + Assert.That( + {GetAdjustedTwoCollectionConstraint(method, insertNewline: true)}{commaAndMessage} + );"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode); + } + + [Test] + public void CodeFixForCollectionAndItemParameterAssertMaintainsReasonableTriviaWithEndOfLineClosingParen( + [ValueSource(nameof(CollectionAndItemParameterAsserts))] string method, + [Values] bool hasMessage) + { + var commaAndMessage = hasMessage ? @", + ""message""" : string.Empty; + var code = TestUtility.WrapInTestMethod(@$" + var collection = new[] {{ typeof(byte), typeof(char) }}; + var expected = typeof(byte); + ↓CollectionAssert.{method}( + collection, + expected{commaAndMessage});"); + var fixedCode = TestUtility.WrapInTestMethod(@$" + var collection = new[] {{ typeof(byte), typeof(char) }}; + var expected = typeof(byte); + Assert.That( + collection, + {CollectionAssertUsageAnalyzer.CollectionAndItemParameterAsserts[method]}{commaAndMessage});"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode); + } + + [Test] + public void CodeFixForCollectionAndItemParameterAssertMaintainsReasonableTriviaWithNewLineClosingParen( + [ValueSource(nameof(CollectionAndItemParameterAsserts))] string method, + [Values] bool hasMessage) + { + var commaAndMessage = hasMessage ? @", + ""message""" : string.Empty; + var code = TestUtility.WrapInTestMethod(@$" + var collection = new[] {{ typeof(byte), typeof(char) }}; + var expected = typeof(byte); + ↓CollectionAssert.{method}( + collection, + expected{commaAndMessage} + );"); + var fixedCode = TestUtility.WrapInTestMethod(@$" + var collection = new[] {{ typeof(byte), typeof(char) }}; + var expected = typeof(byte); + Assert.That( + collection, + {CollectionAssertUsageAnalyzer.CollectionAndItemParameterAsserts[method]}{commaAndMessage} + );"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode); + } + [TestCaseSource(nameof(TwoCollectionParameterAsserts))] public void AnalyzeTwoCollectionWhenOnlyMessageArgumentIsUsed(string method) { @@ -325,7 +455,7 @@ public void AnalyzeCollectionAndItemWhenFormatAndParamsArgumentsAreUsedOutOfOrde RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode); } - private static string GetAdjustedTwoCollectionConstraint(string method) + private static string GetAdjustedTwoCollectionConstraint(string method, bool insertNewline = false) { (string actualArgument, string constraintArgument) = CollectionAssertUsageCodeFix.CollectionAssertToOneUnswappedParameterConstraints.ContainsKey(method) @@ -334,7 +464,10 @@ private static string GetAdjustedTwoCollectionConstraint(string method) string constraint = CollectionAssertUsageAnalyzer.TwoCollectionParameterAsserts[method] .Replace("expected", constraintArgument); - return $"{actualArgument}, {constraint}"; + return insertNewline + ? $@"{actualArgument}, + {constraint}" + : $"{actualArgument}, {constraint}"; } } } diff --git a/src/nunit.analyzers.tests/ConstraintsUsage/ComparisonConstraintUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ConstraintsUsage/ComparisonConstraintUsageCodeFixTests.cs index 232872b0..7acafdb6 100644 --- a/src/nunit.analyzers.tests/ConstraintsUsage/ComparisonConstraintUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ConstraintsUsage/ComparisonConstraintUsageCodeFixTests.cs @@ -92,5 +92,54 @@ public void FixesWhenComparisonOperatorUseConstantOnLeftHandSide(string operator RoslynAssert.CodeFix(analyzer, fix, diagnostic, code, fixedCode); } + + [TestCase(">=", "Is.LessThan")] + [TestCase(">", "Is.LessThanOrEqualTo")] + [TestCase("<=", "Is.GreaterThan")] + [TestCase("<", "Is.GreaterThanOrEqualTo")] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen(string operatorToken, string constraint) + { + var code = TestUtility.WrapInTestMethod(@$" + int actual = 5; + Assert.That( + ↓actual {operatorToken} 9, + Is.False);"); + + var fixedCode = TestUtility.WrapInTestMethod(@$" + int actual = 5; + Assert.That( + actual, + {constraint}(9));"); + + var diagnostic = ExpectedDiagnostic.Create(AnalyzerIdentifiers.ComparisonConstraintUsage, + string.Format(CultureInfo.InvariantCulture, ComparisonConstraintUsageConstants.Message, constraint)); + + RoslynAssert.CodeFix(analyzer, fix, diagnostic, code, fixedCode); + } + + [TestCase(">=", "Is.GreaterThanOrEqualTo")] + [TestCase(">", "Is.GreaterThan")] + [TestCase("<=", "Is.LessThanOrEqualTo")] + [TestCase("<", "Is.LessThan")] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen(string operatorToken, string constraint) + { + var code = TestUtility.WrapInTestMethod(@$" + int actual = 5; + Assert.That( + ↓actual {operatorToken} 9 + );"); + + var fixedCode = TestUtility.WrapInTestMethod(@$" + int actual = 5; + Assert.That( + actual, + {constraint}(9) + );"); + + var diagnostic = ExpectedDiagnostic.Create(AnalyzerIdentifiers.ComparisonConstraintUsage, + string.Format(CultureInfo.InvariantCulture, ComparisonConstraintUsageConstants.Message, constraint)); + + RoslynAssert.CodeFix(analyzer, fix, diagnostic, code, fixedCode); + } } } diff --git a/src/nunit.analyzers.tests/ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs index 9b6fc0be..3dd48a47 100644 --- a/src/nunit.analyzers.tests/ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs @@ -308,19 +308,46 @@ public void FixesEqualsMethodWithAssertFalseWithMessage() } [Test] - public void CodeFixPreservesLineBreakBeforeMessage() + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { - var code = TestUtility.WrapInTestMethod(@" + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapInTestMethod($@" var actual = ""abc""; + ClassicAssert.False( + actual.Equals(""bcd""){commaAndMessage});"); - ClassicAssert.False(actual.Equals(""bcd""), - ""Assertion message from new line"");"); - - var fixedCode = TestUtility.WrapInTestMethod(@" + var fixedCode = TestUtility.WrapInTestMethod($@" var actual = ""abc""; + Assert.That( + actual, + Is.Not.EqualTo(""bcd""){commaAndMessage});"); + + RoslynAssert.CodeFix(analyzer, fix, equalConstraintDiagnostic, code, fixedCode); + } - Assert.That(actual, Is.Not.EqualTo(""bcd""), - ""Assertion message from new line"");"); + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + { + var commaAndMessage = hasMessage + ? @", + ""message""" + : string.Empty; + var code = TestUtility.WrapInTestMethod($@" + var actual = ""abc""; + Assert.That( + actual.Equals(""abc""), + Is.True{commaAndMessage} + );"); + + var fixedCode = TestUtility.WrapInTestMethod($@" + var actual = ""abc""; + Assert.That( + actual, + Is.EqualTo(""abc""){commaAndMessage} + );"); RoslynAssert.CodeFix(analyzer, fix, equalConstraintDiagnostic, code, fixedCode); } diff --git a/src/nunit.analyzers.tests/ConstraintsUsage/SomeItemsConstraintUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ConstraintsUsage/SomeItemsConstraintUsageCodeFixTests.cs index 1c23876c..cc7948d8 100644 --- a/src/nunit.analyzers.tests/ConstraintsUsage/SomeItemsConstraintUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ConstraintsUsage/SomeItemsConstraintUsageCodeFixTests.cs @@ -24,11 +24,11 @@ public class SomeItemsConstraintUsageCodeFixTests public void AnalyzeWhenListContainsUsedAssertThat() { var testCode = TestUtility.WrapInTestMethod(@" - Assert.That(↓new List {1, 2, 3}.Contains(1));", + Assert.That(↓new List { 1, 2, 3 }.Contains(1));", additionalUsings: "using System.Collections.Generic;"); var fixedCode = TestUtility.WrapInTestMethod(@" - Assert.That(new List {1, 2, 3}, Does.Contain(1));", + Assert.That(new List { 1, 2, 3 }, Does.Contain(1));", additionalUsings: "using System.Collections.Generic;"); RoslynAssert.CodeFix(analyzer, fix, doesContainDiagnostic, testCode, fixedCode); @@ -38,11 +38,11 @@ public void AnalyzeWhenListContainsUsedAssertThat() public void AnalyzeWhenListContainsUsedAssertIsTrue() { var testCode = TestUtility.WrapInTestMethod(@" - ClassicAssert.IsTrue(↓new List {1, 2, 3}.Contains(1));", + ClassicAssert.IsTrue(↓new List { 1, 2, 3 }.Contains(1));", additionalUsings: "using System.Collections.Generic;"); var fixedCode = TestUtility.WrapInTestMethod(@" - Assert.That(new List {1, 2, 3}, Does.Contain(1));", + Assert.That(new List { 1, 2, 3 }, Does.Contain(1));", additionalUsings: "using System.Collections.Generic;"); RoslynAssert.CodeFix(analyzer, fix, doesContainDiagnostic, testCode, fixedCode); @@ -52,11 +52,11 @@ public void AnalyzeWhenListContainsUsedAssertIsTrue() public void AnalyzeWhenListContainsUsedAssertIsFalse() { var testCode = TestUtility.WrapInTestMethod(@" - ClassicAssert.IsFalse(↓new List {1, 2, 3}.Contains(1));", + ClassicAssert.IsFalse(↓new List { 1, 2, 3 }.Contains(1));", additionalUsings: "using System.Collections.Generic;"); var fixedCode = TestUtility.WrapInTestMethod(@" - Assert.That(new List {1, 2, 3}, Does.Not.Contain(1));", + Assert.That(new List { 1, 2, 3 }, Does.Not.Contain(1));", additionalUsings: "using System.Collections.Generic;"); RoslynAssert.CodeFix(analyzer, fix, doesNotContainDiagnostic, testCode, fixedCode); @@ -66,11 +66,11 @@ public void AnalyzeWhenListContainsUsedAssertIsFalse() public void AnalyzeWhenLinqContainsUsedAssertThat() { var testCode = TestUtility.WrapInTestMethod(@" - Assert.That(↓new[] {1, 2, 3}.Contains(1));", + Assert.That(↓new[] { 1, 2, 3 }.Contains(1));", additionalUsings: "using System.Linq;"); var fixedCode = TestUtility.WrapInTestMethod(@" - Assert.That(new[] {1, 2, 3}, Does.Contain(1));", + Assert.That(new[] { 1, 2, 3 }, Does.Contain(1));", additionalUsings: "using System.Linq;"); RoslynAssert.CodeFix(analyzer, fix, doesContainDiagnostic, testCode, fixedCode); @@ -80,11 +80,11 @@ public void AnalyzeWhenLinqContainsUsedAssertThat() public void AnalyzeWhenLinqContainsUsedAssertIsTrue() { var testCode = TestUtility.WrapInTestMethod(@" - ClassicAssert.IsTrue(↓new[] {1, 2, 3}.Contains(1));", + ClassicAssert.IsTrue(↓new[] { 1, 2, 3 }.Contains(1));", additionalUsings: "using System.Linq;"); var fixedCode = TestUtility.WrapInTestMethod(@" - Assert.That(new[] {1, 2, 3}, Does.Contain(1));", + Assert.That(new[] { 1, 2, 3 }, Does.Contain(1));", additionalUsings: "using System.Linq;"); RoslynAssert.CodeFix(analyzer, fix, doesContainDiagnostic, testCode, fixedCode); @@ -94,11 +94,47 @@ public void AnalyzeWhenLinqContainsUsedAssertIsTrue() public void AnalyzeWhenLinqContainsUsedAssertIsFalse() { var testCode = TestUtility.WrapInTestMethod(@" - ClassicAssert.IsFalse(↓new[] {1, 2, 3}.Contains(1));", + ClassicAssert.IsFalse(↓new[] { 1, 2, 3 }.Contains(1));", additionalUsings: "using System.Linq;"); var fixedCode = TestUtility.WrapInTestMethod(@" - Assert.That(new[] {1, 2, 3}, Does.Not.Contain(1));", + Assert.That(new[] { 1, 2, 3 }, Does.Not.Contain(1));", + additionalUsings: "using System.Linq;"); + + RoslynAssert.CodeFix(analyzer, fix, doesNotContainDiagnostic, testCode, fixedCode); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen() + { + var testCode = TestUtility.WrapInTestMethod(@" + ClassicAssert.IsFalse( + ↓new[] { 1, 2, 3 }.Contains(1));", + additionalUsings: "using System.Linq;"); + + var fixedCode = TestUtility.WrapInTestMethod(@" + Assert.That( + new[] { 1, 2, 3 }, + Does.Not.Contain(1));", + additionalUsings: "using System.Linq;"); + + RoslynAssert.CodeFix(analyzer, fix, doesNotContainDiagnostic, testCode, fixedCode); + } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen() + { + var testCode = TestUtility.WrapInTestMethod(@" + ClassicAssert.IsFalse( + ↓new[] { 1, 2, 3 }.Contains(1) + );", + additionalUsings: "using System.Linq;"); + + var fixedCode = TestUtility.WrapInTestMethod(@" + Assert.That( + new[] { 1, 2, 3 }, + Does.Not.Contain(1) + );", additionalUsings: "using System.Linq;"); RoslynAssert.CodeFix(analyzer, fix, doesNotContainDiagnostic, testCode, fixedCode); diff --git a/src/nunit.analyzers.tests/ConstraintsUsage/StringConstraintUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ConstraintsUsage/StringConstraintUsageCodeFixTests.cs index 785f19dd..7da1d63b 100644 --- a/src/nunit.analyzers.tests/ConstraintsUsage/StringConstraintUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ConstraintsUsage/StringConstraintUsageCodeFixTests.cs @@ -121,5 +121,38 @@ public void AnalyzeStringBooleanMethodAssertThatIsFalse(string method, string an RoslynAssert.CodeFix(analyzer, fix, ExpectedDiagnostic.Create(analyzerId), code, fixedCode); } + + [TestCaseSource(nameof(NegativeAssertData))] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen(string method, string analyzerId, string suggestedConstraint) + { + var code = TestUtility.WrapInTestMethod($@" + ClassicAssert.IsFalse( + ↓""abc"".{method}(""ab""));"); + + var fixedCode = TestUtility.WrapInTestMethod($@" + Assert.That( + ""abc"", + {suggestedConstraint}(""ab""));"); + + RoslynAssert.CodeFix(analyzer, fix, ExpectedDiagnostic.Create(analyzerId), code, fixedCode); + } + + [TestCaseSource(nameof(NegativeAssertData))] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen(string method, string analyzerId, string suggestedConstraint) + { + var code = TestUtility.WrapInTestMethod($@" + Assert.That( + ↓""abc"".{method}(""ab""), + Is.False + );"); + + var fixedCode = TestUtility.WrapInTestMethod($@" + Assert.That( + ""abc"", + {suggestedConstraint}(""ab"") + );"); + + RoslynAssert.CodeFix(analyzer, fix, ExpectedDiagnostic.Create(analyzerId), code, fixedCode); + } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFix.cs index fc46671b..f349eae3 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFix.cs @@ -42,11 +42,11 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg equalToInvocationNode, SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfEqualConstraintWithin))) .WithArgumentList(SyntaxFactory.ArgumentList( - SyntaxFactory.SingletonSeparatedList(toleranceArgumentNoColon))); + SyntaxFactory.SingletonSeparatedList(toleranceArgumentNoColon.WithoutTrivia()))); } var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, SyntaxFactory.Argument(equalToInvocationNode)); + return (actualArgument, SyntaxFactory.Argument(equalToInvocationNode).WithTriviaFrom(actualArgument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFix.cs index 55c2f91d..c1b54685 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFix.cs @@ -34,7 +34,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.SingletonSeparatedList(expectedArgument)))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, constraintArgument); + return (actualArgument.WithoutTrailingTrivia(), constraintArgument.WithTriviaFrom(actualArgument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFix.cs index f632ea51..92b8f3bf 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFix.cs @@ -34,7 +34,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.SingletonSeparatedList(expectedArgument)))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, constraintArgument); + return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFix.cs index d1340ab1..58fa6725 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFix.cs @@ -31,7 +31,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.SingletonSeparatedList(expectedArgument)))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, constraintArgument); + return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/ClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/ClassicModelAssertUsageCodeFix.cs index 58b12827..7067ee86 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/ClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/ClassicModelAssertUsageCodeFix.cs @@ -77,6 +77,13 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) if (CodeFixHelper.GetInterpolatedMessageArgumentOrDefault(messageArgument, args, unconditional: false, argsIsArray) is ArgumentSyntax interpolatedMessageArgument) newArguments.Add(interpolatedMessageArgument); + // Fix trailing trivia for the first and the last argument + if (newArguments.Count > 1) + newArguments[0] = newArguments[0].WithoutTrailingTrivia(); + var lastIndex = newArguments.Count - 1; + var previousLastArgument = invocationNode.ArgumentList.Arguments.Last(); + newArguments[lastIndex] = newArguments[lastIndex].WithTrailingTrivia(previousLastArgument.GetTrailingTrivia()); + var newArgumentsList = invocationNode.ArgumentList.WithArguments(newArguments); newInvocationNode = newInvocationNode.WithArgumentList(newArgumentsList); diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFix.cs index 94876d81..afd5ef40 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFix.cs @@ -31,7 +31,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.SingletonSeparatedList(expectedArgument)))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, constraintArgument); + return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFix.cs index 2045d853..3c45bbea 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFix.cs @@ -28,10 +28,10 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsGreaterThan))) .WithArgumentList(SyntaxFactory.ArgumentList( - SyntaxFactory.SingletonSeparatedList(arg2Argument)))); + SyntaxFactory.SingletonSeparatedList(arg2Argument.WithoutTrivia())))); var arg1Argument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfArg1Parameter].WithNameColon(null); - return (arg1Argument, constraintArgument); + return (arg1Argument, constraintArgument.WithTriviaFrom(arg1Argument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFix.cs index 0fab1795..3a05a2fe 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFix.cs @@ -28,10 +28,10 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsGreaterThanOrEqualTo))) .WithArgumentList(SyntaxFactory.ArgumentList( - SyntaxFactory.SingletonSeparatedList(arg2Argument)))); + SyntaxFactory.SingletonSeparatedList(arg2Argument.WithoutTrivia())))); var arg1Argument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfArg1Parameter].WithNameColon(null); - return (arg1Argument, constraintArgument); + return (arg1Argument, constraintArgument.WithTriviaFrom(arg1Argument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFix.cs index 3adb8b76..5dc55bac 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFix.cs @@ -32,7 +32,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsEmpty))); - return (actualArgument, constraintArgument); + return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFix.cs index e52debad..a5f3fa43 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFix.cs @@ -27,8 +27,12 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), - SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsFalse))); - return (actualArgument, constraintArgument); + SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsFalse))) + .WithTriviaFrom(actualArgument); + + // Swallow the trailing trivia of actualArgument because the comma should immediately follow it + // This also removes comments, but ignore them for now. + return (actualArgument.WithoutTrailingTrivia(), constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFix.cs index dc3a59ae..fd46d5d9 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFix.cs @@ -29,7 +29,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax ConstraintArgu SyntaxFactory.GenericName(NUnitFrameworkConstants.NameOfIsInstanceOf) .WithTypeArgumentList(typeArguments)))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, constraintArgument); + return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); } protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArgument) ConstructActualAndConstraintArguments( @@ -47,7 +47,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.SingletonSeparatedList(expectedArgument)))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, constraintArgument); + return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFix.cs index 81295efc..fd346de1 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFix.cs @@ -27,7 +27,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsNaN))); - return (actualArgument, constraintArgument); + return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFix.cs index 3f0a7724..dfa2fb7b 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFix.cs @@ -34,7 +34,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsNot)), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsEmpty))); - return (actualArgument, constraintArgument); + return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFix.cs index 39cb57c1..7c4b54bf 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFix.cs @@ -32,7 +32,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax ConstraintArgu SyntaxFactory.GenericName(NUnitFrameworkConstants.NameOfIsInstanceOf) .WithTypeArgumentList(typeArguments)))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, constraintArgument); + return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); } protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArgument) ConstructActualAndConstraintArguments( @@ -53,7 +53,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.SingletonSeparatedList(expectedArgument)))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, constraintArgument); + return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFix.cs index 8d5f9ea9..c31b4e9d 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFix.cs @@ -32,7 +32,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsNull))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfAnObjectParameter].WithNameColon(null); - return (actualArgument, constraintArgument); + return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFix.cs index 908ee2cb..5f5137bb 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFix.cs @@ -29,7 +29,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsNull))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfAnObjectParameter].WithNameColon(null); - return (actualArgument, constraintArgument); + return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFix.cs index 2eb25e67..9f7d0c05 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFix.cs @@ -29,7 +29,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsTrue))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfConditionParameter].WithNameColon(null); - return (actualArgument, constraintArgument); + return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFix.cs index e0cb12ca..efc8263b 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFix.cs @@ -28,10 +28,10 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsLessThan))) .WithArgumentList(SyntaxFactory.ArgumentList( - SyntaxFactory.SingletonSeparatedList(arg2Argument)))); + SyntaxFactory.SingletonSeparatedList(arg2Argument.WithoutTrivia())))); var arg1Argument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfArg1Parameter].WithNameColon(null); - return (arg1Argument, constraintArgument); + return (arg1Argument, constraintArgument.WithTriviaFrom(arg1Argument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFix.cs index 4c69a932..7a43f69f 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFix.cs @@ -28,10 +28,10 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsLessThanOrEqualTo))) .WithArgumentList(SyntaxFactory.ArgumentList( - SyntaxFactory.SingletonSeparatedList(arg2Argument)))); + SyntaxFactory.SingletonSeparatedList(arg2Argument.WithoutTrivia())))); var arg1Argument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfArg1Parameter].WithNameColon(null); - return (arg1Argument, constraintArgument); + return (arg1Argument, constraintArgument.WithTriviaFrom(arg1Argument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFix.cs index c76db4cf..05ec00cf 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFix.cs @@ -30,7 +30,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsNot)), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsZero))); - return (actualArgument, constraintArgument); + return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFix.cs index 4eb547d9..9a9e0ec4 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFix.cs @@ -27,7 +27,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsZero))); - return (actualArgument, constraintArgument); + return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); } } } diff --git a/src/nunit.analyzers/CollectionAssertUsage/CollectionAssertUsageCodeFix.cs b/src/nunit.analyzers/CollectionAssertUsage/CollectionAssertUsageCodeFix.cs index 043bc667..c1694864 100644 --- a/src/nunit.analyzers/CollectionAssertUsage/CollectionAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/CollectionAssertUsage/CollectionAssertUsageCodeFix.cs @@ -93,11 +93,12 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg Diagnostic diagnostic, IReadOnlyDictionary argumentNamesToArguments) { - var (actualArgument, constraintArgument) = GetActualAndConstraintArguments(diagnostic, argumentNamesToArguments); + var (actualArgument, originalConstraintArgument) = GetActualAndConstraintArguments(diagnostic, argumentNamesToArguments); + var newConstraintArgument = originalConstraintArgument; if (argumentNamesToArguments.TryGetValue(NameOfComparerParameter, out ArgumentSyntax? comparerArgument)) { - ExpressionSyntax expression = constraintArgument.Expression; + ExpressionSyntax expression = originalConstraintArgument.Expression; // We need to drop the 'AsCollection' when using an IComparer. if (expression is MemberAccessExpressionSyntax memberAccessExpression && @@ -106,7 +107,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg expression = memberAccessExpression.Expression; } - constraintArgument = Argument( + newConstraintArgument = Argument( InvocationExpression( MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, @@ -115,7 +116,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg ArgumentList(SingletonSeparatedList(comparerArgument)))); } - return (actualArgument, constraintArgument); + return (actualArgument.WithoutTrailingTrivia(), newConstraintArgument.WithTriviaFrom(actualArgument)); } private static (ArgumentSyntax actualArgument, ArgumentSyntax constraintArgument) GetActualAndConstraintArguments( @@ -142,7 +143,7 @@ private static (ArgumentSyntax actualArgument, ArgumentSyntax constraintArgument { var secondParameterName = CollectionAssertToSecondParameterName[methodName]; var secondArgument = argumentNamesToArguments[secondParameterName].WithNameColon(null); - var constraintArgument = Argument(constraints.CreateConstraint(secondArgument)); + var constraintArgument = Argument(constraints.CreateConstraint(secondArgument.WithoutTrivia())); return (firstArgument, constraintArgument); } diff --git a/src/nunit.analyzers/ConstraintUsage/BaseConditionConstraintCodeFix.cs b/src/nunit.analyzers/ConstraintUsage/BaseConditionConstraintCodeFix.cs index 406a50ab..043dcc4b 100644 --- a/src/nunit.analyzers/ConstraintUsage/BaseConditionConstraintCodeFix.cs +++ b/src/nunit.analyzers/ConstraintUsage/BaseConditionConstraintCodeFix.cs @@ -8,6 +8,7 @@ using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; +using Microsoft.CodeAnalysis.Formatting; using NUnit.Analyzers.Extensions; using NUnit.Analyzers.Helpers; using static NUnit.Analyzers.Constants.NUnitFrameworkConstants; @@ -73,7 +74,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context) if (assertMethod is null) return; - var newAssertNode = UpdateAssertNode(assertNode, assertMethod, actual, constraintExpression); + var newAssertNode = UpdateAssertNode(assertNode, conditionNode, assertMethod, actual, constraintExpression); if (newAssertNode is null) return; @@ -107,10 +108,10 @@ protected virtual (ExpressionSyntax? actual, ExpressionSyntax? constraintExpress return SyntaxFactory.InvocationExpression( SyntaxFactory.ParseExpression(constraintString), - SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(expected)))); + SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(expected.WithoutTrivia())))); } - protected static InvocationExpressionSyntax? UpdateAssertNode(InvocationExpressionSyntax assertNode, IMethodSymbol assertMethod, + protected static InvocationExpressionSyntax? UpdateAssertNode(InvocationExpressionSyntax assertNode, ExpressionSyntax? conditionNode, IMethodSymbol assertMethod, ExpressionSyntax actual, ExpressionSyntax constraintExpression) { // Replace the original ClassicAssert. invocation name into Assert.That @@ -126,13 +127,26 @@ protected virtual (ExpressionSyntax? actual, ExpressionSyntax? constraintExpress ? assertNode.ArgumentList.Arguments.Skip(2) : assertNode.ArgumentList.Arguments.Skip(1); + var actualArgument = SyntaxFactory.Argument(actual); + var actualArgumentWithRightTrivia = conditionNode is not null + ? actualArgument.WithLeadingTrivia(conditionNode.GetLeadingTrivia()) // ignore the trailing trivia, as there is a following argument + : actualArgument; + + var lastOriginalArgument = assertNode.ArgumentList.Arguments.Last(); + var constraintArgument = SyntaxFactory.Argument(constraintExpression).WithTriviaFrom(lastOriginalArgument); + var constraintArgumentWithRightTrivia = remainingArguments.Any() + ? constraintArgument.WithoutTrailingTrivia() // remove the trailing trivia, as there is a following argument + : constraintArgument; + var newArguments = new[] { - SyntaxFactory.Argument(actual), - SyntaxFactory.Argument(constraintExpression) + actualArgumentWithRightTrivia, + constraintArgumentWithRightTrivia }.Union(remainingArguments); - var newArgumentsList = assertNode.ArgumentList.WithArguments(newArguments); + var newArgumentsList = assertNode.ArgumentList + .WithArguments(newArguments) + .WithAdditionalAnnotations(Formatter.Annotation); return newAssertNode.WithArgumentList(newArgumentsList); } diff --git a/src/nunit.analyzers/ConstraintUsage/EqualConstraintUsageCodeFix.cs b/src/nunit.analyzers/ConstraintUsage/EqualConstraintUsageCodeFix.cs index cc059520..91c9438b 100644 --- a/src/nunit.analyzers/ConstraintUsage/EqualConstraintUsageCodeFix.cs +++ b/src/nunit.analyzers/ConstraintUsage/EqualConstraintUsageCodeFix.cs @@ -35,7 +35,10 @@ protected override (ExpressionSyntax? actual, ExpressionSyntax? constraintExpres constraintExpression = null; } - return (actual, constraintExpression); + // Fix trivia + return actual is not null && constraintExpression is not null + ? (actual.WithTriviaFrom(constraintExpression), constraintExpression.WithTriviaFrom(actual)) + : (actual, constraintExpression); } private static (ExpressionSyntax? actual, ExpressionOrPatternSyntax? expected) GetActualExpected(SyntaxNode conditionNode) diff --git a/src/nunit.analyzers/ConstraintUsage/SomeItemsConstraintUsageCodeFix.cs b/src/nunit.analyzers/ConstraintUsage/SomeItemsConstraintUsageCodeFix.cs index 026c3e49..34a62194 100644 --- a/src/nunit.analyzers/ConstraintUsage/SomeItemsConstraintUsageCodeFix.cs +++ b/src/nunit.analyzers/ConstraintUsage/SomeItemsConstraintUsageCodeFix.cs @@ -23,7 +23,12 @@ protected override (ExpressionSyntax? actual, ExpressionSyntax? constraintExpres var expected = invocation.ArgumentList.Arguments.FirstOrDefault()?.Expression; var constraintExpression = GetConstraintExpression(suggestedConstraintString, expected); - return (actual, constraintExpression); + // Fix trivia + return ( + actual, + constraintExpression is not null + ? constraintExpression.WithTriviaFrom(conditionNode) + : constraintExpression); } else { diff --git a/src/nunit.analyzers/ConstraintUsage/StringConstraintUsageCodeFix.cs b/src/nunit.analyzers/ConstraintUsage/StringConstraintUsageCodeFix.cs index 59031cff..6a950c64 100644 --- a/src/nunit.analyzers/ConstraintUsage/StringConstraintUsageCodeFix.cs +++ b/src/nunit.analyzers/ConstraintUsage/StringConstraintUsageCodeFix.cs @@ -26,7 +26,10 @@ protected override (ExpressionSyntax? actual, ExpressionSyntax? constraintExpres var expected = invocation.ArgumentList.Arguments.FirstOrDefault()?.Expression; var constraintExpression = GetConstraintExpression(suggestedConstraintString, expected); - return (actual, constraintExpression); + // Fix trivia + return actual is not null && constraintExpression is not null + ? (actual.WithTriviaFrom(constraintExpression), constraintExpression.WithTriviaFrom(actual)) + : (actual, constraintExpression); } else { diff --git a/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs b/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs index dffbd509..4f606afb 100644 --- a/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs +++ b/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs @@ -13,7 +13,19 @@ public static ArgumentListSyntax WithArguments( IEnumerable newArguments) { var originalArguments = @this.Arguments; - var originalSeparators = originalArguments.GetSeparators(); + var originalSeparators = originalArguments.GetSeparators().ToArray(); + + // To match the old style as closely as possible, do not attempt anything if the number of arguments stayed the same + if (originalArguments.Count == newArguments.Count()) + { + return @this.WithArguments(SyntaxFactory.SeparatedList(newArguments, originalSeparators)); + } + + // Otherwise, the number of arguments has either increased or decreased, in which case + // there is no one-size-fits-all answer on what to do about the trivias around separators. + // Therefore, add a newline after the the separator if either the opening parenthesis + // or any of the original separators had a trailing newline. + var shouldAddTrailingNewlineAfterComma = TryGetFirstEndOfLineTrivia(@this.OpenParenToken, originalSeparators, out var trailingTrivia); var nodesAndTokens = new List { newArguments.First() }; @@ -25,7 +37,10 @@ public static ArgumentListSyntax WithArguments( if (separator == default(SyntaxToken)) { - separator = SyntaxFactory.Token(SyntaxKind.CommaToken); + separator = SyntaxFactory.Token( + SyntaxFactory.TriviaList(), + SyntaxKind.CommaToken, + shouldAddTrailingNewlineAfterComma ? SyntaxFactory.TriviaList(trailingTrivia) : SyntaxFactory.TriviaList()); } nodesAndTokens.Add(separator); @@ -36,5 +51,32 @@ public static ArgumentListSyntax WithArguments( return @this.WithArguments(newSeparatedList); } + + private static bool TryGetFirstEndOfLineTrivia(SyntaxToken openParenToken, SyntaxToken[] separators, out SyntaxTrivia trailingTrivia) + { + foreach (var trivia in openParenToken.TrailingTrivia) + { + if (trivia.IsKind(SyntaxKind.EndOfLineTrivia)) + { + trailingTrivia = trivia; + return true; + } + } + + foreach (var separator in separators) + { + foreach (var trivia in separator.TrailingTrivia) + { + if (trivia.IsKind(SyntaxKind.EndOfLineTrivia)) + { + trailingTrivia = trivia; + return true; + } + } + } + + trailingTrivia = default; + return false; + } } } From 97c8d51c93471541320eef5d6bc5ff2e6ee34f33 Mon Sep 17 00:00:00 2001 From: Jihoon Park Date: Wed, 5 Jun 2024 20:05:32 -0400 Subject: [PATCH 02/12] Fix build failures on NUnit 3 --- .../IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs | 4 ++++ .../IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs | 4 ++++ .../IsNullAndNullClassicModelAssertUsageCodeFixTests.cs | 4 ++++ .../IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs | 4 ++++ ...TrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs | 4 ++++ 5 files changed, 20 insertions(+) diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs index 63642ed6..1fd516a1 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs @@ -6,7 +6,11 @@ using NUnit.Analyzers.ClassicModelAssertUsage; using NUnit.Analyzers.Constants; using NUnit.Framework; +#if NUNIT4 using NUnit.Framework.Legacy; +#else +using ClassicAssert = NUnit.Framework.Assert; +#endif namespace NUnit.Analyzers.Tests.ClassicModelAssertUsage { diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs index 1c64e5fb..c7890944 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs @@ -6,7 +6,11 @@ using NUnit.Analyzers.ClassicModelAssertUsage; using NUnit.Analyzers.Constants; using NUnit.Framework; +#if NUNIT4 using NUnit.Framework.Legacy; +#else +using ClassicAssert = NUnit.Framework.Assert; +#endif namespace NUnit.Analyzers.Tests.ClassicModelAssertUsage { diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs index 7a0cb78b..5eade86e 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs @@ -6,7 +6,11 @@ using NUnit.Analyzers.ClassicModelAssertUsage; using NUnit.Analyzers.Constants; using NUnit.Framework; +#if NUNIT4 using NUnit.Framework.Legacy; +#else +using ClassicAssert = NUnit.Framework.Assert; +#endif namespace NUnit.Analyzers.Tests.ClassicModelAssertUsage { diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs index 2dd739d0..b10a0676 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs @@ -6,7 +6,11 @@ using NUnit.Analyzers.ClassicModelAssertUsage; using NUnit.Analyzers.Constants; using NUnit.Framework; +#if NUNIT4 using NUnit.Framework.Legacy; +#else +using ClassicAssert = NUnit.Framework.Assert; +#endif namespace NUnit.Analyzers.Tests.ClassicModelAssertUsage { diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs index 8f655242..cc841562 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs @@ -6,7 +6,11 @@ using NUnit.Analyzers.ClassicModelAssertUsage; using NUnit.Analyzers.Constants; using NUnit.Framework; +#if NUNIT4 using NUnit.Framework.Legacy; +#else +using ClassicAssert = NUnit.Framework.Assert; +#endif namespace NUnit.Analyzers.Tests.ClassicModelAssertUsage { From 77929e16c17ba86767493a191ed64378ec7e3c55 Mon Sep 17 00:00:00 2001 From: Jihoon Park Date: Sun, 9 Jun 2024 22:16:16 -0400 Subject: [PATCH 03/12] Centralize the trivia handling logic to ClassicModelAssertUsageCodeFix; add more tests --- ...qualClassicModelAssertUsageCodeFixTests.cs | 16 ++++ ...qualClassicModelAssertUsageCodeFixTests.cs | 16 ++++ ...SameClassicModelAssertUsageCodeFixTests.cs | 28 ++++++ ...SameClassicModelAssertUsageCodeFixTests.cs | 35 ++++++- ...ainsClassicModelAssertUsageCodeFixTests.cs | 29 ++++++ ...aterClassicModelAssertUsageCodeFixTests.cs | 23 +++++ ...qualClassicModelAssertUsageCodeFixTests.cs | 22 +++++ ...mptyClassicModelAssertUsageCodeFixTests.cs | 24 +++++ ...alseClassicModelAssertUsageCodeFixTests.cs | 25 +++++ ...ceOfClassicModelAssertUsageCodeFixTests.cs | 24 +++++ ...sNaNClassicModelAssertUsageCodeFixTests.cs | 24 +++++ ...mptyClassicModelAssertUsageCodeFixTests.cs | 24 +++++ ...ceOfClassicModelAssertUsageCodeFixTests.cs | 24 +++++ ...NullClassicModelAssertUsageCodeFixTests.cs | 27 ++++++ ...NullClassicModelAssertUsageCodeFixTests.cs | 27 ++++++ ...TrueClassicModelAssertUsageCodeFixTests.cs | 25 +++++ ...icModelAssertUsageCondensedCodeFixTests.cs | 25 +++++ ...LessClassicModelAssertUsageCodeFixTests.cs | 22 +++++ ...qualClassicModelAssertUsageCodeFixTests.cs | 22 +++++ ...ZeroClassicModelAssertUsageCodeFixTests.cs | 25 +++++ ...ZeroClassicModelAssertUsageCodeFixTests.cs | 25 +++++ .../CollectionAssertUsageAnalyzerTests.cs | 1 + .../CollectionAssertUsageCodeFixTests.cs | 46 ++++++++++ .../ComparisonConstraintUsageCodeFixTests.cs | 91 ++++++++++++------- .../EqualConstraintUsageCodeFixTests.cs | 18 ++++ .../SomeItemsConstraintUsageCodeFixTests.cs | 18 ++++ .../StringConstraintUsageCodeFixTests.cs | 37 +++++++- .../AreEqualClassicModelAssertUsageCodeFix.cs | 4 +- ...eNotEqualClassicModelAssertUsageCodeFix.cs | 2 +- ...reNotSameClassicModelAssertUsageCodeFix.cs | 2 +- .../AreSameClassicModelAssertUsageCodeFix.cs | 2 +- .../ClassicModelAssertUsageCodeFix.cs | 18 +++- .../ContainsClassicModelAssertUsageCodeFix.cs | 4 +- .../GreaterClassicModelAssertUsageCodeFix.cs | 2 +- ...erOrEqualClassicModelAssertUsageCodeFix.cs | 2 +- .../IsEmptyClassicModelAssertUsageCodeFix.cs | 2 +- ...eAndFalseClassicModelAssertUsageCodeFix.cs | 8 +- ...nstanceOfClassicModelAssertUsageCodeFix.cs | 4 +- .../IsNaNClassicModelAssertUsageCodeFix.cs | 2 +- ...sNotEmptyClassicModelAssertUsageCodeFix.cs | 2 +- ...nstanceOfClassicModelAssertUsageCodeFix.cs | 4 +- ...ndNotNullClassicModelAssertUsageCodeFix.cs | 2 +- ...llAndNullClassicModelAssertUsageCodeFix.cs | 2 +- ...ueAndTrueClassicModelAssertUsageCodeFix.cs | 2 +- .../LessClassicModelAssertUsageCodeFix.cs | 2 +- ...ssOrEqualClassicModelAssertUsageCodeFix.cs | 2 +- .../NotZeroClassicModelAssertUsageCodeFix.cs | 2 +- .../ZeroClassicModelAssertUsageCodeFix.cs | 2 +- .../CollectionAssertUsageCodeFix.cs | 2 +- .../EqualConstraintUsageCodeFix.cs | 5 +- .../SomeItemsConstraintUsageCodeFix.cs | 7 +- .../StringConstraintUsageCodeFix.cs | 5 +- .../ArgumentListSyntaxExtensions.cs | 13 ++- 53 files changed, 735 insertions(+), 92 deletions(-) diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs index 4e86d833..47a8b1a5 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs @@ -337,5 +337,21 @@ public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] boo RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapInTestMethod($@" + ↓ClassicAssert.AreEqual( + 2d, 3d, 0.0000001d{optionalNewline});"); + + var fixedCode = TestUtility.WrapInTestMethod($@" + Assert.That( + 3d, Is.EqualTo(2d).Within(0.0000001d){optionalNewline});"); + + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFixTests.cs index fc13672d..f6d76020 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFixTests.cs @@ -145,5 +145,21 @@ public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] boo RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapInTestMethod($@" + ↓ClassicAssert.AreNotEqual( + 2d, 3d{optionalNewline});"); + + var fixedCode = TestUtility.WrapInTestMethod($@" + Assert.That( + 3d, Is.Not.EqualTo(2d){optionalNewline});"); + + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFixTests.cs index 945846ff..2d288cef 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFixTests.cs @@ -195,5 +195,33 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expected = new object(); + var actual = new object(); + + ↓ClassicAssert.AreNotSame( + expected, actual{optionalNewline}); + }}"); + + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expected = new object(); + var actual = new object(); + + Assert.That( + actual, Is.Not.SameAs(expected){optionalNewline}); + }}"); + + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs index ec069870..32260a7f 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs @@ -179,8 +179,7 @@ public void TestMethod() ↓ClassicAssert.AreSame( expected, - actual, - ""message"" + actual{commaAndMessage} ); }}"); var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" @@ -191,11 +190,39 @@ public void TestMethod() Assert.That( actual, - Is.SameAs(expected), - ""message"" + Is.SameAs(expected){commaAndMessage} ); }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expected = new object(); + var actual = new object(); + + ↓ClassicAssert.AreSame( + expected, + actual{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expected = new object(); + var actual = new object(); + + Assert.That( + actual, + Is.SameAs(expected){optionalNewline}); + }}"); + + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs index acd1de81..f123ae9a 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs @@ -195,5 +195,34 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, instanceDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var instance = new object(); + var collection = Array.Empty(); + + ↓ClassicAssert.Contains( + instance, + collection{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var instance = new object(); + var collection = Array.Empty(); + + Assert.That( + collection, + Does.Contain(instance){optionalNewline}); + }}"); + + RoslynAssert.CodeFix(analyzer, fix, instanceDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFixTests.cs index a9761f2d..228018c8 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFixTests.cs @@ -281,5 +281,28 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.Greater( + 2d, + 3d{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + 2d, + Is.GreaterThan(3d){optionalNewline}); + }}"); + + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs index 3afb230f..c432c53a 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs @@ -281,5 +281,27 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.GreaterOrEqual( + 2d, + 3d{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + 2d, + Is.GreaterThanOrEqualTo(3d){optionalNewline}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFixTests.cs index f81d3e72..9fbc2651 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFixTests.cs @@ -215,5 +215,29 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var collection = Array.Empty(); + + ↓ClassicAssert.IsEmpty( + collection, ""message""{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var collection = Array.Empty(); + + Assert.That( + collection, Is.Empty, ""message""{optionalNewline}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs index 1fd516a1..b9691849 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs @@ -226,5 +226,30 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine( + [ValueSource(nameof(diagnosticIds))] string diagnosticId, + [Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var assertion = diagnosticIdsToAssertions[diagnosticId]; + var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.{assertion}( + false, ""message""{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + false, Is.False, ""message""{optionalNewline}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFixTests.cs index 0a63d344..a7aa7b11 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFixTests.cs @@ -415,5 +415,29 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var actual = 42; + + ↓ClassicAssert.IsInstanceOf( + actual, ""message""{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var actual = 42; + + Assert.That( + actual, Is.InstanceOf(), ""message""{optionalNewline}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFixTests.cs index 9088ac71..c968d35c 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFixTests.cs @@ -179,5 +179,29 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = double.NaN; + + ↓ClassicAssert.IsNaN( + expr, ""message""{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = double.NaN; + + Assert.That( + expr, Is.NaN, ""message""{optionalNewline}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFixTests.cs index e54797a9..1d451d80 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFixTests.cs @@ -251,5 +251,29 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var collection = Array.Empty(); + + ↓ClassicAssert.IsNotEmpty( + collection, ""message""{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var collection = Array.Empty(); + + Assert.That( + collection, Is.Not.Empty, ""message""{optionalNewline}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs index 1136a02d..a1f2886f 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs @@ -388,5 +388,29 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var actual = 42; + + ↓ClassicAssert.IsNotInstanceOf( + actual, ""message""{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var actual = 42; + + Assert.That( + actual, Is.Not.InstanceOf(), ""message""{optionalNewline}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs index c7890944..37861c1e 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs @@ -201,5 +201,32 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine( + [ValueSource(nameof(diagnosticIds))] string diagnosticId, + [Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var assertion = diagnosticIdsToAssertions[diagnosticId]; + var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + object? obj = null; + ↓ClassicAssert.{assertion}( + obj, ""message""{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + object? obj = null; + Assert.That( + obj, Is.Not.Null, ""message""{optionalNewline}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs index 5eade86e..b400b95d 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs @@ -201,5 +201,32 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine( + [ValueSource(nameof(diagnosticIds))] string diagnosticId, + [Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var assertion = diagnosticIdsToAssertions[diagnosticId]; + var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + object? obj = null; + ↓ClassicAssert.{assertion}( + obj, ""message""{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + object? obj = null; + Assert.That( + obj, Is.Null, ""message""{optionalNewline}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs index b10a0676..21cf85ff 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs @@ -265,5 +265,30 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine( + [ValueSource(nameof(diagnosticIds))] string diagnosticId, + [Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var assertion = diagnosticIdsToAssertions[diagnosticId]; + var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.{assertion}( + true, ""message""{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + true, Is.True, ""message""{optionalNewline}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs index cc841562..e8176245 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs @@ -192,5 +192,30 @@ public void TestMethod() RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription + IsTrueAndTrueClassicModelAssertUsageCondensedCodeFix.Suffix); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine( + [ValueSource(nameof(diagnosticIds))] string diagnosticId, + [Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var assertion = diagnosticIdsToAssertions[diagnosticId]; + var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.{assertion}( + true, ""message""{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + true, ""message""{optionalNewline}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription + IsTrueAndTrueClassicModelAssertUsageCondensedCodeFix.Suffix); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFixTests.cs index 9380fff3..ffdeebab 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFixTests.cs @@ -281,5 +281,27 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.Less( + 2d, + 3d{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + 2d, + Is.LessThan(3d){optionalNewline}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFixTests.cs index 99d1f17e..5527feff 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFixTests.cs @@ -281,5 +281,27 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + ↓ClassicAssert.LessOrEqual( + 2d, + 3d{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + Assert.That( + 2d, + Is.LessThanOrEqualTo(3d){optionalNewline}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFixTests.cs index 66fb1ef5..1aed1c29 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFixTests.cs @@ -179,5 +179,30 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = default(int); + + ↓ClassicAssert.NotZero( + expr, ""message""{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = default(int); + + Assert.That( + expr, Is.Not.Zero, ""message""{optionalNewline}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFixTests.cs index 1a4d4790..5f69c159 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFixTests.cs @@ -179,5 +179,30 @@ public void TestMethod() }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + + var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = default(int); + + ↓ClassicAssert.Zero( + expr, ""message""{optionalNewline}); + }}"); + var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" + public void TestMethod() + {{ + var expr = default(int); + + Assert.That( + expr, Is.Zero, ""message""{optionalNewline}); + }}"); + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } } } diff --git a/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageAnalyzerTests.cs b/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageAnalyzerTests.cs index 96d13729..e6b45990 100644 --- a/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageAnalyzerTests.cs +++ b/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageAnalyzerTests.cs @@ -1,6 +1,7 @@ using System.Collections.Generic; using Gu.Roslyn.Asserts; using Microsoft.CodeAnalysis.Diagnostics; +using NUnit.Analyzers.ClassicModelAssertUsage; using NUnit.Analyzers.CollectionAssertUsage; using NUnit.Analyzers.Constants; using NUnit.Framework; diff --git a/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageCodeFixTests.cs index 2edbc393..1478f096 100644 --- a/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageCodeFixTests.cs @@ -2,6 +2,7 @@ using Gu.Roslyn.Asserts; using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.Diagnostics; +using NUnit.Analyzers.ClassicModelAssertUsage; using NUnit.Analyzers.CollectionAssertUsage; using NUnit.Analyzers.Constants; using NUnit.Framework; @@ -455,6 +456,51 @@ public void AnalyzeCollectionAndItemWhenFormatAndParamsArgumentsAreUsedOutOfOrde RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode); } + [Test] + public void CodeFixForTwoCollectionParameterAssertsMaintainsReasonableTriviaWithAllArgumentsOnSameLine( + [ValueSource(nameof(TwoCollectionParameterAsserts))] string method, + [Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapInTestMethod(@$" + var collection1 = new[] {{ 1, 2, 3 }}; + var collection2 = new[] {{ 2, 4, 6 }}; + ↓CollectionAssert.{method}( + collection1, + collection2{optionalNewline});"); + var fixedCode = TestUtility.WrapInTestMethod(@$" + var collection1 = new[] {{ 1, 2, 3 }}; + var collection2 = new[] {{ 2, 4, 6 }}; + Assert.That( + {GetAdjustedTwoCollectionConstraint(method, insertNewline: true)}{optionalNewline});"); + + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + + [Test] + public void CodeFixForCollectionAndItemParameterAssertMaintainsReasonableTriviaWithAllArgumentsOnSameLine( + [ValueSource(nameof(CollectionAndItemParameterAsserts))] string method, + [Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapInTestMethod(@$" + var collection = new[] {{ typeof(byte), typeof(char) }}; + var expected = typeof(byte); + ↓CollectionAssert.{method}( + collection, + expected{optionalNewline});"); + var fixedCode = TestUtility.WrapInTestMethod(@$" + var collection = new[] {{ typeof(byte), typeof(char) }}; + var expected = typeof(byte); + Assert.That( + collection, + {CollectionAssertUsageAnalyzer.CollectionAndItemParameterAsserts[method]}{optionalNewline});"); + + RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); + } + private static string GetAdjustedTwoCollectionConstraint(string method, bool insertNewline = false) { (string actualArgument, string constraintArgument) = diff --git a/src/nunit.analyzers.tests/ConstraintsUsage/ComparisonConstraintUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ConstraintsUsage/ComparisonConstraintUsageCodeFixTests.cs index 7acafdb6..030faf91 100644 --- a/src/nunit.analyzers.tests/ConstraintsUsage/ComparisonConstraintUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ConstraintsUsage/ComparisonConstraintUsageCodeFixTests.cs @@ -1,4 +1,6 @@ +using System.Collections.Generic; using System.Globalization; +using System.Linq; using Gu.Roslyn.Asserts; using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.Diagnostics; @@ -12,13 +14,26 @@ public class ComparisonConstraintUsageCodeFixTests { private static readonly DiagnosticAnalyzer analyzer = new ComparisonConstraintUsageAnalyzer(); private static readonly CodeFixProvider fix = new ComparisonConstraintUsageCodeFix(); - - [TestCase(">=", "Is.GreaterThanOrEqualTo")] - [TestCase(">", "Is.GreaterThan")] - [TestCase("<=", "Is.LessThanOrEqualTo")] - [TestCase("<", "Is.LessThan")] - public void FixesComparisonOperator(string operatorToken, string constraint) + private static readonly Dictionary operatorTokensToConstraints = new() + { + { ">=", "Is.GreaterThanOrEqualTo" }, + { ">", "Is.GreaterThan" }, + { "<=", "Is.LessThanOrEqualTo" }, + { "<", "Is.LessThan" }, + }; + private static readonly string[] operatorTokens = operatorTokensToConstraints.Keys.ToArray(); + private static readonly Dictionary operatorTokensToConstraintsReversed = new() + { + { ">=", "Is.LessThan" }, + { ">", "Is.LessThanOrEqualTo" }, + { "<=", "Is.GreaterThan" }, + { "<", "Is.GreaterThanOrEqualTo" }, + }; + + [Test] + public void FixesComparisonOperator([ValueSource(nameof(operatorTokens))] string operatorToken) { + var constraint = operatorTokensToConstraints[operatorToken]; var code = TestUtility.WrapInTestMethod(@$" int actual = 5; Assert.That(↓actual {operatorToken} 9);"); @@ -33,12 +48,10 @@ public void FixesComparisonOperator(string operatorToken, string constraint) RoslynAssert.CodeFix(analyzer, fix, diagnostic, code, fixedCode); } - [TestCase(">=", "Is.GreaterThanOrEqualTo")] - [TestCase(">", "Is.GreaterThan")] - [TestCase("<=", "Is.LessThanOrEqualTo")] - [TestCase("<", "Is.LessThan")] - public void FixesComparisonOperatorWithIsTrue(string operatorToken, string constraint) + [Test] + public void FixesComparisonOperatorWithIsTrue([ValueSource(nameof(operatorTokens))] string operatorToken) { + var constraint = operatorTokensToConstraints[operatorToken]; var code = TestUtility.WrapInTestMethod(@$" int actual = 5; Assert.That(↓actual {operatorToken} 9, Is.True);"); @@ -53,12 +66,10 @@ public void FixesComparisonOperatorWithIsTrue(string operatorToken, string const RoslynAssert.CodeFix(analyzer, fix, diagnostic, code, fixedCode); } - [TestCase(">=", "Is.LessThan")] - [TestCase(">", "Is.LessThanOrEqualTo")] - [TestCase("<=", "Is.GreaterThan")] - [TestCase("<", "Is.GreaterThanOrEqualTo")] - public void FixesWhenComparisonOperatorUsedWithIsFalse(string operatorToken, string constraint) + [Test] + public void FixesWhenComparisonOperatorUsedWithIsFalse([ValueSource(nameof(operatorTokens))] string operatorToken) { + var constraint = operatorTokensToConstraintsReversed[operatorToken]; var code = TestUtility.WrapInTestMethod(@$" int actual = 5; Assert.That(↓actual {operatorToken} 9, Is.False);"); @@ -73,12 +84,10 @@ public void FixesWhenComparisonOperatorUsedWithIsFalse(string operatorToken, str RoslynAssert.CodeFix(analyzer, fix, diagnostic, code, fixedCode); } - [TestCase(">=", "Is.LessThan")] - [TestCase(">", "Is.LessThanOrEqualTo")] - [TestCase("<=", "Is.GreaterThan")] - [TestCase("<", "Is.GreaterThanOrEqualTo")] - public void FixesWhenComparisonOperatorUseConstantOnLeftHandSide(string operatorToken, string constraint) + [Test] + public void FixesWhenComparisonOperatorUseConstantOnLeftHandSide([ValueSource(nameof(operatorTokens))] string operatorToken) { + var constraint = operatorTokensToConstraintsReversed[operatorToken]; var code = TestUtility.WrapInTestMethod(@$" int actual = 5; Assert.That(↓9 {operatorToken} actual, Is.True);"); @@ -93,12 +102,10 @@ public void FixesWhenComparisonOperatorUseConstantOnLeftHandSide(string operator RoslynAssert.CodeFix(analyzer, fix, diagnostic, code, fixedCode); } - [TestCase(">=", "Is.LessThan")] - [TestCase(">", "Is.LessThanOrEqualTo")] - [TestCase("<=", "Is.GreaterThan")] - [TestCase("<", "Is.GreaterThanOrEqualTo")] - public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen(string operatorToken, string constraint) + [Test] + public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([ValueSource(nameof(operatorTokens))] string operatorToken) { + var constraint = operatorTokensToConstraintsReversed[operatorToken]; var code = TestUtility.WrapInTestMethod(@$" int actual = 5; Assert.That( @@ -117,12 +124,10 @@ public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen(string ope RoslynAssert.CodeFix(analyzer, fix, diagnostic, code, fixedCode); } - [TestCase(">=", "Is.GreaterThanOrEqualTo")] - [TestCase(">", "Is.GreaterThan")] - [TestCase("<=", "Is.LessThanOrEqualTo")] - [TestCase("<", "Is.LessThan")] - public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen(string operatorToken, string constraint) + [Test] + public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([ValueSource(nameof(operatorTokens))] string operatorToken) { + var constraint = operatorTokensToConstraints[operatorToken]; var code = TestUtility.WrapInTestMethod(@$" int actual = 5; Assert.That( @@ -141,5 +146,29 @@ public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen(string opera RoslynAssert.CodeFix(analyzer, fix, diagnostic, code, fixedCode); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine( + [ValueSource(nameof(operatorTokens))] string operatorToken, + [Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var constraint = operatorTokensToConstraints[operatorToken]; + var code = TestUtility.WrapInTestMethod(@$" + int actual = 5; + Assert.That( + ↓actual {operatorToken} 9, ""message""{optionalNewline});"); + + var fixedCode = TestUtility.WrapInTestMethod(@$" + int actual = 5; + Assert.That( + actual, {constraint}(9), ""message""{optionalNewline});"); + + var diagnostic = ExpectedDiagnostic.Create(AnalyzerIdentifiers.ComparisonConstraintUsage, + string.Format(CultureInfo.InvariantCulture, ComparisonConstraintUsageConstants.Message, constraint)); + + RoslynAssert.CodeFix(analyzer, fix, diagnostic, code, fixedCode); + } } } diff --git a/src/nunit.analyzers.tests/ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs index 3dd48a47..220180bc 100644 --- a/src/nunit.analyzers.tests/ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs @@ -351,5 +351,23 @@ public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] boo RoslynAssert.CodeFix(analyzer, fix, equalConstraintDiagnostic, code, fixedCode); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapInTestMethod($@" + var actual = ""abc""; + Assert.That( + actual.Equals(""abc""), Is.True{optionalNewline});"); + + var fixedCode = TestUtility.WrapInTestMethod($@" + var actual = ""abc""; + Assert.That( + actual, Is.EqualTo(""abc""){optionalNewline});"); + + RoslynAssert.CodeFix(analyzer, fix, equalConstraintDiagnostic, code, fixedCode); + } } } diff --git a/src/nunit.analyzers.tests/ConstraintsUsage/SomeItemsConstraintUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ConstraintsUsage/SomeItemsConstraintUsageCodeFixTests.cs index cc7948d8..1fba9572 100644 --- a/src/nunit.analyzers.tests/ConstraintsUsage/SomeItemsConstraintUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ConstraintsUsage/SomeItemsConstraintUsageCodeFixTests.cs @@ -139,5 +139,23 @@ public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen() RoslynAssert.CodeFix(analyzer, fix, doesNotContainDiagnostic, testCode, fixedCode); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) + { + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var testCode = TestUtility.WrapInTestMethod($@" + ClassicAssert.IsFalse( + ↓new[] {{ 1, 2, 3 }}.Contains(1), ""message""{optionalNewline});", + additionalUsings: "using System.Linq;"); + + var fixedCode = TestUtility.WrapInTestMethod($@" + Assert.That( + new[] {{ 1, 2, 3 }}, Does.Not.Contain(1), ""message""{optionalNewline});", + additionalUsings: "using System.Linq;"); + + RoslynAssert.CodeFix(analyzer, fix, doesNotContainDiagnostic, testCode, fixedCode); + } } } diff --git a/src/nunit.analyzers.tests/ConstraintsUsage/StringConstraintUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ConstraintsUsage/StringConstraintUsageCodeFixTests.cs index 7da1d63b..7b17cbd5 100644 --- a/src/nunit.analyzers.tests/ConstraintsUsage/StringConstraintUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ConstraintsUsage/StringConstraintUsageCodeFixTests.cs @@ -1,3 +1,5 @@ +using System.Collections.Generic; +using System.Linq; using Gu.Roslyn.Asserts; using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.Diagnostics; @@ -19,11 +21,18 @@ public class StringConstraintUsageCodeFixTests new[] { nameof(string.EndsWith), AnalyzerIdentifiers.StringEndsWithConstraintUsage, "Does.EndWith" } }; - private static readonly object[] NegativeAssertData = new[] + private static readonly Dictionary NegativeAssertDictionary = new() { - new[] { nameof(string.Contains), AnalyzerIdentifiers.StringContainsConstraintUsage, "Does.Not.Contain" }, - new[] { nameof(string.StartsWith), AnalyzerIdentifiers.StringStartsWithConstraintUsage, "Does.Not.StartWith" }, - new[] { nameof(string.EndsWith), AnalyzerIdentifiers.StringEndsWithConstraintUsage, "Does.Not.EndWith" } + { nameof(string.Contains), new[] { nameof(string.Contains), AnalyzerIdentifiers.StringContainsConstraintUsage, "Does.Not.Contain" } }, + { nameof(string.StartsWith), new[] { nameof(string.StartsWith), AnalyzerIdentifiers.StringStartsWithConstraintUsage, "Does.Not.StartWith" } }, + { nameof(string.EndsWith), new[] { nameof(string.EndsWith), AnalyzerIdentifiers.StringEndsWithConstraintUsage, "Does.Not.EndWith" } }, + }; + private static readonly object[] NegativeAssertData = NegativeAssertDictionary.Values.ToArray(); + private static readonly string[] StringConstraints = new[] + { + nameof(string.Contains), + nameof(string.StartsWith), + nameof(string.EndsWith), }; [TestCaseSource(nameof(PositiveAssertData))] @@ -154,5 +163,25 @@ public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen(string metho RoslynAssert.CodeFix(analyzer, fix, ExpectedDiagnostic.Create(analyzerId), code, fixedCode); } + + [Test] + public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine( + [ValueSource(nameof(StringConstraints))] string method, + [Values] bool newlineBeforeClosingParen) + { + var analyzerId = NegativeAssertDictionary[method][1]; + var suggestedConstraint = NegativeAssertDictionary[method][2]; + var optionalNewline = newlineBeforeClosingParen ? @" + " : string.Empty; + var code = TestUtility.WrapInTestMethod($@" + Assert.That( + ↓""abc"".{method}(""ab""), Is.False{optionalNewline});"); + + var fixedCode = TestUtility.WrapInTestMethod($@" + Assert.That( + ""abc"", {suggestedConstraint}(""ab""){optionalNewline});"); + + RoslynAssert.CodeFix(analyzer, fix, ExpectedDiagnostic.Create(analyzerId), code, fixedCode); + } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFix.cs index f349eae3..c52e099f 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFix.cs @@ -27,7 +27,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsEqualTo))) .WithArgumentList(SyntaxFactory.ArgumentList( - SyntaxFactory.SingletonSeparatedList(expectedArgument))); + SyntaxFactory.SingletonSeparatedList(expectedArgument.WithoutTrivia()))); // The tolerance argument has to be added to the "Is.EqualTo(expected)" as ".Within(tolerance)" if (argumentNamesToArguments.TryGetValue(NUnitFrameworkConstants.NameOfDeltaParameter, out var toleranceArgument)) @@ -46,7 +46,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg } var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, SyntaxFactory.Argument(equalToInvocationNode).WithTriviaFrom(actualArgument)); + return (actualArgument, SyntaxFactory.Argument(equalToInvocationNode)); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFix.cs index c1b54685..55c2f91d 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFix.cs @@ -34,7 +34,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.SingletonSeparatedList(expectedArgument)))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument.WithoutTrailingTrivia(), constraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFix.cs index 92b8f3bf..f632ea51 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFix.cs @@ -34,7 +34,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.SingletonSeparatedList(expectedArgument)))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFix.cs index 58fa6725..d1340ab1 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFix.cs @@ -31,7 +31,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.SingletonSeparatedList(expectedArgument)))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/ClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/ClassicModelAssertUsageCodeFix.cs index 7067ee86..0d0e1a25 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/ClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/ClassicModelAssertUsageCodeFix.cs @@ -77,12 +77,20 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) if (CodeFixHelper.GetInterpolatedMessageArgumentOrDefault(messageArgument, args, unconditional: false, argsIsArray) is ArgumentSyntax interpolatedMessageArgument) newArguments.Add(interpolatedMessageArgument); - // Fix trailing trivia for the first and the last argument - if (newArguments.Count > 1) - newArguments[0] = newArguments[0].WithoutTrailingTrivia(); + // Fix trailing trivia for new argument based on the old arguments + var oldArguments = invocationNode.ArgumentList.Arguments.ToList(); + newArguments[0] = newArguments[0].WithTriviaFrom(oldArguments[0]) + .WithoutTrailingTrivia(); + + if (oldArguments.Count > 1 && newArguments.Count > 1) + { + newArguments[1] = newArguments[1].WithTriviaFrom(oldArguments[1]) + .WithoutTrailingTrivia(); + } + var lastIndex = newArguments.Count - 1; - var previousLastArgument = invocationNode.ArgumentList.Arguments.Last(); - newArguments[lastIndex] = newArguments[lastIndex].WithTrailingTrivia(previousLastArgument.GetTrailingTrivia()); + newArguments[lastIndex] = newArguments[lastIndex] + .WithTriviaFrom(oldArguments.Last()); var newArgumentsList = invocationNode.ArgumentList.WithArguments(newArguments); newInvocationNode = newInvocationNode.WithArgumentList(newArgumentsList); diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFix.cs index afd5ef40..760d9313 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFix.cs @@ -28,10 +28,10 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfDoes), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfDoesContain))) .WithArgumentList(SyntaxFactory.ArgumentList( - SyntaxFactory.SingletonSeparatedList(expectedArgument)))); + SyntaxFactory.SingletonSeparatedList(expectedArgument.WithoutTrivia())))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFix.cs index 3c45bbea..46857334 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFix.cs @@ -31,7 +31,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.SingletonSeparatedList(arg2Argument.WithoutTrivia())))); var arg1Argument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfArg1Parameter].WithNameColon(null); - return (arg1Argument, constraintArgument.WithTriviaFrom(arg1Argument)); + return (arg1Argument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFix.cs index 3a05a2fe..c743bf12 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFix.cs @@ -31,7 +31,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.SingletonSeparatedList(arg2Argument.WithoutTrivia())))); var arg1Argument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfArg1Parameter].WithNameColon(null); - return (arg1Argument, constraintArgument.WithTriviaFrom(arg1Argument)); + return (arg1Argument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFix.cs index 5dc55bac..3adb8b76 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFix.cs @@ -32,7 +32,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsEmpty))); - return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFix.cs index a5f3fa43..e52debad 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFix.cs @@ -27,12 +27,8 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), - SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsFalse))) - .WithTriviaFrom(actualArgument); - - // Swallow the trailing trivia of actualArgument because the comma should immediately follow it - // This also removes comments, but ignore them for now. - return (actualArgument.WithoutTrailingTrivia(), constraintArgument); + SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsFalse))); + return (actualArgument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFix.cs index fd46d5d9..dc3a59ae 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFix.cs @@ -29,7 +29,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax ConstraintArgu SyntaxFactory.GenericName(NUnitFrameworkConstants.NameOfIsInstanceOf) .WithTypeArgumentList(typeArguments)))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, constraintArgument); } protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArgument) ConstructActualAndConstraintArguments( @@ -47,7 +47,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.SingletonSeparatedList(expectedArgument)))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFix.cs index fd346de1..81295efc 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFix.cs @@ -27,7 +27,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsNaN))); - return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFix.cs index dfa2fb7b..3f0a7724 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFix.cs @@ -34,7 +34,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsNot)), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsEmpty))); - return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFix.cs index 7c4b54bf..39cb57c1 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFix.cs @@ -32,7 +32,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax ConstraintArgu SyntaxFactory.GenericName(NUnitFrameworkConstants.NameOfIsInstanceOf) .WithTypeArgumentList(typeArguments)))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, constraintArgument); } protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArgument) ConstructActualAndConstraintArguments( @@ -53,7 +53,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.SingletonSeparatedList(expectedArgument)))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfActualParameter].WithNameColon(null); - return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFix.cs index c31b4e9d..8d5f9ea9 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFix.cs @@ -32,7 +32,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsNull))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfAnObjectParameter].WithNameColon(null); - return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFix.cs index 5f5137bb..908ee2cb 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFix.cs @@ -29,7 +29,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsNull))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfAnObjectParameter].WithNameColon(null); - return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFix.cs index 9f7d0c05..2eb25e67 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFix.cs @@ -29,7 +29,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsTrue))); var actualArgument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfConditionParameter].WithNameColon(null); - return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFix.cs index efc8263b..1d60a39b 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFix.cs @@ -31,7 +31,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.SingletonSeparatedList(arg2Argument.WithoutTrivia())))); var arg1Argument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfArg1Parameter].WithNameColon(null); - return (arg1Argument, constraintArgument.WithTriviaFrom(arg1Argument)); + return (arg1Argument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFix.cs index 7a43f69f..19959efb 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFix.cs @@ -31,7 +31,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.SingletonSeparatedList(arg2Argument.WithoutTrivia())))); var arg1Argument = argumentNamesToArguments[NUnitFrameworkConstants.NameOfArg1Parameter].WithNameColon(null); - return (arg1Argument, constraintArgument.WithTriviaFrom(arg1Argument)); + return (arg1Argument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFix.cs index 05ec00cf..c76db4cf 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFix.cs @@ -30,7 +30,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsNot)), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsZero))); - return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, constraintArgument); } } } diff --git a/src/nunit.analyzers/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFix.cs b/src/nunit.analyzers/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFix.cs index 9a9e0ec4..4eb547d9 100644 --- a/src/nunit.analyzers/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFix.cs @@ -27,7 +27,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIs), SyntaxFactory.IdentifierName(NUnitFrameworkConstants.NameOfIsZero))); - return (actualArgument, constraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, constraintArgument); } } } diff --git a/src/nunit.analyzers/CollectionAssertUsage/CollectionAssertUsageCodeFix.cs b/src/nunit.analyzers/CollectionAssertUsage/CollectionAssertUsageCodeFix.cs index c1694864..f179ce2a 100644 --- a/src/nunit.analyzers/CollectionAssertUsage/CollectionAssertUsageCodeFix.cs +++ b/src/nunit.analyzers/CollectionAssertUsage/CollectionAssertUsageCodeFix.cs @@ -116,7 +116,7 @@ protected override (ArgumentSyntax ActualArgument, ArgumentSyntax? ConstraintArg ArgumentList(SingletonSeparatedList(comparerArgument)))); } - return (actualArgument.WithoutTrailingTrivia(), newConstraintArgument.WithTriviaFrom(actualArgument)); + return (actualArgument, newConstraintArgument); } private static (ArgumentSyntax actualArgument, ArgumentSyntax constraintArgument) GetActualAndConstraintArguments( diff --git a/src/nunit.analyzers/ConstraintUsage/EqualConstraintUsageCodeFix.cs b/src/nunit.analyzers/ConstraintUsage/EqualConstraintUsageCodeFix.cs index 91c9438b..cc059520 100644 --- a/src/nunit.analyzers/ConstraintUsage/EqualConstraintUsageCodeFix.cs +++ b/src/nunit.analyzers/ConstraintUsage/EqualConstraintUsageCodeFix.cs @@ -35,10 +35,7 @@ protected override (ExpressionSyntax? actual, ExpressionSyntax? constraintExpres constraintExpression = null; } - // Fix trivia - return actual is not null && constraintExpression is not null - ? (actual.WithTriviaFrom(constraintExpression), constraintExpression.WithTriviaFrom(actual)) - : (actual, constraintExpression); + return (actual, constraintExpression); } private static (ExpressionSyntax? actual, ExpressionOrPatternSyntax? expected) GetActualExpected(SyntaxNode conditionNode) diff --git a/src/nunit.analyzers/ConstraintUsage/SomeItemsConstraintUsageCodeFix.cs b/src/nunit.analyzers/ConstraintUsage/SomeItemsConstraintUsageCodeFix.cs index 34a62194..026c3e49 100644 --- a/src/nunit.analyzers/ConstraintUsage/SomeItemsConstraintUsageCodeFix.cs +++ b/src/nunit.analyzers/ConstraintUsage/SomeItemsConstraintUsageCodeFix.cs @@ -23,12 +23,7 @@ protected override (ExpressionSyntax? actual, ExpressionSyntax? constraintExpres var expected = invocation.ArgumentList.Arguments.FirstOrDefault()?.Expression; var constraintExpression = GetConstraintExpression(suggestedConstraintString, expected); - // Fix trivia - return ( - actual, - constraintExpression is not null - ? constraintExpression.WithTriviaFrom(conditionNode) - : constraintExpression); + return (actual, constraintExpression); } else { diff --git a/src/nunit.analyzers/ConstraintUsage/StringConstraintUsageCodeFix.cs b/src/nunit.analyzers/ConstraintUsage/StringConstraintUsageCodeFix.cs index 6a950c64..59031cff 100644 --- a/src/nunit.analyzers/ConstraintUsage/StringConstraintUsageCodeFix.cs +++ b/src/nunit.analyzers/ConstraintUsage/StringConstraintUsageCodeFix.cs @@ -26,10 +26,7 @@ protected override (ExpressionSyntax? actual, ExpressionSyntax? constraintExpres var expected = invocation.ArgumentList.Arguments.FirstOrDefault()?.Expression; var constraintExpression = GetConstraintExpression(suggestedConstraintString, expected); - // Fix trivia - return actual is not null && constraintExpression is not null - ? (actual.WithTriviaFrom(constraintExpression), constraintExpression.WithTriviaFrom(actual)) - : (actual, constraintExpression); + return (actual, constraintExpression); } else { diff --git a/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs b/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs index 4f606afb..9cafb151 100644 --- a/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs +++ b/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs @@ -54,12 +54,17 @@ public static ArgumentListSyntax WithArguments( private static bool TryGetFirstEndOfLineTrivia(SyntaxToken openParenToken, SyntaxToken[] separators, out SyntaxTrivia trailingTrivia) { - foreach (var trivia in openParenToken.TrailingTrivia) + // If there's only one argument, there are no separators. + // Therefore, use the trailing trivia of the opening parenthesis into account to make our best guess. + if (separators.Length == 0) { - if (trivia.IsKind(SyntaxKind.EndOfLineTrivia)) + foreach (var trivia in openParenToken.TrailingTrivia) { - trailingTrivia = trivia; - return true; + if (trivia.IsKind(SyntaxKind.EndOfLineTrivia)) + { + trailingTrivia = trivia; + return true; + } } } From a613e4c600171cb3137732031d06a3fd967bd0e2 Mon Sep 17 00:00:00 2001 From: Jihoon Park Date: Sun, 16 Jun 2024 14:10:19 -0400 Subject: [PATCH 04/12] PR feedback - add an else block --- .../Extensions/ArgumentListSyntaxExtensions.cs | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs b/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs index 9cafb151..a8042a97 100644 --- a/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs +++ b/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs @@ -67,15 +67,17 @@ private static bool TryGetFirstEndOfLineTrivia(SyntaxToken openParenToken, Synta } } } - - foreach (var separator in separators) + else { - foreach (var trivia in separator.TrailingTrivia) + foreach (var separator in separators) { - if (trivia.IsKind(SyntaxKind.EndOfLineTrivia)) + foreach (var trivia in separator.TrailingTrivia) { - trailingTrivia = trivia; - return true; + if (trivia.IsKind(SyntaxKind.EndOfLineTrivia)) + { + trailingTrivia = trivia; + return true; + } } } } From 3f976aece02d5495a5aef575aa408cc0ca8cb0ee Mon Sep 17 00:00:00 2001 From: Jihoon Park Date: Sun, 16 Jun 2024 14:21:59 -0400 Subject: [PATCH 05/12] Move .WithAdditionalAnnotations(Formatter.Annotation) to the extendion method WithArguments --- .../ConstraintUsage/BaseConditionConstraintCodeFix.cs | 5 +---- .../Extensions/ArgumentListSyntaxExtensions.cs | 7 +++++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/nunit.analyzers/ConstraintUsage/BaseConditionConstraintCodeFix.cs b/src/nunit.analyzers/ConstraintUsage/BaseConditionConstraintCodeFix.cs index 043dcc4b..ebca8140 100644 --- a/src/nunit.analyzers/ConstraintUsage/BaseConditionConstraintCodeFix.cs +++ b/src/nunit.analyzers/ConstraintUsage/BaseConditionConstraintCodeFix.cs @@ -8,7 +8,6 @@ using Microsoft.CodeAnalysis.CodeFixes; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; -using Microsoft.CodeAnalysis.Formatting; using NUnit.Analyzers.Extensions; using NUnit.Analyzers.Helpers; using static NUnit.Analyzers.Constants.NUnitFrameworkConstants; @@ -144,9 +143,7 @@ protected virtual (ExpressionSyntax? actual, ExpressionSyntax? constraintExpress constraintArgumentWithRightTrivia }.Union(remainingArguments); - var newArgumentsList = assertNode.ArgumentList - .WithArguments(newArguments) - .WithAdditionalAnnotations(Formatter.Annotation); + var newArgumentsList = assertNode.ArgumentList.WithArguments(newArguments); return newAssertNode.WithArgumentList(newArgumentsList); } diff --git a/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs b/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs index a8042a97..cb2761d7 100644 --- a/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs +++ b/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs @@ -3,6 +3,7 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; +using Microsoft.CodeAnalysis.Formatting; namespace NUnit.Analyzers.Extensions { @@ -18,7 +19,8 @@ public static ArgumentListSyntax WithArguments( // To match the old style as closely as possible, do not attempt anything if the number of arguments stayed the same if (originalArguments.Count == newArguments.Count()) { - return @this.WithArguments(SyntaxFactory.SeparatedList(newArguments, originalSeparators)); + return @this.WithArguments(SyntaxFactory.SeparatedList(newArguments, originalSeparators)) + .WithAdditionalAnnotations(Formatter.Annotation); } // Otherwise, the number of arguments has either increased or decreased, in which case @@ -49,7 +51,8 @@ public static ArgumentListSyntax WithArguments( var newSeparatedList = SyntaxFactory.SeparatedList(nodesAndTokens); - return @this.WithArguments(newSeparatedList); + return @this.WithArguments(newSeparatedList) + .WithAdditionalAnnotations(Formatter.Annotation); } private static bool TryGetFirstEndOfLineTrivia(SyntaxToken openParenToken, SyntaxToken[] separators, out SyntaxTrivia trailingTrivia) From 155d64e194340598cc345a4291ab9483e6cbb9d1 Mon Sep 17 00:00:00 2001 From: Jihoon Park Date: Mon, 17 Jun 2024 20:49:41 -0400 Subject: [PATCH 06/12] Convert verbatim strings to regular strings for readability --- ...EqualClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...EqualClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...tSameClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...eSameClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...tainsClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...eaterClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...EqualClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...EmptyClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...FalseClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...nceOfClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...IsNaNClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...EmptyClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...nceOfClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...tNullClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...dNullClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...dTrueClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...sicModelAssertUsageCondensedCodeFixTests.cs | 6 ++---- .../LessClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...EqualClassicModelAssertUsageCodeFixTests.cs | 6 ++---- ...tZeroClassicModelAssertUsageCodeFixTests.cs | 6 ++---- .../ZeroClassicModelAssertUsageCodeFixTests.cs | 6 ++---- .../CollectionAssertUsageCodeFixTests.cs | 18 ++++++------------ .../EqualConstraintUsageCodeFixTests.cs | 6 ++---- 23 files changed, 50 insertions(+), 100 deletions(-) diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs index 47a8b1a5..5d225afb 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs @@ -298,8 +298,7 @@ public void Test(object actual, object expected) public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapInTestMethod($@" ↓ClassicAssert.AreEqual( @@ -319,8 +318,7 @@ public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] b public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapInTestMethod($@" ↓ClassicAssert.AreEqual( diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFixTests.cs index f6d76020..5fab2a0e 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFixTests.cs @@ -108,8 +108,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapInTestMethod($@" ↓ClassicAssert.AreNotEqual( @@ -128,8 +127,7 @@ public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] b public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapInTestMethod($@" ↓ClassicAssert.AreNotEqual( diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFixTests.cs index 2d288cef..e018845b 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFixTests.cs @@ -138,8 +138,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() @@ -168,8 +167,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs index 32260a7f..7ef58786 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs @@ -138,8 +138,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() @@ -168,8 +167,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs index f123ae9a..90f0c99a 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs @@ -138,8 +138,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() @@ -168,8 +167,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFixTests.cs index 228018c8..2bf61d94 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFixTests.cs @@ -236,8 +236,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() @@ -260,8 +259,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs index c432c53a..839ba011 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs @@ -236,8 +236,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() @@ -260,8 +259,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFixTests.cs index 9fbc2651..0678ab04 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFixTests.cs @@ -164,8 +164,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() @@ -191,8 +190,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs index b9691849..d99cb774 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs @@ -176,8 +176,7 @@ public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen( { var assertion = diagnosticIdsToAssertions[diagnosticId]; var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); @@ -204,8 +203,7 @@ public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen( { var assertion = diagnosticIdsToAssertions[diagnosticId]; var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFixTests.cs index a7aa7b11..3728faae 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFixTests.cs @@ -364,8 +364,7 @@ public void TestMethod() public void CodeFixForGenericMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() @@ -391,8 +390,7 @@ public void TestMethod() public void CodeFixForGenericMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFixTests.cs index c968d35c..610ce692 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFixTests.cs @@ -128,8 +128,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() @@ -155,8 +154,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFixTests.cs index 1d451d80..d1210b8a 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFixTests.cs @@ -200,8 +200,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() @@ -227,8 +226,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs index a1f2886f..8445a05e 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs @@ -334,8 +334,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() @@ -366,8 +365,7 @@ public void TestMethod() public void CodeFixForGenericMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs index 37861c1e..1bb68a16 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs @@ -147,8 +147,7 @@ public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen( { var assertion = diagnosticIdsToAssertions[diagnosticId]; var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); @@ -177,8 +176,7 @@ public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen( { var assertion = diagnosticIdsToAssertions[diagnosticId]; var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs index b400b95d..c0a7f772 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs @@ -147,8 +147,7 @@ public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen( { var assertion = diagnosticIdsToAssertions[diagnosticId]; var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); @@ -177,8 +176,7 @@ public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen( { var assertion = diagnosticIdsToAssertions[diagnosticId]; var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs index 21cf85ff..664a9994 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs @@ -215,8 +215,7 @@ public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen( { var assertion = diagnosticIdsToAssertions[diagnosticId]; var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); @@ -243,8 +242,7 @@ public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen( { var assertion = diagnosticIdsToAssertions[diagnosticId]; var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs index e8176245..3db16b3d 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs @@ -142,8 +142,7 @@ public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen( { var assertion = diagnosticIdsToAssertions[diagnosticId]; var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); @@ -170,8 +169,7 @@ public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen( { var assertion = diagnosticIdsToAssertions[diagnosticId]; var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFixTests.cs index ffdeebab..209f33fc 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFixTests.cs @@ -236,8 +236,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() @@ -260,8 +259,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFixTests.cs index 5527feff..d2ed6596 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFixTests.cs @@ -236,8 +236,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() @@ -260,8 +259,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFixTests.cs index 1aed1c29..9bdbafda 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFixTests.cs @@ -128,8 +128,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() @@ -155,8 +154,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFixTests.cs index 5f69c159..9de4d445 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFixTests.cs @@ -128,8 +128,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() @@ -155,8 +154,7 @@ public void TestMethod() public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() diff --git a/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageCodeFixTests.cs index 1478f096..8fd603d5 100644 --- a/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageCodeFixTests.cs @@ -129,8 +129,7 @@ public void CodeFixForOneCollectionParameterAssertMaintainsReasonableTriviaWithE [ValueSource(nameof(OneCollectionParameterAsserts))] string method, [Values] bool hasMessage) { - var commaAndMessage = hasMessage ? @", - ""message""" : string.Empty; + var commaAndMessage = hasMessage ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapInTestMethod(@$" var collection = new[] {{ 1, 2, 3 }}; ↓CollectionAssert.{method}( @@ -148,8 +147,7 @@ public void CodeFixForOneCollectionParameterAssertMaintainsReasonableTriviaWithN [ValueSource(nameof(OneCollectionParameterAsserts))] string method, [Values] bool hasMessage) { - var commaAndMessage = hasMessage ? @", - ""message""" : string.Empty; + var commaAndMessage = hasMessage ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapInTestMethod(@$" var collection = new[] {{ 1, 2, 3 }}; ↓CollectionAssert.{method}( @@ -169,8 +167,7 @@ public void CodeFixForTwoCollectionParameterAssertMaintainsReasonableTriviaWithE [ValueSource(nameof(TwoCollectionParameterAsserts))] string method, [Values] bool hasMessage) { - var commaAndMessage = hasMessage ? @", - ""message""" : string.Empty; + var commaAndMessage = hasMessage ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapInTestMethod(@$" var collection1 = new[] {{ 1, 2, 3 }}; var collection2 = new[] {{ 2, 4, 6 }}; @@ -190,8 +187,7 @@ public void CodeFixForTwoCollectionParameterAssertMaintainsReasonableTriviaWithN [ValueSource(nameof(TwoCollectionParameterAsserts))] string method, [Values] bool hasMessage) { - var commaAndMessage = hasMessage ? @", - ""message""" : string.Empty; + var commaAndMessage = hasMessage ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapInTestMethod(@$" var collection1 = new[] {{ 1, 2, 3 }}; var collection2 = new[] {{ 2, 4, 6 }}; @@ -213,8 +209,7 @@ public void CodeFixForCollectionAndItemParameterAssertMaintainsReasonableTriviaW [ValueSource(nameof(CollectionAndItemParameterAsserts))] string method, [Values] bool hasMessage) { - var commaAndMessage = hasMessage ? @", - ""message""" : string.Empty; + var commaAndMessage = hasMessage ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapInTestMethod(@$" var collection = new[] {{ typeof(byte), typeof(char) }}; var expected = typeof(byte); @@ -235,8 +230,7 @@ public void CodeFixForCollectionAndItemParameterAssertMaintainsReasonableTriviaW [ValueSource(nameof(CollectionAndItemParameterAsserts))] string method, [Values] bool hasMessage) { - var commaAndMessage = hasMessage ? @", - ""message""" : string.Empty; + var commaAndMessage = hasMessage ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapInTestMethod(@$" var collection = new[] {{ typeof(byte), typeof(char) }}; var expected = typeof(byte); diff --git a/src/nunit.analyzers.tests/ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs index 220180bc..8ce86730 100644 --- a/src/nunit.analyzers.tests/ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs @@ -311,8 +311,7 @@ public void FixesEqualsMethodWithAssertFalseWithMessage() public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapInTestMethod($@" var actual = ""abc""; @@ -332,8 +331,7 @@ public void CodeFixMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] b public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage - ? @", - ""message""" + ? ",\r\n \"message\"" : string.Empty; var code = TestUtility.WrapInTestMethod($@" var actual = ""abc""; From d335ace3b0c8aa0fc93bbddc4be3ab76df05e650 Mon Sep 17 00:00:00 2001 From: Jihoon Park Date: Fri, 28 Jun 2024 11:00:24 +0900 Subject: [PATCH 07/12] Rename 'Right' to 'Correct' to clarify --- .../ConstraintUsage/BaseConditionConstraintCodeFix.cs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/nunit.analyzers/ConstraintUsage/BaseConditionConstraintCodeFix.cs b/src/nunit.analyzers/ConstraintUsage/BaseConditionConstraintCodeFix.cs index ebca8140..c6622747 100644 --- a/src/nunit.analyzers/ConstraintUsage/BaseConditionConstraintCodeFix.cs +++ b/src/nunit.analyzers/ConstraintUsage/BaseConditionConstraintCodeFix.cs @@ -127,20 +127,20 @@ protected virtual (ExpressionSyntax? actual, ExpressionSyntax? constraintExpress : assertNode.ArgumentList.Arguments.Skip(1); var actualArgument = SyntaxFactory.Argument(actual); - var actualArgumentWithRightTrivia = conditionNode is not null + var actualArgumentWithCorrectTrivia = conditionNode is not null ? actualArgument.WithLeadingTrivia(conditionNode.GetLeadingTrivia()) // ignore the trailing trivia, as there is a following argument : actualArgument; var lastOriginalArgument = assertNode.ArgumentList.Arguments.Last(); var constraintArgument = SyntaxFactory.Argument(constraintExpression).WithTriviaFrom(lastOriginalArgument); - var constraintArgumentWithRightTrivia = remainingArguments.Any() + var constraintArgumentWithCorrectTrivia = remainingArguments.Any() ? constraintArgument.WithoutTrailingTrivia() // remove the trailing trivia, as there is a following argument : constraintArgument; var newArguments = new[] { - actualArgumentWithRightTrivia, - constraintArgumentWithRightTrivia + actualArgumentWithCorrectTrivia, + constraintArgumentWithCorrectTrivia }.Union(remainingArguments); var newArgumentsList = assertNode.ArgumentList.WithArguments(newArguments); From 9f17b90ccd721be6d6c95cdae1b91c4d0149e17f Mon Sep 17 00:00:00 2001 From: Jihoon Park Date: Fri, 28 Jun 2024 11:01:04 +0900 Subject: [PATCH 08/12] Fix comment: the the -> the --- src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs b/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs index cb2761d7..f23a88cc 100644 --- a/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs +++ b/src/nunit.analyzers/Extensions/ArgumentListSyntaxExtensions.cs @@ -25,7 +25,7 @@ public static ArgumentListSyntax WithArguments( // Otherwise, the number of arguments has either increased or decreased, in which case // there is no one-size-fits-all answer on what to do about the trivias around separators. - // Therefore, add a newline after the the separator if either the opening parenthesis + // Therefore, add a newline after the separator if either the opening parenthesis // or any of the original separators had a trailing newline. var shouldAddTrailingNewlineAfterComma = TryGetFirstEndOfLineTrivia(@this.OpenParenToken, originalSeparators, out var trailingTrivia); From 3bb943f01883bf01aa37643a1a15ebad234d61c9 Mon Sep 17 00:00:00 2001 From: Jihoon Park Date: Fri, 28 Jun 2024 11:28:06 +0900 Subject: [PATCH 09/12] Fix a '...AllArgumentsOnSameLine' test --- .../AreSameClassicModelAssertUsageCodeFixTests.cs | 6 ++---- .../ContainsClassicModelAssertUsageCodeFixTests.cs | 6 ++---- 2 files changed, 4 insertions(+), 8 deletions(-) diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs index 7ef58786..982a0dfe 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs @@ -206,8 +206,7 @@ public void TestMethod() var actual = new object(); ↓ClassicAssert.AreSame( - expected, - actual{optionalNewline}); + expected, actual{optionalNewline}); }}"); var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() @@ -216,8 +215,7 @@ public void TestMethod() var actual = new object(); Assert.That( - actual, - Is.SameAs(expected){optionalNewline}); + actual, Is.SameAs(expected){optionalNewline}); }}"); RoslynAssert.CodeFix(analyzer, fix, expectedDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs index 90f0c99a..7389a8e4 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs @@ -206,8 +206,7 @@ public void TestMethod() var collection = Array.Empty(); ↓ClassicAssert.Contains( - instance, - collection{optionalNewline}); + instance, collection{optionalNewline}); }}"); var fixedCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() @@ -216,8 +215,7 @@ public void TestMethod() var collection = Array.Empty(); Assert.That( - collection, - Does.Contain(instance){optionalNewline}); + collection, Does.Contain(instance){optionalNewline}); }}"); RoslynAssert.CodeFix(analyzer, fix, instanceDiagnostic, code, fixedCode, fixTitle: ClassicModelAssertUsageCodeFix.TransformToConstraintModelDescription); From 6e1ddff8abc67b63d7707b0ea84952dee22aa63f Mon Sep 17 00:00:00 2001 From: Jihoon Park Date: Fri, 28 Jun 2024 11:28:25 +0900 Subject: [PATCH 10/12] Fix test name --- .../IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs index 8445a05e..e040549c 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs @@ -362,7 +362,7 @@ public void TestMethod() } [Test] - public void CodeFixForGenericMaintainsReasonableTriviaWithNewLineClosingParen([Values] bool hasMessage) + public void CodeFixForGenericMaintainsReasonableTriviaWithEndOfLineClosingParen([Values] bool hasMessage) { var commaAndMessage = hasMessage ? ",\r\n \"message\"" From fae8a12de1d1bfac2d95be5dd0d053107846227c Mon Sep 17 00:00:00 2001 From: Jihoon Park Date: Fri, 28 Jun 2024 11:28:51 +0900 Subject: [PATCH 11/12] Simplify StringConstraints --- .../StringConstraintUsageCodeFixTests.cs | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/src/nunit.analyzers.tests/ConstraintsUsage/StringConstraintUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ConstraintsUsage/StringConstraintUsageCodeFixTests.cs index 7b17cbd5..856a4516 100644 --- a/src/nunit.analyzers.tests/ConstraintsUsage/StringConstraintUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ConstraintsUsage/StringConstraintUsageCodeFixTests.cs @@ -14,12 +14,13 @@ public class StringConstraintUsageCodeFixTests private static readonly DiagnosticAnalyzer analyzer = new StringConstraintUsageAnalyzer(); private static readonly CodeFixProvider fix = new StringConstraintUsageCodeFix(); - private static readonly object[] PositiveAssertData = new[] + private static readonly Dictionary PositiveAssertDictionary = new() { - new[] { nameof(string.Contains), AnalyzerIdentifiers.StringContainsConstraintUsage, "Does.Contain" }, - new[] { nameof(string.StartsWith), AnalyzerIdentifiers.StringStartsWithConstraintUsage, "Does.StartWith" }, - new[] { nameof(string.EndsWith), AnalyzerIdentifiers.StringEndsWithConstraintUsage, "Does.EndWith" } + { nameof(string.Contains), new[] { nameof(string.Contains), AnalyzerIdentifiers.StringContainsConstraintUsage, "Does.Contain" } }, + { nameof(string.StartsWith), new[] { nameof(string.StartsWith), AnalyzerIdentifiers.StringStartsWithConstraintUsage, "Does.StartWith" } }, + { nameof(string.EndsWith), new[] { nameof(string.EndsWith), AnalyzerIdentifiers.StringEndsWithConstraintUsage, "Does.EndWith" } }, }; + private static readonly object[] PositiveAssertData = PositiveAssertDictionary.Values.ToArray(); private static readonly Dictionary NegativeAssertDictionary = new() { @@ -28,12 +29,7 @@ public class StringConstraintUsageCodeFixTests { nameof(string.EndsWith), new[] { nameof(string.EndsWith), AnalyzerIdentifiers.StringEndsWithConstraintUsage, "Does.Not.EndWith" } }, }; private static readonly object[] NegativeAssertData = NegativeAssertDictionary.Values.ToArray(); - private static readonly string[] StringConstraints = new[] - { - nameof(string.Contains), - nameof(string.StartsWith), - nameof(string.EndsWith), - }; + private static readonly string[] StringConstraints = PositiveAssertDictionary.Keys.ToArray(); [TestCaseSource(nameof(PositiveAssertData))] public void AnalyzeStringBooleanMethodAssertTrue(string method, string analyzerId, string suggestedConstraint) From 9d005d8ed306ae8e8cb9690c28d180b8de42b05b Mon Sep 17 00:00:00 2001 From: Jihoon Park Date: Fri, 28 Jun 2024 11:43:00 +0900 Subject: [PATCH 12/12] Convert verbatim strings to regular strings for readability --- .../AreEqualClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../AreNotEqualClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../AreNotSameClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../AreSameClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../ContainsClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../GreaterClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../IsEmptyClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../IsInstanceOfClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../IsNaNClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../IsNotEmptyClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs | 3 +-- ...sNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../IsNullAndNullClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs | 3 +-- ...ueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs | 3 +-- .../LessClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../LessOrEqualClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../NotZeroClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../ZeroClassicModelAssertUsageCodeFixTests.cs | 3 +-- .../CollectionAssertUsageCodeFixTests.cs | 6 ++---- .../ComparisonConstraintUsageCodeFixTests.cs | 3 +-- .../ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs | 3 +-- .../SomeItemsConstraintUsageCodeFixTests.cs | 3 +-- .../ConstraintsUsage/StringConstraintUsageCodeFixTests.cs | 3 +-- 26 files changed, 27 insertions(+), 54 deletions(-) diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs index 5d225afb..88dbb6d9 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreEqualClassicModelAssertUsageCodeFixTests.cs @@ -339,8 +339,7 @@ public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] boo [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapInTestMethod($@" ↓ClassicAssert.AreEqual( 2d, 3d, 0.0000001d{optionalNewline});"); diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFixTests.cs index 5fab2a0e..bfeb92a1 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotEqualClassicModelAssertUsageCodeFixTests.cs @@ -147,8 +147,7 @@ public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] boo [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapInTestMethod($@" ↓ClassicAssert.AreNotEqual( 2d, 3d{optionalNewline});"); diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFixTests.cs index e018845b..3055b58f 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreNotSameClassicModelAssertUsageCodeFixTests.cs @@ -197,8 +197,7 @@ public void TestMethod() [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() {{ diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs index 982a0dfe..288c5816 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/AreSameClassicModelAssertUsageCodeFixTests.cs @@ -197,8 +197,7 @@ public void TestMethod() [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() {{ diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs index 7389a8e4..1df5d73d 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ContainsClassicModelAssertUsageCodeFixTests.cs @@ -197,8 +197,7 @@ public void TestMethod() [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() {{ diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFixTests.cs index 2bf61d94..e1c09bbb 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterClassicModelAssertUsageCodeFixTests.cs @@ -283,8 +283,7 @@ public void TestMethod() [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() {{ diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs index 839ba011..16bdff1d 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/GreaterOrEqualClassicModelAssertUsageCodeFixTests.cs @@ -283,8 +283,7 @@ public void TestMethod() [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() {{ diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFixTests.cs index 0678ab04..d3ff7601 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsEmptyClassicModelAssertUsageCodeFixTests.cs @@ -217,8 +217,7 @@ public void TestMethod() [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() {{ diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs index d99cb774..ca3c6858 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsFalseAndFalseClassicModelAssertUsageCodeFixTests.cs @@ -230,8 +230,7 @@ public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine( [ValueSource(nameof(diagnosticIds))] string diagnosticId, [Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var assertion = diagnosticIdsToAssertions[diagnosticId]; var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFixTests.cs index 3728faae..3e06e049 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsInstanceOfClassicModelAssertUsageCodeFixTests.cs @@ -417,8 +417,7 @@ public void TestMethod() [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() {{ diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFixTests.cs index 610ce692..26c4b617 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNaNClassicModelAssertUsageCodeFixTests.cs @@ -181,8 +181,7 @@ public void TestMethod() [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() {{ diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFixTests.cs index d1210b8a..ceae65b6 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotEmptyClassicModelAssertUsageCodeFixTests.cs @@ -253,8 +253,7 @@ public void TestMethod() [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() {{ diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs index e040549c..a53e6927 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotInstanceOfClassicModelAssertUsageCodeFixTests.cs @@ -390,8 +390,7 @@ public void TestMethod() [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() {{ diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs index 1bb68a16..4427fb9a 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNotNullAndNotNullClassicModelAssertUsageCodeFixTests.cs @@ -205,8 +205,7 @@ public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine( [ValueSource(nameof(diagnosticIds))] string diagnosticId, [Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var assertion = diagnosticIdsToAssertions[diagnosticId]; var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs index c0a7f772..4797d42a 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsNullAndNullClassicModelAssertUsageCodeFixTests.cs @@ -205,8 +205,7 @@ public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine( [ValueSource(nameof(diagnosticIds))] string diagnosticId, [Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var assertion = diagnosticIdsToAssertions[diagnosticId]; var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs index 664a9994..7cb41e77 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCodeFixTests.cs @@ -269,8 +269,7 @@ public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine( [ValueSource(nameof(diagnosticIds))] string diagnosticId, [Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var assertion = diagnosticIdsToAssertions[diagnosticId]; var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs index 3db16b3d..5bd2d66e 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/IsTrueAndTrueClassicModelAssertUsageCondensedCodeFixTests.cs @@ -196,8 +196,7 @@ public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine( [ValueSource(nameof(diagnosticIds))] string diagnosticId, [Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var assertion = diagnosticIdsToAssertions[diagnosticId]; var expectedDiagnostic = ExpectedDiagnostic.Create(diagnosticId); diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFixTests.cs index 209f33fc..10af177b 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessClassicModelAssertUsageCodeFixTests.cs @@ -283,8 +283,7 @@ public void TestMethod() [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() {{ diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFixTests.cs index d2ed6596..8e8e6fc5 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/LessOrEqualClassicModelAssertUsageCodeFixTests.cs @@ -283,8 +283,7 @@ public void TestMethod() [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() {{ diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFixTests.cs index 9bdbafda..73551c95 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/NotZeroClassicModelAssertUsageCodeFixTests.cs @@ -181,8 +181,7 @@ public void TestMethod() [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() diff --git a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFixTests.cs index 9de4d445..a6e2f4a6 100644 --- a/src/nunit.analyzers.tests/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ClassicModelAssertUsage/ZeroClassicModelAssertUsageCodeFixTests.cs @@ -181,8 +181,7 @@ public void TestMethod() [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapMethodInClassNamespaceAndAddUsings($@" public void TestMethod() diff --git a/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageCodeFixTests.cs b/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageCodeFixTests.cs index 8fd603d5..ca4e9f81 100644 --- a/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/CollectionAssertUsage/CollectionAssertUsageCodeFixTests.cs @@ -455,8 +455,7 @@ public void CodeFixForTwoCollectionParameterAssertsMaintainsReasonableTriviaWith [ValueSource(nameof(TwoCollectionParameterAsserts))] string method, [Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapInTestMethod(@$" var collection1 = new[] {{ 1, 2, 3 }}; var collection2 = new[] {{ 2, 4, 6 }}; @@ -477,8 +476,7 @@ public void CodeFixForCollectionAndItemParameterAssertMaintainsReasonableTriviaW [ValueSource(nameof(CollectionAndItemParameterAsserts))] string method, [Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapInTestMethod(@$" var collection = new[] {{ typeof(byte), typeof(char) }}; var expected = typeof(byte); diff --git a/src/nunit.analyzers.tests/ConstraintsUsage/ComparisonConstraintUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ConstraintsUsage/ComparisonConstraintUsageCodeFixTests.cs index 030faf91..3e39e3cc 100644 --- a/src/nunit.analyzers.tests/ConstraintsUsage/ComparisonConstraintUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ConstraintsUsage/ComparisonConstraintUsageCodeFixTests.cs @@ -152,8 +152,7 @@ public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine( [ValueSource(nameof(operatorTokens))] string operatorToken, [Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var constraint = operatorTokensToConstraints[operatorToken]; var code = TestUtility.WrapInTestMethod(@$" int actual = 5; diff --git a/src/nunit.analyzers.tests/ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs index 8ce86730..79c35cd5 100644 --- a/src/nunit.analyzers.tests/ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ConstraintsUsage/EqualConstraintUsageCodeFixTests.cs @@ -353,8 +353,7 @@ public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen([Values] boo [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapInTestMethod($@" var actual = ""abc""; Assert.That( diff --git a/src/nunit.analyzers.tests/ConstraintsUsage/SomeItemsConstraintUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ConstraintsUsage/SomeItemsConstraintUsageCodeFixTests.cs index 1fba9572..923f9b5d 100644 --- a/src/nunit.analyzers.tests/ConstraintsUsage/SomeItemsConstraintUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ConstraintsUsage/SomeItemsConstraintUsageCodeFixTests.cs @@ -143,8 +143,7 @@ public void CodeFixMaintainsReasonableTriviaWithNewLineClosingParen() [Test] public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine([Values] bool newlineBeforeClosingParen) { - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var testCode = TestUtility.WrapInTestMethod($@" ClassicAssert.IsFalse( ↓new[] {{ 1, 2, 3 }}.Contains(1), ""message""{optionalNewline});", diff --git a/src/nunit.analyzers.tests/ConstraintsUsage/StringConstraintUsageCodeFixTests.cs b/src/nunit.analyzers.tests/ConstraintsUsage/StringConstraintUsageCodeFixTests.cs index 856a4516..fb05ee19 100644 --- a/src/nunit.analyzers.tests/ConstraintsUsage/StringConstraintUsageCodeFixTests.cs +++ b/src/nunit.analyzers.tests/ConstraintsUsage/StringConstraintUsageCodeFixTests.cs @@ -167,8 +167,7 @@ public void CodeFixMaintainsReasonableTriviaWithAllArgumentsOnSameLine( { var analyzerId = NegativeAssertDictionary[method][1]; var suggestedConstraint = NegativeAssertDictionary[method][2]; - var optionalNewline = newlineBeforeClosingParen ? @" - " : string.Empty; + var optionalNewline = newlineBeforeClosingParen ? "\r\n " : string.Empty; var code = TestUtility.WrapInTestMethod($@" Assert.That( ↓""abc"".{method}(""ab""), Is.False{optionalNewline});");