Modernization: Update to .NET 10 LTS and refresh dependencies (Issue #8)

ApexParser.Example/ApexCodeFormat/CustomApexCodeGeneratorTests.cs

@@ -19,21 +19,21 @@ protected void CompareLineByLine(string actual, string expected)
 
             for (int i = 0; i < Min(expectedList.Length, actualList.Length); i++)
             {
-                Assert.AreEqual(expectedList[i].Trim(), actualList[i].Trim());
+                Assert.That(actualList[i].Trim(), Is.EqualTo(expectedList[i].Trim()));
             }
 
             if (Abs(expectedList.Length - actualList.Length) > 1)
             {
-                Assert.Fail("Too many difference in lines: expected {0}, actual {1}", expectedList.Length, actualList.Length);
+                Assert.Fail($"Too many difference in lines: expected {expectedList.Length}, actual {actualList.Length}");
             }
         }
 
         [Test]
         public void TestUsingInvalidInput()
         {
-            Assert.AreEqual(string.Empty, CustomApexCodeGenerator.FormatApex(null));
-            Assert.AreEqual(string.Empty, CustomApexCodeGenerator.FormatApex("  "));
-            Assert.AreEqual(string.Empty, CustomApexCodeGenerator.GenerateApex(null));
+            Assert.That(CustomApexCodeGenerator.FormatApex(null), Is.EqualTo(string.Empty));
+            Assert.That(CustomApexCodeGenerator.FormatApex("  "), Is.EqualTo(string.Empty));
+            Assert.That(CustomApexCodeGenerator.GenerateApex(null), Is.EqualTo(string.Empty));
         }
 
         [Test]

ApexParser.Example/ApexParser.Example.csproj

@@ -1,8 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateProgramFile>false</GenerateProgramFile>
   </PropertyGroup>
 
@@ -23,12 +23,12 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="CommandLineParser" Version="2.4.3" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="2.10.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
-    <PackageReference Include="Newtonsoft.Json" Version="12.0.1" />
-    <PackageReference Include="NUnit" Version="3.11.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.13.0" />
+    <PackageReference Include="CommandLineParser" Version="2.9.1" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="5.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
+    <PackageReference Include="NUnit" Version="4.4.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="6.0.1" />
   </ItemGroup>
 
 </Project>

ApexParser.Example/ApexTestFind/ApexTestFinderTest.cs

@@ -14,174 +14,174 @@ public class ApexTestFinderTest
         public void GetApexClassesReferencingAGivenClassReturnsEmptyArrayForEmptyList()
         {
             var result = ApexTestFinder.GetApexClassesReferencingAGivenClass((string[])null, "Something");
-            Assert.NotNull(result);
-            Assert.IsEmpty(result);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result, Is.Empty);
 
             result = ApexTestFinder.GetApexClassesReferencingAGivenClass(Array.Empty<string>(), "Something");
-            Assert.NotNull(result);
-            Assert.IsEmpty(result);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result, Is.Empty);
         }
 
         [Test]
         public void GetCSharpClassesReferencingAGivenClassReturnsEmptyArrayForEmptyList()
         {
             var result = ApexTestFinder.GetApexClassesReferencingAGivenClass((MemberDeclarationSyntax[])null, "Something");
-            Assert.NotNull(result);
-            Assert.IsEmpty(result);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result, Is.Empty);
 
             result = ApexTestFinder.GetApexClassesReferencingAGivenClass(Array.Empty<MemberDeclarationSyntax>(), "Something");
