Xuint test guide

Comprehensive guide for Xunit, a popular testing framework for C#:

Xunit Basics:

1. Fact Attribute:

   [Fact]
   public void TestMethod()
   {
       // Test code here
   }
   

2. Theory Attribute (Parameterized Tests):

   [Theory]
   [InlineData(1, 2)]
   [InlineData(3, 4)]
   public void TestMethod(int a, int b)
   {
       // Test code using parameters a and b
   }
   

3. Assert.True:

   Assert.True(condition);
   

4. Assert.False:

   Assert.False(condition);
   

Equality Assertions:

5. Assert.Equal:

   Assert.Equal(expected, actual);
   

6. Assert.NotEqual:

   Assert.NotEqual(expected, actual);
   

7. Assert.Collection:

   Assert.Collection(collection, item => Assert.Equal(expectedItem, item));
   

Nullability Assertions:

8. Assert.Null:

   Assert.Null(actual);
   

9. Assert.NotNull:

   Assert.NotNull(actual);
   

Numeric Assertions:

10. Assert.InRange:

    Assert.InRange(actual, low, high);
    

11. Assert.NotInRange:

    Assert.NotInRange(actual, low, high);
    

String Assertions:

12. Assert.Contains:

    Assert.Contains(substring, actual);
    

13. Assert.StartsWith:

    Assert.StartsWith(prefix, actual);
    

14. Assert.EndsWith:

    Assert.EndsWith(suffix, actual);
    

Collection Assertions:

15. Assert.Empty:

    Assert.Empty(collection);
    

16. Assert.NotEmpty:

    Assert.NotEmpty(collection);
    

17. Assert.Contains:

    Assert.Contains(expectedItem, collection);
    

18. Assert.DoesNotContain:

    Assert.DoesNotContain(unexpectedItem, collection);
    

19. Assert.Single:

    Assert.Single(collection);
    

20. Assert.Equal (Collection):

    Assert.Equal(expectedCollection, actualCollection);
    

Exception Assertions:

21. Assert.Throws:

    Assert.Throws<ExceptionType>(() => SomeMethod());
    

22. Assert.ThrowsAny:

    Assert.ThrowsAny<ExceptionType>(() => SomeMethod());
    

23. Assert.ThrowsAsync:

    await Assert.ThrowsAsync<ExceptionType>(async () => await SomeAsyncMethod());
    

Xunit Class Fixtures:

24. IClassFixture:

    public class MyTestClass : IClassFixture<MyFixtureClass>
    {
        // Test code using shared fixture
    }
    

25. ICollectionFixture:

    [CollectionDefinition("MyCollection")]
    public class MyCollection : ICollectionFixture<MyFixtureClass>
    {
        // Collection-wide fixture setup
    }
    

Xunit Traits and Categories:

26. Trait Attribute:

    [Trait("Category", "Integration")]
    public void IntegrationTest()
    {
        // Integration test code
    }
    

27. Skip Test:

    [Fact(Skip = "Reason for skipping")]
    public void SkippedTest()
    {
        // Skipped test code
    }
    

Additional Xunit Assertions:

28. Approximate Numeric Equality:

    Assert.Equal(expected, actual, precision: 2);
    

29. Assert.IsType:

    Assert.IsType<ExpectedType>(actual);
    

30. Assert.IsAssignableFrom:

    Assert.IsAssignableFrom<IInterfaceType>(actual);
    

Data Member for Theories:

31. InlineData with MemberData:

    [Theory]
    [MemberData(nameof(TestData))]
    public void TestMethod(int a, int b)
    {
        // Test code using parameters a and b
    }
    
    public static IEnumerable<object[]> TestData()
    {
        yield return new object[] { 1, 2 };
        yield return new object[] { 3, 4 };
    }
    

Xunit Output:

32. Capturing Output:

    var output = new StringWriter();
    Console.SetOut(output);
    
    // Test code
    
    var capturedOutput = output.ToString();
    

Timeout for Tests:

33. Timeout Attribute:

    [Fact(Timeout = 1000)] // Timeout in milliseconds
    public void TestMethod()
    {
        // Test code
    }
    

Xunit Assertions with FluentAssertions:

34. Using FluentAssertions with Xunit:

    actual.Should().Be(expected);
    

Xunit Class Cleanup:

35. IClassFixture with IDisposable:

    public class MyTestClass : IClassFixture<MyFixtureClass>, IDisposable
    {
        // Test code
    
        public void Dispose()
        {
            // Cleanup code
        }
    }
    

Xunit Test Ordering:

36. Test Order Attribute:

    [TestMethod]
    [TestOrder(1)]
    public void TestMethod1()
    {
        // Test code
    }
    
    [TestMethod]
    [TestOrder(2)]
    public void TestMethod2()
    {
        // Test code
    }
    

These are some of the commonly used Xunit assertions and features. For more details and advanced features, refer to the official Xunit documentation.