Port & update appropriate v2 samples to v3

Author: bradwilson

global.json

@@ -0,0 +1,6 @@
+{
+  "sdk": {
+    "version": "8.0.100",
+    "rollForward": "latestMinor"
+  }
+}

v2/CollectionFixtureExample/packages.config

@@ -0,0 +1,21 @@
+# top-most EditorConfig file
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+
+[*.sln]
+end_of_line = crlf
+
+[*.{csproj,json,props,targets,xslt,yaml,yml}]
+indent_size = 2
+
+[*.cs]
+dotnet_diagnostic.CA1050.severity  = none  # Declare types in namespaces
+dotnet_diagnostic.IDE0022.severity = none  # Use block body for method
+dotnet_diagnostic.IDE0040.severity = none  # Add accessibility modifiers
+dotnet_diagnostic.IDE0130.severity = none  # Namespace does not match folder structure

v3/.editorconfig

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net472;net8.0</TargetFrameworks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="$(Version_Microsoft_NET_Test_Sdk)" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="$(Version_xunit_runner_visualstudio)" PrivateAssets="all" />
+    <PackageReference Include="xunit.v3" Version="$(Version_xunit_v3)" />
+  </ItemGroup>
+
+</Project>

v3/AssemblyFixtureExample/AssemblyFixtureExample.csproj

@@ -0,0 +1,40 @@
+using System;
+using Xunit;
+
+// Attach this type as a fixture. This will be created one for the test assembly and shared for
+// any test which wants to get access to it (via constructor).
+//
+// All fixtures can optionally implement IDisposable, IAsyncDisposable, or IAsyncLifetime in order
+// get full lifetime control.
+[assembly: AssemblyFixture(typeof(MyAssemblyFixture))]
+
+public class Sample1(MyAssemblyFixture fixture)
+{
+    [Fact]
+    public void EnsureSingleton() =>
+        Assert.Equal(1, fixture.InstantiationCount);
+}
+
+public class Sample2(MyAssemblyFixture fixture)
+{
+    [Fact]
+    public void EnsureSingleton() =>
+        Assert.Equal(1, fixture.InstantiationCount);
+}
+
+public class MyAssemblyFixture : IDisposable
+{
+    static int instantiationCount;
+
+    public MyAssemblyFixture() =>
+        instantiationCount++;
+
+    public int InstantiationCount =>
+        instantiationCount;
+
+    public void Dispose()
+    {
+        // Uncomment this and it will surface as an assembly cleanup failure
+        //throw new DivideByZeroException();
+    }
+}

v3/AssemblyFixtureExample/Samples.cs

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net472;net8.0</TargetFrameworks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="$(Version_Microsoft_NET_Test_Sdk)" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="$(Version_xunit_runner_visualstudio)" PrivateAssets="all" />
+    <PackageReference Include="xunit.v3" Version="$(Version_xunit_v3)" />
+  </ItemGroup>
+
+</Project>

v3/AssertExamples/AssertExamples.csproj

@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+using Xunit;
+
+public class AsyncExamples
+{
+    // Your async tests can return Task...
+    [Fact]
+    public async Task CodeThrowsAsync()
+    {
+        var ex = await Assert.ThrowsAsync<NotImplementedException>(ThrowingMethod);
+
+        Assert.IsType<NotImplementedException>(ex);
+    }
+
+    // ...or ValueTask
+    [Fact]
+    public async ValueTask RecordAsync()
+    {
+        var ex = await Record.ExceptionAsync(ThrowingMethod);
+
+        Assert.IsType<NotImplementedException>(ex);
+    }
+
+    async Task ThrowingMethod()
+    {
+        await Task.Yield();
+
+        throw new NotImplementedException();
+    }
+}

