upgrade to .NET 10, slnx, NUnit 4, add GitHub CI

Author: Laoujin

.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Restore
+        run: dotnet restore NSubstituteTutorial.slnx
+
+      - name: Build
+        run: dotnet build NSubstituteTutorial.slnx --no-restore
+
+      - name: Test
+        run: dotnet test NSubstituteTutorial.slnx --no-build --verbosity normal

NSubstituteTutorial.sln

@@ -0,0 +1,7 @@
+<Solution>
+  <Project Path="nsubstitute\nsubstitute-tut.csproj" />
+  <Folder Name="/Solution Items/">
+    <File Path=".gitignore" />
+    <File Path="README.md" />
+  </Folder>
+</Solution>

NSubstituteTutorial.slnx

@@ -0,0 +1,6 @@
+{
+  "sdk": {
+    "version": "10.0.100",
+    "rollForward": "latestFeature"
+  }
+}

global.json

@@ -1,10 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Security.Claims;
-using System.Security.Principal;
-using System.Windows.Input;
+using System.Security.Principal;
 using NSubstitute;
 using NSubstitute.Core;
 using NSubstitute.Extensions;
@@ -42,7 +36,7 @@ public void CreateSubstitute_ForClass()
             }
             catch (CouldNotSetReturnDueToTypeMismatchException ex) when (ex.Message.Contains("Return values cannot be configured for non-virtual/non-abstract members"))
             {
-                Assert.True(true, "NSubstitute only works with virtual/abstract members when substituting an actual class");
+                Assert.That(true, Is.True, "NSubstitute only works with virtual/abstract members when substituting an actual class");
             }
         }
 
@@ -99,8 +93,8 @@ public void CreateSubstitute_ForMultipleTypes()
         {
             // Multiple substitutions (at most one class)
             var msub = Substitute.For<ICalculator, IDisposable>();
-            Assert.IsInstanceOf<ICalculator>(msub);
-            Assert.IsInstanceOf<IDisposable>(msub);
+            Assert.That(msub, Is.InstanceOf<ICalculator>());
+            Assert.That(msub, Is.InstanceOf<IDisposable>());
 
 
             // For more than three types
@@ -110,8 +104,8 @@ public void CreateSubstitute_ForMultipleTypes()
                 new[] { typeof(IComparable), typeof(IDisposable), typeof(ICloneable), typeof(Calculator) },
                 new object[] { 8 } // @base ctor argument for Calculator
             );
-            Assert.IsInstanceOf<IDisposable>(gt3Sub);
-            Assert.IsInstanceOf<Calculator>(gt3Sub);
+            Assert.That(gt3Sub, Is.InstanceOf<IDisposable>());
+            Assert.That(gt3Sub, Is.InstanceOf<Calculator>());
 
             var calcer = (Calculator)gt3Sub;
             calcer.Add(1, 1).Returns(2);
@@ -198,24 +192,24 @@ public void ProvideValues_WithoutSetup_ReturnsDefaultOrEmpty()
 
             // Default for IEnumerable<T> is Enumerable.Empty<T>()
             var testy = Substitute.For<VirtualsTest>();
-            Assert.That(testy.Virtual.Count(), Is.EqualTo(0));
-            Assert.Null(testy.NotVirtual);
+            Assert.That(testy.Virtual!.Count(), Is.EqualTo(0));
+            Assert.That(testy.NotVirtual, Is.Null);
 
             // Default for string is ""
             var identity = Substitute.For<IIdentity>();
-            Assert.AreEqual("", identity.Name);
+            Assert.That(identity.Name, Is.EqualTo(""));
 
             // Members returning an interface will automatically return a sub (recursively)
             var principal = Substitute.For<IPrincipal>();
-            IIdentity principalIdentity = principal.Identity;
+            var principalIdentity = principal.Identity!;
             principalIdentity.Name.Returns("Neo");
             Assert.That(principalIdentity.Name, Is.EqualTo("Neo"));
         }
 
         public class VirtualsTest
         {
-            public virtual IEnumerable<string> Virtual { get; set; }
-            public IEnumerable<string> NotVirtual { get; set; }
+            public virtual IEnumerable<string>? Virtual { get; set; }
+            public IEnumerable<string>? NotVirtual { get; set; }
         }
 
         [Test]
@@ -237,18 +231,18 @@ public void ProvideValues_ForMethodsAndProperties()
 
             // Provide multiple return values
             nsub.Mode.Returns("DEC", "HEX", "BIN");
-            Assert.AreEqual("DEC", nsub.Mode);
-            Assert.AreEqual("HEX", nsub.Mode);
-            Assert.AreEqual("BIN", nsub.Mode);
+            Assert.That(nsub.Mode, Is.EqualTo("DEC"));
+            Assert.That(nsub.Mode, Is.EqualTo("HEX"));
+            Assert.That(nsub.Mode, Is.EqualTo("BIN"));
 
             // Multiple return values with a function
             nsub.Mode.Returns(
                 x => "DEC",
                 x => "HEX",
                 x => throw new Exception()
             );
-            Assert.AreEqual("DEC", nsub.Mode);
-            Assert.AreEqual("HEX", nsub.Mode);
+            Assert.That(nsub.Mode, Is.EqualTo("DEC"));
+            Assert.That(nsub.Mode, Is.EqualTo("HEX"));
             Assert.Throws<Exception>(() => { var result = nsub.Mode; });
         }
 
@@ -272,8 +266,8 @@ public void ProvideValues_WithRefAndOut()
                 return 2;
             });
 
