add examples for ThrowsAsync, Arg.AnyType, ForTypeForwardingTo

Author: Laoujin

nsubstitute/1-Tutorial.cs

@@ -360,5 +360,63 @@ public void PerformingActionsWithArguments()
         }
         #endregion
         #endregion
+
+        #region New in NSubstitute 4+/5+
+        [Test]
+        public void ThrowsAsync_ForAsyncMethods()
+        {
+            // ThrowsAsync: throw exceptions from async methods (added in v4.4)
+            var sub = Substitute.For<ICalculator>();
+
+            sub.AddAsync(1, 1).ThrowsAsync(new InvalidOperationException("Async failure"));
+
+            Assert.ThrowsAsync<InvalidOperationException>(async () => await sub.AddAsync(1, 1));
+
+            // Also works with ThrowsAsync<T>
+            sub.AddAsync(2, 2).ThrowsAsync<ArgumentException>();
+            Assert.ThrowsAsync<ArgumentException>(async () => await sub.AddAsync(2, 2));
+        }
+
+        [Test]
+        public void ArgAnyType_VerifyGenericCalls()
+        {
+            // Arg.AnyType: match any generic type parameter (added in v5.1)
+            // Useful for verifying calls to generic methods regardless of type argument
+            var sub = Substitute.For<ICalculator>();
+
+            sub.Store("a", 123);
+            sub.Store("b", "hello");
+            sub.Store("c", 3.14);
+
+            // Without Arg.AnyType, you'd need to verify each type separately:
+            sub.Received().Store("a", 123);
+            sub.Received().Store("b", "hello");
+            sub.Received().Store("c", 3.14);
+
+            // With Arg.AnyType, verify all Store calls regardless of T
+            sub.Received(3).Store(Arg.Any<string>(), Arg.Any<Arg.AnyType>());
+        }
+
+        [Test]
+        public void ForTypeForwardingTo_TestSpy()
+        {
+            // Test spy: forward calls to a real implementation (added in v5.3)
+            // Useful when you want to verify calls but still execute real logic
+            var realCalculator = new Calculator();
+            var spy = Substitute.ForTypeForwardingTo<ICalculator, Calculator>();
+
+            // Calls go to real implementation
+            int result = spy.Add(2, 3);
+            Assert.That(result, Is.EqualTo(5)); // Real calculation
+
+            // But we can still verify calls
+            spy.Received().Add(2, 3);
+
+            // And override specific methods
+            spy.Add(10, 10).Returns(999);
+            Assert.That(spy.Add(10, 10), Is.EqualTo(999)); // Overridden
+            Assert.That(spy.Add(5, 5), Is.EqualTo(10));    // Still real
+        }
+        #endregion
     }
 }

nsubstitute/2-Moq-Comparison.cs

@@ -125,5 +125,19 @@ public void Verification()
             // Properties
             var requiredAssignmentForCompiler = nsub.DidNotReceive().Mode;
         }
+
+        [Test]
+        public void ThrowsAsync_Comparison()
+        {
+            // Moq
+            var moq = new Mock<ICalculator>();
+            moq.Setup(calc => calc.AddAsync(1, 1)).ThrowsAsync(new InvalidOperationException());
+            Assert.ThrowsAsync<InvalidOperationException>(async () => await moq.Object.AddAsync(1, 1));
+
+            // NSubstitute
+            var nsub = Substitute.For<ICalculator>();
+            nsub.AddAsync(1, 1).ThrowsAsync(new InvalidOperationException());
+            Assert.ThrowsAsync<InvalidOperationException>(async () => await nsub.AddAsync(1, 1));
+        }
     }
 }

nsubstitute/Calculator.cs

@@ -4,12 +4,10 @@ public class Calculator : ICalculator
     {
         public Calculator()
         {
-            
         }
 
         public Calculator(int @base)
         {
-            
         }
 
         public virtual int Add(int a, int b)
@@ -29,5 +27,15 @@ public void SetMode(string mode)
         {
             Mode = mode;
         }
+
+        public virtual async Task<int> AddAsync(int a, int b)
+        {
+            await Task.Delay(10);
+            return a + b;
+        }
+
+        public virtual T GetValue<T>(string key) => default!;
+
+        public virtual void Store<T>(string key, T value) { }
     }
 }

nsubstitute/ICalculator.cs

@@ -6,5 +6,12 @@ public interface ICalculator
         int Divide(int n, int divisor, out float remainder);
         string Mode { get; set; }
         void SetMode(string mode);
+
+        // Added for async examples
+        Task<int> AddAsync(int a, int b);
+
+        // Added for generic matching examples
+        T GetValue<T>(string key);
+        void Store<T>(string key, T value);
     }
 }