v3/AssertExamples/AsyncExamples.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+// Collection equivalence means the collections have the exact same values
+// in any order.
+
+public class CollectionExamples
+{
+    [Fact]
+    public void CollectionEquality()
+    {
+        List<int> left = [4, 12, 16, 27];
+        List<int> right = [4, 12, 16, 27];
+
+        Assert.Equal(left, right, new CollectionEquivalenceComparer<int>());
+    }
+
+    [Fact]
+    public void LeftCollectionSmallerThanRight()
+    {
+        List<int> left = [4, 12, 16];
+        List<int> right = [4, 12, 16, 27];
+
+        Assert.NotEqual(left, right, new CollectionEquivalenceComparer<int>());
+    }
+
+    [Fact]
+    public void LeftCollectionLargerThanRight()
+    {
+        List<int> left = [4, 12, 16, 27, 42];
+        List<int> right = [4, 12, 16, 27];
+
+        Assert.NotEqual(left, right, new CollectionEquivalenceComparer<int>());
+    }
+
+    [Fact]
+    public void SameValuesOutOfOrder()
+    {
+        List<int> left = [4, 16, 12, 27];
+        List<int> right = [4, 12, 16, 27];
+
+        Assert.Equal(left, right, new CollectionEquivalenceComparer<int>());
+    }
+
+    [Fact]
+    public void DuplicatedItemInOneListOnly()
+    {
+        List<int> left = [4, 12, 16, 27, 4];
+        List<int> right = [4, 12, 16, 27];
+
+        Assert.NotEqual(left, right, new CollectionEquivalenceComparer<int>());
+    }
+
+    [Fact]
+    public void DuplicatedItemInBothLists()
+    {
+        List<int> left = [4, 16, 12, 27, 4];
+        List<int> right = [4, 12, 16, 4, 27];
+
+        Assert.Equal(left, right, new CollectionEquivalenceComparer<int>());
+    }
+}
+
+class CollectionEquivalenceComparer<T> : IEqualityComparer<IEnumerable<T>>
+   where T : IEquatable<T>
+{
+    public bool Equals(IEnumerable<T>? x, IEnumerable<T>? y)
+    {
+        if (x is null)
+            return y is null;
+        if (y is null)
+            return false;
+
+        var leftList = new List<T>(x);
+        var rightList = new List<T>(y);
+        leftList.Sort();
+        rightList.Sort();
+
+        using var enumeratorX = leftList.GetEnumerator();
+        using var enumeratorY = rightList.GetEnumerator();
+
+        while (true)
+        {
+            bool hasNextX = enumeratorX.MoveNext();
+            bool hasNextY = enumeratorY.MoveNext();
+
+            if (!hasNextX || !hasNextY)
+                return (hasNextX == hasNextY);
+
+            if (!enumeratorX.Current.Equals(enumeratorY.Current))
+                return false;
+        }
+    }
+
+    public int GetHashCode(IEnumerable<T> obj) =>
+        throw new NotImplementedException();
+}

v3/AssertExamples/CollectionExamples.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+public class EqualExamples
+{
+    [Fact]
+    public void EqualStringIgnoreCase()
+    {
+        string expected = "TestString";
+        string actual = "teststring";
+
+        Assert.False(actual == expected);
+        Assert.NotEqual(expected, actual);
+        Assert.Equal(expected, actual, StringComparer.CurrentCultureIgnoreCase);
+    }
+
+    class DateComparer : IEqualityComparer<DateTime>
+    {
+        public bool Equals(DateTime x, DateTime y) =>
+            x.Date == y.Date;
+
+        public int GetHashCode(DateTime obj) =>
+            obj.GetHashCode();
+    }
+
+    [Fact]
+    public void DateShouldBeEqualEvenThoughTimesAreDifferent()
+    {
+        var firstTime = DateTime.Now.Date;
+        var later = firstTime.AddMinutes(90);
+
+        Assert.NotEqual(firstTime, later);
+        Assert.Equal(firstTime, later, new DateComparer());
+    }
+}

v3/AssertExamples/EqualExamples.cs