-            Assert.NotNull(result);
-            Assert.IsEmpty(result);
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result, Is.Empty);
         }
 
         private static ClassDeclarationSyntax ParseClass(string apexClass)
         {
             var result = ApexSharpParser.GetApexAst(apexClass) as ClassDeclarationSyntax;
-            Assert.NotNull(result);
+            Assert.That(result, Is.Not.Null);
             return result;
         }
 
         [Test]
         public void IsTestClassReturnsFalseForNullOrEmptyClass()
         {
-            Assert.IsFalse(ApexTestFinder.IsTestClass(null));
+            Assert.That(ApexTestFinder.IsTestClass(null), Is.False);
 
             var emptyClass = new ClassDeclarationSyntax { Identifier = "EmptyClass" };
-            Assert.IsFalse(ApexTestFinder.IsTestClass(emptyClass));
+            Assert.That(ApexTestFinder.IsTestClass(emptyClass), Is.False);
 
             var sampleClass = ParseClass("class SampleClass {}");
-            Assert.IsFalse(ApexTestFinder.IsTestClass(sampleClass));
+            Assert.That(ApexTestFinder.IsTestClass(sampleClass), Is.False);
         }
 
         [Test]
         public void IsTestClassReturnsTrueForClassDecoratedWithTestAttribute()
         {
             var testFixture = ParseClass("@TestFixture class NUnitSample {}");
-            Assert.NotNull(testFixture);
-            Assert.IsTrue(ApexTestFinder.IsTestClass(testFixture));
+            Assert.That(testFixture, Is.Not.Null);
+            Assert.That(ApexTestFinder.IsTestClass(testFixture), Is.True);
 
             testFixture = ParseClass("@Test class MSTestSample {}");
-            Assert.NotNull(testFixture);
-            Assert.IsTrue(ApexTestFinder.IsTestClass(testFixture));
+            Assert.That(testFixture, Is.Not.Null);
+            Assert.That(ApexTestFinder.IsTestClass(testFixture), Is.True);
 
             testFixture = ParseClass("@isTest class ApexSample {}");
-            Assert.NotNull(testFixture);
-            Assert.IsTrue(ApexTestFinder.IsTestClass(testFixture));
+            Assert.That(testFixture, Is.Not.Null);
+            Assert.That(ApexTestFinder.IsTestClass(testFixture), Is.True);
 
             testFixture = ParseClass("@Dummy class NotATestSample {}");
-            Assert.NotNull(testFixture);
-            Assert.IsFalse(ApexTestFinder.IsTestClass(testFixture));
+            Assert.That(testFixture, Is.Not.Null);
+            Assert.That(ApexTestFinder.IsTestClass(testFixture), Is.False);
         }
 
         [Test]
         public void TextReferencesAClass()
         {
-            Assert.IsFalse(ApexTestFinder.TextReferencesAClass(null, "Foo"));
-            Assert.IsFalse(ApexTestFinder.TextReferencesAClass(" ", "Foo"));
-            Assert.IsFalse(ApexTestFinder.TextReferencesAClass("Foo", null));
-            Assert.IsFalse(ApexTestFinder.TextReferencesAClass("Foo", " "));
-            Assert.IsTrue(ApexTestFinder.TextReferencesAClass("Foo.Bar()", "Foo"));
-            Assert.IsFalse(ApexTestFinder.TextReferencesAClass("NonFoo.Bar()", "Foo"));
+            Assert.That(ApexTestFinder.TextReferencesAClass(null, "Foo"), Is.False);
+            Assert.That(ApexTestFinder.TextReferencesAClass(" ", "Foo"), Is.False);
+            Assert.That(ApexTestFinder.TextReferencesAClass("Foo", null), Is.False);
+            Assert.That(ApexTestFinder.TextReferencesAClass("Foo", " "), Is.False);
+            Assert.That(ApexTestFinder.TextReferencesAClass("Foo.Bar()", "Foo"), Is.True);
+            Assert.That(ApexTestFinder.TextReferencesAClass("NonFoo.Bar()", "Foo"), Is.False);
         }
 
         [Test]
         public void HasReferencesToReturnsFalseForNullOrEmptyClass()
         {
-            Assert.IsFalse(ApexTestFinder.HasReferencesTo(null, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(null, "Foo"), Is.False);
 
             var emptyClass = new ClassDeclarationSyntax { Identifier = "EmptyClass" };
-            Assert.IsFalse(ApexTestFinder.HasReferencesTo(emptyClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(emptyClass, "Foo"), Is.False);
 
             var sampleClass = ParseClass("class SampleClass {}");
-            Assert.IsFalse(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.False);
         }
 
         [Test]
         public void HasReferencesToReturnsTrueForStaticMethodCallReferences()
         {
             var sampleClass = ParseClass("class SampleClass { void Test() { Foo.Bar(); } }");
-            Assert.IsTrue(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.True);
 
             // commented out
             sampleClass = ParseClass("class SampleClass { void Test() { /* Foo.Bar(); */ } }");
-            Assert.IsFalse(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.False);
         }
 
         [Test]
         public void HasReferencesToReturnsTrueForTheVariableDeclarations()
         {
             var sampleClass = ParseClass("class SampleClass { void Test() { Foo x; } }");
-            Assert.IsTrue(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.True);
 
             // commented out
             sampleClass = ParseClass("class SampleClass { void Test() { /* Foo x; */ } }");
-            Assert.IsFalse(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.False);
         }
 
         [Test]
         public void HasReferencesToReturnsTrueForTheVariableInitializationExpressions()
         {
             var sampleClass = ParseClass("class SampleClass { void Test() { object x = new Foo(); } }");
-            Assert.IsTrue(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.True);
 
             // commented out
             sampleClass = ParseClass("class SampleClass { void Test() { /* object x = new Foo(); */ } }");
-            Assert.IsFalse(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.False);
         }
 
         [Test]
         public void HasReferencesToReturnsTrueForTheConstructorExpressions()
         {
             var sampleClass = ParseClass("class SampleClass { void Test() { new Foo(); } }");
-            Assert.IsTrue(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.True);
 
             // commented out
             sampleClass = ParseClass("class SampleClass { void Test() { /* new Foo(); */ } }");
-            Assert.IsFalse(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.False);
         }
 
         [Test]
         public void HasReferencesToReturnsTrueForTheFieldDeclarations()
         {
             var sampleClass = ParseClass("class SampleClass { Foo f; }");
-            Assert.IsTrue(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.True);
 
             // commented out
             sampleClass = ParseClass("class SampleClass { /* Foo f; */ }");
-            Assert.IsFalse(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.False);
         }
 
         [Test]
         public void HasReferencesToReturnsTrueForTheFieldInitializationExpressions()
         {
             var sampleClass = ParseClass("class SampleClass { object x = new Foo(); }");
-            Assert.IsTrue(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.True);
 
             // commented out
             sampleClass = ParseClass("class SampleClass { /* object x = new Foo(); */ }");
-            Assert.IsFalse(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.False);
         }
 
         [Test]
         public void HasReferencesToReturnsTrueForThePropertyDeclarations()
         {
             var sampleClass = ParseClass("class SampleClass { Foo f { get; } }");
-            Assert.IsTrue(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.True);
 
             // commented out
             sampleClass = ParseClass("class SampleClass { /* Foo f { get; } */ }");
-            Assert.IsFalse(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.False);
         }
 
         [Test]
         public void HasReferencesToReturnsTrueForTheMethodDeclarations()
         {
             var sampleClass = ParseClass("class SampleClass { Foo getSomething() { } }");
-            Assert.IsTrue(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.True);
 
             // commented out
             sampleClass = ParseClass("class SampleClass { /* Foo getSomething() { } */ }");
-            Assert.IsFalse(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"));
+            Assert.That(ApexTestFinder.HasReferencesTo(sampleClass, "Foo"), Is.False);
         }
 
         [Test]
@@ -195,8 +195,8 @@ public void GetApexClassesReferencingAGivenClassReturnsClassNames()
                 "@isTest class NotMyClass { void Test() { FooBar x = new FooBar(); } }",
             }, "Foo");
 
-            Assert.AreEqual(1, classes.Length);
-            Assert.AreEqual("MyClass", classes[0]);
+            Assert.That(classes.Length, Is.EqualTo(1));
+            Assert.That(classes[0], Is.EqualTo("MyClass"));
         }
 
         [Test]