-            Assert.AreEqual(2, nsub.Divide(12, 5, out remainder));
-            Assert.AreEqual(0.4F, remainder);
+            Assert.That(nsub.Divide(12, 5, out remainder), Is.EqualTo(2));
+            Assert.That(remainder, Is.EqualTo(0.4F));
         }
 
         [Test]
@@ -334,7 +328,7 @@ public void ProvideValues_AndDoesCallback()
 
             nsub.Add(7, 3);
             nsub.Add(2, 2);
-            Assert.AreEqual(counter, 2);
+            Assert.That(counter, Is.EqualTo(2));
         }
 
         [Test]
@@ -349,7 +343,7 @@ public void SubstituteVoids_WithWhenDo()
                 .Do(x => called = true);
 
             sub.SetMode("HEX");
-            Assert.True(called);
+            Assert.That(called, Is.True);
         }
 
         #region Performing actions with arguments
@@ -362,7 +356,7 @@ public void PerformingActionsWithArguments()
             nsub.Add(10, 42);
             nsub.Add(11, 0); // does not overwrite argumentUsed because first arg is not 10
 
-            Assert.AreEqual(42, argumentUsed);
+            Assert.That(argumentUsed, Is.EqualTo(42));
         }
         #endregion
         #endregion

nsubstitute/1-Tutorial.cs

@@ -1,7 +1,5 @@
-using System;
 using Moq;
 using NSubstitute;
-using NSubstitute.Core;
 using NSubstitute.ExceptionExtensions;
 using NUnit.Framework;
 
@@ -18,19 +16,19 @@ public void BasicExample()
         {
             // Methods
             moq.Setup(calc => calc.Add(1, 1)).Returns(2);
-            Assert.AreEqual(2, moq.Object.Add(1, 1));
+            Assert.That(moq.Object.Add(1, 1), Is.EqualTo(2));
 
             nsub.Add(1, 1).Returns(2);
-            Assert.AreEqual(2, nsub.Add(1, 1));
+            Assert.That(nsub.Add(1, 1), Is.EqualTo(2));
 
             // Properties
             moq.Setup(calc => calc.Mode).Returns("DEC");
-            Assert.AreEqual("DEC", moq.Object.Mode);
+            Assert.That(moq.Object.Mode, Is.EqualTo("DEC"));
 
             nsub.Mode = "DEC";
             // Can also use the same syntax as for methods:
             // nsub.Mode.Returns("DEC");
-            Assert.AreEqual("DEC", nsub.Mode);
+            Assert.That(nsub.Mode, Is.EqualTo("DEC"));
         }
 
         [Test]
@@ -41,8 +39,8 @@ public void OutAndRef()
                 moq.Setup(calc => calc.Divide(12, 5, out remainder)).Returns(2);
                 remainder = 0;
 
-                Assert.AreEqual(2, moq.Object.Divide(12, 5, out remainder));
-                Assert.AreEqual(0.4F, remainder);
+                Assert.That(moq.Object.Divide(12, 5, out remainder), Is.EqualTo(2));
+                Assert.That(remainder, Is.EqualTo(0.4F));
             }
 
             {
@@ -53,19 +51,19 @@ public void OutAndRef()
                 });
                 remainder = 0;
 
-                Assert.AreEqual(2, nsub.Divide(12, 5, out remainder));
-                Assert.AreEqual(0.4F, remainder);
+                Assert.That(nsub.Divide(12, 5, out remainder), Is.EqualTo(2));
+                Assert.That(remainder, Is.EqualTo(0.4F));
             }
         }
 
         [Test]
         public void ManipulateResult()
         {
             moq.Setup(calc => calc.Add(1, 1)).Returns((int a, int b) => a + b + 1);
-            Assert.AreEqual(3, moq.Object.Add(1, 1));
+            Assert.That(moq.Object.Add(1, 1), Is.EqualTo(3));
 
             nsub.Add(1, 1).Returns(r => (int) r[0] + (int) r[1] + 1);
-            Assert.AreEqual(3, nsub.Add(1, 1));
+            Assert.That(nsub.Add(1, 1), Is.EqualTo(3));
         }
 
         [Test]
@@ -87,8 +85,9 @@ public void ThrowExceptions()
 
             // The extension method syntax is much cleaner
             // Without it, the setup becomes the following
-            nsub.Add(1, 1).Returns(x => { throw new InvalidOperationException(); });
-            nsub.When(x => x.SetMode("HEX")).Do(x => { throw new ArgumentException(); });
+            var nsub2 = Substitute.For<ICalculator>();
+            nsub2.Add(1, 1).Returns(x => { throw new InvalidOperationException(); });
+            nsub2.When(x => x.SetMode("HEX")).Do(x => { throw new ArgumentException(); });
         }
 
         [Test]

nsubstitute/2-Moq-Comparison.cs

@@ -1,10 +1,6 @@
-using System;
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
 using NSubstitute;
 using NSubstitute.Core;
-using NSubstitute.Exceptions;
 using NUnit.Framework;
 
 namespace NSubstituteTutorial
@@ -78,7 +74,7 @@ public void InvokeArgumentCallbacks()
             var command = new OrderPlacedCommand(processor);
             command.Execute();
 
-            Assert.True(command.OkCalled);
+            Assert.That(command.OkCalled, Is.True);
         }
         #endregion
 

nsubstitute/3-Not-Covered.cs

@@ -23,7 +23,7 @@ public int Divide(int n, int divisor, out float remainder)
             return n / divisor;
         }
 
-        public string Mode { get; set; }
+        public string Mode { get; set; } = "";
 
         public void SetMode(string mode)
         {

nsubstitute/Calculator.cs

@@ -1,5 +1,3 @@
-using System;
-
 namespace NSubstituteTutorial
 {
     public interface ICalculator