@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <!--
+    Since we've imported the assertions via source, and have nullable enabled, we need to let the
+    assertion library know that by defining XUNIT_NULLABLE.
+      For more information, see https://github.com/xunit/assert.xunit/#annotations
+    -->
+    <DefineConstants>$(DefineConstants);XUNIT_NULLABLE</DefineConstants>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net472;net8.0</TargetFrameworks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="$(Version_Microsoft_NET_Test_Sdk)" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="$(Version_xunit_runner_visualstudio)" PrivateAssets="all" />
+    <!--
+    We want to reference xunit.v3.assert.source (so that we can extend the Assert class itself),
+    which means we need to bring in references to the three individual packages instead of referencing
+    xunit.v3 directly.
+    -->
+    <PackageReference Include="xunit.analyzers" Version="$(Version_xunit_analyzers)" />
+    <PackageReference Include="xunit.v3.assert.source" Version="$(Version_xunit_v3)" />
+    <PackageReference Include="xunit.v3.core" Version="$(Version_xunit_v3)" />
+  </ItemGroup>
+
+  <!-- Need this to allow nullable support in the source-based assertion library to work with .NET Framework -->
+  <ItemGroup Condition=" '$(TargetFramework)' == 'net472' ">
+    <PackageReference Include="TunnelVisionLabs.ReferenceAssemblyAnnotator" Version="1.0.0-alpha.160" PrivateAssets="all" IncludeAssets="runtime; build; native; contentfiles; analyzers; buildtransitive" />
+    <PackageDownload Include="Microsoft.NETCore.App.Ref" Version="[8.0.11]" />
+  </ItemGroup>
+
+</Project>

v3/AssertExtensions/AssertExtensions.csproj

@@ -0,0 +1,5 @@
+public class Person(string firstName, string lastName)
+{
+    public string FirstName => firstName;
+    public string LastName => lastName;
+}

v3/AssertExtensions/ExtendingAssert/Person.cs

@@ -0,0 +1,8 @@
+namespace Xunit;
+
+// When importing xUnit.net's assertion library as source, the Assert class is partial and you can additional
+public partial class Assert
+{
+    public static void IsBrad(Person person) =>
+        Equal("Brad", person.FirstName);
+}

v3/AssertExtensions/ExtendingAssert/PersonAssertions.cs

@@ -0,0 +1,17 @@
+using Xunit;
+
+// This is an example of writing your own assertion that lives under Assert, by importing the assertion
+// library as source rather than as binary, so that you can write more assertions on the Assert
+// partial class.
+public class PersonAssertionsExamples
+{
+    [Fact]
+    public void EnsureBradness()
+    {
+        var person1 = new Person("Brad", "Wilson");
+        var person2 = new Person("Brad", "Pitt");
+
+        Assert.IsBrad(person1);
+        Assert.IsBrad(person2);
+    }
+}

v3/AssertExtensions/ExtendingAssert/PersonAssertionsExamples.cs

@@ -0,0 +1,41 @@
+namespace Xunit.Extensions.AssertExtensions;
+
+/// <summary>
+/// Extensions which provide assertions to classes derived from <see cref="bool"/>.
+/// </summary>
+public static class BooleanExtensions
+{
+    /// <summary>
+    /// Verifies that the condition is false.
+    /// </summary>
+    /// <param name="condition">The condition to be tested</param>
+    /// <exception cref="FalseException">Thrown if the condition is not false</exception>
+    public static void ShouldBeFalse(this bool condition) =>
+        Assert.False(condition);
+
+    /// <summary>
+    /// Verifies that the condition is false.
+    /// </summary>
+    /// <param name="condition">The condition to be tested</param>
+    /// <param name="userMessage">The message to show when the condition is not false</param>
+    /// <exception cref="FalseException">Thrown if the condition is not false</exception>
+    public static void ShouldBeFalse(this bool condition, string userMessage) =>
+        Assert.False(condition, userMessage);
+
+    /// <summary>
+    /// Verifies that an expression is true.
+    /// </summary>
+    /// <param name="condition">The condition to be inspected</param>
+    /// <exception cref="TrueException">Thrown when the condition is false</exception>
+    public static void ShouldBeTrue(this bool condition) =>
+        Assert.True(condition);
+
+    /// <summary>
+    /// Verifies that an expression is true.
+    /// </summary>
+    /// <param name="condition">The condition to be inspected</param>
+    /// <param name="userMessage">The message to be shown when the condition is false</param>
+    /// <exception cref="TrueException">Thrown when the condition is false</exception>
+    public static void ShouldBeTrue(this bool condition, string userMessage) =>
+        Assert.True(condition, userMessage);
+}