@@ -206,8 +206,8 @@ public void GetAllTextClassesReturnsAllTextClassesAsExpected()
             var subfolder = Path.Combine(location, "..", "..", "..", "ApexClasses");
             var classes = ApexTestFinder.GetAllTestClasses(subfolder, "Dx");
 
-            Assert.AreEqual(1, classes.Count);
-            Assert.IsTrue(classes.Contains("DxTestTwo"));
+            Assert.That(classes.Count, Is.EqualTo(1));
+            Assert.That(classes.Contains("DxTestTwo"), Is.True);
         }
 
         private static bool IsTestClass(MemberDeclarationSyntax ast)
@@ -220,21 +220,21 @@ private static bool IsTestClass(MemberDeclarationSyntax ast)
         public void DetectTestClassExample1()
         {
             var ast = ApexSharpParser.GetApexAst("class Example1 {}");
-            Assert.IsFalse(IsTestClass(ast));
+            Assert.That(IsTestClass(ast), Is.False);
         }
 
         [Test]
         public void DetectTestClassExample2()
         {
             var ast = ApexSharpParser.GetApexAst("@isTest class Example2 {}");
-            Assert.IsTrue(IsTestClass(ast));
+            Assert.That(IsTestClass(ast), Is.True);
         }
 
         [Test]
         public void DetectTestClassExample3()
         {
             var ast = ApexSharpParser.GetApexAst("@isTest enum Example2 { A, B, C }");
-            Assert.IsFalse(IsTestClass(ast));
+            Assert.That(IsTestClass(ast), Is.False);
         }
     }
 }

ApexParser.Example/CaseClean/ApexCleanCodeGenTests.cs

@@ -14,12 +14,12 @@ public class ApexCleanCodeGenTests
         [Test]
         public void NormalizeWorksAsExpected()
         {
-            Assert.AreEqual(null, Normalize(null));
-            Assert.AreEqual(string.Empty, Normalize(string.Empty));
-            Assert.AreEqual("  ", Normalize("  "));
-            Assert.AreEqual("FooBar+123", Normalize("FooBar+123"));
-            Assert.AreEqual("AbstractRecordField", Normalize("abstractrecordfield"));
-            Assert.AreEqual("getContext or fooBar + setRecord", Normalize("GetContext or fooBar + setrecord"));
+            Assert.That(Normalize(null), Is.EqualTo(null));
+            Assert.That(Normalize(string.Empty), Is.EqualTo(string.Empty));
+            Assert.That(Normalize("  "), Is.EqualTo("  "));
+            Assert.That(Normalize("FooBar+123"), Is.EqualTo("FooBar+123"));
+            Assert.That(Normalize("abstractrecordfield"), Is.EqualTo("AbstractRecordField"));
+            Assert.That(Normalize("GetContext or fooBar + setrecord"), Is.EqualTo("getContext or fooBar + setRecord"));
         }
 
         [Test]
@@ -43,8 +43,8 @@ public static void testPluckDecimals()
 
             var parsed = ApexSharpParser.GetApexAst(apex);
             var generated = ApexCleanCodeGen.GenerateApex(parsed);
-            Assert.NotNull(generated);
-            Assert.AreEqual(@"class Something
+            Assert.That(generated, Is.Not.Null);
+            Assert.That(generated, Is.EqualTo(@"class Something
 {
     @IsTest
     public static void testPluckDecimals()
@@ -58,7 +58,7 @@ public static void testPluckDecimals()
         System.debug(150.0, revenues[3]);
     }
 }
-", generated);
+"));
         }
     }
 }