diff --git a/test/Directory.Build.props b/test/Directory.Build.props
index a0b1fcf254b..aa2bdcea6c3 100644
--- a/test/Directory.Build.props
+++ b/test/Directory.Build.props
@@ -7,7 +7,7 @@
   <PropertyGroup>
     <!--
     .NET 9 preview 2 or later run tests in parallel by default.
-    It is necessary to disable this feature because there are tests that need to be executed sequentially that are marked with `[Collection("docfx STA")]`.
+    It is necessary to disable this feature because there are tests that need to be executed sequentially that are marked with `[DoNotParallelize]`.
     -->
     <TestTfmsInParallel>false</TestTfmsInParallel>
   </PropertyGroup>
@@ -30,8 +30,9 @@
 
   <ItemGroup>
     <PackageReference Include="AwesomeAssertions" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" />
-    <PackageReference Include="xunit.runner.visualstudio" />
-    <PackageReference Include="xunit" />
+    <PackageReference Include="MSTest" />
+
+    <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
+    <AssemblyAttribute Include="Microsoft.VisualStudio.TestTools.UnitTesting.Parallelize" />
   </ItemGroup>
 </Project>
diff --git a/test/Directory.Packages.props b/test/Directory.Packages.props
index b6dd29a5e18..8cabbad86e7 100644
--- a/test/Directory.Packages.props
+++ b/test/Directory.Packages.props
@@ -4,11 +4,9 @@
 
   <ItemGroup>
     <PackageVersion Include="AwesomeAssertions" Version="8.0.2" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageVersion Include="Verify.DiffPlex" Version="3.1.2" />
-    <PackageVersion Include="Verify.Xunit" Version="28.16.0" />
-    <PackageVersion Include="xunit.runner.visualstudio" Version="3.0.2" />
-    <PackageVersion Include="xunit" Version="2.9.3" />
+    <PackageVersion Include="Verify.MSTest" Version="28.16.0" />
+    <PackageVersion Include="MSTest" Version="3.8.3" />
   </ItemGroup>
   
   <ItemGroup>
diff --git a/test/Docfx.Build.Common.Tests/FileLinkInfoTest.cs b/test/Docfx.Build.Common.Tests/FileLinkInfoTest.cs
index 07c66c3714b..3f7022cc11e 100644
--- a/test/Docfx.Build.Common.Tests/FileLinkInfoTest.cs
+++ b/test/Docfx.Build.Common.Tests/FileLinkInfoTest.cs
@@ -3,13 +3,13 @@
 
 using Docfx.Common;
 using FluentAssertions;
-using Xunit;
 
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class FileLinkInfoTest
 {
-    [Fact]
+    [TestMethod]
     public void TestFileLinkInfo_EncodedWorkspaceCharacter()
     {
         string fromFileInSource = "articles/vpn-gateway/vpn-gateway-verify-connection-resource-manager.md";
diff --git a/test/Docfx.Build.Common.Tests/MarkdownReaderTest.cs b/test/Docfx.Build.Common.Tests/MarkdownReaderTest.cs
index 5e5da0a699e..a2a79775c31 100644
--- a/test/Docfx.Build.Common.Tests/MarkdownReaderTest.cs
+++ b/test/Docfx.Build.Common.Tests/MarkdownReaderTest.cs
@@ -6,13 +6,13 @@
 using Docfx.Build.Engine;
 using Docfx.MarkdigEngine;
 using Docfx.Plugins;
-using Xunit;
 
 namespace Docfx.Build.Common.Tests;
 
+[TestClass]
 public class MarkdownReaderTest
 {
-    [Fact]
+    [TestMethod]
     public void TestReadMarkdownAsOverwrite()
     {
         var content = @"---
@@ -34,11 +34,11 @@ public void TestReadMarkdownAsOverwrite()
 
         var ft = new FileAndType(baseDir, fileName, DocumentType.Overwrite);
         var results = MarkdownReader.ReadMarkdownAsOverwrite(host, ft).ToList();
-        Assert.NotNull(results);
-        Assert.Single(results);
-        Assert.Equal("Test", results[0].Uid);
-        Assert.Equal("Hello", results[0].Metadata["remarks"]);
-        Assert.Equal("\n<p sourcefile=\"ut_ReadMarkdownAsOverwrite.md\" sourcestartlinenumber=\"6\">This is unit test!</p>\n", results[0].Conceptual);
+        Assert.IsNotNull(results);
+        Assert.ContainsSingle(results);
+        Assert.AreEqual("Test", results[0].Uid);
+        Assert.AreEqual("Hello", results[0].Metadata["remarks"]);
+        Assert.AreEqual("\n<p sourcefile=\"ut_ReadMarkdownAsOverwrite.md\" sourcestartlinenumber=\"6\">This is unit test!</p>\n", results[0].Conceptual);
         File.Delete(fileName);
 
         // Test conceptual content between two yamlheader
@@ -55,13 +55,13 @@ This is unit test!
         content = Regex.Replace(content, "\r?\n", "\r\n");
         File.WriteAllText(fileName, content);
         results = MarkdownReader.ReadMarkdownAsOverwrite(host, ft).ToList();
-        Assert.NotNull(results);
-        Assert.Equal(2, results.Count);
-        Assert.Equal("Test1", results[0].Uid);
-        Assert.Equal("Test2", results[1].Uid);
-        Assert.Equal("Hello", results[0].Metadata["remarks"]);
-        Assert.Equal("\n<p sourcefile=\"ut_ReadMarkdownAsOverwrite.md\" sourcestartlinenumber=\"5\">This is unit test!</p>\n", results[0].Conceptual);
-        Assert.Equal(string.Empty, results[1].Conceptual);
+        Assert.IsNotNull(results);
+        Assert.AreEqual(2, results.Count);
+        Assert.AreEqual("Test1", results[0].Uid);
+        Assert.AreEqual("Test2", results[1].Uid);
+        Assert.AreEqual("Hello", results[0].Metadata["remarks"]);
+        Assert.AreEqual("\n<p sourcefile=\"ut_ReadMarkdownAsOverwrite.md\" sourcestartlinenumber=\"5\">This is unit test!</p>\n", results[0].Conceptual);
+        Assert.AreEqual(string.Empty, results[1].Conceptual);
         File.Delete(fileName);
 
         content = @"---
@@ -76,13 +76,13 @@ This is unit test!
         content = Regex.Replace(content, "\r?\n", "\r\n");
         File.WriteAllText(fileName, content);
         results = MarkdownReader.ReadMarkdownAsOverwrite(host, ft).ToList();
-        Assert.NotNull(results);
-        Assert.Equal(2, results.Count);
-        Assert.Equal("Test1", results[0].Uid);
-        Assert.Equal("Hello", results[0].Metadata["remarks"]);
-        Assert.Equal("\n<p sourcefile=\"ut_ReadMarkdownAsOverwrite.md\" sourcestartlinenumber=\"5\">This is unit test!</p>\n", results[0].Conceptual);
-        Assert.Equal("Test2", results[1].Uid);
-        Assert.Equal("", results[1].Conceptual);
+        Assert.IsNotNull(results);
+        Assert.AreEqual(2, results.Count);
+        Assert.AreEqual("Test1", results[0].Uid);
+        Assert.AreEqual("Hello", results[0].Metadata["remarks"]);
+        Assert.AreEqual("\n<p sourcefile=\"ut_ReadMarkdownAsOverwrite.md\" sourcestartlinenumber=\"5\">This is unit test!</p>\n", results[0].Conceptual);
+        Assert.AreEqual("Test2", results[1].Uid);
+        Assert.AreEqual("", results[1].Conceptual);
         File.Delete(fileName);
 
         // Test conceptual content with extra empty line between two yamlheader
@@ -102,24 +102,24 @@ This is unit test!
         content = Regex.Replace(content, "\r?\n", "\r\n");
         File.WriteAllText(fileName, content);
         results = MarkdownReader.ReadMarkdownAsOverwrite(host, ft).ToList();
-        Assert.NotNull(results);
-        Assert.Equal(2, results.Count);
-        Assert.Equal("Test1", results[0].Uid);
-        Assert.Equal("Test2", results[1].Uid);
-        Assert.Equal("Hello", results[0].Metadata["remarks"]);
-        Assert.Equal("\n<p sourcefile=\"ut_ReadMarkdownAsOverwrite.md\" sourcestartlinenumber=\"7\">This is unit test!</p>\n", results[0].Conceptual);
-        Assert.Equal(string.Empty, results[1].Conceptual);
+        Assert.IsNotNull(results);
+        Assert.AreEqual(2, results.Count);
+        Assert.AreEqual("Test1", results[0].Uid);
+        Assert.AreEqual("Test2", results[1].Uid);
+        Assert.AreEqual("Hello", results[0].Metadata["remarks"]);
+        Assert.AreEqual("\n<p sourcefile=\"ut_ReadMarkdownAsOverwrite.md\" sourcestartlinenumber=\"7\">This is unit test!</p>\n", results[0].Conceptual);
+        Assert.AreEqual(string.Empty, results[1].Conceptual);
         File.Delete(fileName);
 
         // Test different line ending
         content = "---\nuid: Test\nremarks: Hello\n---\nThis is unit test!\n";
         File.WriteAllText(fileName, content);
         results = MarkdownReader.ReadMarkdownAsOverwrite(host, ft).ToList();
-        Assert.NotNull(results);
-        Assert.Single(results);
-        Assert.Equal("Test", results[0].Uid);
-        Assert.Equal("Hello", results[0].Metadata["remarks"]);
-        Assert.Equal("\n<p sourcefile=\"ut_ReadMarkdownAsOverwrite.md\" sourcestartlinenumber=\"5\">This is unit test!</p>\n", results[0].Conceptual);
+        Assert.IsNotNull(results);
+        Assert.ContainsSingle(results);
+        Assert.AreEqual("Test", results[0].Uid);
+        Assert.AreEqual("Hello", results[0].Metadata["remarks"]);
+        Assert.AreEqual("\n<p sourcefile=\"ut_ReadMarkdownAsOverwrite.md\" sourcestartlinenumber=\"5\">This is unit test!</p>\n", results[0].Conceptual);
         File.Delete(fileName);
 
         // Test link to files and Uids in overwrite document
@@ -136,47 +136,46 @@ [Not exist link2](link2.md)
         content = Regex.Replace(content, "\r?\n", "\r\n");
         File.WriteAllText(fileName, content);
         results = MarkdownReader.ReadMarkdownAsOverwrite(host, ft).ToList();
-        Assert.NotNull(results);
-        Assert.Single(results);
-        Assert.Equal("Test", results[0].Uid);
-        Assert.Equal("Hello", results[0].Metadata["remarks"]);
-        Assert.Equal(2, results[0].LinkToFiles.Count);
-        Assert.True(results[0].LinkToFiles.OrderBy(f => f).SequenceEqual(new[] { "~/link.md", "~/link2.md", }));
-        Assert.Single(results[0].LinkToUids);
-        Assert.Equal("NotExistUid", results[0].LinkToUids.ElementAt(0));
-        Assert.Equal(2, results[0].FileLinkSources.Count);
+        Assert.IsNotNull(results);
+        Assert.ContainsSingle(results);
+        Assert.AreEqual("Test", results[0].Uid);
+        Assert.AreEqual("Hello", results[0].Metadata["remarks"]);
+        Assert.AreEqual(2, results[0].LinkToFiles.Count);
+        Assert.IsTrue(results[0].LinkToFiles.OrderBy(f => f).SequenceEqual(new[] { "~/link.md", "~/link2.md", }));
+        Assert.ContainsSingle(results[0].LinkToUids);
+        Assert.AreEqual("NotExistUid", results[0].LinkToUids.ElementAt(0));
+        Assert.AreEqual(2, results[0].FileLinkSources.Count);
         var fileLinkSource0 = results[0].FileLinkSources["~/link.md"];
-        Assert.NotNull(fileLinkSource0);
-        Assert.Single(fileLinkSource0);
-        Assert.Null(fileLinkSource0[0].Anchor);
-        Assert.Equal(7, fileLinkSource0[0].LineNumber);
-        Assert.Equal(fileName, fileLinkSource0[0].SourceFile);
-        Assert.Equal("~/link.md", fileLinkSource0[0].Target);
-        Assert.Single(results[0].UidLinkSources);
+        Assert.IsNotNull(fileLinkSource0);
+        Assert.ContainsSingle(fileLinkSource0);
+        Assert.IsNull(fileLinkSource0[0].Anchor);
+        Assert.AreEqual(7, fileLinkSource0[0].LineNumber);
+        Assert.AreEqual(fileName, fileLinkSource0[0].SourceFile);
+        Assert.AreEqual("~/link.md", fileLinkSource0[0].Target);
+        Assert.ContainsSingle(results[0].UidLinkSources);
         var fileLinkSource1 = results[0].FileLinkSources["~/link2.md"];
-        Assert.NotNull(fileLinkSource1);
-        Assert.Single(fileLinkSource1);
-        Assert.Null(fileLinkSource1[0].Anchor);
-        Assert.Equal(8, fileLinkSource1[0].LineNumber);
-        Assert.Equal(fileName, fileLinkSource1[0].SourceFile);
-        Assert.Equal("~/link2.md", fileLinkSource1[0].Target);
-        Assert.Single(results[0].UidLinkSources);
+        Assert.IsNotNull(fileLinkSource1);
+        Assert.ContainsSingle(fileLinkSource1);
+        Assert.IsNull(fileLinkSource1[0].Anchor);
+        Assert.AreEqual(8, fileLinkSource1[0].LineNumber);
+        Assert.AreEqual(fileName, fileLinkSource1[0].SourceFile);
+        Assert.AreEqual("~/link2.md", fileLinkSource1[0].Target);
+        Assert.ContainsSingle(results[0].UidLinkSources);
         var uidLinkSource = results[0].UidLinkSources["NotExistUid"];
-        Assert.NotNull(uidLinkSource);
-        Assert.Single(uidLinkSource);
-        Assert.Null(uidLinkSource[0].Anchor);
-        Assert.Equal(5, uidLinkSource[0].LineNumber);
-        Assert.Equal(fileName, uidLinkSource[0].SourceFile);
-        Assert.Equal("NotExistUid", uidLinkSource[0].Target);
-        Assert.Equal(
+        Assert.IsNotNull(uidLinkSource);
+        Assert.ContainsSingle(uidLinkSource);
+        Assert.IsNull(uidLinkSource[0].Anchor);
+        Assert.AreEqual(5, uidLinkSource[0].LineNumber);
+        Assert.AreEqual(fileName, uidLinkSource[0].SourceFile);
+        Assert.AreEqual("NotExistUid", uidLinkSource[0].Target);
+        Assert.AreEqual(
             """
                 <p sourcefile="ut_ReadMarkdownAsOverwrite.md" sourcestartlinenumber="5"><xref href="NotExistUid" data-throw-if-not-resolved="False" data-raw-source="@NotExistUid" sourcefile="ut_ReadMarkdownAsOverwrite.md" sourcestartlinenumber="5"></xref></p>
                 <p sourcefile="ut_ReadMarkdownAsOverwrite.md" sourcestartlinenumber="7"><a href="link.md" sourcefile="ut_ReadMarkdownAsOverwrite.md" sourcestartlinenumber="7">Not exist link</a>
                 <a href="link2.md" sourcefile="ut_ReadMarkdownAsOverwrite.md" sourcestartlinenumber="8">Not exist link2</a></p>
                 <p sourcefile="ut_ReadMarkdownAsOverwrite.md" sourcestartlinenumber="10">This is unit test!</p>
-                """,
-            results[0].Conceptual.Trim(),
-            ignoreLineEndingDifferences: true);
+                """.ReplaceLineEndings(),
+            results[0].Conceptual.Trim().ReplaceLineEndings());
         File.Delete(fileName);
     }
 }
diff --git a/test/Docfx.Build.Common.Tests/ModelAttributeHandlerTest.cs b/test/Docfx.Build.Common.Tests/ModelAttributeHandlerTest.cs
index 79047dc6bb0..276fe344be8 100644
--- a/test/Docfx.Build.Common.Tests/ModelAttributeHandlerTest.cs
+++ b/test/Docfx.Build.Common.Tests/ModelAttributeHandlerTest.cs
@@ -6,15 +6,15 @@
 using Docfx.DataContracts.Common;
 using Docfx.MarkdigEngine;
 using Docfx.Plugins;
-using Xunit;
 
 namespace Docfx.Build.Common.Tests;
 
+[TestClass]
 public class ModelAttributeHandlerTest
 {
     #region UniqueIdentityAttribute
 
-    [Fact]
+    [TestMethod]
     public void TestSimpleModelWithUniqueIdentityReferenceAttributeShouldSucceed()
     {
         var model = new SimpleModel
@@ -25,12 +25,12 @@ public void TestSimpleModelWithUniqueIdentityReferenceAttributeShouldSucceed()
 
         var context = Handle(model);
 
-        Assert.Equal(2, context.LinkToUids.Count);
+        Assert.AreEqual(2, context.LinkToUids.Count);
         Assert.Contains(model.Identity, context.LinkToUids);
         Assert.Contains(model.Identities[0], context.LinkToUids);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestModelWithLoopShouldSucceed()
     {
         var model = new LoopModel
@@ -40,10 +40,10 @@ public void TestModelWithLoopShouldSucceed()
         };
         model.Reference = model;
         var context = Handle(model);
-        Assert.Single(context.LinkToUids);
+        Assert.ContainsSingle(context.LinkToUids);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestModelWithInvalidTypeShouldThrow()
     {
         var model = new InvalidModel
@@ -56,7 +56,7 @@ public void TestModelWithInvalidTypeShouldThrow()
             );
     }
 
-    [Fact]
+    [TestMethod]
     public void TestModelWithInvalidItemTypeShouldThrow()
     {
         var model = new InvalidModel2
@@ -68,7 +68,7 @@ public void TestModelWithInvalidItemTypeShouldThrow()
             );
     }
 
-    [Fact]
+    [TestMethod]
     public void TestComplexModelWithUniqueIdentityReferenceAttributeShouldSucceed()
     {
         var model = new ComplexModel
@@ -104,17 +104,17 @@ public void TestComplexModelWithUniqueIdentityReferenceAttributeShouldSucceed()
         };
         var context = Handle(model);
 
-        Assert.Equal(12, context.LinkToUids.Count);
-        Assert.Equal(new List<string> {
+        Assert.AreEqual(12, context.LinkToUids.Count);
+        CollectionAssert.AreEqual(new string[] {
             "0", "0.0", "0.0.0", "1", "1.1", "1.1.1","1.1.2", "1.2", "1.3","2",  "2.2", "3",
-        }, context.LinkToUids.OrderBy(x => x));
+        }, context.LinkToUids.OrderBy(x => x).ToArray());
     }
 
     #endregion
 
     #region MarkdownContentAttribute
 
-    [Fact]
+    [TestMethod]
     public void TestSimpleModelWithMarkdownContentAttributeShouldSucceed()
     {
         var model = new MarkdownModel1
@@ -130,17 +130,17 @@ public void TestSimpleModelWithMarkdownContentAttributeShouldSucceed()
 
         var context = Handle(model);
 
-        Assert.Single(context.LinkToUids);
-        Assert.Single(context.LinkToFiles);
-        Assert.Single(context.FileLinkSources);
-        Assert.Single(context.UidLinkSources);
-        Assert.Equal(
+        Assert.ContainsSingle(context.LinkToUids);
+        Assert.ContainsSingle(context.LinkToFiles);
+        Assert.ContainsSingle(context.FileLinkSources);
+        Assert.ContainsSingle(context.UidLinkSources);
+        Assert.AreEqual(
             @"<p sourcefile=""test"" sourcestartlinenumber=""1"">Hello <em sourcefile=""test"" sourcestartlinenumber=""1"">world</em>, <xref href=""xref"" data-throw-if-not-resolved=""False"" data-raw-source=""@xref"" sourcefile=""test"" sourcestartlinenumber=""1""></xref>, <a href=""link.md"" sourcefile=""test"" sourcestartlinenumber=""1"">link</a></p>
 ".Replace("\r\n", "\n"),
             model.Content);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestMarkdownContentAttributeWithContentPlaceholderShouldSucceed()
     {
         var model = new MarkdownModel1
@@ -171,22 +171,22 @@ public void TestMarkdownContentAttributeWithContentPlaceholderShouldSucceed()
         context.PlaceholderContent = "placeholder";
         context = Handle(model, context);
 
-        Assert.Single(context.LinkToUids);
-        Assert.Single(context.LinkToFiles);
-        Assert.Single(context.FileLinkSources);
-        Assert.Single(context.UidLinkSources);
+        Assert.ContainsSingle(context.LinkToUids);
+        Assert.ContainsSingle(context.LinkToFiles);
+        Assert.ContainsSingle(context.FileLinkSources);
+        Assert.ContainsSingle(context.UidLinkSources);
         var expected = @"<p sourcefile=""test"" sourcestartlinenumber=""1"">Hello <em sourcefile=""test"" sourcestartlinenumber=""1"">world</em>, <xref href=""xref"" data-throw-if-not-resolved=""False"" data-raw-source=""@xref"" sourcefile=""test"" sourcestartlinenumber=""1""></xref>, <a href=""link.md"" sourcefile=""test"" sourcestartlinenumber=""1"">link</a></p>
 ".Replace("\r\n", "\n");
-        Assert.Equal(expected, model.Content);
-        Assert.Equal(context.PlaceholderContent, model.Content2);
-        Assert.Equal(context.PlaceholderContent, model.Inner.Content);
-        Assert.Equal(context.PlaceholderContent, model.Inner.Content2);
-        Assert.Equal(context.PlaceholderContent, model.Inner.Content3[0]);
-        Assert.Equal(context.PlaceholderContent, model.Inner.Content4["key1"]);
-        Assert.Equal(context.PlaceholderContent, model.Inner.Content5["key1"]);
+        Assert.AreEqual(expected, model.Content);
+        Assert.AreEqual(context.PlaceholderContent, model.Content2);
+        Assert.AreEqual(context.PlaceholderContent, model.Inner.Content);
+        Assert.AreEqual(context.PlaceholderContent, model.Inner.Content2);
+        Assert.AreEqual(context.PlaceholderContent, model.Inner.Content3[0]);
+        Assert.AreEqual(context.PlaceholderContent, model.Inner.Content4["key1"]);
+        Assert.AreEqual(context.PlaceholderContent, model.Inner.Content5["key1"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestMarkdownContentIgnoreAttributeShouldSucceed()
     {
         var model = new MarkdownModelWithIgnore
@@ -218,22 +218,22 @@ public void TestMarkdownContentIgnoreAttributeShouldSucceed()
         context.PlaceholderContent = "placeholder";
         context = Handle(model, context);
 
-        Assert.Equal(3, context.LinkToUids.Count);
-        Assert.Single(context.LinkToFiles);
-        Assert.Single(context.FileLinkSources);
-        Assert.Single(context.UidLinkSources);
+        Assert.AreEqual(3, context.LinkToUids.Count);
+        Assert.ContainsSingle(context.LinkToFiles);
+        Assert.ContainsSingle(context.FileLinkSources);
+        Assert.ContainsSingle(context.UidLinkSources);
         var expected = @"<p sourcefile=""test"" sourcestartlinenumber=""1"">Hello <em sourcefile=""test"" sourcestartlinenumber=""1"">world</em>, <xref href=""xref"" data-throw-if-not-resolved=""False"" data-raw-source=""@xref"" sourcefile=""test"" sourcestartlinenumber=""1""></xref>, <a href=""link.md"" sourcefile=""test"" sourcestartlinenumber=""1"">link</a></p>
 ".Replace("\r\n", "\n");
-        Assert.Equal(expected, model.Content);
-        Assert.Equal(context.PlaceholderContent, model.Content2);
-        Assert.Equal("*content", model.Inner.Content);
-        Assert.Equal("*content", model.Inner.Content2);
-        Assert.Equal("Identity1", model.Inner.Content3[0]);
-        Assert.Equal("*content", model.Inner.Content4["key1"]);
-        Assert.Equal("*content", model.Inner.Content5["key1"]);
+        Assert.AreEqual(expected, model.Content);
+        Assert.AreEqual(context.PlaceholderContent, model.Content2);
+        Assert.AreEqual("*content", model.Inner.Content);
+        Assert.AreEqual("*content", model.Inner.Content2);
+        Assert.AreEqual("Identity1", model.Inner.Content3[0]);
+        Assert.AreEqual("*content", model.Inner.Content4["key1"]);
+        Assert.AreEqual("*content", model.Inner.Content5["key1"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TesteModelWithIListMarkdownContentAttributeShouldSucceed()
     {
         var model = new MarkdownModelWithIList
@@ -247,20 +247,20 @@ public void TesteModelWithIListMarkdownContentAttributeShouldSucceed()
         context.PlaceholderContent = "placeholder";
         context = Handle(model, context);
 
-        Assert.Single(context.LinkToUids);
-        Assert.Empty(context.LinkToFiles);
-        Assert.Empty(context.FileLinkSources);
-        Assert.Single(context.UidLinkSources);
-        Assert.Equal("<p sourcefile=\"test\" sourcestartlinenumber=\"1\"><em sourcefile=\"test\" sourcestartlinenumber=\"1\">list</em></p>\n", model.ListContent[0]);
-        Assert.Equal("<p sourcefile=\"test\" sourcestartlinenumber=\"1\"><xref href=\"xref\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@xref\" sourcefile=\"test\" sourcestartlinenumber=\"1\"></xref></p>\n", model.ArrayContent[0]);
-        Assert.Equal("placeholder", model.ArrayContent[1]);
+        Assert.ContainsSingle(context.LinkToUids);
+        Assert.IsEmpty(context.LinkToFiles);
+        Assert.IsEmpty(context.FileLinkSources);
+        Assert.ContainsSingle(context.UidLinkSources);
+        Assert.AreEqual("<p sourcefile=\"test\" sourcestartlinenumber=\"1\"><em sourcefile=\"test\" sourcestartlinenumber=\"1\">list</em></p>\n", model.ListContent[0]);
+        Assert.AreEqual("<p sourcefile=\"test\" sourcestartlinenumber=\"1\"><xref href=\"xref\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@xref\" sourcefile=\"test\" sourcestartlinenumber=\"1\"></xref></p>\n", model.ArrayContent[0]);
+        Assert.AreEqual("placeholder", model.ArrayContent[1]);
     }
 
     #endregion
 
     #region UrlContentAttribute
 
-    [Fact]
+    [TestMethod]
     public void TestSimpleModelWithUrlContentAttributeShouldSucceed()
     {
         var model = new SimpleModel
@@ -270,11 +270,11 @@ public void TestSimpleModelWithUrlContentAttributeShouldSucceed()
 
         var context = Handle(model);
 
-        Assert.Empty(context.LinkToUids);
-        Assert.Empty(context.UidLinkSources);
-        Assert.Single(context.LinkToFiles);
-        Assert.Single(context.FileLinkSources);
-        Assert.Equal("~/linkTarget", model.Href);
+        Assert.IsEmpty(context.LinkToUids);
+        Assert.IsEmpty(context.UidLinkSources);
+        Assert.ContainsSingle(context.LinkToFiles);
+        Assert.ContainsSingle(context.FileLinkSources);
+        Assert.AreEqual("~/linkTarget", model.Href);
     }
     #endregion
 
diff --git a/test/Docfx.Build.Common.Tests/ReflectionHelperTest.cs b/test/Docfx.Build.Common.Tests/ReflectionHelperTest.cs
index 70dcd04bf18..4dcbedd8eaf 100644
--- a/test/Docfx.Build.Common.Tests/ReflectionHelperTest.cs
+++ b/test/Docfx.Build.Common.Tests/ReflectionHelperTest.cs
@@ -1,13 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.Build.Common.Tests;
 
+[TestClass]
 public class ReflectionHelperTest
 {
-    [Fact]
+    [TestMethod]
     public void TestGetPropertyValueForClass()
     {
         var obj = new MyClass
@@ -16,12 +15,12 @@ public void TestGetPropertyValueForClass()
             MyProperty2 = 100,
             MyProperty3 = null,
         };
-        Assert.Equal("Hello", ReflectionHelper.GetPropertyValue(obj, typeof(MyClass).GetProperty(nameof(MyClass.MyProperty1))));
-        Assert.Equal(100, ReflectionHelper.GetPropertyValue(obj, typeof(MyClass).GetProperty(nameof(MyClass.MyProperty2))));
-        Assert.Null(ReflectionHelper.GetPropertyValue(obj, typeof(MyClass).GetProperty(nameof(MyClass.MyProperty3))));
+        Assert.AreEqual("Hello", ReflectionHelper.GetPropertyValue(obj, typeof(MyClass).GetProperty(nameof(MyClass.MyProperty1))));
+        Assert.AreEqual(100, ReflectionHelper.GetPropertyValue(obj, typeof(MyClass).GetProperty(nameof(MyClass.MyProperty2))));
+        Assert.IsNull(ReflectionHelper.GetPropertyValue(obj, typeof(MyClass).GetProperty(nameof(MyClass.MyProperty3))));
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGetPropertyValueForStructure()
     {
         var obj = new MyStruct
@@ -30,12 +29,12 @@ public void TestGetPropertyValueForStructure()
             MyProperty2 = 100,
             MyProperty3 = null,
         };
-        Assert.Equal("Hello", ReflectionHelper.GetPropertyValue(obj, typeof(MyStruct).GetProperty(nameof(MyStruct.MyProperty1))));
-        Assert.Equal(100, ReflectionHelper.GetPropertyValue(obj, typeof(MyStruct).GetProperty(nameof(MyStruct.MyProperty2))));
-        Assert.Null(ReflectionHelper.GetPropertyValue(obj, typeof(MyStruct).GetProperty(nameof(MyStruct.MyProperty3))));
+        Assert.AreEqual("Hello", ReflectionHelper.GetPropertyValue(obj, typeof(MyStruct).GetProperty(nameof(MyStruct.MyProperty1))));
+        Assert.AreEqual(100, ReflectionHelper.GetPropertyValue(obj, typeof(MyStruct).GetProperty(nameof(MyStruct.MyProperty2))));
+        Assert.IsNull(ReflectionHelper.GetPropertyValue(obj, typeof(MyStruct).GetProperty(nameof(MyStruct.MyProperty3))));
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGetPropertyValueForClassByInterface()
     {
         var obj = new MyClass
@@ -44,12 +43,12 @@ public void TestGetPropertyValueForClassByInterface()
             MyProperty2 = 100,
             MyProperty3 = null,
         };
-        Assert.Equal("Hello", ReflectionHelper.GetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty1))));
-        Assert.Equal(100, ReflectionHelper.GetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty2))));
-        Assert.Null(ReflectionHelper.GetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty3))));
+        Assert.AreEqual("Hello", ReflectionHelper.GetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty1))));
+        Assert.AreEqual(100, ReflectionHelper.GetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty2))));
+        Assert.IsNull(ReflectionHelper.GetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty3))));
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGetPropertyValueForStructureByInterface()
     {
         var obj = new MyStruct
@@ -58,73 +57,73 @@ public void TestGetPropertyValueForStructureByInterface()
             MyProperty2 = 100,
             MyProperty3 = null,
         };
-        Assert.Equal("Hello", ReflectionHelper.GetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty1))));
-        Assert.Equal(100, ReflectionHelper.GetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty2))));
-        Assert.Null(ReflectionHelper.GetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty3))));
+        Assert.AreEqual("Hello", ReflectionHelper.GetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty1))));
+        Assert.AreEqual(100, ReflectionHelper.GetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty2))));
+        Assert.IsNull(ReflectionHelper.GetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty3))));
     }
 
-    [Fact]
+    [TestMethod]
     public void TestSetPropertyValueForClass()
     {
         var obj = new MyClass();
         ReflectionHelper.SetPropertyValue(obj, typeof(MyClass).GetProperty(nameof(MyClass.MyProperty1)), "Hello");
-        Assert.Equal("Hello", obj.MyProperty1);
+        Assert.AreEqual("Hello", obj.MyProperty1);
         ReflectionHelper.SetPropertyValue(obj, typeof(MyClass).GetProperty(nameof(MyClass.MyProperty1)), null);
-        Assert.Null(obj.MyProperty1);
+        Assert.IsNull(obj.MyProperty1);
         ReflectionHelper.SetPropertyValue(obj, typeof(MyClass).GetProperty(nameof(MyClass.MyProperty2)), 100);
-        Assert.Equal(100, obj.MyProperty2);
+        Assert.AreEqual(100, obj.MyProperty2);
         ReflectionHelper.SetPropertyValue(obj, typeof(MyClass).GetProperty(nameof(MyClass.MyProperty3)), true);
-        Assert.True(obj.MyProperty3);
+        Assert.IsTrue(obj.MyProperty3);
         ReflectionHelper.SetPropertyValue(obj, typeof(MyClass).GetProperty(nameof(MyClass.MyProperty3)), null);
-        Assert.Null(obj.MyProperty3);
+        Assert.IsNull(obj.MyProperty3);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestSetPropertyValueForStructure()
     {
         object obj = new MyStruct();
         ReflectionHelper.SetPropertyValue(obj, typeof(MyStruct).GetProperty(nameof(MyStruct.MyProperty1)), "Hello");
-        Assert.Equal("Hello", ((MyStruct)obj).MyProperty1);
+        Assert.AreEqual("Hello", ((MyStruct)obj).MyProperty1);
         ReflectionHelper.SetPropertyValue(obj, typeof(MyStruct).GetProperty(nameof(MyStruct.MyProperty1)), null);
-        Assert.Null(((MyStruct)obj).MyProperty1);
+        Assert.IsNull(((MyStruct)obj).MyProperty1);
         ReflectionHelper.SetPropertyValue(obj, typeof(MyStruct).GetProperty(nameof(MyStruct.MyProperty2)), 100);
-        Assert.Equal(100, ((MyStruct)obj).MyProperty2);
+        Assert.AreEqual(100, ((MyStruct)obj).MyProperty2);
         ReflectionHelper.SetPropertyValue(obj, typeof(MyStruct).GetProperty(nameof(MyStruct.MyProperty3)), true);
-        Assert.True(((MyStruct)obj).MyProperty3);
+        Assert.IsTrue(((MyStruct)obj).MyProperty3);
         ReflectionHelper.SetPropertyValue(obj, typeof(MyStruct).GetProperty(nameof(MyStruct.MyProperty3)), null);
-        Assert.Null(((MyStruct)obj).MyProperty3);
+        Assert.IsNull(((MyStruct)obj).MyProperty3);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestSetPropertyValueForClassByInterface()
     {
         var obj = new MyClass();
         ReflectionHelper.SetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty1)), "Hello");
-        Assert.Equal("Hello", obj.MyProperty1);
+        Assert.AreEqual("Hello", obj.MyProperty1);
         ReflectionHelper.SetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty1)), null);
-        Assert.Null(obj.MyProperty1);
+        Assert.IsNull(obj.MyProperty1);
         ReflectionHelper.SetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty2)), 100);
-        Assert.Equal(100, obj.MyProperty2);
+        Assert.AreEqual(100, obj.MyProperty2);
         ReflectionHelper.SetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty3)), true);
-        Assert.True(obj.MyProperty3);
+        Assert.IsTrue(obj.MyProperty3);
         ReflectionHelper.SetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty3)), null);
-        Assert.Null(obj.MyProperty3);
+        Assert.IsNull(obj.MyProperty3);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestSetPropertyValueForStructureByInterface()
     {
         MyInterface obj = new MyStruct();
         ReflectionHelper.SetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty1)), "Hello");
-        Assert.Equal("Hello", obj.MyProperty1);
+        Assert.AreEqual("Hello", obj.MyProperty1);
         ReflectionHelper.SetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty1)), null);
-        Assert.Null(obj.MyProperty1);
+        Assert.IsNull(obj.MyProperty1);
         ReflectionHelper.SetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty2)), 100);
-        Assert.Equal(100, obj.MyProperty2);
+        Assert.AreEqual(100, obj.MyProperty2);
         ReflectionHelper.SetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty3)), true);
-        Assert.True(obj.MyProperty3);
+        Assert.IsTrue(obj.MyProperty3);
         ReflectionHelper.SetPropertyValue(obj, typeof(MyInterface).GetProperty(nameof(MyInterface.MyProperty3)), null);
-        Assert.Null(obj.MyProperty3);
+        Assert.IsNull(obj.MyProperty3);
     }
 
     public class MyClass : MyInterface
diff --git a/test/Docfx.Build.ManagedReference.Tests/ManagedReferenceDocumentProcessorTest.cs b/test/Docfx.Build.ManagedReference.Tests/ManagedReferenceDocumentProcessorTest.cs
index 1c46adc1a98..6e5e5528142 100644
--- a/test/Docfx.Build.ManagedReference.Tests/ManagedReferenceDocumentProcessorTest.cs
+++ b/test/Docfx.Build.ManagedReference.Tests/ManagedReferenceDocumentProcessorTest.cs
@@ -11,10 +11,10 @@
 using Docfx.Tests.Common;
 
 using Newtonsoft.Json.Linq;
-using Xunit;
 
 namespace Docfx.Build.ManagedReference.Tests;
 
+[TestClass]
 public class ManagedReferenceDocumentProcessorTest : TestBase
 {
     private readonly string _outputFolder;
@@ -40,55 +40,55 @@ public ManagedReferenceDocumentProcessorTest()
         _templateManager = new TemplateManager(["template"], null, "TestData/");
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMrefShouldSucceed()
     {
         FileCollection files = new(_defaultFiles);
         BuildDocument(files);
 
         var outputRawModelPath = GetRawModelFilePath("CatLibrary.Cat-2.yml");
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<ApiBuildOutput>(outputRawModelPath);
-        Assert.NotNull(model);
+        Assert.IsNotNull(model);
 
-        Assert.Equal("Hello world!", model.Metadata["meta"]);
-        Assert.Equal("item level metadata should overwrite page level metadata.", model.Metadata["anotherMeta"]);
-        Assert.Single(model.Attributes);
-        Assert.Equal("System.SerializableAttribute.#ctor", model.Attributes[0].Constructor);
-        Assert.Empty(model.Attributes[0].Arguments);
-        Assert.Equal("System.SerializableAttribute", model.Attributes[0].Type);
+        Assert.AreEqual("Hello world!", model.Metadata["meta"]);
+        Assert.AreEqual("item level metadata should overwrite page level metadata.", model.Metadata["anotherMeta"]);
+        Assert.ContainsSingle(model.Attributes);
+        Assert.AreEqual("System.SerializableAttribute.#ctor", model.Attributes[0].Constructor);
+        Assert.IsEmpty(model.Attributes[0].Arguments);
+        Assert.AreEqual("System.SerializableAttribute", model.Attributes[0].Type);
 
-        Assert.Equal(2, model.Implements.Count);
+        Assert.AreEqual(2, model.Implements.Count);
 
-        Assert.Single(model.Inheritance);
+        Assert.ContainsSingle(model.Inheritance);
 
-        Assert.Equal(6, model.InheritedMembers.Count);
+        Assert.AreEqual(6, model.InheritedMembers.Count);
 
-        Assert.Equal(2, model.Syntax.Content.Count);
-        Assert.Equal("csharp", model.Syntax.Content[0].Language);
-        Assert.Equal("<p>[A](http://A/).</p>\n", model.AdditionalNotes.Implementer);
-        Assert.Equal("[Serializable]\npublic class Cat<T, K> : ICat, IAnimal where T : class, new ()where K : struct", model.Syntax.Content[0].Value);
-        Assert.Equal("vb", model.Syntax.Content[1].Language);
-        Assert.Equal("<Serializable>\nPublic Class Cat(Of T As {Class, New}, K As Structure)\n    Implements ICat, IAnimal", model.Syntax.Content[1].Value);
+        Assert.AreEqual(2, model.Syntax.Content.Count);
+        Assert.AreEqual("csharp", model.Syntax.Content[0].Language);
+        Assert.AreEqual("<p>[A](http://A/).</p>\n", model.AdditionalNotes.Implementer);
+        Assert.AreEqual("[Serializable]\npublic class Cat<T, K> : ICat, IAnimal where T : class, new ()where K : struct", model.Syntax.Content[0].Value);
+        Assert.AreEqual("vb", model.Syntax.Content[1].Language);
+        Assert.AreEqual("<Serializable>\nPublic Class Cat(Of T As {Class, New}, K As Structure)\n    Implements ICat, IAnimal", model.Syntax.Content[1].Value);
 
-        Assert.Equal(2, model.Syntax.TypeParameters.Count);
-        Assert.Equal("T", model.Syntax.TypeParameters[0].Name);
-        Assert.Equal("<p sourcefile=\"TestData/mref/CatLibrary.Cat-2.yml\" sourcestartlinenumber=\"1\">This type should be class and can new instance.</p>\n", model.Syntax.TypeParameters[0].Description);
-        Assert.Equal("K", model.Syntax.TypeParameters[1].Name);
-        Assert.Equal("<p sourcefile=\"TestData/mref/CatLibrary.Cat-2.yml\" sourcestartlinenumber=\"1\">This type is a struct type, class type can't be used for this parameter.</p>\n", model.Syntax.TypeParameters[1].Description);
+        Assert.AreEqual(2, model.Syntax.TypeParameters.Count);
+        Assert.AreEqual("T", model.Syntax.TypeParameters[0].Name);
+        Assert.AreEqual("<p sourcefile=\"TestData/mref/CatLibrary.Cat-2.yml\" sourcestartlinenumber=\"1\">This type should be class and can new instance.</p>\n", model.Syntax.TypeParameters[0].Description);
+        Assert.AreEqual("K", model.Syntax.TypeParameters[1].Name);
+        Assert.AreEqual("<p sourcefile=\"TestData/mref/CatLibrary.Cat-2.yml\" sourcestartlinenumber=\"1\">This type is a struct type, class type can't be used for this parameter.</p>\n", model.Syntax.TypeParameters[1].Description);
 
-        Assert.Single(model.Examples);
-        Assert.Equal("<p>Here's example of how to create an instance of **Cat** class. As T is limited with <code>class</code> and K is limited with <code>struct</code>.</p>\n<pre><code class=\"c#\">    var a = new Cat(object, int)();\n    int catNumber = new int();\n    unsafe\n    {\n        a.GetFeetLength(catNumber);\n    }</code></pre>\n<p>As you see, here we bring in <strong>pointer</strong> so we need to add <span class=\"languagekeyword\">unsafe</span> keyword.</p>\n", model.Examples[0]);
+        Assert.ContainsSingle(model.Examples);
+        Assert.AreEqual("<p>Here's example of how to create an instance of **Cat** class. As T is limited with <code>class</code> and K is limited with <code>struct</code>.</p>\n<pre><code class=\"c#\">    var a = new Cat(object, int)();\n    int catNumber = new int();\n    unsafe\n    {\n        a.GetFeetLength(catNumber);\n    }</code></pre>\n<p>As you see, here we bring in <strong>pointer</strong> so we need to add <span class=\"languagekeyword\">unsafe</span> keyword.</p>\n", model.Examples[0]);
 
-        Assert.Equal(20, model.Children.Count);
+        Assert.AreEqual(20, model.Children.Count);
         var cm = model.Children[1];
-        Assert.Equal("<p>[A](http://A/).</p>\n", cm.AdditionalNotes.Implementer);
-        Assert.Equal("<p>[B](http://B/).</p>\n", cm.AdditionalNotes.Inheritor);
-        Assert.Equal("<p>[C](http://C/).</p>\n", cm.AdditionalNotes.Caller);
+        Assert.AreEqual("<p>[A](http://A/).</p>\n", cm.AdditionalNotes.Implementer);
+        Assert.AreEqual("<p>[B](http://B/).</p>\n", cm.AdditionalNotes.Inheritor);
+        Assert.AreEqual("<p>[C](http://C/).</p>\n", cm.AdditionalNotes.Caller);
 
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMrefWithComplexFileNameShouldSucceed()
     {
         FileCollection files = new(_defaultFiles);
@@ -97,35 +97,35 @@ public void ProcessMrefWithComplexFileNameShouldSucceed()
         BuildDocument(files);
 
         var outputRawModelPath = GetRawModelFilePath("Namespace1.Class1`2.yml");
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<ApiBuildOutput>(outputRawModelPath);
-        Assert.NotNull(model);
+        Assert.IsNotNull(model);
         outputRawModelPath = GetRawModelFilePath("Namespace1.Class1`2.#ctor.yml");
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         model = JsonUtility.Deserialize<ApiBuildOutput>(outputRawModelPath);
-        Assert.NotNull(model);
+        Assert.IsNotNull(model);
         var outputHtml = GetOutputFilePath("mref/Namespace1.Class1`2.html");
-        Assert.True(File.Exists(outputHtml));
+        Assert.IsTrue(File.Exists(outputHtml));
         var content = File.ReadAllText(outputHtml);
-        Assert.Equal("<p><a class=\"xref\" href=\"Namespace1.Class1%602.%23ctor.html#constructor\">Constructor</a></p>\n", content);
+        Assert.AreEqual("<p><a class=\"xref\" href=\"Namespace1.Class1%602.%23ctor.html#constructor\">Constructor</a></p>\n", content);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMrefWithXRefMapShouldSucceed()
     {
         var files = new FileCollection(_defaultFiles);
         BuildDocument(files);
 
         var xrefMapPath = Path.Combine(Directory.GetCurrentDirectory(), _outputFolder, XRefArchive.MajorFileName);
-        Assert.True(File.Exists(xrefMapPath));
+        Assert.IsTrue(File.Exists(xrefMapPath));
 
         var xrefMap = YamlUtility.Deserialize<XRefMap>(xrefMapPath);
 
-        Assert.NotNull(xrefMap.References);
-        Assert.Equal(34, xrefMap.References.Count);
+        Assert.IsNotNull(xrefMap.References);
+        Assert.AreEqual(34, xrefMap.References.Count);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMrefWithDefaultOverwriteShouldSucceed()
     {
         FileCollection files = new(_defaultFiles);
@@ -133,46 +133,46 @@ public void ProcessMrefWithDefaultOverwriteShouldSucceed()
         BuildDocument(files);
         {
             var outputRawModelPath = GetRawModelFilePath("CatLibrary.Cat-2.yml");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<ApiBuildOutput>(outputRawModelPath);
-            Assert.Equal("<p sourcefile=\"TestData/overwrite/mref.overwrite.default.md\" sourcestartlinenumber=\"1\">Overwrite summary</p>", model.Children[0].Metadata["summary"].ToString().Trim());
-            Assert.Equal("<p sourcefile=\"TestData/overwrite/mref.overwrite.default.md\" sourcestartlinenumber=\"6\">Overwrite content</p>", model.Children[0].Conceptual.Trim());
+            Assert.AreEqual("<p sourcefile=\"TestData/overwrite/mref.overwrite.default.md\" sourcestartlinenumber=\"1\">Overwrite summary</p>", model.Children[0].Metadata["summary"].ToString().Trim());
+            Assert.AreEqual("<p sourcefile=\"TestData/overwrite/mref.overwrite.default.md\" sourcestartlinenumber=\"6\">Overwrite content</p>", model.Children[0].Conceptual.Trim());
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMrefWithSimpleOverwriteShouldSucceed()
     {
         FileCollection files = new(_defaultFiles);
         files.Add(DocumentType.Overwrite, ["TestData/overwrite/mref.overwrite.simple.md"]);
         BuildDocument(files);
         var outputRawModelPath = GetRawModelFilePath("CatLibrary.Cat-2.yml");
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<ApiBuildOutput>(outputRawModelPath);
-        Assert.Equal("\n<p sourcefile=\"TestData/overwrite/mref.overwrite.simple.md\" sourcestartlinenumber=\"6\">Overwrite content</p>\n", model.Summary);
-        Assert.Null(model.Conceptual);
+        Assert.AreEqual("\n<p sourcefile=\"TestData/overwrite/mref.overwrite.simple.md\" sourcestartlinenumber=\"6\">Overwrite content</p>\n", model.Summary);
+        Assert.IsNull(model.Conceptual);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMrefWithParametersOverwriteShouldSucceed()
     {
         var files = new FileCollection(_defaultFiles);
         files.Add(DocumentType.Overwrite, ["TestData/overwrite/mref.overwrite.parameters.md"]);
         BuildDocument(files);
         var outputRawModelPath = GetRawModelFilePath("CatLibrary.Cat-2.yml");
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<ApiBuildOutput>(outputRawModelPath);
 
         var method = model.Children.First(s => s.Uid == "CatLibrary.Cat`2.CatLibrary#IAnimal#Eat``1(``0)");
 
         // Verify overwrite parameters
-        Assert.Equal("<p sourcefile=\"TestData/overwrite/mref.overwrite.parameters.md\" sourcestartlinenumber=\"1\">The overwritten description for a</p>\n", method.Syntax.Parameters[0].Description);
-        Assert.NotNull(method.Syntax.Parameters[0].Type);
-        Assert.Equal("\n<p sourcefile=\"TestData/overwrite/mref.overwrite.parameters.md\" sourcestartlinenumber=\"12\">This is overwritten type parameters</p>\n", method.Syntax.TypeParameters[0].Description);
-        Assert.Null(model.Conceptual);
+        Assert.AreEqual("<p sourcefile=\"TestData/overwrite/mref.overwrite.parameters.md\" sourcestartlinenumber=\"1\">The overwritten description for a</p>\n", method.Syntax.Parameters[0].Description);
+        Assert.IsNotNull(method.Syntax.Parameters[0].Type);
+        Assert.AreEqual("\n<p sourcefile=\"TestData/overwrite/mref.overwrite.parameters.md\" sourcestartlinenumber=\"12\">This is overwritten type parameters</p>\n", method.Syntax.TypeParameters[0].Description);
+        Assert.IsNull(model.Conceptual);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMrefWithNotPredefinedOverwriteShouldSucceed()
     {
         FileCollection files = new(_defaultFiles);
@@ -180,15 +180,15 @@ public void ProcessMrefWithNotPredefinedOverwriteShouldSucceed()
         BuildDocument(files);
         {
             var outputRawModelPath = GetRawModelFilePath("CatLibrary.Cat-2.yml");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<ApiBuildOutput>(outputRawModelPath);
 
-            Assert.Equal("\n<p sourcefile=\"TestData/overwrite/mref.overwrite.not.predefined.md\" sourcestartlinenumber=\"6\">Overwrite content</p>\n"
+            Assert.AreEqual("\n<p sourcefile=\"TestData/overwrite/mref.overwrite.not.predefined.md\" sourcestartlinenumber=\"6\">Overwrite content</p>\n"
                 , model.Metadata["not_defined_property"]);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMrefWithDynamicDevLangsShouldSucceed()
     {
         FileCollection files = new(_defaultFiles);
@@ -198,19 +198,19 @@ public void ProcessMrefWithDynamicDevLangsShouldSucceed()
         BuildDocument(files);
 
         var outputRawModelPath = GetRawModelFilePath("System.String.yml");
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<ApiBuildOutput>(outputRawModelPath);
-        Assert.NotNull(model);
-        Assert.NotNull(model.Syntax);
-        Assert.NotNull(model.Syntax.Content);
-        Assert.Equal(4, model.Syntax.Content.Count);
-        Assert.Equal("public ref class String sealed", model.Syntax.Content.First(c => c.Language == "cpp").Value);
-        Assert.Equal("public sealed class String", model.Syntax.Content.First(c => c.Language == "csharp").Value);
-        Assert.Equal("type String", model.Syntax.Content.First(c => c.Language == "fsharp").Value);
-        Assert.Equal("Public NotInheritable Class String", model.Syntax.Content.First(c => c.Language == "vb").Value);
+        Assert.IsNotNull(model);
+        Assert.IsNotNull(model.Syntax);
+        Assert.IsNotNull(model.Syntax.Content);
+        Assert.AreEqual(4, model.Syntax.Content.Count);
+        Assert.AreEqual("public ref class String sealed", model.Syntax.Content.First(c => c.Language == "cpp").Value);
+        Assert.AreEqual("public sealed class String", model.Syntax.Content.First(c => c.Language == "csharp").Value);
+        Assert.AreEqual("type String", model.Syntax.Content.First(c => c.Language == "fsharp").Value);
+        Assert.AreEqual("Public NotInheritable Class String", model.Syntax.Content.First(c => c.Language == "vb").Value);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMrefWithInvalidCrossReferenceShouldWarn()
     {
         var files = new FileCollection(Directory.GetCurrentDirectory());
@@ -222,19 +222,19 @@ public void ProcessMrefWithInvalidCrossReferenceShouldWarn()
         BuildDocument(files);
 
         var warnings = listener.GetItemsByLogLevel(LogLevel.Warning);
-        Assert.Single(warnings);
+        Assert.ContainsSingle(warnings);
         var warning = warnings.Single();
-        Assert.Equal("2 invalid cross reference(s) \"<xref:invalidXref1>\", \"<xref:invalidXref2>\".", warning.Message);
-        Assert.Equal("TestData/mref/System.String.yml", warning.File);
+        Assert.AreEqual("2 invalid cross reference(s) \"<xref:invalidXref1>\", \"<xref:invalidXref2>\".", warning.Message);
+        Assert.AreEqual("TestData/mref/System.String.yml", warning.File);
 
         var infos = listener.GetItemsByLogLevel(LogLevel.Info).Where(i => i.Message.Contains("Details for invalid cross reference(s)")).ToList();
-        Assert.Single(infos);
-        Assert.Equal("Details for invalid cross reference(s): \"<xref:invalidXref1>\" in line 6, \"<xref:invalidXref2>\" in line 8", infos[0].Message);
-        Assert.Equal("TestData/overwrite/mref.overwrite.invalid.ref.md", infos[0].File);
-        Assert.Null(infos[0].Line);
+        Assert.ContainsSingle(infos);
+        Assert.AreEqual("Details for invalid cross reference(s): \"<xref:invalidXref1>\" in line 6, \"<xref:invalidXref2>\" in line 8", infos[0].Message);
+        Assert.AreEqual("TestData/overwrite/mref.overwrite.invalid.ref.md", infos[0].File);
+        Assert.IsNull(infos[0].Line);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMrefWithInvalidOverwriteShouldFail()
     {
         FileCollection files = new(_defaultFiles);
@@ -242,7 +242,7 @@ public void ProcessMrefWithInvalidOverwriteShouldFail()
         Assert.Throws<DocumentException>(() => BuildDocument(files));
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMrefWithRemarksOverwriteShouldSucceed()
     {
         var files = new FileCollection(_defaultFiles);
@@ -250,14 +250,14 @@ public void ProcessMrefWithRemarksOverwriteShouldSucceed()
         BuildDocument(files);
         {
             var outputRawModelPath = GetRawModelFilePath("CatLibrary.Cat-2.yml");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<ApiBuildOutput>(outputRawModelPath);
             var method = model.Children.First(s => s.Uid == "CatLibrary.Cat`2.#ctor(`0)");
-            Assert.Equal("\n<p sourcefile=\"TestData/overwrite/mref.overwrite.remarks.md\" sourcestartlinenumber=\"6\">Remarks content</p>\n", method.Remarks);
+            Assert.AreEqual("\n<p sourcefile=\"TestData/overwrite/mref.overwrite.remarks.md\" sourcestartlinenumber=\"6\">Remarks content</p>\n", method.Remarks);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMrefWithMultiUidOverwriteShouldSucceed()
     {
         var files = new FileCollection(_defaultFiles);
@@ -265,31 +265,31 @@ public void ProcessMrefWithMultiUidOverwriteShouldSucceed()
         BuildDocument(files);
         {
             var outputRawModelPath = GetRawModelFilePath("CatLibrary.Cat-2.yml");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<ApiBuildOutput>(outputRawModelPath);
-            Assert.Equal("\n<p sourcefile=\"TestData/overwrite/mref.overwrite.multi.uid.md\" sourcestartlinenumber=\"6\">Overwrite content1</p>\n", model.Conceptual);
-            Assert.Equal("\n<p sourcefile=\"TestData/overwrite/mref.overwrite.multi.uid.md\" sourcestartlinenumber=\"13\">Overwrite &quot;content2&quot;</p>\n", model.Summary);
-            Assert.Equal("\n<p sourcefile=\"TestData/overwrite/mref.overwrite.multi.uid.md\" sourcestartlinenumber=\"20\">Overwrite 'content3'</p>\n", model.Metadata["not_defined_property"]);
+            Assert.AreEqual("\n<p sourcefile=\"TestData/overwrite/mref.overwrite.multi.uid.md\" sourcestartlinenumber=\"6\">Overwrite content1</p>\n", model.Conceptual);
+            Assert.AreEqual("\n<p sourcefile=\"TestData/overwrite/mref.overwrite.multi.uid.md\" sourcestartlinenumber=\"13\">Overwrite &quot;content2&quot;</p>\n", model.Summary);
+            Assert.AreEqual("\n<p sourcefile=\"TestData/overwrite/mref.overwrite.multi.uid.md\" sourcestartlinenumber=\"20\">Overwrite 'content3'</p>\n", model.Metadata["not_defined_property"]);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void SystemKeysListShouldBeComplete()
     {
         var files = new FileCollection(_defaultFiles);
         BuildDocument(files);
         var outputRawModelPath = GetRawModelFilePath("CatLibrary.Cat-2.yml");
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<Dictionary<string, object>>(outputRawModelPath);
         var systemKeys = ToList(model[Constants.PropertyName.SystemKeys]);
-        Assert.NotEmpty(systemKeys);
+        Assert.IsNotEmpty(systemKeys);
         foreach (var key in model.Keys.Where(key => key[0] != '_' && key != "meta" && key != "anotherMeta"))
         {
             Assert.Contains(key, systemKeys);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void LoadArticleWithEmptyFileShouldWarnAndReturnNull()
     {
         var fileWithNoContent = "TestData/mref/FileWithNoContent.yml";
@@ -301,12 +301,12 @@ public void LoadArticleWithEmptyFileShouldWarnAndReturnNull()
         var actualFileModel = processor.Load(file, null);
 
         var warnings = listener.GetItemsByLogLevel(LogLevel.Warning);
-        Assert.Single(warnings);
+        Assert.ContainsSingle(warnings);
         var warning = warnings.Single();
-        Assert.Equal("Please add `YamlMime` as the first line of file, e.g.: `### YamlMime:ManagedReference`, otherwise the file will be not treated as ManagedReference source file in near future.", warning.Message);
-        Assert.Equal(fileWithNoContent, warning.File);
+        Assert.AreEqual("Please add `YamlMime` as the first line of file, e.g.: `### YamlMime:ManagedReference`, otherwise the file will be not treated as ManagedReference source file in near future.", warning.Message);
+        Assert.AreEqual(fileWithNoContent, warning.File);
 
-        Assert.Null(actualFileModel);
+        Assert.IsNull(actualFileModel);
     }
 
     private void BuildDocument(FileCollection files)
diff --git a/test/Docfx.Build.OverwriteDocuments.Tests/MarkdownFragmentsCreatorTest.cs b/test/Docfx.Build.OverwriteDocuments.Tests/MarkdownFragmentsCreatorTest.cs
index f08c2c55d73..45c76af44d6 100644
--- a/test/Docfx.Build.OverwriteDocuments.Tests/MarkdownFragmentsCreatorTest.cs
+++ b/test/Docfx.Build.OverwriteDocuments.Tests/MarkdownFragmentsCreatorTest.cs
@@ -3,35 +3,35 @@
 
 using Markdig;
 using Markdig.Syntax;
-using Xunit;
 
 namespace Docfx.Build.OverwriteDocuments.Tests;
 
+[TestClass]
 public class MarkdownFragmentsCreatorTest
 {
-    [Fact]
+    [TestMethod]
     public void BaseTest()
     {
         var markdown = File.ReadAllText("TestData/System.String.yml.md");
         var ast = Markdown.Parse(markdown);
         var model = new MarkdownFragmentsCreator().Create(ast).ToList();
 
-        Assert.Equal(2, model.Count);
-        Assert.Equal("System.String", model[0].Uid);
-        Assert.NotNull(model[0].UidSource);
-        Assert.Equal("author: rpetrusha\nms.author: ronpet\nmanager: wpickett", model[0].YamlCodeBlock.Replace("\r", ""));
-        Assert.NotNull(model[0].YamlCodeBlockSource);
-        Assert.Equal(4, model[0].Contents.Count);
-        Assert.Equal("summary", model[0].Contents[0].PropertyName);
-        Assert.NotNull(model[0].Contents[0].PropertyNameSource);
-        Assert.Single(model[0].Contents[0].PropertyValue);
-        Assert.IsType<ParagraphBlock>(model[0].Contents[0].PropertyValue[0]);
-        Assert.Equal("remarks", model[0].Contents[1].PropertyName);
-        Assert.Equal(6, model[0].Contents[1].PropertyValue.Count);
-        Assert.Equal("System.String.#ctor(System.Char*)", model[1].Uid);
+        Assert.AreEqual(2, model.Count);
+        Assert.AreEqual("System.String", model[0].Uid);
+        Assert.IsNotNull(model[0].UidSource);
+        Assert.AreEqual("author: rpetrusha\nms.author: ronpet\nmanager: wpickett", model[0].YamlCodeBlock.Replace("\r", ""));
+        Assert.IsNotNull(model[0].YamlCodeBlockSource);
+        Assert.AreEqual(4, model[0].Contents.Count);
+        Assert.AreEqual("summary", model[0].Contents[0].PropertyName);
+        Assert.IsNotNull(model[0].Contents[0].PropertyNameSource);
+        Assert.ContainsSingle(model[0].Contents[0].PropertyValue);
+        Assert.IsInstanceOfType<ParagraphBlock>(model[0].Contents[0].PropertyValue[0]);
+        Assert.AreEqual("remarks", model[0].Contents[1].PropertyName);
+        Assert.AreEqual(6, model[0].Contents[1].PropertyValue.Count);
+        Assert.AreEqual("System.String.#ctor(System.Char*)", model[1].Uid);
     }
 
-    [Fact]
+    [TestMethod]
     public void MissingStartingH1CodeHeadingShouldFail()
     {
         var markdown = @"## `summary`
@@ -42,11 +42,11 @@ markdown content
         var ast = Markdown.Parse(markdown);
 
         var ex = Assert.Throws<MarkdownFragmentsException>(() => new MarkdownFragmentsCreator().Create(ast).ToList());
-        Assert.Equal("Expect L1InlineCodeHeading", ex.Message);
-        Assert.Equal(0, ex.Position);
+        Assert.AreEqual("Expect L1InlineCodeHeading", ex.Message);
+        Assert.AreEqual(0, ex.Position);
     }
 
-    [Fact]
+    [TestMethod]
     public void MarkdownContentAfterL1CodeHeadingShouldFail()
     {
         var markdown = @"# `Lesson_1`
@@ -62,11 +62,11 @@ markdown content
         var ast = Markdown.Parse(markdown);
 
         var ex = Assert.Throws<MarkdownFragmentsException>(() => new MarkdownFragmentsCreator().Create(ast).ToList());
-        Assert.Equal("Expect L1InlineCodeHeading", ex.Message);
-        Assert.Equal(8, ex.Position);
+        Assert.AreEqual("Expect L1InlineCodeHeading", ex.Message);
+        Assert.AreEqual(8, ex.Position);
     }
 
-    [Fact]
+    [TestMethod]
     public void YamlCodeBlockShouldBeNextToL1CodeHeading()
     {
         var markdown = @"# `YAML`
@@ -82,8 +82,8 @@ public void YamlCodeBlockShouldBeNextToL1CodeHeading()
         var ast = Markdown.Parse(markdown);
         var model = new MarkdownFragmentsCreator().Create(ast).ToList();
 
-        Assert.Null(model[0].YamlCodeBlock);
-        Assert.Null(model[0].YamlCodeBlockSource);
-        Assert.IsType<FencedCodeBlock>(model[0].Contents[0].PropertyValue[1]);
+        Assert.IsNull(model[0].YamlCodeBlock);
+        Assert.IsNull(model[0].YamlCodeBlockSource);
+        Assert.IsInstanceOfType<FencedCodeBlock>(model[0].Contents[0].PropertyValue[1]);
     }
 }
diff --git a/test/Docfx.Build.OverwriteDocuments.Tests/OverwriteDocumentModelCreatorTest.cs b/test/Docfx.Build.OverwriteDocuments.Tests/OverwriteDocumentModelCreatorTest.cs
index 01dbcbe25ee..182329d177e 100644
--- a/test/Docfx.Build.OverwriteDocuments.Tests/OverwriteDocumentModelCreatorTest.cs
+++ b/test/Docfx.Build.OverwriteDocuments.Tests/OverwriteDocumentModelCreatorTest.cs
@@ -6,15 +6,15 @@
 using Markdig;
 using Markdig.Syntax;
 using Newtonsoft.Json.Linq;
-using Xunit;
 
 namespace Docfx.Build.OverwriteDocuments.Tests;
 
+[TestClass]
 public class OverwriteDocumentModelCreatorTest
 {
     private readonly TestLoggerListener _listener = new();
 
-    [Fact]
+    [TestMethod]
     public void YamlCodeBlockTest()
     {
         var yamlCodeBlockString = @"name: name overwrite
@@ -27,13 +27,13 @@ public void YamlCodeBlockTest()
     description: overwrite in yaml block";
         var testYamlCodeBlock = Markdown.Parse($"```\n{yamlCodeBlockString}\n```")[0];
         var actual = JObject.FromObject(OverwriteDocumentModelCreator.ConvertYamlCodeBlock(yamlCodeBlockString, testYamlCodeBlock));
-        Assert.Equal("name overwrite", actual["name"].ToString());
-        Assert.Equal("Application 1", actual["definitions"][0]["name"].ToString());
-        Assert.Equal("id", actual["definitions"][0]["properties"][0]["name"].ToString());
-        Assert.Equal("overwrite in yaml block", actual["definitions"][0]["properties"][1]["description"].ToString());
+        Assert.AreEqual("name overwrite", actual["name"].ToString());
+        Assert.AreEqual("Application 1", actual["definitions"][0]["name"].ToString());
+        Assert.AreEqual("id", actual["definitions"][0]["properties"][0]["name"].ToString());
+        Assert.AreEqual("overwrite in yaml block", actual["definitions"][0]["properties"][1]["description"].ToString());
     }
 
-    [Fact]
+    [TestMethod]
     public void ContentConvertTest()
     {
         var testBlockList = Markdown.Parse("Test").ToList();
@@ -59,23 +59,23 @@ public void ContentConvertTest()
         }
 
         var contentsMetadata = new OverwriteDocumentModelCreator("test.yml.md").ConvertContents([], contents);
-        Assert.Equal(3, contentsMetadata.Count);
-        Assert.Equal("summary,return,function", ExtractDictionaryKeys(contentsMetadata));
-        Assert.Equal(2, ((Dictionary<object, object>)contentsMetadata["return"]).Count);
-        Assert.Equal("description,type",
+        Assert.AreEqual(3, contentsMetadata.Count);
+        Assert.AreEqual("summary,return,function", ExtractDictionaryKeys(contentsMetadata));
+        Assert.AreEqual(2, ((Dictionary<object, object>)contentsMetadata["return"]).Count);
+        Assert.AreEqual("description,type",
             ExtractDictionaryKeys((Dictionary<object, object>)contentsMetadata["return"]));
-        Assert.Single((Dictionary<object, object>)contentsMetadata["function"]);
-        Assert.Equal(2,
+        Assert.ContainsSingle((Dictionary<object, object>)contentsMetadata["function"]);
+        Assert.AreEqual(2,
             ((List<object>)((Dictionary<object, object>)contentsMetadata["function"])["parameters"]).Count);
-        Assert.Equal("id,description,type",
+        Assert.AreEqual("id,description,type",
             ExtractDictionaryKeys(
                 (Dictionary<object, object>)((List<object>)((Dictionary<object, object>)contentsMetadata["function"])["parameters"])[0]));
-        Assert.Equal("id,description",
+        Assert.AreEqual("id,description",
             ExtractDictionaryKeys(
                 (Dictionary<object, object>)((List<object>)((Dictionary<object, object>)contentsMetadata["function"])["parameters"])[1]));
     }
 
-    [Fact]
+    [TestMethod]
     public void DuplicateOPathInMarkdownSectionTest()
     {
         var testOPath = "function/parameters";
@@ -107,13 +107,13 @@ public void DuplicateOPathInMarkdownSectionTest()
         }
 
         var logs = _listener.Items;
-        Assert.Single(logs, l => l.Code == WarningCodes.Overwrite.InvalidMarkdownFragments);
-        Assert.Single(contentsMetadata);
-        Assert.Equal("test2",
+        Assert.ContainsSingle(logs.Where(l => l.Code == WarningCodes.Overwrite.InvalidMarkdownFragments));
+        Assert.ContainsSingle(contentsMetadata);
+        Assert.AreEqual("test2",
             ((ParagraphBlock)((MarkdownDocument)((Dictionary<object, object>)contentsMetadata["function"])["parameters"])[0]).Inline.FirstChild.ToString());
     }
 
-    [Fact]
+    [TestMethod]
     public void DuplicateOPathsInYamlCodeBlockAndContentsBlockTest()
     {
         // Yaml section
@@ -161,15 +161,15 @@ public void DuplicateOPathsInYamlCodeBlockAndContentsBlockTest()
 
         var logs = _listener.Items;
         var warningLogs = logs.Where(l => l.Code == WarningCodes.Overwrite.InvalidMarkdownFragments).ToList();
-        Assert.Single(warningLogs);
-        Assert.Equal("Two duplicate OPaths `definitions[name=\"Application 1\"]/properties[name=\"displayName\"]/description` in yaml code block and contents block", warningLogs[0].Message);
-        Assert.Equal("name overwrite", metadata["name"].ToString());
-        Assert.Equal(typeof(MarkdownDocument), metadata["summary"].GetType());
-        Assert.Equal(typeof(MarkdownDocument), ((Dictionary<object, object>)((List<object>)((Dictionary<object, object>)((List<object>)metadata["definitions"])[0])["properties"])[1])["description"].GetType());
-        Assert.Equal(typeof(MarkdownDocument), ((Dictionary<object, object>)((List<object>)((Dictionary<object, object>)((List<object>)metadata["definitions"])[0])["properties"])[2])["description"].GetType());
+        Assert.ContainsSingle(warningLogs);
+        Assert.AreEqual("Two duplicate OPaths `definitions[name=\"Application 1\"]/properties[name=\"displayName\"]/description` in yaml code block and contents block", warningLogs[0].Message);
+        Assert.AreEqual("name overwrite", metadata["name"].ToString());
+        Assert.AreEqual(typeof(MarkdownDocument), metadata["summary"].GetType());
+        Assert.AreEqual(typeof(MarkdownDocument), ((Dictionary<object, object>)((List<object>)((Dictionary<object, object>)((List<object>)metadata["definitions"])[0])["properties"])[1])["description"].GetType());
+        Assert.AreEqual(typeof(MarkdownDocument), ((Dictionary<object, object>)((List<object>)((Dictionary<object, object>)((List<object>)metadata["definitions"])[0])["properties"])[2])["description"].GetType());
     }
 
-    [Fact]
+    [TestMethod]
     public void InvalidOPathsTest1()
     {
         var testBlockList = Markdown.Parse("Test").ToList();
@@ -190,13 +190,13 @@ public void InvalidOPathsTest1()
         }
 
         var ex = Assert.Throws<MarkdownFragmentsException>(() => new OverwriteDocumentModelCreator("test.yml.md").ConvertContents([], contents));
-        Assert.Equal(
+        Assert.AreEqual(
             "A(parameters) is not expected to be an array like \"A[c=d]/B\", however it is used as an array in line 0 with `parameters[id=\"para1\"]/...`",
             ex.Message);
-        Assert.Equal(0, ex.Position);
+        Assert.AreEqual(0, ex.Position);
     }
 
-    [Fact]
+    [TestMethod]
     public void InvalidOPathsTest2()
     {
         var testBlockList = Markdown.Parse("Test").ToList();
@@ -217,10 +217,10 @@ public void InvalidOPathsTest2()
         }
 
         var ex = Assert.Throws<MarkdownFragmentsException>(() => new OverwriteDocumentModelCreator("test.yml.md").ConvertContents([], contents));
-        Assert.Equal(
+        Assert.AreEqual(
             "A(parameters) is not expected to be an object like \"A/B\", however it is used as an object in line 0 with `parameters/...`",
             ex.Message);
-        Assert.Equal(0, ex.Position);
+        Assert.AreEqual(0, ex.Position);
     }
 
     private static string ExtractDictionaryKeys(Dictionary<object, object> dict)
diff --git a/test/Docfx.Build.OverwriteDocuments.Tests/OverwriteUtilityTest.cs b/test/Docfx.Build.OverwriteDocuments.Tests/OverwriteUtilityTest.cs
index e7e5513b21a..f177348fe62 100644
--- a/test/Docfx.Build.OverwriteDocuments.Tests/OverwriteUtilityTest.cs
+++ b/test/Docfx.Build.OverwriteDocuments.Tests/OverwriteUtilityTest.cs
@@ -1,37 +1,36 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.Build.OverwriteDocuments.Tests;
 
+[TestClass]
 public class OverwriteUtilityTest
 {
-    [Fact]
+    [TestMethod]
     public void ParseOPathTest()
     {
         var OPathString = "a/f[c= \"d\"]/g/b[c =\"d/d_d d\"]/e";
         var OPathSegments = OverwriteUtility.ParseOPath(OPathString);
-        Assert.Equal(5, OPathSegments.Count);
-        Assert.Equal("a,f,g,b,e", OPathSegments.Select(o => o.SegmentName).Aggregate((a, b) => a + "," + b));
-        Assert.Equal("c", OPathSegments[1].Key);
-        Assert.Equal("d", OPathSegments[1].Value);
-        Assert.Equal("d/d_d d", OPathSegments[3].Value);
+        Assert.AreEqual(5, OPathSegments.Count);
+        Assert.AreEqual("a,f,g,b,e", OPathSegments.Select(o => o.SegmentName).Aggregate((a, b) => a + "," + b));
+        Assert.AreEqual("c", OPathSegments[1].Key);
+        Assert.AreEqual("d", OPathSegments[1].Value);
+        Assert.AreEqual("d/d_d d", OPathSegments[3].Value);
     }
 
-    [Theory]
-    [InlineData("abc[]d=\"e\"/g]")]
-    [InlineData("abc[d='e']/g")]
-    [InlineData("abc[d=\"e\"]/g/")]
-    [InlineData("abc[d=2]/g/")]
-    [InlineData("abc[d=true]/g/")]
-    [InlineData("abc[a=\"b]\b")]
-    [InlineData("abc/efg[a=\"b\"]")]
-    [InlineData("abc/efg[a=\"b\"]e/g")]
-    [InlineData("abc/[efg=\"hij\"]/e")]
+    [TestMethod]
+    [DataRow("abc[]d=\"e\"/g]")]
+    [DataRow("abc[d='e']/g")]
+    [DataRow("abc[d=\"e\"]/g/")]
+    [DataRow("abc[d=2]/g/")]
+    [DataRow("abc[d=true]/g/")]
+    [DataRow("abc[a=\"b]\b")]
+    [DataRow("abc/efg[a=\"b\"]")]
+    [DataRow("abc/efg[a=\"b\"]e/g")]
+    [DataRow("abc/[efg=\"hij\"]/e")]
     public void ParseInvalidOPathsTest(string OPathString)
     {
         var ex = Assert.Throws<ArgumentException>(() => OverwriteUtility.ParseOPath(OPathString));
-        Assert.Equal($"{OPathString} is not a valid OPath", ex.Message);
+        Assert.AreEqual($"{OPathString} is not a valid OPath", ex.Message);
     }
 }
diff --git a/test/Docfx.Build.RestApi.Tests/RestApiDocumentProcessorTest.cs b/test/Docfx.Build.RestApi.Tests/RestApiDocumentProcessorTest.cs
index e2dcb241d03..e3ba51723fc 100644
--- a/test/Docfx.Build.RestApi.Tests/RestApiDocumentProcessorTest.cs
+++ b/test/Docfx.Build.RestApi.Tests/RestApiDocumentProcessorTest.cs
@@ -11,11 +11,11 @@
 using Docfx.Tests.Common;
 
 using Newtonsoft.Json.Linq;
-using Xunit;
 
 namespace Docfx.Build.RestApi.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class RestApiDocumentProcessorTest : TestBase
 {
     private readonly string _outputFolder;
@@ -37,120 +37,120 @@ public RestApiDocumentProcessorTest()
         };
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessSwaggerShouldSucceed()
     {
         FileCollection files = new(_defaultFiles);
         BuildDocument(files);
 
         var outputRawModelPath = GetRawModelFilePath("contacts.json");
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-        Assert.Equal("graph.windows.net/myorganization/Contacts/1.0", model.Uid);
-        Assert.Equal("graph_windows_net_myorganization_Contacts_1_0", model.HtmlId);
-        Assert.Equal(10, model.Children.Count);
-        Assert.Equal("Hello world!", model.Metadata["meta"]);
+        Assert.AreEqual("graph.windows.net/myorganization/Contacts/1.0", model.Uid);
+        Assert.AreEqual("graph_windows_net_myorganization_Contacts_1_0", model.HtmlId);
+        Assert.AreEqual(10, model.Children.Count);
+        Assert.AreEqual("Hello world!", model.Metadata["meta"]);
 
         // Verify $ref in path
         var item0 = model.Children[0];
-        Assert.Equal("graph.windows.net/myorganization/Contacts/1.0/get contacts", item0.Uid);
-        Assert.Equal("<p sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">You can get a collection of contacts from your tenant.</p>\n", item0.Summary);
-        Assert.Single(item0.Parameters);
-        Assert.Equal("1.6", item0.Parameters[0].Metadata["default"]);
-        Assert.Single(item0.Responses);
-        Assert.Equal("200", item0.Responses[0].HttpStatusCode);
+        Assert.AreEqual("graph.windows.net/myorganization/Contacts/1.0/get contacts", item0.Uid);
+        Assert.AreEqual("<p sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">You can get a collection of contacts from your tenant.</p>\n", item0.Summary);
+        Assert.ContainsSingle(item0.Parameters);
+        Assert.AreEqual("1.6", item0.Parameters[0].Metadata["default"]);
+        Assert.ContainsSingle(item0.Responses);
+        Assert.AreEqual("200", item0.Responses[0].HttpStatusCode);
 
         // Verify tags of child
-        Assert.Equal("contacts", item0.Tags[0]);
+        Assert.AreEqual("contacts", item0.Tags[0]);
         var item1 = model.Children[1];
-        Assert.Equal("contacts", item1.Tags[0]);
-        Assert.Equal("pet store", item1.Tags[1]);
+        Assert.AreEqual("contacts", item1.Tags[0]);
+        Assert.AreEqual("pet store", item1.Tags[1]);
 
         // Verify tags of root
-        Assert.Equal(3, model.Tags.Count);
+        Assert.AreEqual(3, model.Tags.Count);
         var tag0 = model.Tags[0];
-        Assert.Equal("contact", tag0.Name);
-        Assert.Equal("<p sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">Everything about the <strong sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">contacts</strong></p>\n", tag0.Description);
-        Assert.Equal("contact-bookmark", tag0.HtmlId);
-        Assert.Single(tag0.Metadata);
+        Assert.AreEqual("contact", tag0.Name);
+        Assert.AreEqual("<p sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">Everything about the <strong sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">contacts</strong></p>\n", tag0.Description);
+        Assert.AreEqual("contact-bookmark", tag0.HtmlId);
+        Assert.ContainsSingle(tag0.Metadata);
         var externalDocs = (JObject)tag0.Metadata["externalDocs"];
-        Assert.NotNull(externalDocs);
-        Assert.Equal("Find out more", externalDocs["description"]);
-        Assert.Equal("http://swagger.io", externalDocs["url"]);
+        Assert.IsNotNull(externalDocs);
+        Assert.AreEqual("Find out more", externalDocs["description"]);
+        Assert.AreEqual("http://swagger.io", externalDocs["url"]);
         var tag1 = model.Tags[1];
-        Assert.Equal("pet_store", tag1.HtmlId);
+        Assert.AreEqual("pet_store", tag1.HtmlId);
 
         // Verify path parameters
         // Path parameter applicable for get operation
-        Assert.Equal(2, item1.Parameters.Count);
-        Assert.Equal("object_id", item1.Parameters[0].Name);
-        Assert.Equal("api-version", item1.Parameters[1].Name);
-        Assert.Equal(true, item1.Parameters[1].Metadata["required"]);
+        Assert.AreEqual(2, item1.Parameters.Count);
+        Assert.AreEqual("object_id", item1.Parameters[0].Name);
+        Assert.AreEqual("api-version", item1.Parameters[1].Name);
+        Assert.AreEqual(true, item1.Parameters[1].Metadata["required"]);
 
         // Override ""api-version" parameters by $ref for patch operation
         var item2 = model.Children[2];
-        Assert.Equal(3, item2.Parameters.Count);
-        Assert.Equal("object_id", item2.Parameters[0].Name);
-        Assert.Equal("api-version", item2.Parameters[1].Name);
-        Assert.Equal(false, item2.Parameters[1].Metadata["required"]);
+        Assert.AreEqual(3, item2.Parameters.Count);
+        Assert.AreEqual("object_id", item2.Parameters[0].Name);
+        Assert.AreEqual("api-version", item2.Parameters[1].Name);
+        Assert.AreEqual(false, item2.Parameters[1].Metadata["required"]);
 
         // Override ""api-version" parameters by self definition for delete operation
         var item3 = model.Children[3];
-        Assert.Equal(2, item3.Parameters.Count);
-        Assert.Equal("object_id", item3.Parameters[0].Name);
-        Assert.Equal("api-version", item3.Parameters[1].Name);
-        Assert.Equal(false, item3.Parameters[1].Metadata["required"]);
+        Assert.AreEqual(2, item3.Parameters.Count);
+        Assert.AreEqual("object_id", item3.Parameters[0].Name);
+        Assert.AreEqual("api-version", item3.Parameters[1].Name);
+        Assert.AreEqual(false, item3.Parameters[1].Metadata["required"]);
 
         // When operation parameters is not set, inherit from th parameters for post operation
         var item4 = model.Children[4];
-        Assert.Single(item4.Parameters);
-        Assert.Equal("api-version", item4.Parameters[0].Name);
-        Assert.Equal(true, item4.Parameters[0].Metadata["required"]);
+        Assert.ContainsSingle(item4.Parameters);
+        Assert.AreEqual("api-version", item4.Parameters[0].Name);
+        Assert.AreEqual(true, item4.Parameters[0].Metadata["required"]);
 
         // When 'definitions' has direct child with $ref defined, should resolve it
         var item5 = model.Children[6];
         var parameter2 = (JObject)item5.Parameters[2].Metadata["schema"];
-        Assert.Equal("string", parameter2["type"]);
-        Assert.Equal("uri", parameter2["format"]);
+        Assert.AreEqual("string", parameter2["type"]);
+        Assert.AreEqual("uri", parameter2["format"]);
         // Verify markup result of parameters
-        Assert.Equal("<p sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">The request body <em sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">contains</em> a single property that specifies the URL of the user or contact to add as manager.</p>\n",
+        Assert.AreEqual("<p sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">The request body <em sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">contains</em> a single property that specifies the URL of the user or contact to add as manager.</p>\n",
             item5.Parameters[2].Description);
-        Assert.Equal("<p sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\"><strong sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">uri</strong> description.</p>\n",
+        Assert.AreEqual("<p sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\"><strong sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">uri</strong> description.</p>\n",
             (string)parameter2["description"]);
-        Assert.Equal("<p sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">No Content. Indicates <strong sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">success</strong>. No response body is returned.</p>\n",
+        Assert.AreEqual("<p sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">No Content. Indicates <strong sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">success</strong>. No response body is returned.</p>\n",
             item5.Responses[0].Description);
 
         // Verify for markup result of securityDefinitions
         var securityDefinitions = (JObject)model.Metadata.Single(m => m.Key == "securityDefinitions").Value;
         var auth = (JObject)securityDefinitions["auth"];
-        Assert.Equal("<p sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">securityDefinitions <em sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">description</em>.</p>\n",
+        Assert.AreEqual("<p sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">securityDefinitions <em sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">description</em>.</p>\n",
             auth["description"].ToString());
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessSwaggerWithExternalReferenceShouldSucceed()
     {
         FileCollection files = new(_defaultFiles);
         BuildDocument(files);
 
         var outputRawModelPath = GetRawModelFilePath("contacts.json");
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
 
         var operation = model.Children.Single(c => c.OperationId == "get contact direct reports links");
         var externalSchema = operation.Parameters[2].Metadata["schema"];
         var externalParameters = ((JObject)externalSchema)["parameters"];
-        Assert.Equal("cache1", externalParameters["name"]);
+        Assert.AreEqual("cache1", externalParameters["name"]);
         var scheduleEntries = externalParameters["parameters"]["properties"]["scheduleEntries"];
-        Assert.Equal(JTokenType.Array, scheduleEntries.Type);
-        Assert.Equal(2, ((JArray)scheduleEntries).Count);
-        Assert.Equal("Monday", ((JArray)scheduleEntries)[0]["dayOfWeek"]);
+        Assert.AreEqual(JTokenType.Array, scheduleEntries.Type);
+        Assert.AreEqual(2, ((JArray)scheduleEntries).Count);
+        Assert.AreEqual("Monday", ((JArray)scheduleEntries)[0]["dayOfWeek"]);
 
         var responses = ((JObject)externalSchema)["responses"];
-        Assert.Equal("fake metadata", responses["200"]["examples"]["application/json"]["odata.metadata"]);
+        Assert.AreEqual("fake metadata", responses["200"]["examples"]["application/json"]["odata.metadata"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessSwaggerWithExternalEmbeddedReferenceShouldSucceed()
     {
         var files = new FileCollection(Directory.GetCurrentDirectory());
@@ -158,18 +158,18 @@ public void ProcessSwaggerWithExternalEmbeddedReferenceShouldSucceed()
         BuildDocument(files);
 
         var outputRawModelPath = GetRawModelFilePath("contactsForExternalRef.json");
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
 
         var operation = model.Children.Single(c => c.OperationId == "update_contact_manager");
         var externalSchema = (JObject)operation.Parameters[2].Metadata["schema"];
-        Assert.Equal("<p sourcefile=\"TestData/swagger/contactsForExternalRef.json\" sourcestartlinenumber=\"1\"><strong sourcefile=\"TestData/swagger/contactsForExternalRef.json\" sourcestartlinenumber=\"1\">uri</strong> description.</p>\n", externalSchema["description"].ToString());
-        Assert.Equal("string", externalSchema["type"]);
-        Assert.Equal("uri", externalSchema["format"]);
-        Assert.Equal("refUrl", externalSchema["x-internal-ref-name"]);
+        Assert.AreEqual("<p sourcefile=\"TestData/swagger/contactsForExternalRef.json\" sourcestartlinenumber=\"1\"><strong sourcefile=\"TestData/swagger/contactsForExternalRef.json\" sourcestartlinenumber=\"1\">uri</strong> description.</p>\n", externalSchema["description"].ToString());
+        Assert.AreEqual("string", externalSchema["type"]);
+        Assert.AreEqual("uri", externalSchema["format"]);
+        Assert.AreEqual("refUrl", externalSchema["x-internal-ref-name"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessSwaggerWithNotExistedExternalReferenceShouldFail()
     {
         var files = new FileCollection(Directory.GetCurrentDirectory());
@@ -179,12 +179,12 @@ public void ProcessSwaggerWithNotExistedExternalReferenceShouldFail()
 
         BuildDocument(files);
 
-        Assert.NotNull(listener.Items);
-        Assert.Single(listener.Items);
+        Assert.IsNotNull(listener.Items);
+        Assert.ContainsSingle(listener.Items);
         Assert.Contains("External swagger path not exist", listener.Items[0].Message);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessSwaggerWithExternalReferenceHasRefInsideShouldFail()
     {
         var files = new FileCollection(Directory.GetCurrentDirectory());
@@ -194,12 +194,12 @@ public void ProcessSwaggerWithExternalReferenceHasRefInsideShouldFail()
 
         BuildDocument(files);
 
-        Assert.NotNull(listener.Items);
-        Assert.Single(listener.Items);
+        Assert.IsNotNull(listener.Items);
+        Assert.ContainsSingle(listener.Items);
         Assert.Contains("$ref in refWithRefInside.json is not supported in external reference currently.", listener.Items[0].Message);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessSwaggerWithXRefMapShouldSucceed()
     {
         var files = new FileCollection(_defaultFiles);
@@ -208,22 +208,22 @@ public void ProcessSwaggerWithXRefMapShouldSucceed()
         var xrefMapPath = Path.Combine(Directory.GetCurrentDirectory(), _outputFolder, XRefArchive.MajorFileName);
         var xrefMap = YamlUtility.Deserialize<XRefMap>(xrefMapPath);
 
-        Assert.NotNull(xrefMap.References);
+        Assert.IsNotNull(xrefMap.References);
         var rootItem = xrefMap.References[0];
-        Assert.Equal("graph.windows.net/myorganization/Contacts/1.0", rootItem.Uid);
-        Assert.Equal("Contacts", rootItem.Name);
-        Assert.Equal("swagger/contacts.json", rootItem.Href);
+        Assert.AreEqual("graph.windows.net/myorganization/Contacts/1.0", rootItem.Uid);
+        Assert.AreEqual("Contacts", rootItem.Name);
+        Assert.AreEqual("swagger/contacts.json", rootItem.Href);
         var childItem1 = xrefMap.References[1];
-        Assert.Equal("graph.windows.net/myorganization/Contacts/1.0/delete contact", childItem1.Uid);
-        Assert.Equal("delete contact", childItem1.Name);
-        Assert.Equal("swagger/contacts.json", childItem1.Href);
+        Assert.AreEqual("graph.windows.net/myorganization/Contacts/1.0/delete contact", childItem1.Uid);
+        Assert.AreEqual("delete contact", childItem1.Name);
+        Assert.AreEqual("swagger/contacts.json", childItem1.Href);
         var tagItem1 = xrefMap.References[9];
-        Assert.Equal("graph.windows.net/myorganization/Contacts/1.0/tag/contact", tagItem1.Uid);
-        Assert.Equal("contact", tagItem1.Name);
-        Assert.Equal("swagger/contacts.json", tagItem1.Href);
+        Assert.AreEqual("graph.windows.net/myorganization/Contacts/1.0/tag/contact", tagItem1.Uid);
+        Assert.AreEqual("contact", tagItem1.Name);
+        Assert.AreEqual("swagger/contacts.json", tagItem1.Href);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessSwaggerWithTagsOverwriteShouldSucceed()
     {
         FileCollection files = new(_defaultFiles);
@@ -232,18 +232,18 @@ public void ProcessSwaggerWithTagsOverwriteShouldSucceed()
 
         {
             var outputRawModelPath = GetRawModelFilePath("contacts.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
             var tag1 = model.Tags[0];
-            Assert.Equal("<p sourcefile=\"TestData/overwrite/rest.overwrite.tags.md\" sourcestartlinenumber=\"6\">Overwrite <em sourcefile=\"TestData/overwrite/rest.overwrite.tags.md\" sourcestartlinenumber=\"6\">description</em> content</p>\n", tag1.Description);
-            Assert.Null(tag1.Conceptual);
+            Assert.AreEqual("<p sourcefile=\"TestData/overwrite/rest.overwrite.tags.md\" sourcestartlinenumber=\"6\">Overwrite <em sourcefile=\"TestData/overwrite/rest.overwrite.tags.md\" sourcestartlinenumber=\"6\">description</em> content</p>\n", tag1.Description);
+            Assert.IsNull(tag1.Conceptual);
             var tag2 = model.Tags[1];
-            Assert.Equal("<p sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">Access to Petstore orders</p>\n", tag2.Description);
-            Assert.Equal("<p sourcefile=\"TestData/overwrite/rest.overwrite.tags.md\" sourcestartlinenumber=\"12\">Overwrite <strong sourcefile=\"TestData/overwrite/rest.overwrite.tags.md\" sourcestartlinenumber=\"12\">conceptual</strong> content</p>\n", tag2.Conceptual);
+            Assert.AreEqual("<p sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">Access to Petstore orders</p>\n", tag2.Description);
+            Assert.AreEqual("<p sourcefile=\"TestData/overwrite/rest.overwrite.tags.md\" sourcestartlinenumber=\"12\">Overwrite <strong sourcefile=\"TestData/overwrite/rest.overwrite.tags.md\" sourcestartlinenumber=\"12\">conceptual</strong> content</p>\n", tag2.Conceptual);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessSwaggerWithDefaultOverwriteShouldSucceed()
     {
         FileCollection files = new(_defaultFiles);
@@ -252,27 +252,27 @@ public void ProcessSwaggerWithDefaultOverwriteShouldSucceed()
 
         {
             var outputRawModelPath = GetRawModelFilePath("contacts.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-            Assert.Equal("<p sourcefile=\"TestData/overwrite/rest.overwrite.default.md\" sourcestartlinenumber=\"1\">Overwrite summary</p>\n", model.Summary);
-            Assert.Equal("\n<p sourcefile=\"TestData/overwrite/rest.overwrite.default.md\" sourcestartlinenumber=\"6\">Overwrite content</p>\n", model.Conceptual);
+            Assert.AreEqual("<p sourcefile=\"TestData/overwrite/rest.overwrite.default.md\" sourcestartlinenumber=\"1\">Overwrite summary</p>\n", model.Summary);
+            Assert.AreEqual("\n<p sourcefile=\"TestData/overwrite/rest.overwrite.default.md\" sourcestartlinenumber=\"6\">Overwrite content</p>\n", model.Conceptual);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessSwaggerWithSimpleOverwriteShouldSucceed()
     {
         FileCollection files = new(_defaultFiles);
         files.Add(DocumentType.Overwrite, new[] { "TestData/overwrite/rest.overwrite.simple.md" });
         BuildDocument(files);
         var outputRawModelPath = GetRawModelFilePath("contacts.json");
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-        Assert.Equal("\n<p sourcefile=\"TestData/overwrite/rest.overwrite.simple.md\" sourcestartlinenumber=\"6\">Overwrite content</p>\n", model.Summary);
-        Assert.Null(model.Conceptual);
+        Assert.AreEqual("\n<p sourcefile=\"TestData/overwrite/rest.overwrite.simple.md\" sourcestartlinenumber=\"6\">Overwrite content</p>\n", model.Summary);
+        Assert.IsNull(model.Conceptual);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessSwaggerWithInvalidLinksOverwriteShouldSucceedWithWarning()
     {
         using var listener = new TestListenerScope();
@@ -283,84 +283,84 @@ public void ProcessSwaggerWithInvalidLinksOverwriteShouldSucceedWithWarning()
         files.Add(DocumentType.Overwrite, ["TestData/overwrite/rest.overwrite.invalid.links.second.md"]);
         BuildDocument(files);
 
-        Assert.Equal(7, listener.Items.Count); // Additional warning for "There is no template processing document type(s): RestApi"
+        Assert.AreEqual(7, listener.Items.Count); // Additional warning for "There is no template processing document type(s): RestApi"
 
         var outputRawModelPath = GetRawModelFilePath("contacts.json");
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
 
         var warningsForLinkA = listener.Items.Where(i => i.Message == "Invalid file link:(~/TestData/overwrite/a.md).").ToList();
-        Assert.Equal(
+        Assert.AreEqual(
             "<p sourcefile=\"TestData/overwrite/rest.overwrite.invalid.links.first.md\" sourcestartlinenumber=\"13\">Remarks content <a href=\"b.md\" sourcefile=\"TestData/overwrite/rest.overwrite.invalid.links.first.md\" sourcestartlinenumber=\"13\">remarks</a></p>",
             model.Remarks.Trim());
-        Assert.Equal("6", warningsForLinkA.Single(i => i.File == "TestData/overwrite/rest.overwrite.invalid.links.first.md").Line);
+        Assert.AreEqual("6", warningsForLinkA.Single(i => i.File == "TestData/overwrite/rest.overwrite.invalid.links.first.md").Line);
 
-        Assert.Equal(
+        Assert.AreEqual(
             "<p sourcefile=\"TestData/overwrite/rest.overwrite.invalid.links.first.md\" sourcestartlinenumber=\"6\">Summary content <a href=\"a.md\" sourcefile=\"TestData/overwrite/rest.overwrite.invalid.links.first.md\" sourcestartlinenumber=\"6\">summary</a></p>",
             model.Summary.Trim());
         var summaryLink = listener.Items.Single(i => i.Message == "Invalid file link:(~/TestData/overwrite/b.md).");
-        Assert.Equal("TestData/overwrite/rest.overwrite.invalid.links.first.md", summaryLink.File);
+        Assert.AreEqual("TestData/overwrite/rest.overwrite.invalid.links.first.md", summaryLink.File);
 
         var warningsForLinkAForSecond = warningsForLinkA.Where(i => i.File == "TestData/overwrite/rest.overwrite.invalid.links.second.md").ToList();
-        Assert.Equal(
+        Assert.AreEqual(
             "<p sourcefile=\"TestData/overwrite/rest.overwrite.invalid.links.second.md\" sourcestartlinenumber=\"5\">Conceptual content <a href=\"a.md\" sourcefile=\"TestData/overwrite/rest.overwrite.invalid.links.second.md\" sourcestartlinenumber=\"5\">Conceptual</a></p>\n<p sourcefile=\"TestData/overwrite/rest.overwrite.invalid.links.second.md\" sourcestartlinenumber=\"7\"><a href=\"a.md\" sourcefile=\"TestData/overwrite/rest.overwrite.invalid.links.second.md\" sourcestartlinenumber=\"7\">Conceptual</a></p>",
             model.Conceptual.Trim());
-        Assert.Equal(1, warningsForLinkAForSecond.Count(i => i.Line == "5"));
-        Assert.Equal(1, warningsForLinkAForSecond.Count(i => i.Line == "7"));
+        Assert.AreEqual(1, warningsForLinkAForSecond.Count(i => i.Line == "5"));
+        Assert.AreEqual(1, warningsForLinkAForSecond.Count(i => i.Line == "7"));
 
         var outputTagRawModelPath = GetRawModelFilePath("tag.json");
-        Assert.True(File.Exists(outputTagRawModelPath));
+        Assert.IsTrue(File.Exists(outputTagRawModelPath));
         var tagModel = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputTagRawModelPath);
 
-        Assert.Equal(
+        Assert.AreEqual(
             "<p sourcefile=\"TestData/overwrite/rest.overwrite.invalid.links.second.md\" sourcestartlinenumber=\"13\">Another uid content <a href=\"a.md\" sourcefile=\"TestData/overwrite/rest.overwrite.invalid.links.second.md\" sourcestartlinenumber=\"13\">Another</a></p>",
             tagModel.Conceptual.Trim());
-        Assert.Equal(1, warningsForLinkAForSecond.Count(i => i.Line == "13"));
+        Assert.AreEqual(1, warningsForLinkAForSecond.Count(i => i.Line == "13"));
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessSwaggerWithParametersOverwriteShouldSucceed()
     {
         var files = new FileCollection(_defaultFiles);
         files.Add(DocumentType.Overwrite, ["TestData/overwrite/rest.overwrite.parameters.md"]);
         BuildDocument(files);
         var outputRawModelPath = GetRawModelFilePath("contacts.json");
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
 
         // Verify overwrite parameters
         var parametersForUpdate = model.Children.Single(c => c.OperationId == "update contact").Parameters;
-        Assert.Equal("<p sourcefile=\"TestData/overwrite/rest.overwrite.parameters.md\" sourcestartlinenumber=\"1\">The new object_id description</p>\n",
+        Assert.AreEqual("<p sourcefile=\"TestData/overwrite/rest.overwrite.parameters.md\" sourcestartlinenumber=\"1\">The new object_id description</p>\n",
             parametersForUpdate.Single(p => p.Name == "object_id").Description);
         var bodyparam = parametersForUpdate.Single(p => p.Name == "bodyparam");
-        Assert.Equal("<p sourcefile=\"TestData/overwrite/rest.overwrite.parameters.md\" sourcestartlinenumber=\"1\">The new bodyparam description</p>\n",
+        Assert.AreEqual("<p sourcefile=\"TestData/overwrite/rest.overwrite.parameters.md\" sourcestartlinenumber=\"1\">The new bodyparam description</p>\n",
             bodyparam.Description);
         var properties = (JObject)((JObject)bodyparam.Metadata["schema"])["properties"];
         var objectType = properties["objectType"];
-        Assert.Equal("string", objectType["type"]);
-        Assert.Equal("this is overwrite objectType description", objectType["description"]);
+        Assert.AreEqual("string", objectType["type"]);
+        Assert.AreEqual("this is overwrite objectType description", objectType["description"]);
         var errorDetail = properties["provisioningErrors"]["items"]["schema"]["properties"]["errorDetail"];
-        Assert.Equal(JTokenType.Boolean, errorDetail["readOnly"].Type);
-        Assert.Equal("false", errorDetail["readOnly"].ToString().ToLower());
-        Assert.Equal("this is overwrite errorDetail description", errorDetail["description"]);
+        Assert.AreEqual(JTokenType.Boolean, errorDetail["readOnly"].Type);
+        Assert.AreEqual("false", errorDetail["readOnly"].ToString().ToLower());
+        Assert.AreEqual("this is overwrite errorDetail description", errorDetail["description"]);
 
         var paramForUpdateManager = model.Children.Single(c => c.OperationId == "get contact memberOf links").Parameters.Single(p => p.Name == "bodyparam");
         var paramForAllOf = ((JObject)paramForUpdateManager.Metadata["schema"])["allOf"];
         // First allOf item is not overwritten
-        Assert.Equal("<p sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">original first allOf description</p>\n", paramForAllOf[0]["description"]);
+        Assert.AreEqual("<p sourcefile=\"TestData/swagger/contacts.json\" sourcestartlinenumber=\"1\">original first allOf description</p>\n", paramForAllOf[0]["description"]);
         // Second allOf item is overwritten
-        Assert.Equal("this is second overwrite allOf description", paramForAllOf[1]["description"]);
-        Assert.Equal("this is overwrite location description", paramForAllOf[1]["properties"]["location"]["description"]);
+        Assert.AreEqual("this is second overwrite allOf description", paramForAllOf[1]["description"]);
+        Assert.AreEqual("this is overwrite location description", paramForAllOf[1]["properties"]["location"]["description"]);
         // Third allOf item's enum value is overwritten
         var paramForLevel = paramForAllOf[2]["properties"]["level"];
-        Assert.Equal("this is overwrite level description", paramForLevel["description"]);
-        Assert.Equal(3, paramForLevel["enum"].Count());
-        Assert.Equal("Verbose", paramForLevel["enum"][0].ToString());
-        Assert.Equal("Info", paramForLevel["enum"][1].ToString());
-        Assert.Equal("Warning", paramForLevel["enum"][2].ToString());
+        Assert.AreEqual("this is overwrite level description", paramForLevel["description"]);
+        Assert.AreEqual(3, paramForLevel["enum"].Count());
+        Assert.AreEqual("Verbose", paramForLevel["enum"][0].ToString());
+        Assert.AreEqual("Info", paramForLevel["enum"][1].ToString());
+        Assert.AreEqual("Warning", paramForLevel["enum"][2].ToString());
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessSwaggerWithNotPredefinedOverwriteShouldSucceed()
     {
         FileCollection files = new(_defaultFiles);
@@ -368,14 +368,14 @@ public void ProcessSwaggerWithNotPredefinedOverwriteShouldSucceed()
         BuildDocument(files);
         {
             var outputRawModelPath = GetRawModelFilePath("contacts.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-            Assert.Equal("\n<p sourcefile=\"TestData/overwrite/rest.overwrite.not.predefined.md\" sourcestartlinenumber=\"6\">Overwrite content</p>\n", model.Metadata["not_defined_property"]);
-            Assert.Null(model.Conceptual);
+            Assert.AreEqual("\n<p sourcefile=\"TestData/overwrite/rest.overwrite.not.predefined.md\" sourcestartlinenumber=\"6\">Overwrite content</p>\n", model.Metadata["not_defined_property"]);
+            Assert.IsNull(model.Conceptual);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessSwaggerWithInvalidOverwriteShouldFail()
     {
         FileCollection files = new(_defaultFiles);
@@ -383,7 +383,7 @@ public void ProcessSwaggerWithInvalidOverwriteShouldFail()
         Assert.Throws<DocumentException>(() => BuildDocument(files));
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessSwaggerWithUnmergeableOverwriteShouldSucceed()
     {
         FileCollection files = new(_defaultFiles);
@@ -391,13 +391,13 @@ public void ProcessSwaggerWithUnmergeableOverwriteShouldSucceed()
         BuildDocument(files);
         {
             var outputRawModelPath = GetRawModelFilePath("contacts.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-            Assert.Equal("graph_windows_net_myorganization_Contacts_1_0", model.HtmlId);
+            Assert.AreEqual("graph_windows_net_myorganization_Contacts_1_0", model.HtmlId);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessSwaggerWithRemarksOverwriteShouldSucceed()
     {
         var files = new FileCollection(_defaultFiles);
@@ -405,13 +405,13 @@ public void ProcessSwaggerWithRemarksOverwriteShouldSucceed()
         BuildDocument(files);
         {
             var outputRawModelPath = GetRawModelFilePath("contacts.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-            Assert.Equal("\n<p sourcefile=\"TestData/overwrite/rest.overwrite.remarks.md\" sourcestartlinenumber=\"6\">Remarks content</p>\n", model.Remarks);
+            Assert.AreEqual("\n<p sourcefile=\"TestData/overwrite/rest.overwrite.remarks.md\" sourcestartlinenumber=\"6\">Remarks content</p>\n", model.Remarks);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessSwaggerWithMultiUidOverwriteShouldSucceed()
     {
         var files = new FileCollection(_defaultFiles);
@@ -420,16 +420,16 @@ public void ProcessSwaggerWithMultiUidOverwriteShouldSucceed()
         BuildDocument(files);
         {
             var outputRawModelPath = GetRawModelFilePath("contacts.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-            Assert.Equal("graph_windows_net_myorganization_Contacts_1_0", model.HtmlId);
-            Assert.Equal("\n<p sourcefile=\"TestData/overwrite/rest.overwrite.multi.uid.md\" sourcestartlinenumber=\"6\">Overwrite content1</p>\n", model.Conceptual);
-            Assert.Equal("\n<p sourcefile=\"TestData/overwrite/rest.overwrite.multi.uid.md\" sourcestartlinenumber=\"13\">Overwrite &quot;content2&quot;</p>\n", model.Summary);
-            Assert.Equal("\n<p sourcefile=\"TestData/overwrite/rest.overwrite.multi.uid.md\" sourcestartlinenumber=\"20\">Overwrite 'content3'</p>\n", model.Metadata["not_defined_property"]);
+            Assert.AreEqual("graph_windows_net_myorganization_Contacts_1_0", model.HtmlId);
+            Assert.AreEqual("\n<p sourcefile=\"TestData/overwrite/rest.overwrite.multi.uid.md\" sourcestartlinenumber=\"6\">Overwrite content1</p>\n", model.Conceptual);
+            Assert.AreEqual("\n<p sourcefile=\"TestData/overwrite/rest.overwrite.multi.uid.md\" sourcestartlinenumber=\"13\">Overwrite &quot;content2&quot;</p>\n", model.Summary);
+            Assert.AreEqual("\n<p sourcefile=\"TestData/overwrite/rest.overwrite.multi.uid.md\" sourcestartlinenumber=\"20\">Overwrite 'content3'</p>\n", model.Metadata["not_defined_property"]);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void SystemKeysListShouldBeComplete()
     {
         var userKeys = new[] { "meta", "swagger", "securityDefinitions", "schemes" };
@@ -437,10 +437,10 @@ public void SystemKeysListShouldBeComplete()
         BuildDocument(files);
 
         var outputRawModelPath = GetRawModelFilePath("contacts.json");
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<Dictionary<string, object>>(outputRawModelPath);
         var systemKeys = ToList(model[Constants.PropertyName.SystemKeys]);
-        Assert.NotEmpty(systemKeys);
+        Assert.IsNotEmpty(systemKeys);
         foreach (var key in model.Keys.Where(key => key[0] != '_' && !userKeys.Contains(key)))
         {
             Assert.Contains(key, systemKeys);
diff --git a/test/Docfx.Build.RestApi.Tests/SwaggerJsonParserTest.cs b/test/Docfx.Build.RestApi.Tests/SwaggerJsonParserTest.cs
index 8444caf7e37..3e4bef6f649 100644
--- a/test/Docfx.Build.RestApi.Tests/SwaggerJsonParserTest.cs
+++ b/test/Docfx.Build.RestApi.Tests/SwaggerJsonParserTest.cs
@@ -5,122 +5,122 @@
 
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
-using Xunit;
 
 namespace Docfx.Build.RestApi.Tests;
 
+[TestClass]
 public class SwaggerJsonParserTest
 {
-    [Fact]
+    [TestMethod]
     public void ParseSimpleSwaggerJsonShouldSucceed()
     {
         var swaggerFile = "TestData/swagger/simple_swagger2.json";
         var swagger = SwaggerJsonParser.Parse(swaggerFile);
 
-        Assert.Single(swagger.Paths.Values);
+        Assert.ContainsSingle(swagger.Paths.Values);
         var actionJObject = swagger.Paths["/contacts"].Metadata["get"] as JObject;
-        Assert.NotNull(actionJObject);
+        Assert.IsNotNull(actionJObject);
         var action = actionJObject.ToObject<OperationObject>();
         var parameters = action.Parameters;
-        Assert.Single(parameters);
-        Assert.Equal("query", parameters[0].Metadata["in"]);
-        Assert.Single(action.Responses);
+        Assert.ContainsSingle(parameters);
+        Assert.AreEqual("query", parameters[0].Metadata["in"]);
+        Assert.ContainsSingle(action.Responses);
         var response = action.Responses["200"];
-        Assert.Single(response.Examples);
+        Assert.ContainsSingle(response.Examples);
         var example = response.Examples["application/json"];
-        Assert.NotNull(example);
+        Assert.IsNotNull(example);
     }
 
-    [Fact]
+    [TestMethod]
     public void ParseSwaggerJsonWithReferenceShouldSucceed()
     {
         var swaggerFile = "TestData/swagger/ref_swagger2.json";
         var swagger = SwaggerJsonParser.Parse(swaggerFile);
 
-        Assert.Single(swagger.Paths);
-        Assert.Single(swagger.Paths["/contacts"].Metadata);
+        Assert.ContainsSingle(swagger.Paths);
+        Assert.ContainsSingle(swagger.Paths["/contacts"].Metadata);
         var actionJObject = swagger.Paths["/contacts"].Metadata["patch"] as JObject;
-        Assert.NotNull(actionJObject);
+        Assert.IsNotNull(actionJObject);
         var action = actionJObject.ToObject<OperationObject>();
         var parameters = action.Parameters;
         var schema = parameters[0].Metadata["schema"] as JObject;
-        Assert.NotNull(schema);
-        Assert.Equal("Sales", schema["example"]["department"].ToString());
+        Assert.IsNotNull(schema);
+        Assert.AreEqual("Sales", schema["example"]["department"].ToString());
 
         // Reference object
         var properties = schema["properties"] as JObject;
-        Assert.NotNull(properties);
-        Assert.Equal(2, properties.Count);
-        Assert.Equal("string", properties["objectType"]["type"]);
-        Assert.Equal("array", properties["provisioningErrors"]["type"]);
+        Assert.IsNotNull(properties);
+        Assert.AreEqual(2, properties.Count);
+        Assert.AreEqual("string", properties["objectType"]["type"]);
+        Assert.AreEqual("array", properties["provisioningErrors"]["type"]);
         var refProperty = properties["provisioningErrors"]["items"]["schema"] as JObject;
-        Assert.NotNull(refProperty);
-        Assert.Equal("string", refProperty["properties"]["errorDetail"]["type"]);
+        Assert.IsNotNull(refProperty);
+        Assert.AreEqual("string", refProperty["properties"]["errorDetail"]["type"]);
 
         schema = parameters[1].Metadata["schema"] as JObject;
         properties = schema["properties"] as JObject;
         var message = properties["message"];
-        Assert.Equal("A message describing the error, intended to be suitable for display in a user interface.", message["description"]);
+        Assert.AreEqual("A message describing the error, intended to be suitable for display in a user interface.", message["description"]);
 
-        Assert.Single(action.Responses);
+        Assert.ContainsSingle(action.Responses);
         var response = action.Responses["204"];
-        Assert.Single(response.Examples);
+        Assert.ContainsSingle(response.Examples);
         var example = response.Examples["application/json"];
-        Assert.NotNull(example);
+        Assert.IsNotNull(example);
     }
 
-    [Fact]
+    [TestMethod]
     public void ParseSwaggerJsonWithTagShouldSucceed()
     {
         const string swaggerFile = "TestData/swagger/tag_swagger2.json";
         var swagger = SwaggerJsonParser.Parse(swaggerFile);
 
-        Assert.Equal(3, swagger.Tags.Count);
+        Assert.AreEqual(3, swagger.Tags.Count);
         var tag0 = swagger.Tags[0];
-        Assert.Equal("contact", tag0.Name);
-        Assert.Equal("Everything about the **contacts**", tag0.Description);
-        Assert.Equal("contact-bookmark", tag0.BookmarkId);
-        Assert.Single(tag0.Metadata);
+        Assert.AreEqual("contact", tag0.Name);
+        Assert.AreEqual("Everything about the **contacts**", tag0.Description);
+        Assert.AreEqual("contact-bookmark", tag0.BookmarkId);
+        Assert.ContainsSingle(tag0.Metadata);
         var externalDocs = (JObject)tag0.Metadata["externalDocs"];
-        Assert.NotNull(externalDocs);
-        Assert.Equal("Find out more", externalDocs["description"]);
-        Assert.Equal("http://swagger.io", externalDocs["url"]);
+        Assert.IsNotNull(externalDocs);
+        Assert.AreEqual("Find out more", externalDocs["description"]);
+        Assert.AreEqual("http://swagger.io", externalDocs["url"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void ParseSwaggerJsonWithPathParametersShouldSucceed()
     {
         const string swaggerFile = "TestData/swagger/pathParameters_swagger2.json";
         var swagger = SwaggerJsonParser.Parse(swaggerFile);
 
-        Assert.Single(swagger.Paths.Values);
+        Assert.ContainsSingle(swagger.Paths.Values);
         var parameters = swagger.Paths["/contacts"].Parameters;
-        Assert.Equal(2, parameters.Count);
+        Assert.AreEqual(2, parameters.Count);
 
         // $ref parameter
-        Assert.Equal("api-version", parameters[0].Name);
-        Assert.Equal(false, parameters[0].Metadata["required"]);
-        Assert.Equal("api version description", parameters[0].Description);
+        Assert.AreEqual("api-version", parameters[0].Name);
+        Assert.AreEqual(false, parameters[0].Metadata["required"]);
+        Assert.AreEqual("api version description", parameters[0].Description);
 
         // self defined parameter
-        Assert.Equal("subscriptionId", parameters[1].Name);
-        Assert.Equal(true, parameters[1].Metadata["required"]);
-        Assert.Equal("subscription id", parameters[1].Description);
+        Assert.AreEqual("subscriptionId", parameters[1].Name);
+        Assert.AreEqual(true, parameters[1].Metadata["required"]);
+        Assert.AreEqual("subscription id", parameters[1].Description);
     }
 
-    [Fact]
+    [TestMethod]
     public void ParseSwaggerJsonWithLoopReferenceShouldSucceed()
     {
         const string swaggerFile = "TestData/swagger/loopref_swagger2.json";
         var swagger = SwaggerJsonParser.Parse(swaggerFile);
 
-        Assert.Single(swagger.Paths.Values);
+        Assert.ContainsSingle(swagger.Paths.Values);
         var actionJObject = swagger.Paths["/contacts"].Metadata["patch"] as JObject;
-        Assert.NotNull(actionJObject);
+        Assert.IsNotNull(actionJObject);
         var action = actionJObject.ToObject<OperationObject>();
         var schemaJObject = (JObject)action.Parameters[0].Metadata["schema"];
         var schemaObj = schemaJObject.ToString(Formatting.Indented);
-        Assert.Equal(@"{
+        Assert.AreEqual(@"{
   ""properties"": {
     ""provisioningErrors"": {
       ""type"": ""array"",
@@ -147,19 +147,19 @@ public void ParseSwaggerJsonWithLoopReferenceShouldSucceed()
 }".Replace("\r\n", "\n"), schemaObj.Replace("\r\n", "\n"));
     }
 
-    [Fact]
+    [TestMethod]
     public void ParseSwaggerJsonWithExternalLoopReferenceShouldSucceed()
     {
         const string swaggerFile = "TestData/swagger/externalLoopRef_A.json";
         var swagger = SwaggerJsonParser.Parse(swaggerFile);
 
-        Assert.Single(swagger.Paths.Values);
+        Assert.ContainsSingle(swagger.Paths.Values);
         var actionJObject = swagger.Paths["/contacts"].Metadata["patch"] as JObject;
-        Assert.NotNull(actionJObject);
+        Assert.IsNotNull(actionJObject);
         var action = actionJObject.ToObject<OperationObject>();
         var schemaJObject = (JObject)action.Parameters[0].Metadata["schema"];
         var schemaObj = schemaJObject.ToString(Formatting.Indented);
-        Assert.Equal(@"{
+        Assert.AreEqual(@"{
   ""properties"": {
     ""provisioningErrors"": {
       ""type"": ""array"",
@@ -185,7 +185,7 @@ public void ParseSwaggerJsonWithExternalLoopReferenceShouldSucceed()
   }
 }".Replace("\r\n", "\n"), schemaObj.Replace("\r\n", "\n"));
     }
-    [Fact]
+    [TestMethod]
     public void ParseKeyWordSwaggerJsonShouldSucceed()
     {
         var swaggerFile = "TestData/swagger/resolveKeywordWithRefInside.json";
@@ -193,7 +193,7 @@ public void ParseKeyWordSwaggerJsonShouldSucceed()
 
         ///test x-ms-examples: unresolved.
         var xmsexamples = swagger.Metadata["x-ms-examples"] as JObject;
-        Assert.NotNull(xmsexamples["$ref"]);
+        Assert.IsNotNull(xmsexamples["$ref"]);
 
         var get = swagger.Paths["/{resourceUri}/providers/microsoft.insights/metrics"].Metadata["get"] as JObject;
         var responses = get["responses"] as JObject;
@@ -201,35 +201,35 @@ public void ParseKeyWordSwaggerJsonShouldSucceed()
         ///test responses/../examples: unresolved.
         var response200 = responses["200"] as JObject;
         var examplesOfResponse200 = response200["examples"] as JObject;
-        Assert.NotNull(examplesOfResponse200["$ref"]);
+        Assert.IsNotNull(examplesOfResponse200["$ref"]);
 
         ///test responses/examples: resolved.
         var examplesOfResponse = responses["examples"] as JObject;
-        Assert.Null(examplesOfResponse["$ref"]);
+        Assert.IsNull(examplesOfResponse["$ref"]);
 
         ///test parameters/examples: resolved.
         var parameters = get["parameters"] as JObject;
         var examplesOfParameters = parameters["examples"] as JObject;
-        Assert.Null(examplesOfParameters["$ref"]);
+        Assert.IsNull(examplesOfParameters["$ref"]);
 
         ///test definitions/../example: unresolved.
         var definitions = swagger.Definitions as JObject;
         var tag = definitions["Tag"] as JObject;
         var examplesOfTag = tag["example"] as JObject;
-        Assert.NotNull(examplesOfTag["$ref"]);
+        Assert.IsNotNull(examplesOfTag["$ref"]);
 
         ///test definitions/example: resolved.
         var examplesOfDefinitions = definitions["example"] as JObject;
-        Assert.Null(examplesOfDefinitions["$ref"]);
+        Assert.IsNull(examplesOfDefinitions["$ref"]);
 
         ///test properties/../example: unresolved.
         var propertiesOfTag = tag["properties"] as JObject;
         var unresolvedOfTag = propertiesOfTag["unresolved"] as JObject;
         var examplesOfUnresolved = unresolvedOfTag["example"] as JObject;
-        Assert.NotNull(examplesOfUnresolved["$ref"]);
+        Assert.IsNotNull(examplesOfUnresolved["$ref"]);
 
         ///test properties/example: resolved.
         var examplesOfResolved = propertiesOfTag["example"] as JObject;
-        Assert.Null(examplesOfResolved["$ref"]);
+        Assert.IsNull(examplesOfResolved["$ref"]);
     }
 }
diff --git a/test/Docfx.Build.RestApi.WithPlugins.Tests/SplitRestApiToOperationLevelTest.cs b/test/Docfx.Build.RestApi.WithPlugins.Tests/SplitRestApiToOperationLevelTest.cs
index db65cfef4c8..3ecba3c0eae 100644
--- a/test/Docfx.Build.RestApi.WithPlugins.Tests/SplitRestApiToOperationLevelTest.cs
+++ b/test/Docfx.Build.RestApi.WithPlugins.Tests/SplitRestApiToOperationLevelTest.cs
@@ -11,11 +11,11 @@
 using Docfx.Plugins;
 using Docfx.Tests.Common;
 using Newtonsoft.Json.Linq;
-using Xunit;
 
 namespace Docfx.Build.RestApi.WithPlugins.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class SplitRestApiToOperationLevelTest : TestBase
 {
     private readonly string _outputFolder;
@@ -39,7 +39,7 @@ public SplitRestApiToOperationLevelTest()
         _templateManager = new TemplateManager(["template"], null, "TestData/");
     }
 
-    [Fact]
+    [TestMethod]
     public void SplitRestApiToOperationLevelShouldSucceed()
     {
         var files = new FileCollection(_defaultFiles);
@@ -48,45 +48,45 @@ public void SplitRestApiToOperationLevelShouldSucceed()
         {
             // Verify original petstore page
             var outputRawModelPath = GetRawModelFilePath("petstore.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-            Assert.NotNull(model);
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0", model.Uid);
-            Assert.Empty(model.Children);
-            Assert.True((bool)model.Metadata["_isSplittedByOperation"]);
-            Assert.Empty(model.Tags);
-            Assert.Equal("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Find out more about Swagger</p>\n", ((JObject)model.Metadata["externalDocs"])["description"]);
+            Assert.IsNotNull(model);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0", model.Uid);
+            Assert.IsEmpty(model.Children);
+            Assert.IsTrue((bool)model.Metadata["_isSplittedByOperation"]);
+            Assert.IsEmpty(model.Tags);
+            Assert.AreEqual("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Find out more about Swagger</p>\n", ((JObject)model.Metadata["externalDocs"])["description"]);
         }
         {
             // Verify splitted operation page
             var outputRawModelPath = GetRawModelFilePath("petstore/addPet.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-            Assert.NotNull(model);
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0/addPet", model.Uid);
-            Assert.Null(model.HtmlId);
-            Assert.Equal("addPet", model.Name);
-            Assert.Equal("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Add a new pet to the store</p>\n", model.Summary);
-            Assert.Empty(model.Tags);
-            Assert.Equal("swagger/petstore/addPet.html", model.Metadata["_path"]);
-            Assert.Equal("TestData/swagger/petstore/addPet.json", model.Metadata["_key"]);
-            Assert.True(model.Metadata.ContainsKey("externalDocs"));
-            Assert.True((bool)model.Metadata["_isSplittedToOperation"]);
-            Assert.Single(model.Children);
-            Assert.Empty(model.Tags);
+            Assert.IsNotNull(model);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0/addPet", model.Uid);
+            Assert.IsNull(model.HtmlId);
+            Assert.AreEqual("addPet", model.Name);
+            Assert.AreEqual("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Add a new pet to the store</p>\n", model.Summary);
+            Assert.IsEmpty(model.Tags);
+            Assert.AreEqual("swagger/petstore/addPet.html", model.Metadata["_path"]);
+            Assert.AreEqual("TestData/swagger/petstore/addPet.json", model.Metadata["_key"]);
+            Assert.IsTrue(model.Metadata.ContainsKey("externalDocs"));
+            Assert.IsTrue((bool)model.Metadata["_isSplittedToOperation"]);
+            Assert.ContainsSingle(model.Children);
+            Assert.IsEmpty(model.Tags);
 
             // Test overwritten metadata
-            Assert.Equal("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Find out more about addPet</p>\n", ((JObject)model.Metadata["externalDocs"])["description"]);
+            Assert.AreEqual("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Find out more about addPet</p>\n", ((JObject)model.Metadata["externalDocs"])["description"]);
 
             var child = model.Children[0];
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0/addPet/operation", child.Uid);
-            Assert.Null(child.HtmlId);
-            Assert.Null(child.Summary); // Summary is popped to operation page
-            Assert.Empty(child.Tags);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0/addPet/operation", child.Uid);
+            Assert.IsNull(child.HtmlId);
+            Assert.IsNull(child.Summary); // Summary is popped to operation page
+            Assert.IsEmpty(child.Tags);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void SplitRestApiToOperationLevelWithTocShouldSucceed()
     {
         var files = new FileCollection(_defaultFiles);
@@ -96,55 +96,55 @@ public void SplitRestApiToOperationLevelWithTocShouldSucceed()
         {
             // Verify original petstore page
             var outputRawModelPath = GetRawModelFilePath("petstore.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-            Assert.NotNull(model);
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0", model.Uid);
-            Assert.Empty(model.Children);
-            Assert.Empty(model.Tags);
+            Assert.IsNotNull(model);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0", model.Uid);
+            Assert.IsEmpty(model.Children);
+            Assert.IsEmpty(model.Tags);
         }
         {
             // Verify splitted operation page
             var outputRawModelPath = GetRawModelFilePath("petstore/addPet.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-            Assert.NotNull(model);
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0/addPet", model.Uid);
-            Assert.Null(model.HtmlId);
-            Assert.Equal("addPet", model.Name);
-            Assert.Equal("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Add a new pet to the store</p>\n", model.Summary);
-            Assert.Empty(model.Tags);
-            Assert.Equal("swagger/petstore/addPet.html", model.Metadata["_path"]);
-            Assert.Equal("TestData/swagger/petstore/addPet.json", model.Metadata["_key"]);
-            Assert.Equal("../toc.yml", model.Metadata["_tocRel"]);
-            Assert.True(model.Metadata.ContainsKey("externalDocs"));
-            Assert.Single(model.Children);
-            Assert.Empty(model.Tags);
+            Assert.IsNotNull(model);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0/addPet", model.Uid);
+            Assert.IsNull(model.HtmlId);
+            Assert.AreEqual("addPet", model.Name);
+            Assert.AreEqual("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Add a new pet to the store</p>\n", model.Summary);
+            Assert.IsEmpty(model.Tags);
+            Assert.AreEqual("swagger/petstore/addPet.html", model.Metadata["_path"]);
+            Assert.AreEqual("TestData/swagger/petstore/addPet.json", model.Metadata["_key"]);
+            Assert.AreEqual("../toc.yml", model.Metadata["_tocRel"]);
+            Assert.IsTrue(model.Metadata.ContainsKey("externalDocs"));
+            Assert.ContainsSingle(model.Children);
+            Assert.IsEmpty(model.Tags);
 
             var child = model.Children[0];
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0/addPet/operation", child.Uid);
-            Assert.Null(child.HtmlId);
-            Assert.Null(child.Summary); // Summary has been popped to operation page
-            Assert.Empty(child.Tags);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0/addPet/operation", child.Uid);
+            Assert.IsNull(child.HtmlId);
+            Assert.IsNull(child.Summary); // Summary has been popped to operation page
+            Assert.IsEmpty(child.Tags);
         }
         {
             // Verify toc page
             var outputRawModelPath = GetRawModelFilePath("toc.yml");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<TocItemViewModel>(outputRawModelPath);
-            Assert.NotNull(model);
-            Assert.Single(model.Items);
+            Assert.IsNotNull(model);
+            Assert.ContainsSingle(model.Items);
             var rootModel = model.Items[0];
-            Assert.Equal("petstore.html", rootModel.TopicHref);
-            Assert.Equal(20, rootModel.Items.Count);
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0/addPet", rootModel.Items[0].TopicUid);
-            Assert.Equal("petstore/addPet.html", rootModel.Items[0].TopicHref);
-            Assert.Equal("petstore/addPet.html", rootModel.Items[0].Href);
-            Assert.Equal("addPet", rootModel.Items[0].Name);
+            Assert.AreEqual("petstore.html", rootModel.TopicHref);
+            Assert.AreEqual(20, rootModel.Items.Count);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0/addPet", rootModel.Items[0].TopicUid);
+            Assert.AreEqual("petstore/addPet.html", rootModel.Items[0].TopicHref);
+            Assert.AreEqual("petstore/addPet.html", rootModel.Items[0].Href);
+            Assert.AreEqual("addPet", rootModel.Items[0].Name);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void SplitRestApiToTagAndOperationLevelWithTocShouldSucceed()
     {
         var files = new FileCollection(_defaultFiles);
@@ -154,77 +154,77 @@ public void SplitRestApiToTagAndOperationLevelWithTocShouldSucceed()
         {
             // Verify original petstore page
             var outputRawModelPath = GetRawModelFilePath("petstore.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-            Assert.NotNull(model);
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0", model.Uid);
-            Assert.Empty(model.Children);
-            Assert.Empty(model.Tags);
-            Assert.True((bool)model.Metadata["_isSplittedByTag"]);
+            Assert.IsNotNull(model);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0", model.Uid);
+            Assert.IsEmpty(model.Children);
+            Assert.IsEmpty(model.Tags);
+            Assert.IsTrue((bool)model.Metadata["_isSplittedByTag"]);
         }
         {
             // Verify splitted tag page
             var outputRawModelPath = GetRawModelFilePath("petstore/pet.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-            Assert.NotNull(model);
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0/tag/pet", model.Uid);
-            Assert.Equal("pet", model.Name);
-            Assert.Equal("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Everything about your Pets</p>\n", model.Description);
-            Assert.Empty(model.Children);
-            Assert.Empty(model.Tags);
-            Assert.Equal("swagger/petstore/pet.html", model.Metadata["_path"]);
-            Assert.Equal("TestData/swagger/petstore/pet.json", model.Metadata["_key"]);
-            Assert.True(model.Metadata.ContainsKey("externalDocs"));
-            Assert.True((bool)model.Metadata["_isSplittedToTag"]);
-            Assert.True((bool)model.Metadata["_isSplittedByOperation"]);
+            Assert.IsNotNull(model);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0/tag/pet", model.Uid);
+            Assert.AreEqual("pet", model.Name);
+            Assert.AreEqual("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Everything about your Pets</p>\n", model.Description);
+            Assert.IsEmpty(model.Children);
+            Assert.IsEmpty(model.Tags);
+            Assert.AreEqual("swagger/petstore/pet.html", model.Metadata["_path"]);
+            Assert.AreEqual("TestData/swagger/petstore/pet.json", model.Metadata["_key"]);
+            Assert.IsTrue(model.Metadata.ContainsKey("externalDocs"));
+            Assert.IsTrue((bool)model.Metadata["_isSplittedToTag"]);
+            Assert.IsTrue((bool)model.Metadata["_isSplittedByOperation"]);
         }
         {
             // Verify splitted operation page
             var outputRawModelPath = GetRawModelFilePath("petstore/pet/addPet.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-            Assert.NotNull(model);
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0/addPet", model.Uid);
-            Assert.Null(model.HtmlId);
-            Assert.Equal("addPet", model.Name);
-            Assert.Equal("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Add a new pet to the store</p>\n", model.Summary);
-            Assert.Empty(model.Tags);
-            Assert.Equal("swagger/petstore/pet/addPet.html", model.Metadata["_path"]);
-            Assert.Equal("TestData/swagger/petstore/pet/addPet.json", model.Metadata["_key"]);
-            Assert.Equal("../../toc.yml", model.Metadata["_tocRel"]);
-            Assert.True(model.Metadata.ContainsKey("externalDocs"));
-            Assert.Single(model.Children);
-            Assert.True((bool)model.Metadata["_isSplittedToOperation"]);
+            Assert.IsNotNull(model);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0/addPet", model.Uid);
+            Assert.IsNull(model.HtmlId);
+            Assert.AreEqual("addPet", model.Name);
+            Assert.AreEqual("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Add a new pet to the store</p>\n", model.Summary);
+            Assert.IsEmpty(model.Tags);
+            Assert.AreEqual("swagger/petstore/pet/addPet.html", model.Metadata["_path"]);
+            Assert.AreEqual("TestData/swagger/petstore/pet/addPet.json", model.Metadata["_key"]);
+            Assert.AreEqual("../../toc.yml", model.Metadata["_tocRel"]);
+            Assert.IsTrue(model.Metadata.ContainsKey("externalDocs"));
+            Assert.ContainsSingle(model.Children);
+            Assert.IsTrue((bool)model.Metadata["_isSplittedToOperation"]);
 
             var child = model.Children[0];
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0/addPet/operation", child.Uid);
-            Assert.Null(child.HtmlId);
-            Assert.Null(child.Summary); // Summary has been popped to operation page
-            Assert.Empty(child.Tags);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0/addPet/operation", child.Uid);
+            Assert.IsNull(child.HtmlId);
+            Assert.IsNull(child.Summary); // Summary has been popped to operation page
+            Assert.IsEmpty(child.Tags);
         }
         {
             // Verify toc page
             var outputRawModelPath = GetRawModelFilePath("toc.yml");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<TocItemViewModel>(outputRawModelPath);
-            Assert.NotNull(model);
-            Assert.Single(model.Items);
+            Assert.IsNotNull(model);
+            Assert.ContainsSingle(model.Items);
             var rootModel = model.Items[0];
-            Assert.Equal("petstore.html", rootModel.TopicHref);
-            Assert.Equal(3, rootModel.Items.Count);
+            Assert.AreEqual("petstore.html", rootModel.TopicHref);
+            Assert.AreEqual(3, rootModel.Items.Count);
             var firstTagToc = rootModel.Items[0];
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0/tag/pet", firstTagToc.TopicUid);
-            Assert.Equal("petstore/pet.html", firstTagToc.TopicHref);
-            Assert.Equal("petstore/pet.html", firstTagToc.Href);
-            Assert.Equal("pet", firstTagToc.Name);
-            Assert.Equal(8, firstTagToc.Items.Count);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0/tag/pet", firstTagToc.TopicUid);
+            Assert.AreEqual("petstore/pet.html", firstTagToc.TopicHref);
+            Assert.AreEqual("petstore/pet.html", firstTagToc.Href);
+            Assert.AreEqual("pet", firstTagToc.Name);
+            Assert.AreEqual(8, firstTagToc.Items.Count);
             var firstOperationToc = firstTagToc.Items[0];
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0/addPet", firstOperationToc.TopicUid);
-            Assert.Equal("petstore/pet/addPet.html", firstOperationToc.TopicHref);
-            Assert.Equal("petstore/pet/addPet.html", firstOperationToc.Href);
-            Assert.Equal("addPet", firstOperationToc.Name);
-            Assert.Null(firstOperationToc.Items);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0/addPet", firstOperationToc.TopicUid);
+            Assert.AreEqual("petstore/pet/addPet.html", firstOperationToc.TopicHref);
+            Assert.AreEqual("petstore/pet/addPet.html", firstOperationToc.Href);
+            Assert.AreEqual("addPet", firstOperationToc.Name);
+            Assert.IsNull(firstOperationToc.Items);
         }
     }
 
diff --git a/test/Docfx.Build.RestApi.WithPlugins.Tests/SplitRestApiToTagLevelTest.cs b/test/Docfx.Build.RestApi.WithPlugins.Tests/SplitRestApiToTagLevelTest.cs
index 22a06714040..1260b4aff49 100644
--- a/test/Docfx.Build.RestApi.WithPlugins.Tests/SplitRestApiToTagLevelTest.cs
+++ b/test/Docfx.Build.RestApi.WithPlugins.Tests/SplitRestApiToTagLevelTest.cs
@@ -12,11 +12,11 @@
 using Docfx.Tests.Common;
 
 using Newtonsoft.Json.Linq;
-using Xunit;
 
 namespace Docfx.Build.RestApi.WithPlugins.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class SplitRestApiToTagLevelTest : TestBase
 {
     private readonly string _outputFolder;
@@ -40,7 +40,7 @@ public SplitRestApiToTagLevelTest()
         _templateManager = new TemplateManager(["template"], null, "TestData/");
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessRestApiShouldSucceed()
     {
         var files = new FileCollection(_defaultFiles);
@@ -49,38 +49,38 @@ public void ProcessRestApiShouldSucceed()
         {
             // Verify original petstore page
             var outputRawModelPath = GetRawModelFilePath("petstore.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-            Assert.NotNull(model);
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0", model.Uid);
-            Assert.Empty(model.Children);
-            Assert.Empty(model.Tags);
-            Assert.True((bool)model.Metadata["_isSplittedByTag"]);
-            Assert.Equal("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Find out more about Swagger</p>\n", ((JObject)model.Metadata["externalDocs"])["description"]);
+            Assert.IsNotNull(model);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0", model.Uid);
+            Assert.IsEmpty(model.Children);
+            Assert.IsEmpty(model.Tags);
+            Assert.IsTrue((bool)model.Metadata["_isSplittedByTag"]);
+            Assert.AreEqual("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Find out more about Swagger</p>\n", ((JObject)model.Metadata["externalDocs"])["description"]);
         }
         {
             // Verify splitted tag page
             var outputRawModelPath = GetRawModelFilePath("petstore/pet.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-            Assert.NotNull(model);
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0/tag/pet", model.Uid);
-            Assert.Equal("pet", model.Name);
-            Assert.Equal("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Everything about your Pets</p>\n", model.Description);
-            Assert.Equal(8, model.Children.Count);
-            Assert.Empty(model.Tags);
-            Assert.Empty(model.Children[0].Tags);
-            Assert.Equal("swagger/petstore/pet.html", model.Metadata["_path"]);
-            Assert.Equal("TestData/swagger/petstore/pet.json", model.Metadata["_key"]);
-            Assert.True(model.Metadata.ContainsKey("externalDocs"));
-            Assert.True((bool)model.Metadata["_isSplittedToTag"]);
+            Assert.IsNotNull(model);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0/tag/pet", model.Uid);
+            Assert.AreEqual("pet", model.Name);
+            Assert.AreEqual("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Everything about your Pets</p>\n", model.Description);
+            Assert.AreEqual(8, model.Children.Count);
+            Assert.IsEmpty(model.Tags);
+            Assert.IsEmpty(model.Children[0].Tags);
+            Assert.AreEqual("swagger/petstore/pet.html", model.Metadata["_path"]);
+            Assert.AreEqual("TestData/swagger/petstore/pet.json", model.Metadata["_key"]);
+            Assert.IsTrue(model.Metadata.ContainsKey("externalDocs"));
+            Assert.IsTrue((bool)model.Metadata["_isSplittedToTag"]);
 
             // Test overwritten metadata
-            Assert.Equal("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Find out more about pets</p>\n", ((JObject)model.Metadata["externalDocs"])["description"]);
+            Assert.AreEqual("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Find out more about pets</p>\n", ((JObject)model.Metadata["externalDocs"])["description"]);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessRestApiWithTocShouldSucceed()
     {
         var files = new FileCollection(_defaultFiles);
@@ -90,41 +90,41 @@ public void ProcessRestApiWithTocShouldSucceed()
         {
             // Verify original petstore page
             var outputRawModelPath = GetRawModelFilePath("petstore.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-            Assert.NotNull(model);
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0", model.Uid);
-            Assert.Empty(model.Children);
-            Assert.Empty(model.Tags);
+            Assert.IsNotNull(model);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0", model.Uid);
+            Assert.IsEmpty(model.Children);
+            Assert.IsEmpty(model.Tags);
         }
         {
             // Verify splitted tag page
             var outputRawModelPath = GetRawModelFilePath("petstore/pet.json");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<RestApiRootItemViewModel>(outputRawModelPath);
-            Assert.NotNull(model);
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0/tag/pet", model.Uid);
-            Assert.Equal("pet", model.Name);
-            Assert.Equal("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Everything about your Pets</p>\n", model.Description);
-            Assert.Equal(8, model.Children.Count);
-            Assert.Empty(model.Tags);
-            Assert.Empty(model.Children[0].Tags);
-            Assert.Equal("swagger/petstore/pet.html", model.Metadata["_path"]);
-            Assert.Equal("TestData/swagger/petstore/pet.json", model.Metadata["_key"]);
-            Assert.True(model.Metadata.ContainsKey("externalDocs"));
+            Assert.IsNotNull(model);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0/tag/pet", model.Uid);
+            Assert.AreEqual("pet", model.Name);
+            Assert.AreEqual("<p sourcefile=\"TestData/swagger/petstore.json\" sourcestartlinenumber=\"1\">Everything about your Pets</p>\n", model.Description);
+            Assert.AreEqual(8, model.Children.Count);
+            Assert.IsEmpty(model.Tags);
+            Assert.IsEmpty(model.Children[0].Tags);
+            Assert.AreEqual("swagger/petstore/pet.html", model.Metadata["_path"]);
+            Assert.AreEqual("TestData/swagger/petstore/pet.json", model.Metadata["_key"]);
+            Assert.IsTrue(model.Metadata.ContainsKey("externalDocs"));
         }
         {
             // Verify toc page
             var outputRawModelPath = GetRawModelFilePath("toc.yml");
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<TocItemViewModel>(outputRawModelPath);
-            Assert.NotNull(model);
-            Assert.Single(model.Items);
+            Assert.IsNotNull(model);
+            Assert.ContainsSingle(model.Items);
             var rootModel = model.Items[0];
-            Assert.Equal("petstore.html", rootModel.TopicHref);
-            Assert.Equal(3, rootModel.Items.Count);
-            Assert.Equal("petstore.swagger.io/v2/Swagger Petstore/1.0.0/tag/pet", rootModel.Items[0].TopicUid);
-            Assert.Equal("pet", rootModel.Items[0].Name);
+            Assert.AreEqual("petstore.html", rootModel.TopicHref);
+            Assert.AreEqual(3, rootModel.Items.Count);
+            Assert.AreEqual("petstore.swagger.io/v2/Swagger Petstore/1.0.0/tag/pet", rootModel.Items[0].TopicUid);
+            Assert.AreEqual("pet", rootModel.Items[0].Name);
         }
     }
 
diff --git a/test/Docfx.Build.SchemaDriven.Tests/JsonPointerTest.cs b/test/Docfx.Build.SchemaDriven.Tests/JsonPointerTest.cs
index 381e10fa736..754604ef5c0 100644
--- a/test/Docfx.Build.SchemaDriven.Tests/JsonPointerTest.cs
+++ b/test/Docfx.Build.SchemaDriven.Tests/JsonPointerTest.cs
@@ -5,12 +5,13 @@
 using Docfx.Exceptions;
 using Docfx.Tests.Common;
 using FluentAssertions;
-using Xunit;
 
 namespace Docfx.Build.SchemaDriven.Tests;
+
+[TestClass]
 public class JsonPointerTest : TestBase
 {
-    [Fact]
+    [TestMethod]
     public void TestJsonPointerSpec()
     {
         var root = ConvertToObjectHelper.ConvertToDynamic(ConvertToObjectHelper.ConvertJObjectToObject(JsonUtility.FromJsonString<object>(
@@ -43,7 +44,7 @@ public void TestJsonPointerSpec()
         new JsonPointer("/m~0n").GetValue(root).Should().Be(8);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestJsonPointerWithComplexObject()
     {
         var root = ConvertToObjectHelper.ConvertToDynamic(ConvertToObjectHelper.ConvertJObjectToObject(JsonUtility.FromJsonString<object>(@"
@@ -67,26 +68,26 @@ public void TestJsonPointerWithComplexObject()
    }
 ")));
 
-        Assert.Equal(root, new JsonPointer("").GetValue(root));
-        Assert.Equal("value1", new JsonPointer("/dict/key1").GetValue(root));
-        Assert.Equal("arr2", new JsonPointer("/dict/key2/1").GetValue(root));
-        Assert.Equal("value1", new JsonPointer("/dict/key3/key3/key3/key1").GetValue(root));
-        Assert.Null(new JsonPointer("/dict/key4").GetValue(root));
-        Assert.Null(new JsonPointer("/dict/key4/key1").GetValue(root));
-        Assert.Null(new JsonPointer("/dict/key2/2").GetValue(root));
+        Assert.AreEqual(root, new JsonPointer("").GetValue(root));
+        Assert.AreEqual("value1", new JsonPointer("/dict/key1").GetValue(root));
+        Assert.AreEqual("arr2", new JsonPointer("/dict/key2/1").GetValue(root));
+        Assert.AreEqual("value1", new JsonPointer("/dict/key3/key3/key3/key1").GetValue(root));
+        Assert.IsNull(new JsonPointer("/dict/key4").GetValue(root));
+        Assert.IsNull(new JsonPointer("/dict/key4/key1").GetValue(root));
+        Assert.IsNull(new JsonPointer("/dict/key2/2").GetValue(root));
 
         var jp = new JsonPointer("/dict/key1");
         jp.SetValue(ref root, 1);
-        Assert.Equal(1, jp.GetValue(root));
+        Assert.AreEqual(1, jp.GetValue(root));
 
         jp = new JsonPointer("/dict/key3/key2/1");
         jp.SetValue(ref root, 2);
-        Assert.Equal(2, jp.GetValue(root));
+        Assert.AreEqual(2, jp.GetValue(root));
 
         jp = new JsonPointer("");
         jp.SetValue(ref root, 3);
-        Assert.Equal(3, root);
-        Assert.Equal(3, jp.GetValue(root));
+        Assert.AreEqual(3, root);
+        Assert.AreEqual(3, jp.GetValue(root));
 
         Assert.Throws<InvalidJsonPointerException>(() => new JsonPointer("/dict/key2/2").SetValue(ref root, 1));
     }
diff --git a/test/Docfx.Build.SchemaDriven.Tests/MarkdownFragmentsValidationTest.cs b/test/Docfx.Build.SchemaDriven.Tests/MarkdownFragmentsValidationTest.cs
index 814cdd70777..b4639582534 100644
--- a/test/Docfx.Build.SchemaDriven.Tests/MarkdownFragmentsValidationTest.cs
+++ b/test/Docfx.Build.SchemaDriven.Tests/MarkdownFragmentsValidationTest.cs
@@ -6,11 +6,10 @@
 using Docfx.Plugins;
 using Docfx.Tests.Common;
 
-using Xunit;
-
 namespace Docfx.Build.SchemaDriven.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class MarkdownFragmentsValidationTest : TestBase
 {
     private string _outputFolder;
@@ -26,7 +25,7 @@ public class MarkdownFragmentsValidationTest : TestBase
 
     private const string RawModelFileExtension = ".raw.json";
 
-    [Fact]
+    [TestMethod]
     public void OverwriteUnEditableTest()
     {
         _outputFolder = GetRandomFolder();
@@ -58,18 +57,17 @@ public void OverwriteUnEditableTest()
 
         var logs = _listener.Items;
         var warningLogs = logs.Where(l => l.Code == WarningCodes.Overwrite.InvalidMarkdownFragments).ToList();
-        Assert.True(File.Exists(_rawModelFilePath));
-        Assert.Equal(5, warningLogs.Count);
-        Assert.Equal(
+        Assert.IsTrue(File.Exists(_rawModelFilePath));
+        Assert.AreEqual(5, warningLogs.Count);
+        Assert.AreEqual(
             @"Markdown property `depot_name` is not allowed inside a YAML code block
 You cannot overwrite a readonly property: `site_name`, please add an `editable` tag on this property or mark its contentType as `markdown` in schema if you want to overwrite this property
 There is an invalid H2: `name`: the contentType of this property in schema must be `markdown`
 There is an invalid H2: `operations[id=""management.azure.com.advisor.fragmentsValidation.create""]/summary`: the contentType of this property in schema must be `markdown`
-""/operations/1"" in overwrite object fails to overwrite ""/operations"" for ""management.azure.com.advisor.fragmentsValidation"" because it does not match any existing item.",
-            string.Join(Environment.NewLine, warningLogs.Select(x => x.Message)),
-            ignoreLineEndingDifferences: true);
-        Assert.Equal("14", warningLogs[2].Line);
-        Assert.Equal("17", warningLogs[3].Line);
+""/operations/1"" in overwrite object fails to overwrite ""/operations"" for ""management.azure.com.advisor.fragmentsValidation"" because it does not match any existing item.".ReplaceLineEndings(),
+            string.Join(Environment.NewLine, warningLogs.Select(x => x.Message)));
+        Assert.AreEqual("14", warningLogs[2].Line);
+        Assert.AreEqual("17", warningLogs[3].Line);
     }
 
     private void BuildDocument(FileCollection files)
diff --git a/test/Docfx.Build.SchemaDriven.Tests/MergeMarkdownFragmentsTest.cs b/test/Docfx.Build.SchemaDriven.Tests/MergeMarkdownFragmentsTest.cs
index 15909a250f9..254d1e50422 100644
--- a/test/Docfx.Build.SchemaDriven.Tests/MergeMarkdownFragmentsTest.cs
+++ b/test/Docfx.Build.SchemaDriven.Tests/MergeMarkdownFragmentsTest.cs
@@ -7,11 +7,11 @@
 using Docfx.Tests.Common;
 
 using Newtonsoft.Json.Linq;
-using Xunit;
 
 namespace Docfx.Build.SchemaDriven.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class MergeMarkdownFragmentsTest : TestBase
 {
     private readonly string _outputFolder;
@@ -43,7 +43,7 @@ public MergeMarkdownFragmentsTest()
         _files.Add(DocumentType.Article, [yamlFile], _inputFolder);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestMergeMarkdownFragments()
     {
         // Arrange
@@ -53,15 +53,15 @@ public void TestMergeMarkdownFragments()
         BuildDocument(_files);
 
         // Assert
-        Assert.True(File.Exists(_rawModelFilePath));
+        Assert.IsTrue(File.Exists(_rawModelFilePath));
         var rawModel = JsonUtility.Deserialize<JObject>(_rawModelFilePath);
-        Assert.Equal("bob", rawModel["author"]);
+        Assert.AreEqual("bob", rawModel["author"]);
         Assert.Contains("Enables the snoozed or dismissed attribute", rawModel["operations"][0]["summary"].ToString());
         Assert.Contains("Some empty lines between H2 and this paragraph is tolerant", rawModel["definitions"][0]["properties"][0]["description"].ToString());
         Assert.Contains("This is a summary at YAML's", rawModel["summary"].ToString());
     }
 
-    [Fact]
+    [TestMethod]
     public void TestMissingStartingH1CodeHeading()
     {
         // Arrange
@@ -85,15 +85,15 @@ markdown content
 
         var logs = _listener.Items;
         var warningLogs = logs.Where(l => l.Code == WarningCodes.Overwrite.InvalidMarkdownFragments);
-        Assert.True(File.Exists(_rawModelFilePath));
+        Assert.IsTrue(File.Exists(_rawModelFilePath));
         var rawModel = JsonUtility.Deserialize<JObject>(_rawModelFilePath);
-        Assert.Single(warningLogs);
-        Assert.Equal("Unable to parse markdown fragments: Expect L1InlineCodeHeading", warningLogs.First().Message);
-        Assert.Equal("1", warningLogs.First().Line);
-        Assert.Null(rawModel["summary"]);
+        Assert.ContainsSingle(warningLogs);
+        Assert.AreEqual("Unable to parse markdown fragments: Expect L1InlineCodeHeading", warningLogs.First().Message);
+        Assert.AreEqual("1", warningLogs.First().Line);
+        Assert.IsNull(rawModel["summary"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestInvalidSpaceMissing()
     {
         // Arrange
@@ -119,15 +119,15 @@ markdown content
 
         var logs = _listener.Items;
         var warningLogs = logs.Where(l => l.Code == WarningCodes.Overwrite.InvalidMarkdownFragments);
-        Assert.True(File.Exists(_rawModelFilePath));
+        Assert.IsTrue(File.Exists(_rawModelFilePath));
         var rawModel = JsonUtility.Deserialize<JObject>(_rawModelFilePath);
-        Assert.Single(warningLogs);
-        Assert.Equal("Unable to parse markdown fragments: Expect L1InlineCodeHeading", warningLogs.First().Message);
-        Assert.Equal("1", warningLogs.First().Line);
-        Assert.Null(rawModel["summary"]);
+        Assert.ContainsSingle(warningLogs);
+        Assert.AreEqual("Unable to parse markdown fragments: Expect L1InlineCodeHeading", warningLogs.First().Message);
+        Assert.AreEqual("1", warningLogs.First().Line);
+        Assert.IsNull(rawModel["summary"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestValidSpaceMissing()
     {
         // Arrange
@@ -146,12 +146,12 @@ markdown content
         // Act
         BuildDocument(_files);
 
-        Assert.True(File.Exists(_rawModelFilePath));
+        Assert.IsTrue(File.Exists(_rawModelFilePath));
         var rawModel = JsonUtility.Deserialize<JObject>(_rawModelFilePath);
         Assert.Contains("##head_3_without_space", rawModel["summary"].ToString());
     }
 
-    [Fact]
+    [TestMethod]
     public void TestInvalidYaml()
     {
         // Arrange
@@ -180,15 +180,15 @@ markdown content
 
         var logs = _listener.Items;
         var warningLogs = logs.Where(l => l.Code == WarningCodes.Overwrite.InvalidMarkdownFragments);
-        Assert.True(File.Exists(_rawModelFilePath));
+        Assert.IsTrue(File.Exists(_rawModelFilePath));
         var rawModel = JsonUtility.Deserialize<JObject>(_rawModelFilePath);
-        Assert.Single(warningLogs);
-        Assert.Equal("Unable to parse markdown fragments: Encountered an invalid YAML code block: (Line: 1, Col: 1, Idx: 0) - (Line: 1, Col: 28, Idx: 27): Exception during deserialization", warningLogs.First().Message);
-        Assert.Equal("2", warningLogs.First().Line);
-        Assert.Null(rawModel["summary"]);
+        Assert.ContainsSingle(warningLogs);
+        Assert.AreEqual("Unable to parse markdown fragments: Encountered an invalid YAML code block: (Line: 1, Col: 1, Idx: 0) - (Line: 1, Col: 28, Idx: 27): Exception during deserialization", warningLogs.First().Message);
+        Assert.AreEqual("2", warningLogs.First().Line);
+        Assert.IsNull(rawModel["summary"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestInvalidOPath()
     {
         // Arrange
@@ -218,15 +218,15 @@ markdown content
 
         var logs = _listener.Items;
         var warningLogs = logs.Where(l => l.Code == WarningCodes.Overwrite.InvalidMarkdownFragments);
-        Assert.True(File.Exists(_rawModelFilePath));
+        Assert.IsTrue(File.Exists(_rawModelFilePath));
         var rawModel = JsonUtility.Deserialize<JObject>(_rawModelFilePath);
-        Assert.Single(warningLogs);
-        Assert.Equal("Unable to parse markdown fragments: operations[id=]/summary is not a valid OPath", warningLogs.First().Message);
-        Assert.Equal("3", warningLogs.First().Line);
-        Assert.Null(rawModel["summary"]);
+        Assert.ContainsSingle(warningLogs);
+        Assert.AreEqual("Unable to parse markdown fragments: operations[id=]/summary is not a valid OPath", warningLogs.First().Message);
+        Assert.AreEqual("3", warningLogs.First().Line);
+        Assert.IsNull(rawModel["summary"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestNotExistedUid()
     {
         // Arrange
@@ -275,14 +275,14 @@ Some empty lines between H2 and this paragraph is tolerant
 
         var logs = _listener.Items;
         var warningLogs = logs.Where(l => l.Code == WarningCodes.Overwrite.InvalidMarkdownFragments);
-        Assert.True(File.Exists(_rawModelFilePath));
+        Assert.IsTrue(File.Exists(_rawModelFilePath));
         var rawModel = JsonUtility.Deserialize<JObject>(_rawModelFilePath);
-        Assert.Single(warningLogs);
-        Assert.Equal("Unable to find UidDefinition for Uid: uid_not_exist", warningLogs.First().Message);
-        Assert.Empty(rawModel["summary"]);
+        Assert.ContainsSingle(warningLogs);
+        Assert.AreEqual("Unable to find UidDefinition for Uid: uid_not_exist", warningLogs.First().Message);
+        Assert.IsEmpty(rawModel["summary"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestDuplicateOPathsInYamlCodeBlockAndContentsBlock()
     {
         // Arrange
@@ -308,24 +308,24 @@ overwrite in contents block
         // Act
         BuildDocument(_files);
 
-        Assert.True(File.Exists(_rawModelFilePath));
+        Assert.IsTrue(File.Exists(_rawModelFilePath));
         var rawModel = JsonUtility.Deserialize<JObject>(_rawModelFilePath);
-        Assert.Equal("name overwrite", rawModel["name"]);
-        Assert.Equal($"<p sourcefile=\"{_inputFolder}/Suppressions.yml.md\" sourcestartlinenumber=\"1\" jsonPath=\"/definitions/0/properties/0/description\">overwrite in yaml block</p>\n", rawModel["definitions"][0]["properties"][0]["description"].ToString());
-        Assert.Equal($"<p sourceFile=\"{_inputFolder}/Suppressions.yml.md\" sourceStartLineNumber=\"14\">overwrite in contents block</p>\n", rawModel["definitions"][0]["properties"][1]["description"].ToString());
+        Assert.AreEqual("name overwrite", rawModel["name"]);
+        Assert.AreEqual($"<p sourcefile=\"{_inputFolder}/Suppressions.yml.md\" sourcestartlinenumber=\"1\" jsonPath=\"/definitions/0/properties/0/description\">overwrite in yaml block</p>\n", rawModel["definitions"][0]["properties"][0]["description"].ToString());
+        Assert.AreEqual($"<p sourceFile=\"{_inputFolder}/Suppressions.yml.md\" sourceStartLineNumber=\"14\">overwrite in contents block</p>\n", rawModel["definitions"][0]["properties"][1]["description"].ToString());
     }
 
-    [Fact]
+    [TestMethod]
     public void TestFragmentsWithIncremental()
     {
         using var listener = new TestListenerScope();
         // first build
         BuildDocument(_files);
 
-        Assert.True(File.Exists(_rawModelFilePath));
+        Assert.IsTrue(File.Exists(_rawModelFilePath));
         var rawModel = JsonUtility.Deserialize<JObject>(_rawModelFilePath);
-        Assert.Null(rawModel["summary"]);
-        Assert.NotNull(listener.Items.FirstOrDefault(s => s.Message.StartsWith("There is no template processing document type(s): RESTMixedTest")));
+        Assert.IsNull(rawModel["summary"]);
+        Assert.IsNotNull(listener.Items.FirstOrDefault(s => s.Message.StartsWith("There is no template processing document type(s): RESTMixedTest")));
         ClearLog(listener.Items);
 
         // add fragments
@@ -339,12 +339,12 @@ I add a summary.
 
         BuildDocument(_files);
 
-        Assert.True(File.Exists(_rawModelFilePath));
+        Assert.IsTrue(File.Exists(_rawModelFilePath));
         rawModel = JsonUtility.Deserialize<JObject>(_rawModelFilePath);
-        Assert.NotNull(rawModel["summary"]);
+        Assert.IsNotNull(rawModel["summary"]);
         Assert.Contains("I add a summary", rawModel["summary"].ToString());
-        Assert.NotNull(listener.Items.FirstOrDefault(s => s.Message.StartsWith("There is no template processing document type(s): RESTMixedTest")));
-        Assert.NotNull(listener.Items.FirstOrDefault(s => s.Message.Contains("Cannot resolve") && s.Message.Contains("invalid.md")));
+        Assert.IsNotNull(listener.Items.FirstOrDefault(s => s.Message.StartsWith("There is no template processing document type(s): RESTMixedTest")));
+        Assert.IsNotNull(listener.Items.FirstOrDefault(s => s.Message.Contains("Cannot resolve") && s.Message.Contains("invalid.md")));
         List<string> lastMessages;
         var messages = ClearLog(listener.Items);
 
@@ -361,28 +361,28 @@ I add a summary.
 
         BuildDocument(_files);
 
-        Assert.True(File.Exists(_rawModelFilePath));
+        Assert.IsTrue(File.Exists(_rawModelFilePath));
         rawModel = JsonUtility.Deserialize<JObject>(_rawModelFilePath);
-        Assert.NotNull(rawModel["summary"]);
+        Assert.IsNotNull(rawModel["summary"]);
         Assert.Contains("I update a summary", rawModel["summary"].ToString());
-        Assert.NotNull(listener.Items.FirstOrDefault(s => s.Message.StartsWith("There is no template processing document type(s): RESTMixedTest")));
-        Assert.NotNull(listener.Items.FirstOrDefault(s => s.Message.Contains("Cannot resolve") && s.Message.Contains("invalid.md")));
+        Assert.IsNotNull(listener.Items.FirstOrDefault(s => s.Message.StartsWith("There is no template processing document type(s): RESTMixedTest")));
+        Assert.IsNotNull(listener.Items.FirstOrDefault(s => s.Message.Contains("Cannot resolve") && s.Message.Contains("invalid.md")));
         lastMessages = messages;
         messages = ClearLog(listener.Items);
-        Assert.True(messages.SequenceEqual(lastMessages));
+        Assert.IsTrue(messages.SequenceEqual(lastMessages));
 
         // rebuild
         BuildDocument(_files);
 
-        Assert.True(File.Exists(_rawModelFilePath));
+        Assert.IsTrue(File.Exists(_rawModelFilePath));
         rawModel = JsonUtility.Deserialize<JObject>(_rawModelFilePath);
-        Assert.NotNull(rawModel["summary"]);
+        Assert.IsNotNull(rawModel["summary"]);
         Assert.Contains("I update a summary", rawModel["summary"].ToString());
-        Assert.NotNull(listener.Items.FirstOrDefault(s => s.Message.StartsWith("There is no template processing document type(s): RESTMixedTest")));
-        Assert.NotNull(listener.Items.FirstOrDefault(s => s.Message.Contains("Cannot resolve") && s.Message.Contains("invalid.md")));
+        Assert.IsNotNull(listener.Items.FirstOrDefault(s => s.Message.StartsWith("There is no template processing document type(s): RESTMixedTest")));
+        Assert.IsNotNull(listener.Items.FirstOrDefault(s => s.Message.Contains("Cannot resolve") && s.Message.Contains("invalid.md")));
         lastMessages = messages;
         messages = ClearLog(listener.Items);
-        Assert.True(messages.SequenceEqual(lastMessages));
+        Assert.IsTrue(messages.SequenceEqual(lastMessages));
     }
 
     private static List<string> ClearLog(List<ILogItem> items)
diff --git a/test/Docfx.Build.SchemaDriven.Tests/SchemaDrivenProcessorTest.cs b/test/Docfx.Build.SchemaDriven.Tests/SchemaDrivenProcessorTest.cs
index 0337e095193..43a61d1222f 100644
--- a/test/Docfx.Build.SchemaDriven.Tests/SchemaDrivenProcessorTest.cs
+++ b/test/Docfx.Build.SchemaDriven.Tests/SchemaDrivenProcessorTest.cs
@@ -11,11 +11,11 @@
 using Docfx.Tests.Common;
 
 using Newtonsoft.Json.Linq;
-using Xunit;
 
 namespace Docfx.Build.SchemaDriven.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class SchemaDrivenProcessorTest : TestBase
 {
     private readonly string _outputFolder;
@@ -42,7 +42,7 @@ public SchemaDrivenProcessorTest()
         _templateManager = new TemplateManager(["template"], null, _templateFolder);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestRef()
     {
         using var listener = new TestListenerScope();
@@ -86,18 +86,18 @@ public void TestRef()
         files.Add(DocumentType.Article, [inputFile], _inputFolder);
         BuildDocument(files);
 
-        Assert.Single(listener.Items);
+        Assert.ContainsSingle(listener.Items);
 
         var xrefspec = Path.Combine(_outputFolder, "xrefmap.yml");
         var xrefmap = YamlUtility.Deserialize<XRefMap>(xrefspec);
-        Assert.Empty(xrefmap.References);
+        Assert.IsEmpty(xrefmap.References);
 
         var outputFileName = Path.ChangeExtension(inputFileName, ".html");
 
         var outputFilePath = Path.Combine(_outputFolder, outputFileName);
-        Assert.True(File.Exists(outputFilePath));
+        Assert.IsTrue(File.Exists(outputFilePath));
 
-        Assert.Equal(@"
+        CollectionAssert.AreEqual(@"
 <p><strong>Hello</strong></p>
 <p>1<strong>Hello</strong></p>
 <p>1.1<strong>Hello</strong></p>
@@ -114,7 +114,7 @@ public void TestRef()
             File.ReadAllLines(outputFilePath).Where(s => !string.IsNullOrWhiteSpace(s)).Select(s => s.Trim()).ToArray());
     }
 
-    [Fact]
+    [TestMethod]
     public void TestXrefResolver()
     {
         using var listener = new TestListenerScope();
@@ -139,32 +139,32 @@ public void TestXrefResolver()
         BuildDocument(files);
 
         // assert
-        Assert.Single(listener.Items);
+        Assert.ContainsSingle(listener.Items);
         listener.Items.Clear();
 
         var xrefspec = Path.Combine(_outputFolder, "xrefmap.yml");
         var xrefmap = YamlUtility.Deserialize<XRefMap>(xrefspec);
-        Assert.Equal(2, xrefmap.References.Count);
-        Assert.Equal(8, xrefmap.References[0].Keys.Count);
-        Assert.Equal(10, xrefmap.References[1].Keys.Count);
+        Assert.AreEqual(2, xrefmap.References.Count);
+        Assert.AreEqual(8, xrefmap.References[0].Keys.Count);
+        Assert.AreEqual(10, xrefmap.References[1].Keys.Count);
 
-        Assert.Equal("ICat", xrefmap.References[0].Name);
-        Assert.Equal("CatLibrary.ICat.CatLibrary.ICatExtension.Sleep(System.Int64)", xrefmap.References[0]["extensionMethods/0"]);
+        Assert.AreEqual("ICat", xrefmap.References[0].Name);
+        Assert.AreEqual("CatLibrary.ICat.CatLibrary.ICatExtension.Sleep(System.Int64)", xrefmap.References[0]["extensionMethods/0"]);
         var outputFileName = Path.ChangeExtension(inputFileName, ".html");
-        Assert.Equal(outputFileName, xrefmap.References[0].Href);
-        Assert.NotNull(xrefmap.References[0]["summary"]);
+        Assert.AreEqual(outputFileName, xrefmap.References[0].Href);
+        Assert.IsNotNull(xrefmap.References[0]["summary"]);
 
         var outputFilePath = Path.Combine(_outputFolder, outputFileName);
-        Assert.True(File.Exists(outputFilePath));
+        Assert.IsTrue(File.Exists(outputFilePath));
         var outputFileContent = File.ReadAllLines(outputFilePath);
-        Assert.Equal(@"
+        CollectionAssert.AreEqual(@"
 eat:<p>eat event of cat. Every cat must implement this event.
 This method is within <a class=""xref"" href=""CatLibrary.ICat.html"">ICat</a></p>
 |666|<span>net472</span><span>netstandard2_0</span>".Split(["\r\n", "\n"], StringSplitOptions.None),
             outputFileContent);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestXrefResolverShouldWarnWithEmptyUidReference()
     {
         using var listener = new TestListenerScope();
@@ -179,11 +179,11 @@ public void TestXrefResolverShouldWarnWithEmptyUidReference()
         BuildDocument(files);
 
         // assert
-        Assert.NotEmpty(listener.Items);
-        Assert.Contains(listener.Items, i => i.Code == WarningCodes.Build.UidNotFound);
+        Assert.IsNotEmpty(listener.Items);
+        Assert.Contains(i => i.Code == WarningCodes.Build.UidNotFound, listener.Items);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestValidMetadataReferenceWithIncremental()
     {
         using var listener = new TestListenerScope();
@@ -235,26 +235,26 @@ public void TestValidMetadataReferenceWithIncremental()
 
         BuildDocument(files);
 
-        Assert.Equal(4, listener.Items.Count);
-        Assert.NotNull(listener.Items.FirstOrDefault(s => s.Message.StartsWith("There is no template processing document type(s): MetadataReferenceTest,Toc")));
+        Assert.AreEqual(4, listener.Items.Count);
+        Assert.IsNotNull(listener.Items.FirstOrDefault(s => s.Message.StartsWith("There is no template processing document type(s): MetadataReferenceTest,Toc")));
         listener.Items.Clear();
 
         var rawModelFilePath = GetRawModelFilePath(inputFileName1);
-        Assert.True(File.Exists(rawModelFilePath));
+        Assert.IsTrue(File.Exists(rawModelFilePath));
         var rawModel = JsonUtility.Deserialize<JObject>(rawModelFilePath);
 
-        Assert.Equal("overwritten", rawModel["metadata"]["meta"].ToString());
-        Assert.Equal("postbuild1", rawModel["metadata"]["postMeta"].ToString());
-        Assert.Equal("1", rawModel["metadata"]["another"].ToString());
-        Assert.Equal("app-service", rawModel["metadata"]["ms.service"].ToString());
+        Assert.AreEqual("overwritten", rawModel["metadata"]["meta"].ToString());
+        Assert.AreEqual("postbuild1", rawModel["metadata"]["postMeta"].ToString());
+        Assert.AreEqual("1", rawModel["metadata"]["another"].ToString());
+        Assert.AreEqual("app-service", rawModel["metadata"]["ms.service"].ToString());
 
         var rawModelFilePath2 = GetRawModelFilePath(inputFileName2);
-        Assert.True(File.Exists(rawModelFilePath2));
+        Assert.IsTrue(File.Exists(rawModelFilePath2));
         var rawModel2 = JsonUtility.Deserialize<JObject>(rawModelFilePath2);
 
-        Assert.Equal("Hello world!", rawModel2["metadata"]["meta"].ToString());
-        Assert.Equal("2", rawModel2["metadata"]["another"].ToString());
-        Assert.Equal("postbuild2", rawModel2["metadata"]["postMeta"].ToString());
+        Assert.AreEqual("Hello world!", rawModel2["metadata"]["meta"].ToString());
+        Assert.AreEqual("2", rawModel2["metadata"]["another"].ToString());
+        Assert.AreEqual("postbuild2", rawModel2["metadata"]["postMeta"].ToString());
 
         // change dependent markdown
         UpdateFile("toc.md", ["# Updated"], _inputFolder);
@@ -262,19 +262,19 @@ public void TestValidMetadataReferenceWithIncremental()
 
         rawModel = JsonUtility.Deserialize<JObject>(rawModelFilePath);
 
-        Assert.Equal("overwritten", rawModel["metadata"]["meta"].ToString());
-        Assert.Equal("1", rawModel["metadata"]["another"].ToString());
-        Assert.Equal("app-service", rawModel["metadata"]["ms.service"].ToString());
-        Assert.Equal("postbuild1", rawModel["metadata"]["postMeta"].ToString());
+        Assert.AreEqual("overwritten", rawModel["metadata"]["meta"].ToString());
+        Assert.AreEqual("1", rawModel["metadata"]["another"].ToString());
+        Assert.AreEqual("app-service", rawModel["metadata"]["ms.service"].ToString());
+        Assert.AreEqual("postbuild1", rawModel["metadata"]["postMeta"].ToString());
 
         rawModel2 = JsonUtility.Deserialize<JObject>(rawModelFilePath2);
 
-        Assert.Equal("Hello world!", rawModel2["metadata"]["meta"].ToString());
-        Assert.Equal("2", rawModel2["metadata"]["another"].ToString());
-        Assert.Equal("postbuild2", rawModel2["metadata"]["postMeta"].ToString());
+        Assert.AreEqual("Hello world!", rawModel2["metadata"]["meta"].ToString());
+        Assert.AreEqual("2", rawModel2["metadata"]["another"].ToString());
+        Assert.AreEqual("postbuild2", rawModel2["metadata"]["postMeta"].ToString());
     }
 
-    [Fact]
+    [TestMethod]
     public void TestInvalidSchemaDefinition()
     {
         // Json.NET schema has limitation of 1000 calls per hour
@@ -306,7 +306,7 @@ public void TestInvalidSchemaDefinition()
         Assert.Throws<InvalidSchemaException>(() => BuildDocument(files));
     }
 
-    [Fact]
+    [TestMethod]
     public void TestInvalidObjectAgainstSchema()
     {
         using var listener = new TestListenerScope();
@@ -335,10 +335,10 @@ public void TestInvalidObjectAgainstSchema()
         files.Add(DocumentType.Article, [inputFile], _inputFolder);
         BuildDocument(files);
         var errors = listener.Items.Where(s => s.Code == "ViolateSchema").ToList();
-        Assert.Single(errors);
+        Assert.ContainsSingle(errors);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestInvalidMetadataReference()
     {
         using var listener = new TestListenerScope();
diff --git a/test/Docfx.Build.SchemaDriven.Tests/SchemaFragmentsIteratorTest.cs b/test/Docfx.Build.SchemaDriven.Tests/SchemaFragmentsIteratorTest.cs
index a0d6cbcb63b..61439cbdf7c 100644
--- a/test/Docfx.Build.SchemaDriven.Tests/SchemaFragmentsIteratorTest.cs
+++ b/test/Docfx.Build.SchemaDriven.Tests/SchemaFragmentsIteratorTest.cs
@@ -3,14 +3,14 @@
 
 using Docfx.Build.OverwriteDocuments;
 
-using Xunit;
 using YamlDotNet.RepresentationModel;
 
 namespace Docfx.Build.SchemaDriven.Tests;
 
+[TestClass]
 public class SchemaFragmentsIteratorTest
 {
-    [Fact]
+    [TestMethod]
     public void TestSchemaFragmentsIterator()
     {
         // arrange
@@ -27,11 +27,11 @@ public void TestSchemaFragmentsIterator()
         iterator.Traverse(yamlStream.Documents[0].RootNode, [], schema);
 
         // assert
-        Assert.Single(counter.ExistingUids);
-        Assert.Equal("management.azure.com.advisor.suppressions", counter.ExistingUids[0]);
-        Assert.Single(counter.ExistingMarkdownProperties);
-        Assert.Equal("definitions[name=\"Application 1\"]/properties[name=\"id\"]/description", counter.ExistingMarkdownProperties[0]);
-        Assert.Equal(6, counter.MissingMarkdownProperties.Count);
+        Assert.ContainsSingle(counter.ExistingUids);
+        Assert.AreEqual("management.azure.com.advisor.suppressions", counter.ExistingUids[0]);
+        Assert.ContainsSingle(counter.ExistingMarkdownProperties);
+        Assert.AreEqual("definitions[name=\"Application 1\"]/properties[name=\"id\"]/description", counter.ExistingMarkdownProperties[0]);
+        Assert.AreEqual(6, counter.MissingMarkdownProperties.Count);
     }
 
     private class UidPropertyCounter : ISchemaFragmentsHandler
diff --git a/test/Docfx.Build.SchemaDriven.Tests/SchemaMergerTest.cs b/test/Docfx.Build.SchemaDriven.Tests/SchemaMergerTest.cs
index 9ede2aedd41..66a96d563a0 100644
--- a/test/Docfx.Build.SchemaDriven.Tests/SchemaMergerTest.cs
+++ b/test/Docfx.Build.SchemaDriven.Tests/SchemaMergerTest.cs
@@ -8,11 +8,11 @@
 using Docfx.Tests.Common;
 
 using Newtonsoft.Json.Linq;
-using Xunit;
 
 namespace Docfx.Build.SchemaDriven.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class SchemaMergerTest : TestBase
 {
     private readonly string _outputFolder;
@@ -39,7 +39,7 @@ public SchemaMergerTest()
         _templateManager = new TemplateManager(["template"], null, _templateFolder);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestSchemaOverwriteWithGeneralMergeTypes()
     {
         using var listener = new TestListenerScope();
@@ -221,72 +221,72 @@ Overwrite with content
         BuildDocument(files);
 
         // One plugin warning for yml and one plugin warning for overwrite file
-        Assert.Equal(7, listener.Items.Count);
-        Assert.NotNull(listener.Items.FirstOrDefault(s => s.Message.StartsWith("There is no template processing document type(s): testmerger")));
-        Assert.Equal(1, listener.Items.Count(s => s.Message.StartsWith("\"/stringArrayValue/0\" in overwrite object fails to overwrite \"/stringArrayValue\" for \"uid1\" because it does not match any existing item.")));
-        Assert.Equal(1, listener.Items.Count(s => s.Message.StartsWith("\"/intArrayValue/0\" in overwrite object fails to overwrite \"/intArrayValue\" for \"uid1\" because it does not match any existing item.")));
-        Assert.Equal(1, listener.Items.Count(s => s.Message.StartsWith("\"/emptyArray/0\" in overwrite object fails to overwrite \"/emptyArray\" for \"uid1\" because it does not match any existing item.")));
-        Assert.Equal(1, listener.Items.Count(s => s.Message.StartsWith("\"/array/0/stringArrayValue/0\" in overwrite object fails to overwrite \"/array/0/stringArrayValue\" for \"uid1\" because it does not match any existing item.")));
-        Assert.Equal(1, listener.Items.Count(s => s.Message.StartsWith("\"/dict/stringArrayValue/0\" in overwrite object fails to overwrite \"/dict/stringArrayValue\" for \"uid1\" because it does not match any existing item.")));
+        Assert.AreEqual(7, listener.Items.Count);
+        Assert.IsNotNull(listener.Items.FirstOrDefault(s => s.Message.StartsWith("There is no template processing document type(s): testmerger")));
+        Assert.AreEqual(1, listener.Items.Count(s => s.Message.StartsWith("\"/stringArrayValue/0\" in overwrite object fails to overwrite \"/stringArrayValue\" for \"uid1\" because it does not match any existing item.")));
+        Assert.AreEqual(1, listener.Items.Count(s => s.Message.StartsWith("\"/intArrayValue/0\" in overwrite object fails to overwrite \"/intArrayValue\" for \"uid1\" because it does not match any existing item.")));
+        Assert.AreEqual(1, listener.Items.Count(s => s.Message.StartsWith("\"/emptyArray/0\" in overwrite object fails to overwrite \"/emptyArray\" for \"uid1\" because it does not match any existing item.")));
+        Assert.AreEqual(1, listener.Items.Count(s => s.Message.StartsWith("\"/array/0/stringArrayValue/0\" in overwrite object fails to overwrite \"/array/0/stringArrayValue\" for \"uid1\" because it does not match any existing item.")));
+        Assert.AreEqual(1, listener.Items.Count(s => s.Message.StartsWith("\"/dict/stringArrayValue/0\" in overwrite object fails to overwrite \"/dict/stringArrayValue\" for \"uid1\" because it does not match any existing item.")));
 
         listener.Items.Clear();
 
         var rawModelFilePath = GetRawModelFilePath(inputFileName);
-        Assert.True(File.Exists(rawModelFilePath));
+        Assert.IsTrue(File.Exists(rawModelFilePath));
         var rawModel = JsonUtility.Deserialize<JObject>(rawModelFilePath);
 
-        Assert.Equal("Hello world!", rawModel["meta"].Value<string>());
-        Assert.Equal(2, rawModel["intValue"].Value<int>());
-        Assert.Equal("string1", rawModel["stringValue"].Value<string>());
-        Assert.Equal("abc", rawModel["ignoreValue"].Value<string>());
-        Assert.True(rawModel["boolValue"].Value<bool>());
-        Assert.Equal("notEmpty", rawModel["empty"].Value<string>());
+        Assert.AreEqual("Hello world!", rawModel["meta"].Value<string>());
+        Assert.AreEqual(2, rawModel["intValue"].Value<int>());
+        Assert.AreEqual("string1", rawModel["stringValue"].Value<string>());
+        Assert.AreEqual("abc", rawModel["ignoreValue"].Value<string>());
+        Assert.IsTrue(rawModel["boolValue"].Value<bool>());
+        Assert.AreEqual("notEmpty", rawModel["empty"].Value<string>());
 
-        Assert.Single(rawModel["stringArrayValue"]);
-        Assert.Equal(".NET", rawModel["stringArrayValue"][0].Value<string>());
+        Assert.ContainsSingle(rawModel["stringArrayValue"]);
+        Assert.AreEqual(".NET", rawModel["stringArrayValue"][0].Value<string>());
 
-        Assert.Equal(2, rawModel["intArrayValue"].Count());
-        Assert.Equal(1, rawModel["intArrayValue"][0].Value<int>());
-        Assert.Equal(2, rawModel["intArrayValue"][1].Value<int>());
+        Assert.AreEqual(2, rawModel["intArrayValue"].Count());
+        Assert.AreEqual(1, rawModel["intArrayValue"][0].Value<int>());
+        Assert.AreEqual(2, rawModel["intArrayValue"][1].Value<int>());
 
-        Assert.Empty(rawModel["emptyArray"]);
+        Assert.IsEmpty(rawModel["emptyArray"]);
 
         var array1 = rawModel["array"][0];
 
-        Assert.Equal(2, array1["intValue"].Value<int>());
-        Assert.Equal($"\n<p sourcefile=\"{overwriteFile}\" sourcestartlinenumber=\"34\">Nice</p>\n", array1["stringValue"].Value<string>());
-        Assert.Equal("abcdef", array1["ignoreValue"].Value<string>());
-        Assert.False(array1["boolValue"].Value<bool>());
-        Assert.Equal(3, array1["empty"].Value<int>());
+        Assert.AreEqual(2, array1["intValue"].Value<int>());
+        Assert.AreEqual($"\n<p sourcefile=\"{overwriteFile}\" sourcestartlinenumber=\"34\">Nice</p>\n", array1["stringValue"].Value<string>());
+        Assert.AreEqual("abcdef", array1["ignoreValue"].Value<string>());
+        Assert.IsFalse(array1["boolValue"].Value<bool>());
+        Assert.AreEqual(3, array1["empty"].Value<int>());
 
-        Assert.Single(array1["stringArrayValue"]);
-        Assert.Equal(".NET", array1["stringArrayValue"][0].Value<string>());
+        Assert.ContainsSingle(array1["stringArrayValue"]);
+        Assert.AreEqual(".NET", array1["stringArrayValue"][0].Value<string>());
 
-        Assert.Equal(2, array1["intArrayValue"].Count());
-        Assert.Equal(1, array1["intArrayValue"][0].Value<int>());
-        Assert.Equal(2, array1["intArrayValue"][1].Value<int>());
+        Assert.AreEqual(2, array1["intArrayValue"].Count());
+        Assert.AreEqual(1, array1["intArrayValue"][0].Value<int>());
+        Assert.AreEqual(2, array1["intArrayValue"][1].Value<int>());
 
-        Assert.Empty(array1["emptyArray"]);
+        Assert.IsEmpty(array1["emptyArray"]);
 
         var dict = rawModel["dict"];
 
-        Assert.Equal(3, dict["intValue"].Value<int>());
-        Assert.Equal($"\n<p sourcefile=\"{overwriteFile}\" sourcestartlinenumber=\"34\">Nice</p>\n", dict["stringValue"].Value<string>());
-        Assert.False(dict["boolValue"].Value<bool>());
-        Assert.Equal(4, dict["empty"].Value<int>());
+        Assert.AreEqual(3, dict["intValue"].Value<int>());
+        Assert.AreEqual($"\n<p sourcefile=\"{overwriteFile}\" sourcestartlinenumber=\"34\">Nice</p>\n", dict["stringValue"].Value<string>());
+        Assert.IsFalse(dict["boolValue"].Value<bool>());
+        Assert.AreEqual(4, dict["empty"].Value<int>());
 
-        Assert.Single(dict["stringArrayValue"]);
-        Assert.Equal(".NET", dict["stringArrayValue"][0].Value<string>());
+        Assert.ContainsSingle(dict["stringArrayValue"]);
+        Assert.AreEqual(".NET", dict["stringArrayValue"][0].Value<string>());
 
-        Assert.Single(dict["intArrayValue"]);
-        Assert.Equal(4, dict["intArrayValue"][0].Value<int>());
+        Assert.ContainsSingle(dict["intArrayValue"]);
+        Assert.AreEqual(4, dict["intArrayValue"][0].Value<int>());
 
-        Assert.Empty(dict["emptyArray"]);
-        Assert.Equal($"\n<p sourcefile=\"{overwriteFile}\" sourcestartlinenumber=\"41\">Cool</p>\n", dict["another"].Value<string>());
-        Assert.Equal($"\n<p sourcefile=\"{overwriteFile}\" sourcestartlinenumber=\"47\">Overwrite with content</p>\n", dict["summary"].Value<string>());
+        Assert.IsEmpty(dict["emptyArray"]);
+        Assert.AreEqual($"\n<p sourcefile=\"{overwriteFile}\" sourcestartlinenumber=\"41\">Cool</p>\n", dict["another"].Value<string>());
+        Assert.AreEqual($"\n<p sourcefile=\"{overwriteFile}\" sourcestartlinenumber=\"47\">Overwrite with content</p>\n", dict["summary"].Value<string>());
     }
 
-    [Fact]
+    [TestMethod]
     public void TestSchemaOverwriteWithGeneralSchemaOptions()
     {
         using var listener = new TestListenerScope();
@@ -348,20 +348,20 @@ public void TestSchemaOverwriteWithGeneralSchemaOptions()
         BuildDocument(files);
 
         // One plugin warning for yml and one plugin warning for overwrite file
-        Assert.True(listener.Items.Count == 0, listener.Items.Select(s => s.Message).ToDelimitedString());
+        Assert.IsTrue(listener.Items.Count == 0, listener.Items.Select(s => s.Message).ToDelimitedString());
 
         var rawModelFilePath = GetRawModelFilePath(inputFileName);
-        Assert.True(File.Exists(rawModelFilePath));
+        Assert.IsTrue(File.Exists(rawModelFilePath));
         var rawModel = JsonUtility.Deserialize<JObject>(rawModelFilePath);
 
-        Assert.Equal("Hello world!", rawModel["meta"].Value<string>());
-        Assert.Equal($"\n<p sourcefile=\"{overwriteFile}\" sourcestartlinenumber=\"8\">Nice</p>\n", rawModel["summary"].Value<string>());
-        Assert.Equal("src.html", rawModel["href"].Value<string>());
-        Assert.Equal("uid1", rawModel["xref"].Value<string>());
-        Assert.Equal($"<p sourcefile=\"{includeFile2}\" sourcestartlinenumber=\"1\" jsonPath=\"/reference\"><a href=\"~/{inputFile}\" sourcefile=\"{includeFile2}\" sourcestartlinenumber=\"1\">overwrite</a></p>\n", rawModel["reference"].Value<string>());
+        Assert.AreEqual("Hello world!", rawModel["meta"].Value<string>());
+        Assert.AreEqual($"\n<p sourcefile=\"{overwriteFile}\" sourcestartlinenumber=\"8\">Nice</p>\n", rawModel["summary"].Value<string>());
+        Assert.AreEqual("src.html", rawModel["href"].Value<string>());
+        Assert.AreEqual("uid1", rawModel["xref"].Value<string>());
+        Assert.AreEqual($"<p sourcefile=\"{includeFile2}\" sourcestartlinenumber=\"1\" jsonPath=\"/reference\"><a href=\"~/{inputFile}\" sourcefile=\"{includeFile2}\" sourcestartlinenumber=\"1\">overwrite</a></p>\n", rawModel["reference"].Value<string>());
 
         var outputFile = GetOutputFilePath(inputFileName);
-        Assert.Equal("<a class=\"xref\" href=\"src.html\">uid1</a>", File.ReadAllText(outputFile));
+        Assert.AreEqual("<a class=\"xref\" href=\"src.html\">uid1</a>", File.ReadAllText(outputFile));
     }
 
     private void BuildDocument(FileCollection files)
diff --git a/test/Docfx.Build.Tests/ConceptualDocumentProcessorTest.cs b/test/Docfx.Build.Tests/ConceptualDocumentProcessorTest.cs
index c7a5f1eeae3..2651182ab5d 100644
--- a/test/Docfx.Build.Tests/ConceptualDocumentProcessorTest.cs
+++ b/test/Docfx.Build.Tests/ConceptualDocumentProcessorTest.cs
@@ -9,11 +9,11 @@
 using Docfx.Plugins;
 using Docfx.Tests.Common;
 using Newtonsoft.Json.Linq;
-using Xunit;
 
 namespace Docfx.Build.ManagedReference.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class ConceptualDocumentProcessorTest : TestBase
 {
     private readonly string _outputFolder;
@@ -52,9 +52,9 @@ public override void Dispose()
         base.Dispose();
     }
 
-    [Theory]
-    [InlineData(@"<p><a href=""%7E/docs/csharp/language-reference/keywords/select-clause.md""></p>", "~/docs/csharp/language-reference/keywords/select-clause.md")]
-    [InlineData(@"<p><a href=""%7E/../samples/readme.md""></p>", "~/../samples/readme.md")]
+    [TestMethod]
+    [DataRow(@"<p><a href=""%7E/docs/csharp/language-reference/keywords/select-clause.md""></p>", "~/docs/csharp/language-reference/keywords/select-clause.md")]
+    [DataRow(@"<p><a href=""%7E/../samples/readme.md""></p>", "~/../samples/readme.md")]
     public void ProcessMarkdownResultWithEncodedUrlShouldSucceed(string htmlContent, string expectedFileLink)
     {
         var markdownResult = new MarkupResult
@@ -63,10 +63,10 @@ public void ProcessMarkdownResultWithEncodedUrlShouldSucceed(string htmlContent,
         };
 
         markdownResult = MarkupUtility.Parse(markdownResult, "docs/framework/data/wcf/how-to-project-query-results-wcf-data-services.md", ImmutableDictionary.Create<string, FileAndType>());
-        Assert.Equal(expectedFileLink, markdownResult.LinkToFiles.First());
+        Assert.AreEqual(expectedFileLink, markdownResult.LinkToFiles.First());
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMarkdownFileWithComplexCharsShouldSucceed()
     {
         var fileName1 = "A#ctor.md";
@@ -82,16 +82,16 @@ public void ProcessMarkdownFileWithComplexCharsShouldSucceed()
         BuildDocument(files);
         {
             var outputRawModelPath = GetRawModelFilePath(file2);
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var outputHtml = GetOutputFilePath(file2);
-            Assert.True(File.Exists(outputHtml));
+            Assert.IsTrue(File.Exists(outputHtml));
             var content = File.ReadAllText(outputHtml);
-            Assert.Equal("<p><a href=\"A%23ctor.html\">Constructor</a></p>\n",
+            Assert.AreEqual("<p><a href=\"A%23ctor.html\">Constructor</a></p>\n",
 content);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMarkdownFileWithBreakLinkShouldSucceed()
     {
         var fileName = "normal.md";
@@ -101,15 +101,15 @@ public void ProcessMarkdownFileWithBreakLinkShouldSucceed()
         BuildDocument(files);
         {
             var outputRawModelPath = GetRawModelFilePath(file);
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var outputHtml = GetOutputFilePath(file);
-            Assert.True(File.Exists(outputHtml));
+            Assert.IsTrue(File.Exists(outputHtml));
             var content = File.ReadAllText(outputHtml);
-            Assert.Equal("<p><a href=\"a#b\">Main</a></p>\n", content);
+            Assert.AreEqual("<p><a href=\"a#b\">Main</a></p>\n", content);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMarkdownFileWithBreakLinkInTokenShouldSucceed()
     {
         var fileName = "normal.md";
@@ -121,17 +121,17 @@ public void ProcessMarkdownFileWithBreakLinkInTokenShouldSucceed()
         BuildDocument(files);
         {
             var outputRawModelPath = GetRawModelFilePath(file);
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var outputHtml = GetOutputFilePath(file);
-            Assert.True(File.Exists(outputHtml));
+            Assert.IsTrue(File.Exists(outputHtml));
             var content = File.ReadAllText(outputHtml);
-            Assert.Equal(@"<p><a href=""a#b"">Main</a></p>
+            Assert.AreEqual(@"<p><a href=""a#b"">Main</a></p>
 ".Replace("\r\n", "\n"),
 content);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void SystemKeysListShouldBeComplete()
     {
         var fileName = "test.md";
@@ -141,10 +141,10 @@ public void SystemKeysListShouldBeComplete()
         BuildDocument(files);
         {
             var outputRawModelPath = GetRawModelFilePath(file);
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var model = JsonUtility.Deserialize<Dictionary<string, object>>(outputRawModelPath);
             var systemKeys = ToList(model[Constants.PropertyName.SystemKeys]);
-            Assert.NotEmpty(systemKeys);
+            Assert.IsNotEmpty(systemKeys);
             foreach (var key in model.Keys.Where(key => key[0] != '_' && key != "meta"))
             {
                 Assert.Contains(key, systemKeys);
@@ -152,7 +152,7 @@ public void SystemKeysListShouldBeComplete()
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMarkdownFileWithRenameOutputFileName()
     {
         var fileName1 = "a.md";
@@ -176,16 +176,16 @@ public void ProcessMarkdownFileWithRenameOutputFileName()
         BuildDocument(files);
         {
             var outputRawModelPath = GetRawModelFilePath(renameFile2);
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
             var outputHtml = GetOutputFilePath(renameFile2);
-            Assert.True(File.Exists(outputHtml));
+            Assert.IsTrue(File.Exists(outputHtml));
             var content = File.ReadAllText(outputHtml);
-            Assert.Equal($"\n<p><a href=\"{renameFile1}\">Constructor</a></p>\n",
+            Assert.AreEqual($"\n<p><a href=\"{renameFile1}\">Constructor</a></p>\n",
 content);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void ExtractTitle()
     {
         // arrange
@@ -202,17 +202,17 @@ public void ExtractTitle()
 
         // assert
         var outputRawModelPath = GetRawModelFilePath(file);
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<Dictionary<string, object>>(outputRawModelPath);
-        Assert.True(model.TryGetValue("title", out var title));
-        Assert.Equal("This is title", title);
-        Assert.True(model.TryGetValue("rawTitle", out var rawTitle));
-        Assert.Equal(
+        Assert.IsTrue(model.TryGetValue("title", out var title));
+        Assert.AreEqual("This is title", title);
+        Assert.IsTrue(model.TryGetValue("rawTitle", out var rawTitle));
+        Assert.AreEqual(
             "<h1 id=\"this-is-title\" sourcefile=\"title.md\" sourcestartlinenumber=\"1\">This is title</h1>",
             rawTitle);
     }
 
-    [Fact]
+    [TestMethod]
     public void ExtractTitleFromYamlHeader()
     {
         // arrange
@@ -233,13 +233,13 @@ public void ExtractTitleFromYamlHeader()
 
         // assert
         var outputRawModelPath = GetRawModelFilePath(file);
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<Dictionary<string, object>>(outputRawModelPath);
-        Assert.True(model.TryGetValue("title", out var title));
-        Assert.Equal("Overwrite title", title);
+        Assert.IsTrue(model.TryGetValue("title", out var title));
+        Assert.AreEqual("Overwrite title", title);
     }
 
-    [Fact]
+    [TestMethod]
     public void ExtractTitleFromH1IfItIsNullInYamlHeader()
     {
         // arrange
@@ -260,13 +260,13 @@ public void ExtractTitleFromH1IfItIsNullInYamlHeader()
 
         // assert
         var outputRawModelPath = GetRawModelFilePath(file);
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<Dictionary<string, object>>(outputRawModelPath);
-        Assert.True(model.TryGetValue("title", out var title));
-        Assert.Equal("This is title", title);
+        Assert.IsTrue(model.TryGetValue("title", out var title));
+        Assert.AreEqual("This is title", title);
     }
 
-    [Fact]
+    [TestMethod]
     public void ExtractTitleFromH1IfItIsEmptyInYamlHeader()
     {
         // arrange
@@ -287,13 +287,13 @@ public void ExtractTitleFromH1IfItIsEmptyInYamlHeader()
 
         // assert
         var outputRawModelPath = GetRawModelFilePath(file);
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<Dictionary<string, object>>(outputRawModelPath);
-        Assert.True(model.TryGetValue("title", out var title));
-        Assert.Equal("This is title", title);
+        Assert.IsTrue(model.TryGetValue("title", out var title));
+        Assert.AreEqual("This is title", title);
     }
 
-    [Fact]
+    [TestMethod]
     public void TitleOverwriteH1InMetadataCanOverwriteTitleFromH1()
     {
         // arrange
@@ -312,13 +312,13 @@ public void TitleOverwriteH1InMetadataCanOverwriteTitleFromH1()
 
         // assert
         var outputRawModelPath = GetRawModelFilePath(file);
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<Dictionary<string, object>>(outputRawModelPath);
-        Assert.True(model.TryGetValue("title", out var title));
-        Assert.Equal("this title overwrites title from H1", title);
+        Assert.IsTrue(model.TryGetValue("title", out var title));
+        Assert.AreEqual("this title overwrites title from H1", title);
     }
 
-    [Fact]
+    [TestMethod]
     public void TitleOverwriteH1InMetadataCannotOverwriteTitleFromYamlHeader()
     {
         // arrange
@@ -340,13 +340,13 @@ public void TitleOverwriteH1InMetadataCannotOverwriteTitleFromYamlHeader()
 
         // assert
         var outputRawModelPath = GetRawModelFilePath(file);
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<Dictionary<string, object>>(outputRawModelPath);
-        Assert.True(model.TryGetValue("title", out var title));
-        Assert.Equal("This is title from YAML header", title);
+        Assert.IsTrue(model.TryGetValue("title", out var title));
+        Assert.AreEqual("This is title from YAML header", title);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMarkdownFileWithRedirectUrl()
     {
         // arrange
@@ -377,15 +377,15 @@ Some content
 
         // Test `redirection.raw.json` content.
         var outputRawModelPath = GetRawModelFilePath(file);
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<Dictionary<string, object>>(outputRawModelPath);
-        Assert.True(model.TryGetValue(Constants.PropertyName.RedirectUrl, out var redirectUrl));
-        Assert.Equal(RedirectUrl, redirectUrl);
+        Assert.IsTrue(model.TryGetValue(Constants.PropertyName.RedirectUrl, out var redirectUrl));
+        Assert.AreEqual(RedirectUrl, redirectUrl);
 
         // Test `manifest.json` content
         var manifest = GetOutputManifest();
-        Assert.Single(manifest.Files);
-        Assert.True(manifest.Files[0].Type == Constants.DocumentType.Redirection);
+        Assert.ContainsSingle(manifest.Files);
+        Assert.IsTrue(manifest.Files[0].Type == Constants.DocumentType.Redirection);
     }
 
     #region Private Helpers
diff --git a/test/Docfx.Build.Tests/DocumentBuilderTest.cs b/test/Docfx.Build.Tests/DocumentBuilderTest.cs
index 98a7478e338..c09ea507150 100644
--- a/test/Docfx.Build.Tests/DocumentBuilderTest.cs
+++ b/test/Docfx.Build.Tests/DocumentBuilderTest.cs
@@ -10,11 +10,11 @@
 using Docfx.Plugins;
 using Docfx.Tests.Common;
 using Newtonsoft.Json.Linq;
-using Xunit;
 
 namespace Docfx.Build.Engine.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class DocumentBuilderTest : TestBase
 {
     private const string RawModelFileExtension = ".raw.json";
@@ -39,7 +39,7 @@ public override void Dispose()
         base.Dispose();
     }
 
-    [Fact]
+    [TestMethod]
     public void TestBuild()
     {
         #region Prepare test data
@@ -160,35 +160,35 @@ public void TestBuild()
 
             {
                 // check toc.
-                Assert.True(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension(tocFile, RawModelFileExtension))));
+                Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension(tocFile, RawModelFileExtension))));
                 var model = JsonUtility.Deserialize<TocItemViewModel>(Path.Combine(_outputFolder, Path.ChangeExtension(tocFile, RawModelFileExtension))).Items;
-                Assert.NotNull(model);
-                Assert.Equal("test1", model[0].Name);
-                Assert.Equal("test.html#bookmark", model[0].Href);
-                Assert.NotNull(model[0].Items);
-                Assert.Equal("test2", model[0].Items[0].Name);
-                Assert.Equal("test/test.html", model[0].Items[0].Href);
-                Assert.Equal("GitHub", model[0].Items[1].Name);
-                Assert.Equal("GH.md?isAbbreviated=true&shouldBeAbbreviated=true#test", model[0].Items[1].Href);
-                Assert.Equal("Api", model[1].Name);
-                Assert.Null(model[1].Href);
-                Assert.NotNull(model[1].Items);
-                Assert.Equal("Console", model[1].Items[0].Name);
-                Assert.Equal("../System.Console.csyml", model[1].Items[0].Href);
-                Assert.Equal("ConsoleColor", model[1].Items[1].Name);
-                Assert.Equal("../System.ConsoleColor.csyml", model[1].Items[1].Href);
+                Assert.IsNotNull(model);
+                Assert.AreEqual("test1", model[0].Name);
+                Assert.AreEqual("test.html#bookmark", model[0].Href);
+                Assert.IsNotNull(model[0].Items);
+                Assert.AreEqual("test2", model[0].Items[0].Name);
+                Assert.AreEqual("test/test.html", model[0].Items[0].Href);
+                Assert.AreEqual("GitHub", model[0].Items[1].Name);
+                Assert.AreEqual("GH.md?isAbbreviated=true&shouldBeAbbreviated=true#test", model[0].Items[1].Href);
+                Assert.AreEqual("Api", model[1].Name);
+                Assert.IsNull(model[1].Href);
+                Assert.IsNotNull(model[1].Items);
+                Assert.AreEqual("Console", model[1].Items[0].Name);
+                Assert.AreEqual("../System.Console.csyml", model[1].Items[0].Href);
+                Assert.AreEqual("ConsoleColor", model[1].Items[1].Name);
+                Assert.AreEqual("../System.ConsoleColor.csyml", model[1].Items[1].Href);
             }
 
             {
                 // check conceptual.
                 var conceptualOutputPath = Path.Combine(_outputFolder, Path.ChangeExtension(conceptualFile, ".html"));
-                Assert.True(File.Exists(conceptualOutputPath));
-                Assert.True(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension(conceptualFile, RawModelFileExtension))));
+                Assert.IsTrue(File.Exists(conceptualOutputPath));
+                Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension(conceptualFile, RawModelFileExtension))));
                 var model = JsonUtility.Deserialize<Dictionary<string, object>>(Path.Combine(_outputFolder, Path.ChangeExtension(conceptualFile, RawModelFileExtension)));
-                Assert.Equal(
+                Assert.AreEqual(
                     $"<h1 id=\"hello-world\" sourcefile=\"{_inputFolder}/test.md\" sourcestartlinenumber=\"10\">Hello World</h1>",
                     model["rawTitle"]);
-                Assert.Equal(
+                Assert.AreEqual(
                     string.Join(
                         "\n",
                         "<!-- I'm comment -->",
@@ -222,7 +222,7 @@ public void TestBuild()
                         "test",
                         "</p>"),
                     model["conceptual"]);
-                Assert.Equal(
+                Assert.AreEqual(
                     string.Join(
                         "\n",
                         "<!-- I'm comment -->",
@@ -256,39 +256,39 @@ public void TestBuild()
                         "test",
                         "</p>"),
                     File.ReadAllText(conceptualOutputPath));
-                Assert.Equal("Conceptual", model["type"]);
-                Assert.Equal("Hello world!", model["meta"]);
-                Assert.Equal("b", model["a"]);
+                Assert.AreEqual("Conceptual", model["type"]);
+                Assert.AreEqual("Hello world!", model["meta"]);
+                Assert.AreEqual("b", model["a"]);
             }
 
             {
                 // check mref.
-                Assert.True(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension("System.Console.csyml", RawModelFileExtension))));
-                Assert.True(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension("System.ConsoleColor.csyml", RawModelFileExtension))));
+                Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension("System.Console.csyml", RawModelFileExtension))));
+                Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension("System.ConsoleColor.csyml", RawModelFileExtension))));
             }
 
             {
                 // check resource.
-                Assert.True(File.Exists(Path.Combine(_outputFolder, resourceFile)));
-                Assert.True(File.Exists(Path.Combine(_outputFolder, resourceFile + RawModelFileExtension)));
+                Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, resourceFile)));
+                Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, resourceFile + RawModelFileExtension)));
                 var meta = JsonUtility.Deserialize<Dictionary<string, object>>(Path.Combine(_outputFolder, resourceFile + RawModelFileExtension));
-                Assert.Single(meta);
-                Assert.False(meta.ContainsKey("meta"));
+                Assert.ContainsSingle(meta);
+                Assert.IsFalse(meta.ContainsKey("meta"));
             }
 
             {
                 // check xrefmap
-                Assert.True(File.Exists(Path.Combine(_outputFolder, "xrefmap.yml")));
+                Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, "xrefmap.yml")));
                 var xrefMap = YamlUtility.Deserialize<XRefMap>(Path.Combine(_outputFolder, "xrefmap.yml"));
-                Assert.Equal(71, xrefMap.References.Count);
+                Assert.AreEqual(71, xrefMap.References.Count);
 
                 var xref1 = xrefMap.References.Where(xref => xref.Uid.Equals("XRef1")).ToList();
-                Assert.Single(xref1);
-                Assert.Equal(Path.ChangeExtension(conceptualFile3, "html").ToNormalizedPath(), xref1[0]?.Href);
+                Assert.ContainsSingle(xref1);
+                Assert.AreEqual(Path.ChangeExtension(conceptualFile3, "html").ToNormalizedPath(), xref1[0]?.Href);
 
                 var xref2 = xrefMap.References.Where(xref => xref.Uid.Equals("XRef2")).ToList();
-                Assert.Single(xref2);
-                Assert.Equal(Path.ChangeExtension(conceptualFile2, "html").ToNormalizedPath(), xref2[0]?.Href);
+                Assert.ContainsSingle(xref2);
+                Assert.AreEqual(Path.ChangeExtension(conceptualFile2, "html").ToNormalizedPath(), xref2[0]?.Href);
             }
         }
         finally
@@ -297,7 +297,7 @@ public void TestBuild()
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestBuildConceptualWithTemplateShouldSucceed()
     {
         CreateFile("conceptual.html.js", @"
@@ -354,7 +354,7 @@ public void TestBuildConceptualWithTemplateShouldSucceed()
 
         {
             // check toc.
-            Assert.True(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension(tocFile, RawModelFileExtension))));
+            Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension(tocFile, RawModelFileExtension))));
             var model = JsonUtility.Deserialize<Dictionary<string, object>>(Path.Combine(_outputFolder, Path.ChangeExtension(tocFile, RawModelFileExtension)));
             var expected = new Dictionary<string, object>
             {
@@ -422,8 +422,8 @@ public void TestBuildConceptualWithTemplateShouldSucceed()
         {
             // check conceptual.
             var conceptualOutputPath = Path.Combine(_outputFolder, Path.ChangeExtension(conceptualFile, ".html"));
-            Assert.True(File.Exists(conceptualOutputPath));
-            Assert.True(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension(conceptualFile, RawModelFileExtension))));
+            Assert.IsTrue(File.Exists(conceptualOutputPath));
+            Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension(conceptualFile, RawModelFileExtension))));
             var model = JsonUtility.Deserialize<Dictionary<string, object>>(Path.Combine(_outputFolder, Path.ChangeExtension(conceptualFile, RawModelFileExtension)));
             var expected = new Dictionary<string, object>
             {
@@ -500,7 +500,7 @@ public void TestBuildConceptualWithTemplateShouldSucceed()
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestBuildWithInvalidPath()
     {
         #region Prepare test data
@@ -553,26 +553,26 @@ public void TestBuildWithInvalidPath()
 
             {
                 // check toc.
-                Assert.True(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension(tocFile, RawModelFileExtension))));
+                Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension(tocFile, RawModelFileExtension))));
                 var model = JsonUtility.Deserialize<TocItemViewModel>(Path.Combine(_outputFolder, Path.ChangeExtension(tocFile, RawModelFileExtension))).Items;
-                Assert.NotNull(model);
-                Assert.Equal("test1", model[0].Name);
-                Assert.Equal("test.html", model[0].Href);
-                Assert.NotNull(model[0].Items);
-                Assert.Equal("test2", model[0].Items[0].Name);
-                Assert.Equal("test/test.html", model[0].Items[0].Href);
+                Assert.IsNotNull(model);
+                Assert.AreEqual("test1", model[0].Name);
+                Assert.AreEqual("test.html", model[0].Href);
+                Assert.IsNotNull(model[0].Items);
+                Assert.AreEqual("test2", model[0].Items[0].Name);
+                Assert.AreEqual("test/test.html", model[0].Items[0].Href);
             }
 
             {
                 // check conceptual.
                 var conceptualOutputPath = Path.Combine(_outputFolder, Path.ChangeExtension(conceptualFile, ".html"));
-                Assert.True(File.Exists(conceptualOutputPath));
-                Assert.True(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension(conceptualFile, RawModelFileExtension))));
+                Assert.IsTrue(File.Exists(conceptualOutputPath));
+                Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension(conceptualFile, RawModelFileExtension))));
                 var model = JsonUtility.Deserialize<Dictionary<string, object>>(Path.Combine(_outputFolder, Path.ChangeExtension(conceptualFile, RawModelFileExtension)));
-                Assert.Equal(
+                Assert.AreEqual(
                     $"<h1 id=\"hello-world\" sourcefile=\"{_inputFolder}/test.md\" sourcestartlinenumber=\"1\">Hello World</h1>",
                     model["rawTitle"]);
-                Assert.Equal(
+                Assert.AreEqual(
                     string.Join(
                         "\n",
                         "",
@@ -588,7 +588,7 @@ public void TestBuildWithInvalidPath()
                         $"Test link: <a href=\"#top\" sourcefile=\"{_inputFolder}/test.md\" sourcestartlinenumber=\"11\">link 10</a></p>",
                         ""),
                     model["conceptual"].ToString().Replace("\r", ""));
-                Assert.Equal(
+                Assert.AreEqual(
                     string.Join(
                         "\n",
                         "",
@@ -604,8 +604,8 @@ public void TestBuildWithInvalidPath()
                         "Test link: <a href=\"#top\">link 10</a></p>",
                         ""),
                     File.ReadAllText(conceptualOutputPath));
-                Assert.Equal("Conceptual", model["type"]);
-                Assert.Equal("Hello world!", model["meta"]);
+                Assert.AreEqual("Conceptual", model["type"]);
+                Assert.AreEqual("Hello world!", model["meta"]);
             }
         }
         finally
@@ -613,7 +613,7 @@ public void TestBuildWithInvalidPath()
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestBuildWithInvalidPathWithTokenAndMapping()
     {
         #region Prepare test data
@@ -645,9 +645,9 @@ public void TestBuildWithInvalidPathWithTokenAndMapping()
         {
             // check conceptual.
             var conceptualOutputPath = Path.Combine(_outputFolder, "a.html");
-            Assert.True(File.Exists(conceptualOutputPath));
-            Assert.True(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension("a.md", RawModelFileExtension))));
-            Assert.Equal(
+            Assert.IsTrue(File.Exists(conceptualOutputPath));
+            Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, Path.ChangeExtension("a.md", RawModelFileExtension))));
+            Assert.AreEqual(
                 string.Join(
                     "\n",
                     "<p><a href=\"invalid-a.md\">link a</a>",
@@ -675,7 +675,7 @@ protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage reques
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestBuildWithMultipleVersion()
     {
         #region Prepare test data
@@ -696,9 +696,9 @@ public void TestBuildWithMultipleVersion()
             versionDir: versionDir);
 
         var conceptualOutputPath = Path.Combine(_outputFolder, versionDir, Path.ChangeExtension("a.md", RawModelFileExtension));
-        Assert.True(File.Exists(conceptualOutputPath));
+        Assert.IsTrue(File.Exists(conceptualOutputPath));
         var conceptualWithFileMappingOutputPath = Path.Combine(_outputFolder, versionDir, subDir, Path.ChangeExtension("b.md", RawModelFileExtension));
-        Assert.True(File.Exists(conceptualWithFileMappingOutputPath));
+        Assert.IsTrue(File.Exists(conceptualWithFileMappingOutputPath));
     }
 
     private static void AssertMetadataEqual(object expected, object actual)
@@ -706,7 +706,7 @@ private static void AssertMetadataEqual(object expected, object actual)
         var expectedJObject = JObject.FromObject(expected);
         var actualJObject = JObject.FromObject(actual);
         var equal = JObject.DeepEquals(expectedJObject, actualJObject);
-        Assert.True(equal, $"Expected: {expectedJObject.ToJsonString()};{Environment.NewLine}Actual: {actualJObject.ToJsonString()}.");
+        Assert.IsTrue(equal, $"Expected: {expectedJObject.ToJsonString()};{Environment.NewLine}Actual: {actualJObject.ToJsonString()}.");
     }
 
     private void BuildDocument(
diff --git a/test/Docfx.Build.Tests/ExtractSearchIndexFromHtmlTest.cs b/test/Docfx.Build.Tests/ExtractSearchIndexFromHtmlTest.cs
index 478ce955538..1ba27c603a4 100644
--- a/test/Docfx.Build.Tests/ExtractSearchIndexFromHtmlTest.cs
+++ b/test/Docfx.Build.Tests/ExtractSearchIndexFromHtmlTest.cs
@@ -4,16 +4,16 @@
 using System.Text;
 using Docfx.Plugins;
 using HtmlAgilityPack;
-using Xunit;
 
 namespace Docfx.Build.Engine.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class ExtractSearchIndexFromHtmlTest
 {
     private static readonly ExtractSearchIndex _extractor = new();
 
-    [Fact]
+    [TestMethod]
     public void TestBasicFeature()
     {
         var rawHtml = @"
@@ -39,10 +39,10 @@ This is article title
         html.LoadHtml(rawHtml);
         var href = "http://dotnet.github.io/docfx";
         var item = _extractor.ExtractItem(html, href);
-        Assert.Equal(new SearchIndexItem { Href = href, Title = "This is title in head metadata", Summary = "Hello World, Microsoft This is article title docfx can do anything..." }, item);
+        Assert.AreEqual(new SearchIndexItem { Href = href, Title = "This is title in head metadata", Summary = "Hello World, Microsoft This is article title docfx can do anything..." }, item);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestMRefMetadata()
     {
         var rawHtml = @"
@@ -75,7 +75,7 @@ This is article title
             ["Title"] = "ManagedReferenceExample",
             ["Summary"] = "Lorem Ipsum",
         });
-        Assert.Equal(new SearchIndexItem { Href = href, Title = "This is title in head metadata", Summary = "Hello World, Microsoft This is article title docfx can do anything..." }, itemNoMetadata);
+        Assert.AreEqual(new SearchIndexItem { Href = href, Title = "This is title in head metadata", Summary = "Hello World, Microsoft This is article title docfx can do anything..." }, itemNoMetadata);
         _extractor.UseMetadata = true;
         _extractor.UseMetadataTitle = true;
         var itemWithMetadata = _extractor.ExtractItem(html, href, new()
@@ -84,7 +84,7 @@ This is article title
             ["Title"] = "ManagedReferenceExample",
             ["Summary"] = "Lorem Ipsum",
         });
-        Assert.Equal(new SearchIndexItem
+        Assert.AreEqual(new SearchIndexItem
         {
             Href = href,
             Title = "ManagedReferenceExample",
@@ -98,7 +98,7 @@ This is article title
             ["Title"] = "ManagedReferenceExample",
             ["Summary"] = "Lorem Ipsum",
         });
-        Assert.Equal(new SearchIndexItem
+        Assert.AreEqual(new SearchIndexItem
         {
             Href = href,
             Title = "This is title in head metadata",
@@ -107,7 +107,7 @@ This is article title
         }, itemWithMetadataNoTitle);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestSearchableClass()
     {
         var rawHtml = @"
@@ -124,10 +124,10 @@ public void TestSearchableClass()
         html.LoadHtml(rawHtml);
         var href = "http://dotnet.github.io/docfx";
         var item = _extractor.ExtractItem(html, href);
-        Assert.Equal(new SearchIndexItem { Href = href, Title = "This is title in head metadata", Summary = "Cooooooool!" }, item);
+        Assert.AreEqual(new SearchIndexItem { Href = href, Title = "This is title in head metadata", Summary = "Cooooooool!" }, item);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestSearchDisableClass()
     {
         var rawHtml = @"
@@ -150,10 +150,10 @@ This is article title
         html.LoadHtml(rawHtml);
         var href = "http://dotnet.github.io/docfx";
         var item = _extractor.ExtractItem(html, href);
-        Assert.Null(item);
+        Assert.IsNull(item);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestArticleTagWithSearchableClass()
     {
         var rawHtml = @"
@@ -172,10 +172,10 @@ Only index once.
         html.LoadHtml(rawHtml);
         var href = "http://dotnet.github.io/docfx";
         var item = _extractor.ExtractItem(html, href);
-        Assert.Equal(new SearchIndexItem { Href = href, Title = "This is title in head metadata", Summary = "Only index once." }, item);
+        Assert.AreEqual(new SearchIndexItem { Href = href, Title = "This is title in head metadata", Summary = "Only index once." }, item);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestDisableTagWithSearchableClass()
     {
         var rawHtml = @"
@@ -196,10 +196,10 @@ Only index once.
         html.LoadHtml(rawHtml);
         var href = "http://dotnet.github.io/docfx";
         var item = _extractor.ExtractItem(html, href);
-        Assert.Null(item);
+        Assert.IsNull(item);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestEmptyItem()
     {
         var rawHtml = @"
@@ -215,10 +215,10 @@ public void TestEmptyItem()
         html.LoadHtml(rawHtml);
         var href = "http://dotnet.github.io/docfx";
         var item = _extractor.ExtractItem(html, href);
-        Assert.Equal(new SearchIndexItem { Href = href, Title = "This is title in head metadata", Summary = string.Empty }, item);
+        Assert.AreEqual(new SearchIndexItem { Href = href, Title = "This is title in head metadata", Summary = string.Empty }, item);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestBlockTagsVsInlineTags()
     {
         var rawHtml = @"
@@ -235,10 +235,10 @@ public void TestBlockTagsVsInlineTags()
         html.LoadHtml(rawHtml);
         var href = "http://dotnet.github.io/docfx";
         var item = _extractor.ExtractItem(html, href);
-        Assert.Equal(new SearchIndexItem { Href = href, Title = "", Summary = "Insert space in block level html tags Donotinsertspaceininlinehtmltags" }, item);
+        Assert.AreEqual(new SearchIndexItem { Href = href, Title = "", Summary = "Insert space in block level html tags Donotinsertspaceininlinehtmltags" }, item);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestIndexDotJsonWithNonEnglishCharacters()
     {
         var rawHtml = @"
@@ -294,6 +294,6 @@ This is article title
   }
 }";
         var actualIndexJSON = File.ReadAllText(Path.Combine(tempTestFolder, "index.json"), Encoding.UTF8);
-        Assert.Equal(expectedIndexJSON, actualIndexJSON, ignoreLineEndingDifferences: true);
+        Assert.AreEqual(expectedIndexJSON.ReplaceLineEndings(), actualIndexJSON.ReplaceLineEndings());
     }
 }
diff --git a/test/Docfx.Build.Tests/FileMetadataHelperTest.cs b/test/Docfx.Build.Tests/FileMetadataHelperTest.cs
index 72d6703db72..b8f6e01b16e 100644
--- a/test/Docfx.Build.Tests/FileMetadataHelperTest.cs
+++ b/test/Docfx.Build.Tests/FileMetadataHelperTest.cs
@@ -3,13 +3,13 @@
 
 using System.Collections.Immutable;
 using Docfx.Glob;
-using Xunit;
 
 namespace Docfx.Build.Engine.Tests;
 
+[TestClass]
 public class FileMetadataHelperTest
 {
-    [Fact]
+    [TestMethod]
     public void TestGetChangedGlobs_AllTheSame()
     {
         var baseDir = "inputFolder";
@@ -38,11 +38,11 @@ public void TestGetChangedGlobs_AllTheSame()
         });
 
         var actual = FileMetadataHelper.GetChangedGlobs(left, right).ToList();
-        Assert.NotNull(actual);
-        Assert.Empty(actual);
+        Assert.IsNotNull(actual);
+        Assert.IsEmpty(actual);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGetChangedGlobs_AllChanged_With_DifferentBaseDir()
     {
         var patterns = new string[] { "*md", "*.m", "abc", "/[]\\*.cs", "*/*.cs", "**" };
@@ -71,11 +71,11 @@ public void TestGetChangedGlobs_AllChanged_With_DifferentBaseDir()
         });
 
         var actualResults = FileMetadataHelper.GetChangedGlobs(left, right).ToList();
-        Assert.NotNull(actualResults);
-        Assert.Empty(actualResults);
+        Assert.IsNotNull(actualResults);
+        Assert.IsEmpty(actualResults);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGetChangedGlobs_AllChanged_With_DifferentPattern()
     {
         var baseDir = "inputFolder";
@@ -106,16 +106,16 @@ public void TestGetChangedGlobs_AllChanged_With_DifferentPattern()
         });
 
         var actualResults = FileMetadataHelper.GetChangedGlobs(left, right).ToList();
-        Assert.NotNull(actualResults);
-        Assert.Equal(12, actualResults.Count);
+        Assert.IsNotNull(actualResults);
+        Assert.AreEqual(12, actualResults.Count);
         var patterns = patternsA.Concat(patternsB).ToList();
         for (var index = 0; index < patterns.Count; index++)
         {
-            Assert.Equal(patterns[index], actualResults[index].Raw);
+            Assert.AreEqual(patterns[index], actualResults[index].Raw);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGetChangedGlobs_CrossGlobsChanged()
     {
         var baseDir = "inputFolder";
@@ -143,13 +143,13 @@ public void TestGetChangedGlobs_CrossGlobsChanged()
         });
 
         var actualResults = FileMetadataHelper.GetChangedGlobs(left, right).ToList();
-        Assert.NotNull(actualResults);
-        Assert.Equal(2, actualResults.Count);
-        Assert.Equal(patterns[0], actualResults[0].Raw);
-        Assert.Equal(patterns[2], actualResults[1].Raw);
+        Assert.IsNotNull(actualResults);
+        Assert.AreEqual(2, actualResults.Count);
+        Assert.AreEqual(patterns[0], actualResults[0].Raw);
+        Assert.AreEqual(patterns[2], actualResults[1].Raw);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGetChangedGlobs_ReduceGlobsChanged()
     {
         var baseDir = "inputFolder";
@@ -171,12 +171,12 @@ public void TestGetChangedGlobs_ReduceGlobsChanged()
         });
 
         var actualResults = FileMetadataHelper.GetChangedGlobs(left, right).ToList();
-        Assert.NotNull(actualResults);
-        Assert.Single(actualResults);
-        Assert.Equal(patterns[1], actualResults[0].Raw);
+        Assert.IsNotNull(actualResults);
+        Assert.ContainsSingle(actualResults);
+        Assert.AreEqual(patterns[1], actualResults[0].Raw);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGetChangedGlobs_IncreaseGlobsChanged()
     {
         var baseDir = "inputFolder";
@@ -205,12 +205,12 @@ public void TestGetChangedGlobs_IncreaseGlobsChanged()
         });
 
         var actualResults = FileMetadataHelper.GetChangedGlobs(left, right).ToList();
-        Assert.NotNull(actualResults);
-        Assert.Single(actualResults);
-        Assert.Equal(patterns[2], actualResults[0].Raw);
+        Assert.IsNotNull(actualResults);
+        Assert.ContainsSingle(actualResults);
+        Assert.AreEqual(patterns[2], actualResults[0].Raw);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGetChangedGlobs_Changed()
     {
         var baseDir = "inputFolder";
@@ -240,14 +240,14 @@ public void TestGetChangedGlobs_Changed()
         });
 
         var actualResults = FileMetadataHelper.GetChangedGlobs(left, right).ToList();
-        Assert.NotNull(actualResults);
-        Assert.Equal(3, actualResults.Count);
-        Assert.Equal(patterns[5], actualResults[0].Raw);
-        Assert.Equal(patterns[2], actualResults[1].Raw);
-        Assert.Equal(patterns[4], actualResults[2].Raw);
+        Assert.IsNotNull(actualResults);
+        Assert.AreEqual(3, actualResults.Count);
+        Assert.AreEqual(patterns[5], actualResults[0].Raw);
+        Assert.AreEqual(patterns[2], actualResults[1].Raw);
+        Assert.AreEqual(patterns[4], actualResults[2].Raw);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGetChangedGlobs_Changed_Reverse()
     {
         var baseDir = "inputFolder";
@@ -271,8 +271,8 @@ public void TestGetChangedGlobs_Changed_Reverse()
         });
 
         var actualResults = FileMetadataHelper.GetChangedGlobs(left, right).ToList();
-        Assert.NotNull(actualResults);
-        Assert.Single(actualResults);
-        Assert.Equal(patterns[1], actualResults[0].Raw);
+        Assert.IsNotNull(actualResults);
+        Assert.ContainsSingle(actualResults);
+        Assert.AreEqual(patterns[1], actualResults[0].Raw);
     }
 }
diff --git a/test/Docfx.Build.Tests/HtmlTemplateTest.cs b/test/Docfx.Build.Tests/HtmlTemplateTest.cs
index 83b2709b393..6050f76f834 100644
--- a/test/Docfx.Build.Tests/HtmlTemplateTest.cs
+++ b/test/Docfx.Build.Tests/HtmlTemplateTest.cs
@@ -1,33 +1,32 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 using static Docfx.Build.HtmlTemplate;
 
 namespace Docfx.Build.Engine.Tests;
 
+[TestClass]
 public class HtmlTemplateTest
 {
-    [Fact]
+    [TestMethod]
     public void HtmlTemplate_HtmlTest()
     {
-        Assert.Equal("ab", Html($"a{null}b").ToString());
-        Assert.Equal("a1b", Html($"a{1}b").ToString());
-        Assert.Equal("a&lt;br/&gt;b", Html($"a{"<br/>"}b").ToString());
-        Assert.Equal("a<br/>b", Html($"a{UnsafeHtml("<br/>")}b").ToString());
-        Assert.Equal("a<p>2</p>b", Html($"a{Html($"<p>{2}</p>")}b").ToString());
-        Assert.Equal("<ul><li>0</li><li>1</li></ul>", Html($"<ul>{new[] { 0, 1 }.Select(i => Html($"<li>{i}</li>"))}</ul>").ToString());
+        Assert.AreEqual("ab", Html($"a{null}b").ToString());
+        Assert.AreEqual("a1b", Html($"a{1}b").ToString());
+        Assert.AreEqual("a&lt;br/&gt;b", Html($"a{"<br/>"}b").ToString());
+        Assert.AreEqual("a<br/>b", Html($"a{UnsafeHtml("<br/>")}b").ToString());
+        Assert.AreEqual("a<p>2</p>b", Html($"a{Html($"<p>{2}</p>")}b").ToString());
+        Assert.AreEqual("<ul><li>0</li><li>1</li></ul>", Html($"<ul>{new[] { 0, 1 }.Select(i => Html($"<li>{i}</li>"))}</ul>").ToString());
     }
 
-    [Fact]
+    [TestMethod]
     public void HtmlTemplate_HtmlAttributesTest()
     {
-        Assert.Equal("<h1></h1>", Html($"<h1 id=\"{false}\"></h1>").ToString());
-        Assert.Equal("<h1></h1>", Html($"<h1 id=\"{null}\"></h1>").ToString());
-        Assert.Equal("<h1></h1>", Html($"<h1 id='{""}'></h1>").ToString());
-        Assert.Equal("<h1 id='a'></h1>", Html($"<h1 id='{"a"}'></h1>").ToString());
-        Assert.Equal("<h1 id=\"a\"></h1>", Html($"<h1 id=\"{"a"}\"></h1>").ToString());
-        Assert.Equal("<h1 id></h1>", Html($"<h1 id=\"{true}\"></h1>").ToString());
+        Assert.AreEqual("<h1></h1>", Html($"<h1 id=\"{false}\"></h1>").ToString());
+        Assert.AreEqual("<h1></h1>", Html($"<h1 id=\"{null}\"></h1>").ToString());
+        Assert.AreEqual("<h1></h1>", Html($"<h1 id='{""}'></h1>").ToString());
+        Assert.AreEqual("<h1 id='a'></h1>", Html($"<h1 id='{"a"}'></h1>").ToString());
+        Assert.AreEqual("<h1 id=\"a\"></h1>", Html($"<h1 id=\"{"a"}\"></h1>").ToString());
+        Assert.AreEqual("<h1 id></h1>", Html($"<h1 id=\"{true}\"></h1>").ToString());
     }
 }
diff --git a/test/Docfx.Build.Tests/JintProcessorHelperTest.cs b/test/Docfx.Build.Tests/JintProcessorHelperTest.cs
index ff772e00a34..112281ec003 100644
--- a/test/Docfx.Build.Tests/JintProcessorHelperTest.cs
+++ b/test/Docfx.Build.Tests/JintProcessorHelperTest.cs
@@ -3,45 +3,45 @@
 
 using Docfx.Common;
 using Jint;
-using Xunit;
 
 namespace Docfx.Build.Engine.Tests;
 
+[TestClass]
 public class JintProcessorHelperTest
 {
-    [Trait("Related", "JintProcessor")]
-    [Fact]
+    [TestProperty("Related", "JintProcessor")]
+    [TestMethod]
     public void TestJObjectConvertWithJToken()
     {
         var testData = ConvertToObjectHelper.ConvertStrongTypeToObject(new TestData());
         {
             var engine = new Jint.Engine();
             var jsValue = JintProcessorHelper.ConvertObjectToJsValue(engine, testData);
-            Assert.True(jsValue.IsObject());
+            Assert.IsTrue(jsValue.IsObject());
             dynamic value = jsValue.ToObject();
-            Assert.Equal(2, value.ValueA);
-            Assert.Equal("ValueB", value.ValueB);
+            Assert.AreEqual(2, value.ValueA);
+            Assert.AreEqual("ValueB", value.ValueB);
             System.Dynamic.ExpandoObject valueDict = value.ValueDict;
             var dict = (IDictionary<string, object>)valueDict;
-            Assert.Equal("Value1", dict["1"]);
-            Assert.Equal(2.0, dict["key"]);
+            Assert.AreEqual("Value1", dict["1"]);
+            Assert.AreEqual(2.0, dict["key"]);
             object[] array = value.ValueList;
-            Assert.Equal("ValueA", array[0]);
-            Assert.Equal("ValueB", array[1]);
+            Assert.AreEqual("ValueA", array[0]);
+            Assert.AreEqual("ValueB", array[1]);
         }
     }
 
-    [Trait("Related", "JintProcessor")]
-    [Theory]
-    [InlineData("string", "string")]
-    [InlineData(1, 1.0)]
-    [InlineData(true, true)]
-    [InlineData('a', "a")]
+    [TestProperty("Related", "JintProcessor")]
+    [TestMethod]
+    [DataRow("string", "string")]
+    [DataRow(1, 1.0)]
+    [DataRow(true, true)]
+    [DataRow('a', "a")]
     public void TestJObjectConvertWithPrimaryType(object input, object expected)
     {
         var engine = new Jint.Engine();
         var jsValue = JintProcessorHelper.ConvertObjectToJsValue(engine, input);
-        Assert.Equal(expected, jsValue.ToObject());
+        Assert.AreEqual(expected, jsValue.ToObject());
     }
 
     private sealed class TestData
diff --git a/test/Docfx.Build.Tests/MarkdownTocReaderTest.cs b/test/Docfx.Build.Tests/MarkdownTocReaderTest.cs
index d59fa4cae26..f5ab0126811 100644
--- a/test/Docfx.Build.Tests/MarkdownTocReaderTest.cs
+++ b/test/Docfx.Build.Tests/MarkdownTocReaderTest.cs
@@ -2,13 +2,13 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Docfx.Plugins;
-using Xunit;
 
 namespace Docfx.Build.TableOfContents.Tests;
 
+[TestClass]
 public class MarkdownTocReaderTest
 {
-    [Fact]
+    [TestMethod]
     public void TestTocMdReader()
     {
         var toc = MarkdownTocReader.LoadToc(@"
@@ -29,63 +29,63 @@ public void TestTocMdReader()
 ## <xref:article8>
 ## [Article8](xref:article8)
 ", "test.md");
-        Assert.Equal(3, toc.Count);
-        Assert.Equal("Article1", toc[0].Name);
-        Assert.Equal("article1.md", toc[0].Href);
+        Assert.AreEqual(3, toc.Count);
+        Assert.AreEqual("Article1", toc[0].Name);
+        Assert.AreEqual("article1.md", toc[0].Href);
         {
             var toc0 = toc[0].Items;
-            Assert.Equal(3, toc0.Count);
-            Assert.Equal("Container1", toc0[0].Name);
-            Assert.Null(toc0[0].Href);
+            Assert.AreEqual(3, toc0.Count);
+            Assert.AreEqual("Container1", toc0[0].Name);
+            Assert.IsNull(toc0[0].Href);
             {
                 var toc0_0 = toc0[0].Items;
-                Assert.Equal(2, toc0_0.Count);
-                Assert.Equal("Article2", toc0_0[0].Name);
-                Assert.Equal("Article 2", toc0_0[0].DisplayName);
-                Assert.Equal("article2.md", toc0_0[0].Href);
-                Assert.Equal("Article3", toc0_0[1].Name);
-                Assert.Equal("article3.md", toc0_0[1].Href);
+                Assert.AreEqual(2, toc0_0.Count);
+                Assert.AreEqual("Article2", toc0_0[0].Name);
+                Assert.AreEqual("Article 2", toc0_0[0].DisplayName);
+                Assert.AreEqual("article2.md", toc0_0[0].Href);
+                Assert.AreEqual("Article3", toc0_0[1].Name);
+                Assert.AreEqual("article3.md", toc0_0[1].Href);
             }
-            Assert.Equal("Container2", toc0[1].Name);
-            Assert.Null(toc0[1].Href);
+            Assert.AreEqual("Container2", toc0[1].Name);
+            Assert.IsNull(toc0[1].Href);
             {
                 var toc0_1 = toc0[1].Items;
-                Assert.Single(toc0_1);
-                Assert.Equal("Article4", toc0_1[0].Name);
-                Assert.Equal("article4.md", toc0_1[0].Href);
+                Assert.ContainsSingle(toc0_1);
+                Assert.AreEqual("Article4", toc0_1[0].Name);
+                Assert.AreEqual("article4.md", toc0_1[0].Href);
                 {
                     var toc0_1_0 = toc0_1[0].Items;
-                    Assert.Single(toc0_1_0);
-                    Assert.Equal("Article5", toc0_1_0[0].Name);
-                    Assert.Equal("article5.md", toc0_1_0[0].Href);
+                    Assert.ContainsSingle(toc0_1_0);
+                    Assert.AreEqual("Article5", toc0_1_0[0].Name);
+                    Assert.AreEqual("article5.md", toc0_1_0[0].Href);
                 }
             }
-            Assert.Equal("Article6", toc0[2].Name);
-            Assert.Equal("article6.md", toc0[2].Href);
+            Assert.AreEqual("Article6", toc0[2].Name);
+            Assert.AreEqual("article6.md", toc0[2].Href);
         }
-        Assert.Equal("Article7", toc[1].Name);
-        Assert.Equal("article7.md", toc[1].Href);
+        Assert.AreEqual("Article7", toc[1].Name);
+        Assert.AreEqual("article7.md", toc[1].Href);
         {
             var toc1 = toc[1].Items;
-            Assert.Single(toc1);
-            Assert.Equal("External", toc1[0].Name);
-            Assert.Equal("http://www.microsoft.com", toc1[0].Href);
+            Assert.ContainsSingle(toc1);
+            Assert.AreEqual("External", toc1[0].Name);
+            Assert.AreEqual("http://www.microsoft.com", toc1[0].Href);
         }
-        Assert.Equal("XrefArticles", toc[2].Name);
-        Assert.Equal("xref", toc[2].Uid);
+        Assert.AreEqual("XrefArticles", toc[2].Name);
+        Assert.AreEqual("xref", toc[2].Uid);
         {
             var toc1 = toc[2].Items;
-            Assert.Equal(3, toc1.Count);
-            Assert.Null(toc1[0].Name);
-            Assert.Equal("article8", toc1[0].Uid);
-            Assert.Null(toc1[1].Name);
-            Assert.Equal("article8", toc1[1].Uid);
-            Assert.Equal("Article8", toc1[2].Name);
-            Assert.Equal("article8", toc1[2].Uid);
+            Assert.AreEqual(3, toc1.Count);
+            Assert.IsNull(toc1[0].Name);
+            Assert.AreEqual("article8", toc1[0].Uid);
+            Assert.IsNull(toc1[1].Name);
+            Assert.AreEqual("article8", toc1[1].Uid);
+            Assert.AreEqual("Article8", toc1[2].Name);
+            Assert.AreEqual("article8", toc1[2].Uid);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestBadMdToc()
     {
         var ex = Assert.Throws<DocumentException>(() =>
@@ -96,9 +96,9 @@ public void TestBadMdToc()
 >_<
 >_<
 ", "test.md"));
-        Assert.Equal(@"Invalid toc file: test.md, Details: Unknown syntax at line 3:
+        Assert.AreEqual(@"Invalid toc file: test.md, Details: Unknown syntax at line 3:
 [bad]()
 >_<
->_<", ex.Message, ignoreLineEndingDifferences: true);
+>_<".ReplaceLineEndings(), ex.Message.ReplaceLineEndings());
     }
 }
diff --git a/test/Docfx.Build.Tests/PostProcessors/SitemapGeneratorTests.cs b/test/Docfx.Build.Tests/PostProcessors/SitemapGeneratorTests.cs
index 68860158bfb..a20a7e0cdde 100644
--- a/test/Docfx.Build.Tests/PostProcessors/SitemapGeneratorTests.cs
+++ b/test/Docfx.Build.Tests/PostProcessors/SitemapGeneratorTests.cs
@@ -4,12 +4,12 @@
 using System.Xml.Linq;
 using Docfx.Plugins;
 using Docfx.Tests.Common;
-using Xunit;
 using DocumentType = Docfx.DataContracts.Common.Constants.DocumentType;
 
 namespace Docfx.Build.Engine.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class SitemapGeneratorTests : TestBase
 {
     public override void Dispose()
@@ -17,7 +17,7 @@ public override void Dispose()
         base.Dispose();
     }
 
-    [Fact]
+    [TestMethod]
     public void TestSitemapGenerator()
     {
         // Arrange
@@ -53,19 +53,19 @@ public void TestSitemapGenerator()
         manifest = sitemapGenerator.Process(manifest, outputFolder);
 
         // Assert
-        Assert.Equal("https://example.com/", manifest.Sitemap.BaseUrl);
-        Assert.True(File.Exists(sitemapPath));
+        Assert.AreEqual("https://example.com/", manifest.Sitemap.BaseUrl);
+        Assert.IsTrue(File.Exists(sitemapPath));
 
         var sitemap = XDocument.Load(sitemapPath);
         var ns = sitemap.Root.Name.Namespace;
         var urls = sitemap.Root.Elements(ns + "url").ToArray();
-        Assert.Equal(4, urls.Length);
+        Assert.AreEqual(4, urls.Length);
 
         // URLs are ordered based on HTML output's RelativePath.
-        Assert.EndsWith("/Conceptual.html", urls[0].Element(ns + "loc").Value);
-        Assert.EndsWith("/Dashboard.html", urls[1].Element(ns + "loc").Value);
-        Assert.EndsWith("/ManagedReference.html", urls[2].Element(ns + "loc").Value);
-        Assert.EndsWith("/Resource.html", urls[3].Element(ns + "loc").Value);
+        StringAssert.EndsWith(urls[0].Element(ns + "loc").Value, "/Conceptual.html");
+        StringAssert.EndsWith(urls[1].Element(ns + "loc").Value, "/Dashboard.html");
+        StringAssert.EndsWith(urls[2].Element(ns + "loc").Value, "/ManagedReference.html");
+        StringAssert.EndsWith(urls[3].Element(ns + "loc").Value, "/Resource.html");
     }
 
     private static ManifestItem GetManifestItem(string documentType, string outputFileExtension = ".html")
diff --git a/test/Docfx.Build.Tests/RemoveDebugInfoTest.cs b/test/Docfx.Build.Tests/RemoveDebugInfoTest.cs
index 588155d564b..d670105c6db 100644
--- a/test/Docfx.Build.Tests/RemoveDebugInfoTest.cs
+++ b/test/Docfx.Build.Tests/RemoveDebugInfoTest.cs
@@ -4,11 +4,10 @@
 using Docfx.Plugins;
 using Docfx.Tests.Common;
 
-using Xunit;
-
 namespace Docfx.Build.Engine.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class RemoveDebugInfoTest : TestBase
 {
     private readonly string _outputFolder;
@@ -26,7 +25,7 @@ public override void Dispose()
         base.Dispose();
     }
 
-    [Fact]
+    [TestMethod]
     public void TestBasicFeature()
     {
         Manifest manifest = new()
@@ -46,6 +45,6 @@ public void TestBasicFeature()
         }.Process(manifest, _outputFolder);
 
         var actual = File.ReadAllText(Path.Combine(_outputFolder, "a.html"));
-        Assert.Equal("<p id='b1'>section<a href='http://bing.com#top'>Microsoft Bing</a></p>", actual);
+        Assert.AreEqual("<p id='b1'>section<a href='http://bing.com#top'>Microsoft Bing</a></p>", actual);
     }
 }
diff --git a/test/Docfx.Build.Tests/TemplateManagerUnitTest.DotnetToolMode.cs b/test/Docfx.Build.Tests/TemplateManagerUnitTest.DotnetToolMode.cs
index 838bff1a889..5cc2afb7c91 100644
--- a/test/Docfx.Build.Tests/TemplateManagerUnitTest.DotnetToolMode.cs
+++ b/test/Docfx.Build.Tests/TemplateManagerUnitTest.DotnetToolMode.cs
@@ -4,7 +4,6 @@
 using Docfx.Common;
 using Docfx.Tests.Common;
 using FluentAssertions;
-using Xunit;
 using Switches = Docfx.DataContracts.Common.Constants.Switches;
 
 namespace Docfx.Build.Engine.Tests;
@@ -17,8 +16,8 @@ public partial class TemplateManagerUnitTest
     /// <summary>
     /// DotnetToolsMode switch is not set or disabled. (it depends on test execution order)
     /// </summary>
-    [Trait("Related", "TemplateProcessor")]
-    [Fact]
+    [TestProperty("Related", "TemplateProcessor")]
+    [TestMethod]
     public void TestDotnetToolsMode_Default()
     {
         // Arrange
@@ -35,8 +34,8 @@ public void TestDotnetToolsMode_Default()
     /// <summary>
     /// DotnetToolsMode switch is enabled
     /// </summary>
-    [Trait("Related", "TemplateProcessor")]
-    [Fact]
+    [TestProperty("Related", "TemplateProcessor")]
+    [TestMethod]
     public void TestDotnetToolsMode_Enabled()
     {
         // Arrange
@@ -71,8 +70,8 @@ public void TestDotnetToolsMode_Enabled()
     /// <summary>
     /// DotnetToolMode is enabled but path is invalid.
     /// </summary>
-    [Trait("Related", "TemplateProcessor")]
-    [Fact]
+    [TestProperty("Related", "TemplateProcessor")]
+    [TestMethod]
     public void TestDotnetToolsMode_InvalidPath()
     {
         // Arrange
diff --git a/test/Docfx.Build.Tests/TemplateManagerUnitTest.cs b/test/Docfx.Build.Tests/TemplateManagerUnitTest.cs
index 22c766f0612..dc42b97b573 100644
--- a/test/Docfx.Build.Tests/TemplateManagerUnitTest.cs
+++ b/test/Docfx.Build.Tests/TemplateManagerUnitTest.cs
@@ -4,11 +4,10 @@
 using Docfx.Plugins;
 using Docfx.Tests.Common;
 
-using Xunit;
-
 namespace Docfx.Build.Engine.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public partial class TemplateManagerUnitTest : TestBase
 {
     private readonly string _inputFolder;
@@ -20,8 +19,8 @@ public TemplateManagerUnitTest()
         _outputFolder = GetRandomFolder();
     }
 
-    [Trait("Related", "ResourceFinder")]
-    [Fact]
+    [TestProperty("Related", "ResourceFinder")]
+    [TestMethod]
     public void TestTemplateManagerWithMultipleThemesShouldWork()
     {
         // If the same resource name exists in the override folder, use the overridden one
@@ -31,20 +30,20 @@ public void TestTemplateManagerWithMultipleThemesShouldWork()
         manager.ProcessTheme(outputFolder, true);
         // 1. Support tmpl1.zip
         var file1 = Path.Combine(outputFolder, "tmpl1.dot.$");
-        Assert.True(File.Exists(file1));
-        Assert.Equal("Override: This is file with complex filename characters", File.ReadAllText(file1));
+        Assert.IsTrue(File.Exists(file1));
+        Assert.AreEqual("Override: This is file with complex filename characters", File.ReadAllText(file1));
 
         // backslash is also supported
         var file2 = Path.Combine(outputFolder, "sub/file1");
-        Assert.True(File.Exists(file2));
-        Assert.Equal("Override: This is file inside a subfolder", File.ReadAllText(file2));
+        Assert.IsTrue(File.Exists(file2));
+        Assert.AreEqual("Override: This is file inside a subfolder", File.ReadAllText(file2));
     }
 
     #region Mustache template processor test
 
-    [Trait("Related", "TemplateProcessor")]
-    [Trait("Related", "Mustache")]
-    [Fact]
+    [TestProperty("Related", "TemplateProcessor")]
+    [TestProperty("Related", "Mustache")]
+    [TestMethod]
     public void TestMustacheTemplateProcessSingleTemplateWithNoScriptShouldWork()
     {
         // 1. Prepare template
@@ -75,7 +74,7 @@ public void TestMustacheTemplateProcessSingleTemplateWithNoScriptShouldWork()
         ProcessTemplate(templateName, null, new[] { item }, model, _outputFolder, Tuple.Create("default.tmpl", template));
 
         var outputFile = Path.Combine(_outputFolder, Path.ChangeExtension(modelFileName, null));
-        Assert.True(File.Exists(outputFile));
+        Assert.IsTrue(File.Exists(outputFile));
         AssertEqualIgnoreCrlf(@"
 name1=test1,
 name2=;
@@ -84,9 +83,9 @@ public void TestMustacheTemplateProcessSingleTemplateWithNoScriptShouldWork()
 ", File.ReadAllText(outputFile));
     }
 
-    [Trait("Related", "TemplateProcessor")]
-    [Trait("Related", "Mustache")]
-    [Fact]
+    [TestProperty("Related", "TemplateProcessor")]
+    [TestProperty("Related", "Mustache")]
+    [TestMethod]
     public void TestMustacheTemplateProcessSingleTemplateWithNoScriptWithPartialShouldWork()
     {
         // 1. Prepare template
@@ -132,7 +131,7 @@ public void TestMustacheTemplateProcessSingleTemplateWithNoScriptWithPartialShou
             Tuple.Create("partial2.tmpl.partial", partial2));
 
         var outputFile = Path.Combine(_outputFolder, Path.ChangeExtension(modelFileName, null));
-        Assert.True(File.Exists(outputFile));
+        Assert.IsTrue(File.Exists(outputFile));
         AssertEqualIgnoreCrlf(@"
 test1
 test2
@@ -143,9 +142,9 @@ public void TestMustacheTemplateProcessSingleTemplateWithNoScriptWithPartialShou
 ", File.ReadAllText(outputFile));
     }
 
-    [Trait("Related", "TemplateProcessor")]
-    [Trait("Related", "Mustache")]
-    [Fact]
+    [TestProperty("Related", "TemplateProcessor")]
+    [TestProperty("Related", "Mustache")]
+    [TestMethod]
     public void TestMustacheTemplateWithMasterPageShouldWork()
     {
         // 1. Prepare template
@@ -204,8 +203,8 @@ Hello Body
             Tuple.Create("partial2.tmpl.partial", partial2));
 
         var outputFile = Path.Combine(_outputFolder, Path.ChangeExtension(modelFileName, null));
-        Assert.True(File.Exists(Path.Combine(_outputFolder, "reference1.html")));
-        Assert.True(File.Exists(outputFile));
+        Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, "reference1.html")));
+        Assert.IsTrue(File.Exists(outputFile));
         AssertEqualIgnoreCrlf(@"
 Hello Master
 
@@ -226,9 +225,9 @@ Hello Body
 ", File.ReadAllText(outputFile));
     }
 
-    [Trait("Related", "TemplateProcessor")]
-    [Trait("Related", "Mustache")]
-    [Fact]
+    [TestProperty("Related", "TemplateProcessor")]
+    [TestProperty("Related", "Mustache")]
+    [TestMethod]
     public void TestMustacheTemplateProcessInvalidTemplateShouldFail()
     {
         var templateName = "InvalidTemplate.html";
@@ -249,9 +248,9 @@ public void TestMustacheTemplateProcessInvalidTemplateShouldFail()
             );
     }
 
-    [Trait("Related", "TemplateProcessor")]
-    [Trait("Related", "Mustache")]
-    [Fact]
+    [TestProperty("Related", "TemplateProcessor")]
+    [TestProperty("Related", "Mustache")]
+    [TestMethod]
     public void TestMustacheTemplateProcessSingleTemplateWithIncludesShouldWork()
     {
         var templateName = "WithIncludes.html";
@@ -293,17 +292,17 @@ public void TestMustacheTemplateProcessSingleTemplateWithIncludesShouldWork()
             Tuple.Create("reference2.html", string.Empty)
             );
         var outputFilePath = Path.Combine(_outputFolder, Path.ChangeExtension(modelFileName, "html"));
-        Assert.True(File.Exists(outputFilePath));
-        Assert.True(File.Exists(Path.Combine(_outputFolder, "reference1.html")));
-        Assert.True(File.Exists(Path.Combine(_outputFolder, "reference2.html")));
+        Assert.IsTrue(File.Exists(outputFilePath));
+        Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, "reference1.html")));
+        Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, "reference2.html")));
         AssertEqualIgnoreCrlf(@"
 test1
 test2
 ", File.ReadAllText(outputFilePath));
     }
 
-    [Trait("Related", "TemplateProcessor")]
-    [Fact]
+    [TestProperty("Related", "TemplateProcessor")]
+    [TestMethod]
     public void TestMustacheTemplateProcessSingleTemplateWithRequireScriptShouldWork()
     {
         var templateName = "WithRequireScript.html";
@@ -353,7 +352,7 @@ function isAbsolutePath(path) {
             Tuple.Create("util.js", utilScript)
             );
         var outputFilePath = Path.Combine(_outputFolder, Path.ChangeExtension(modelFileName, "html"));
-        Assert.True(File.Exists(outputFilePath));
+        Assert.IsTrue(File.Exists(outputFilePath));
         AssertEqualIgnoreCrlf(@"
 result1 = true
 result2 = true
@@ -361,9 +360,9 @@ function isAbsolutePath(path) {
 ", File.ReadAllText(outputFilePath));
     }
 
-    [Trait("Related", "TemplateProcessor")]
-    [Trait("Related", "Mustache")]
-    [Fact]
+    [TestProperty("Related", "TemplateProcessor")]
+    [TestProperty("Related", "Mustache")]
+    [TestMethod]
     public void TestMustacheTemplateProcessTemplateFolderWithDifferentTypeShouldWork()
     {
         var templateName = "TemplateFolder.html";
@@ -415,14 +414,14 @@ public void TestMustacheTemplateProcessTemplateFolderWithDifferentTypeShouldWork
             Tuple.Create("conceptual.md.js", script)
             );
         var outputFilePath1 = Path.Combine(_outputFolder, "TestTemplateProcessor_TemplateFolderWithDifferentType1.md");
-        Assert.True(File.Exists(outputFilePath1));
+        Assert.IsTrue(File.Exists(outputFilePath1));
         AssertEqualIgnoreCrlf(@"
 conceptual:
 test1
 test2
 ", File.ReadAllText(outputFilePath1));
         var outputFilePath2 = Path.Combine(_outputFolder, "TestTemplateProcessor_TemplateFolderWithDifferentType2.html");
-        Assert.True(File.Exists(outputFilePath2));
+        Assert.IsTrue(File.Exists(outputFilePath2));
         AssertEqualIgnoreCrlf(@"
 default:
 test1
@@ -430,9 +429,9 @@ public void TestMustacheTemplateProcessTemplateFolderWithDifferentTypeShouldWork
 ", File.ReadAllText(outputFilePath2));
     }
 
-    [Trait("Related", "TemplateProcessor")]
-    [Trait("Related", "Mustache")]
-    [Fact]
+    [TestProperty("Related", "TemplateProcessor")]
+    [TestProperty("Related", "Mustache")]
+    [TestMethod]
     public void TestMustacheTemplateWithScriptWithLongStringInModelShouldWork()
     {
         // https://github.com/sebastienros/jint/issues/357
@@ -469,11 +468,11 @@ public void TestMustacheTemplateWithScriptWithLongStringInModelShouldWork()
             Tuple.Create("default.html.js", script)
             );
         var outputFilePath1 = Path.Combine(_outputFolder, "TestMustacheTemplateWithScriptWithLongStringInModelShouldWork.html");
-        Assert.True(File.Exists(outputFilePath1));
-        Assert.Equal($"{{&quot;model&quot;:{{&quot;name&quot;:&quot;{longName}&quot;}},&quot;__global&quot;:{{}}}}", File.ReadAllText(outputFilePath1));
+        Assert.IsTrue(File.Exists(outputFilePath1));
+        Assert.AreEqual($"{{&quot;model&quot;:{{&quot;name&quot;:&quot;{longName}&quot;}},&quot;__global&quot;:{{}}}}", File.ReadAllText(outputFilePath1));
     }
 
-    [Fact]
+    [TestMethod]
     public void JsRegexShouldNotShareStatusAmongFunctions()
     {
         // https://github.com/sebastienros/jint/issues/364
@@ -509,11 +508,11 @@ function isAbsolutePath(path) {
             Tuple.Create("default.html.js", script)
             );
         var outputFilePath1 = Path.Combine(_outputFolder, "file.html");
-        Assert.True(File.Exists(outputFilePath1));
-        Assert.Equal("True,True", File.ReadAllText(outputFilePath1));
+        Assert.IsTrue(File.Exists(outputFilePath1));
+        Assert.AreEqual("True,True", File.ReadAllText(outputFilePath1));
     }
 
-    [Fact]
+    [TestMethod]
     public void JsCreateDateShouldNotThrowError()
     {
         var templateName = "TemplateFolder.html";
@@ -538,8 +537,8 @@ public void JsCreateDateShouldNotThrowError()
             Tuple.Create("default.html.js", script)
             );
         var outputFilePath1 = Path.Combine(_outputFolder, "file.html");
-        Assert.True(File.Exists(outputFilePath1));
-        Assert.Equal("2019-08-19T05:40:30.463Z", File.ReadAllText(outputFilePath1));
+        Assert.IsTrue(File.Exists(outputFilePath1));
+        Assert.AreEqual("2019-08-19T05:40:30.463Z", File.ReadAllText(outputFilePath1));
     }
     #endregion
 
@@ -592,6 +591,6 @@ private static void WriteTemplate(string cwd, params Tuple<string, string>[] fil
 
     private static void AssertEqualIgnoreCrlf(string expected, string actual)
     {
-        Assert.Equal(expected.Replace("\r\n", "\n"), actual.Replace("\r\n", "\n"));
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), actual.Replace("\r\n", "\n"));
     }
 }
diff --git a/test/Docfx.Build.Tests/TemplatePageLoaderUnitTest.cs b/test/Docfx.Build.Tests/TemplatePageLoaderUnitTest.cs
index c85c2c72929..9e1978d65d1 100644
--- a/test/Docfx.Build.Tests/TemplatePageLoaderUnitTest.cs
+++ b/test/Docfx.Build.Tests/TemplatePageLoaderUnitTest.cs
@@ -3,11 +3,10 @@
 
 using Docfx.Tests.Common;
 
-using Xunit;
-
 namespace Docfx.Build.Engine.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class TemplatePageLoaderUnitTest : TestBase
 {
     private readonly string _inputFolder;
@@ -17,32 +16,32 @@ public TemplatePageLoaderUnitTest()
         _inputFolder = GetRandomFolder();
     }
 
-    [Fact]
+    [TestMethod]
     public void TestLoaderWhenNoFileExists()
     {
         using var listener = new TestListenerScope();
         var templates = LoadAllTemplates();
-        Assert.Empty(listener.Items);
-        Assert.Empty(templates);
+        Assert.IsEmpty(listener.Items);
+        Assert.IsEmpty(templates);
 
         CreateFile("a.js", string.Empty, _inputFolder);
         templates = LoadAllTemplates();
-        Assert.Empty(listener.Items);
-        Assert.Empty(templates);
+        Assert.IsEmpty(listener.Items);
+        Assert.IsEmpty(templates);
 
         // only allows file under root folder
         CreateFile("sub/a.tmpl", string.Empty, _inputFolder);
         templates = LoadAllTemplates();
-        Assert.Empty(listener.Items);
-        Assert.Empty(templates);
+        Assert.IsEmpty(listener.Items);
+        Assert.IsEmpty(templates);
 
         CreateFile("a.tmpl.js", string.Empty, _inputFolder);
         templates = LoadAllTemplates();
-        Assert.Empty(listener.Items);
-        Assert.Empty(templates);
+        Assert.IsEmpty(listener.Items);
+        Assert.IsEmpty(templates);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestLoaderWhenRendererExists()
     {
         CreateFile("a.tmpl", string.Empty, _inputFolder);
@@ -50,21 +49,21 @@ public void TestLoaderWhenRendererExists()
         using var listener = new TestListenerScope();
         var templates = LoadAllTemplates();
 
-        Assert.Empty(listener.Items);
+        Assert.IsEmpty(listener.Items);
 
-        Assert.Single(templates);
+        Assert.ContainsSingle(templates);
         var template = templates[0];
-        Assert.NotNull(template.Renderer);
-        Assert.Equal(TemplateType.Default, template.TemplateType);
-        Assert.Equal("a", template.Name);
-        Assert.Equal("a", template.Type);
-        Assert.Equal(string.Empty, template.Extension);
-        Assert.Null(template.Preprocessor);
-        Assert.False(template.ContainsGetOptions);
-        Assert.False(template.ContainsModelTransformation);
+        Assert.IsNotNull(template.Renderer);
+        Assert.AreEqual(TemplateType.Default, template.TemplateType);
+        Assert.AreEqual("a", template.Name);
+        Assert.AreEqual("a", template.Type);
+        Assert.AreEqual(string.Empty, template.Extension);
+        Assert.IsNull(template.Preprocessor);
+        Assert.IsFalse(template.ContainsGetOptions);
+        Assert.IsFalse(template.ContainsModelTransformation);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestLoaderWhenPreprocessorExists()
     {
         CreateFile("a.primary.tmpl", string.Empty, _inputFolder);
@@ -73,24 +72,24 @@ public void TestLoaderWhenPreprocessorExists()
         using var listener = new TestListenerScope();
         var templates = LoadAllTemplates();
 
-        Assert.Empty(listener.Items);
+        Assert.IsEmpty(listener.Items);
 
-        Assert.Single(templates);
+        Assert.ContainsSingle(templates);
         var template = templates[0];
-        Assert.NotNull(template.Renderer);
-        Assert.Equal(TemplateType.Primary, template.TemplateType);
-        Assert.Equal("a.primary", template.Name);
-        Assert.Equal("a", template.Type);
-        Assert.Equal(string.Empty, template.Extension);
-        Assert.NotNull(template.Preprocessor);
-        Assert.False(template.ContainsGetOptions);
-        Assert.True(template.ContainsModelTransformation);
+        Assert.IsNotNull(template.Renderer);
+        Assert.AreEqual(TemplateType.Primary, template.TemplateType);
+        Assert.AreEqual("a.primary", template.Name);
+        Assert.AreEqual("a", template.Type);
+        Assert.AreEqual(string.Empty, template.Extension);
+        Assert.IsNotNull(template.Preprocessor);
+        Assert.IsFalse(template.ContainsGetOptions);
+        Assert.IsTrue(template.ContainsModelTransformation);
 
         var output = template.TransformModel(new { a = 1 });
-        Assert.Null(output);
+        Assert.IsNull(output);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestLoaderWhenStandalonePreprocessorExists()
     {
         CreateFile("a.ext.TMPL.js", "exports.transform = function(){}", _inputFolder);
@@ -98,21 +97,21 @@ public void TestLoaderWhenStandalonePreprocessorExists()
         using var listener = new TestListenerScope();
         var templates = LoadAllTemplates();
 
-        Assert.Empty(listener.Items);
+        Assert.IsEmpty(listener.Items);
 
-        Assert.Single(templates);
+        Assert.ContainsSingle(templates);
         var template = templates[0];
-        Assert.Null(template.Renderer);
-        Assert.Equal(TemplateType.Default, template.TemplateType);
-        Assert.Equal("a.ext", template.Name);
-        Assert.Equal("a", template.Type);
-        Assert.Equal(".ext", template.Extension);
-        Assert.NotNull(template.Preprocessor);
-        Assert.False(template.ContainsGetOptions);
-        Assert.True(template.ContainsModelTransformation);
+        Assert.IsNull(template.Renderer);
+        Assert.AreEqual(TemplateType.Default, template.TemplateType);
+        Assert.AreEqual("a.ext", template.Name);
+        Assert.AreEqual("a", template.Type);
+        Assert.AreEqual(".ext", template.Extension);
+        Assert.IsNotNull(template.Preprocessor);
+        Assert.IsFalse(template.ContainsGetOptions);
+        Assert.IsTrue(template.ContainsModelTransformation);
 
         var output = template.TransformModel(new { a = 1 });
-        Assert.Null(output);
+        Assert.IsNull(output);
     }
 
     private List<Template> LoadAllTemplates()
diff --git a/test/Docfx.Build.Tests/TemplatePreprocessorLoaderUnitTest.cs b/test/Docfx.Build.Tests/TemplatePreprocessorLoaderUnitTest.cs
index 85b8c806178..2d3bda78e76 100644
--- a/test/Docfx.Build.Tests/TemplatePreprocessorLoaderUnitTest.cs
+++ b/test/Docfx.Build.Tests/TemplatePreprocessorLoaderUnitTest.cs
@@ -3,11 +3,10 @@
 
 using Docfx.Tests.Common;
 
-using Xunit;
-
 namespace Docfx.Build.Engine.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class TemplatePreprocessorLoaderUnitTest : TestBase
 {
     private readonly string _inputFolder;
@@ -17,21 +16,21 @@ public TemplatePreprocessorLoaderUnitTest()
         _inputFolder = GetRandomFolder();
     }
 
-    [Fact]
+    [TestMethod]
     public void TestLoaderWithValidInput()
     {
         using var listener = new TestListenerScope();
         var preprocessor = Load("a.ext.TMPL.js", "exports.transform = function(model) { return model; }");
 
-        Assert.Empty(listener.Items);
+        Assert.IsEmpty(listener.Items);
 
-        Assert.NotNull(preprocessor);
-        Assert.False(preprocessor.ContainsGetOptions);
-        Assert.True(preprocessor.ContainsModelTransformation);
+        Assert.IsNotNull(preprocessor);
+        Assert.IsFalse(preprocessor.ContainsGetOptions);
+        Assert.IsTrue(preprocessor.ContainsModelTransformation);
 
         var input = new { a = 1 };
         var output = preprocessor.TransformModel(input);
-        Assert.Equal(input.a, ((dynamic)output).a);
+        Assert.AreEqual(input.a, ((dynamic)output).a);
     }
 
     private ITemplatePreprocessor Load(string path, string content)
diff --git a/test/Docfx.Build.Tests/TemplateProcessorUnitTest.cs b/test/Docfx.Build.Tests/TemplateProcessorUnitTest.cs
index 097a821e3e6..2923d73735e 100644
--- a/test/Docfx.Build.Tests/TemplateProcessorUnitTest.cs
+++ b/test/Docfx.Build.Tests/TemplateProcessorUnitTest.cs
@@ -5,11 +5,10 @@
 using Docfx.Plugins;
 using Docfx.Tests.Common;
 
-using Xunit;
-
 namespace Docfx.Build.Engine.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class TemplateProcessorUnitTest : TestBase
 {
     private readonly string _inputFolder;
@@ -23,7 +22,7 @@ public TemplateProcessorUnitTest()
         _templateFolder = GetRandomFolder();
     }
 
-    [Fact]
+    [TestMethod]
     public void TestXrefWithTemplate()
     {
         CreateFile("partials/xref.html.tmpl", "<h2>{{uid}}</h2><p>{{summary}}</p>{{#isGood}}Good!{{/isGood}}", _templateFolder);
@@ -40,8 +39,8 @@ public void TestXrefWithTemplate()
         };
         var output = Process("index", "input", new { reference = "reference" }, xref);
 
-        Assert.Equal($"{_outputFolder}/input.html".ToNormalizedFullPath(), output.Output[".html"].RelativePath.ToNormalizedPath());
-        Assert.Equal(@"
+        Assert.AreEqual($"{_outputFolder}/input.html".ToNormalizedFullPath(), output.Output[".html"].RelativePath.ToNormalizedPath());
+        Assert.AreEqual(@"
 <h2>reference</h2><p>hello world</p>Good!
 ", File.ReadAllText(Path.Combine(_outputFolder, "input.html")));
 
diff --git a/test/Docfx.Build.Tests/TemplateRendererLoaderUnitTest.cs b/test/Docfx.Build.Tests/TemplateRendererLoaderUnitTest.cs
index d693de7be5d..3364c0295b8 100644
--- a/test/Docfx.Build.Tests/TemplateRendererLoaderUnitTest.cs
+++ b/test/Docfx.Build.Tests/TemplateRendererLoaderUnitTest.cs
@@ -3,11 +3,10 @@
 
 using Docfx.Tests.Common;
 
-using Xunit;
-
 namespace Docfx.Build.Engine.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class TemplateRendererLoaderUnitTest : TestBase
 {
     private readonly string _inputFolder;
@@ -17,32 +16,32 @@ public TemplateRendererLoaderUnitTest()
         _inputFolder = GetRandomFolder();
     }
 
-    [Fact]
+    [TestMethod]
     public void TestLoaderWhenNoFileExists()
     {
         using var listener = new TestListenerScope();
         var renderers = LoadAllRenderers();
-        Assert.Empty(listener.Items);
-        Assert.Empty(renderers);
+        Assert.IsEmpty(listener.Items);
+        Assert.IsEmpty(renderers);
 
         var file1 = CreateFile("a.js", string.Empty, _inputFolder);
         renderers = LoadAllRenderers();
-        Assert.Empty(listener.Items);
-        Assert.Empty(renderers);
+        Assert.IsEmpty(listener.Items);
+        Assert.IsEmpty(renderers);
 
         // only allows file under root folder
         var file2 = CreateFile("sub/a.tmpl", string.Empty, _inputFolder);
         renderers = LoadAllRenderers();
-        Assert.Empty(listener.Items);
-        Assert.Empty(renderers);
+        Assert.IsEmpty(listener.Items);
+        Assert.IsEmpty(renderers);
 
         var file3 = CreateFile("a.tmpl.js", string.Empty, _inputFolder);
         renderers = LoadAllRenderers();
-        Assert.Empty(listener.Items);
-        Assert.Empty(renderers);
+        Assert.IsEmpty(listener.Items);
+        Assert.IsEmpty(renderers);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestLoaderWithValidInput()
     {
         var file1 = CreateFile("a.tmpl", "{{name}}", _inputFolder);
@@ -50,19 +49,19 @@ public void TestLoaderWithValidInput()
         using var listener = new TestListenerScope();
         var renderers = LoadAllRenderers();
 
-        Assert.Empty(listener.Items);
+        Assert.IsEmpty(listener.Items);
 
-        Assert.Single(renderers);
+        Assert.ContainsSingle(renderers);
         var renderer = renderers[0];
-        Assert.NotNull(renderer);
+        Assert.IsNotNull(renderer);
 
         var model = new { name = "model" };
 
         var output = renderer.Render(model);
-        Assert.Equal("model", output);
+        Assert.AreEqual("model", output);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestSingleFileLoaderWithValidInput()
     {
         var path = "a.tmpl";
@@ -71,14 +70,14 @@ public void TestSingleFileLoaderWithValidInput()
         using var listener = new TestListenerScope();
         var renderer = Load(path);
 
-        Assert.Empty(listener.Items);
+        Assert.IsEmpty(listener.Items);
 
-        Assert.NotNull(renderer);
+        Assert.IsNotNull(renderer);
 
         var model = new { name = "model" };
 
         var output = renderer.Render(model);
-        Assert.Equal("model", output);
+        Assert.AreEqual("model", output);
     }
 
     private List<ITemplateRenderer> LoadAllRenderers()
diff --git a/test/Docfx.Build.Tests/TocDocumentProcessorTest.cs b/test/Docfx.Build.Tests/TocDocumentProcessorTest.cs
index 11d201e646f..bd17575f916 100644
--- a/test/Docfx.Build.Tests/TocDocumentProcessorTest.cs
+++ b/test/Docfx.Build.Tests/TocDocumentProcessorTest.cs
@@ -9,11 +9,11 @@
 using Docfx.Plugins;
 using Docfx.Tests.Common;
 using Newtonsoft.Json.Linq;
-using Xunit;
 
 namespace Docfx.Build.TableOfContents.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class TocDocumentProcessorTest : TestBase
 {
     private readonly string _outputFolder;
@@ -40,7 +40,7 @@ public override void Dispose()
         base.Dispose();
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMarkdownTocWithComplexHrefShouldSucceed()
     {
         var fileName = "#ctor";
@@ -55,7 +55,7 @@ public void ProcessMarkdownTocWithComplexHrefShouldSucceed()
         BuildDocument(files);
 
         var outputRawModelPath = Path.GetFullPath(Path.Combine(_outputFolder, Path.ChangeExtension(toc, RawModelFileExtension)));
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<TocItemViewModel>(outputRawModelPath);
         var expectedModel = new TocItemViewModel
         {
@@ -73,7 +73,7 @@ public void ProcessMarkdownTocWithComplexHrefShouldSucceed()
         AssertTocEqual(expectedModel, model);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMarkdownTocWithAbsoluteHrefShouldSucceed()
     {
         var content = @"
@@ -89,7 +89,7 @@ public void ProcessMarkdownTocWithAbsoluteHrefShouldSucceed()
         BuildDocument(files);
 
         var outputRawModelPath = Path.GetFullPath(Path.Combine(_outputFolder, Path.ChangeExtension(toc, RawModelFileExtension)));
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<TocItemViewModel>(outputRawModelPath);
         var expectedModel = new TocItemViewModel
         {
@@ -135,7 +135,7 @@ public void ProcessMarkdownTocWithAbsoluteHrefShouldSucceed()
         AssertTocEqual(expectedModel, model);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMarkdownTocWithRelativeHrefShouldSucceed()
     {
         var file1 = _fileCreator.CreateFile(string.Empty, FileType.MarkdownContent);
@@ -153,7 +153,7 @@ public void ProcessMarkdownTocWithRelativeHrefShouldSucceed()
         files.Add(DocumentType.Article, new[] { file1, file2, toc });
         BuildDocument(files);
         var outputRawModelPath = Path.GetFullPath(Path.Combine(_outputFolder, Path.ChangeExtension(toc, RawModelFileExtension)));
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<TocItemViewModel>(outputRawModelPath);
         var expectedModel = new TocItemViewModel
         {
@@ -207,7 +207,7 @@ public void ProcessMarkdownTocWithRelativeHrefShouldSucceed()
         AssertTocEqual(expectedModel, model);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessYamlTocWithFolderShouldSucceed()
     {
         var file1 = _fileCreator.CreateFile(string.Empty, FileType.MarkdownContent);
@@ -233,7 +233,7 @@ public void ProcessYamlTocWithFolderShouldSucceed()
         files.Add(DocumentType.Article, new[] { file1, file2, toc, subToc });
         BuildDocument(files);
         var outputRawModelPath = Path.GetFullPath(Path.Combine(_outputFolder, Path.ChangeExtension(toc, RawModelFileExtension)));
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<TocItemViewModel>(outputRawModelPath);
         var expectedModel = new TocItemViewModel
         {
@@ -276,7 +276,7 @@ public void ProcessYamlTocWithFolderShouldSucceed()
         AssertTocEqual(expectedModel, model);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessYamlTocWithMetadataShouldSucceed()
     {
         var file1 = _fileCreator.CreateFile(string.Empty, FileType.MarkdownContent);
@@ -295,23 +295,23 @@ public void ProcessYamlTocWithMetadataShouldSucceed()
         files.Add(DocumentType.Article, new[] { file1, toc, });
         BuildDocument(files);
         var outputRawModelPath = Path.GetFullPath(Path.Combine(_outputFolder, Path.ChangeExtension(toc, RawModelFileExtension)));
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
 
         var model = JsonUtility.Deserialize<TocItemViewModel>(outputRawModelPath);
 
         if (JsonUtility.IsSystemTextJsonSupported<TocItemViewModel>())
         {
             var meta = (IDictionary<string, object>)model.Metadata["metadata"];
-            Assert.NotNull(meta);
-            Assert.Single(meta);
-            Assert.Equal("content", meta["meta"]);
+            Assert.IsNotNull(meta);
+            Assert.ContainsSingle(meta);
+            Assert.AreEqual("content", meta["meta"]);
         }
         else
         {
             var meta = (JObject)model.Metadata["metadata"];
-            Assert.NotNull(meta);
-            Assert.Single(meta);
-            Assert.Equal("content", meta["meta"]);
+            Assert.IsNotNull(meta);
+            Assert.ContainsSingle<KeyValuePair<string, JToken>>(meta);
+            Assert.AreEqual("content", meta["meta"]);
         }
 
         var expectedModel = new TocItemViewModel
@@ -338,7 +338,7 @@ public void ProcessYamlTocWithMetadataShouldSucceed()
         AssertTocEqual(expectedModel, model);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessYamlTocWithReferencedTocShouldSucceed()
     {
         var file1 = _fileCreator.CreateFile(string.Empty, FileType.MarkdownContent);
@@ -381,7 +381,7 @@ public void ProcessYamlTocWithReferencedTocShouldSucceed()
         BuildDocument(files);
         var outputRawModelPath = Path.GetFullPath(Path.Combine(_outputFolder, Path.ChangeExtension(toc, RawModelFileExtension)));
 
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<TocItemViewModel>(outputRawModelPath);
         var expectedModel = new TocItemViewModel
         {
@@ -538,10 +538,10 @@ public void ProcessYamlTocWithReferencedTocShouldSucceed()
 
         // Referenced TOC File should exist
         var referencedTocPath = Path.Combine(_outputFolder, Path.ChangeExtension(sub1tocmd, RawModelFileExtension));
-        Assert.True(File.Exists(referencedTocPath));
+        Assert.IsTrue(File.Exists(referencedTocPath));
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessTocWithCircularReferenceShouldFail()
     {
         var referencedToc = _fileCreator.CreateFile(@"
@@ -560,10 +560,10 @@ public void ProcessTocWithCircularReferenceShouldFail()
         FileCollection files = new(_inputFolder);
         files.Add(DocumentType.Article, new[] { toc, subToc });
         var e = Assert.Throws<DocumentException>(() => BuildDocument(files));
-        Assert.Equal($"Circular reference to {StringExtension.ToDisplayPath(Path.GetFullPath(Path.Combine(_inputFolder, subToc)))} is found in {StringExtension.ToDisplayPath(Path.GetFullPath(Path.Combine(_inputFolder, referencedToc)))}", e.Message, true);
+        Assert.AreEqual($"Circular reference to {StringExtension.ToDisplayPath(Path.GetFullPath(Path.Combine(_inputFolder, subToc)))} is found in {StringExtension.ToDisplayPath(Path.GetFullPath(Path.Combine(_inputFolder, referencedToc)))}", e.Message, true);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessMarkdownTocWithNonExistentReferencedTocShouldLogError()
     {
         var pathToReferencedToc = "non-existent/toc.yml";
@@ -580,14 +580,14 @@ public void ProcessMarkdownTocWithNonExistentReferencedTocShouldLogError()
         BuildDocument(files);
         Logger.UnregisterListener(listener);
 
-        Assert.Single(listener.Items);
+        Assert.ContainsSingle(listener.Items);
 
-        Assert.Equal(WarningCodes.Build.InvalidTocInclude, listener.Items[0].Code);
-        Assert.Equal($"Referenced TOC file {StringExtension.ToDisplayPath(Path.GetFullPath(Path.Combine(_inputFolder, pathToReferencedToc)))} does not exist.", listener.Items[0].Message, true);
-        Assert.Equal(LogLevel.Error, listener.Items[0].LogLevel);
+        Assert.AreEqual(WarningCodes.Build.InvalidTocInclude, listener.Items[0].Code);
+        Assert.AreEqual($"Referenced TOC file {StringExtension.ToDisplayPath(Path.GetFullPath(Path.Combine(_inputFolder, pathToReferencedToc)))} does not exist.", listener.Items[0].Message, true);
+        Assert.AreEqual(LogLevel.Error, listener.Items[0].LogLevel);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessYamlTocWithNonExistentReferencedTocShouldLogError()
     {
         var pathToReferencedToc = "non-existent/TOC.md";
@@ -603,14 +603,14 @@ public void ProcessYamlTocWithNonExistentReferencedTocShouldLogError()
         BuildDocument(files);
         Logger.UnregisterListener(listener);
 
-        Assert.Single(listener.Items);
+        Assert.ContainsSingle(listener.Items);
 
-        Assert.Equal(WarningCodes.Build.InvalidTocInclude, listener.Items[0].Code);
-        Assert.Equal($"Referenced TOC file {StringExtension.ToDisplayPath(Path.GetFullPath(Path.Combine(_inputFolder, pathToReferencedToc)))} does not exist.", listener.Items[0].Message, true);
-        Assert.Equal(LogLevel.Error, listener.Items[0].LogLevel);
+        Assert.AreEqual(WarningCodes.Build.InvalidTocInclude, listener.Items[0].Code);
+        Assert.AreEqual($"Referenced TOC file {StringExtension.ToDisplayPath(Path.GetFullPath(Path.Combine(_inputFolder, pathToReferencedToc)))} does not exist.", listener.Items[0].Message, true);
+        Assert.AreEqual(LogLevel.Error, listener.Items[0].LogLevel);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessYamlTocWithTocHrefShouldSucceed()
     {
         var file1 = _fileCreator.CreateFile(string.Empty, FileType.MarkdownContent);
@@ -640,7 +640,7 @@ public void ProcessYamlTocWithTocHrefShouldSucceed()
         BuildDocument(files);
         var outputRawModelPath = Path.GetFullPath(Path.Combine(_outputFolder, Path.ChangeExtension(toc, RawModelFileExtension)));
 
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<TocItemViewModel>(outputRawModelPath);
         var expectedModel = new TocItemViewModel
         {
@@ -687,7 +687,7 @@ public void ProcessYamlTocWithTocHrefShouldSucceed()
         AssertTocEqual(expectedModel, model);
     }
 
-    [Fact]
+    [TestMethod]
     public void RelativePathToTocShouldChooseTheNearestReferenceToc()
     {
         // |-toc.md
@@ -712,12 +712,12 @@ public void RelativePathToTocShouldChooseTheNearestReferenceToc()
 
         // Assert
         var outputRawModelPath = Path.GetFullPath(Path.Combine(_outputFolder, Path.ChangeExtension(file, RawModelFileExtension)));
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<Dictionary<string, object>>(outputRawModelPath);
-        Assert.Equal("../../toc.md", model["_tocRel"]);
+        Assert.AreEqual("../../toc.md", model["_tocRel"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void RelativePathToTocShouldExistWithUrlEncodedHref()
     {
         // Arrange
@@ -734,13 +734,13 @@ public void RelativePathToTocShouldExistWithUrlEncodedHref()
 
         // Assert
         var outputRawModelPath = Path.GetFullPath(Path.Combine(_outputFolder, Path.ChangeExtension(file, RawModelFileExtension)));
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<Dictionary<string, object>>(outputRawModelPath);
-        Assert.Equal("../toc.md", model["_tocRel"]);
-        Assert.Equal("Hello world!", model["meta"]);
+        Assert.AreEqual("../toc.md", model["_tocRel"]);
+        Assert.AreEqual("Hello world!", model["meta"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessYamlTocWithTocHrefAndHomepageShouldFail()
     {
         var content = @"
@@ -753,10 +753,10 @@ public void ProcessYamlTocWithTocHrefAndHomepageShouldFail()
         FileCollection files = new(_inputFolder);
         files.Add(DocumentType.Article, new[] { toc });
         var e = Assert.Throws<DocumentException>(() => BuildDocument(files));
-        Assert.Equal("TopicHref should be used to specify the homepage for /Topic1/ when tocHref is used.", e.Message);
+        Assert.AreEqual("TopicHref should be used to specify the homepage for /Topic1/ when tocHref is used.", e.Message);
     }
 
-    [Fact]
+    [TestMethod]
     public void LoadBadTocYamlFileShouldGiveLineNumber()
     {
         var content = @"
@@ -768,10 +768,10 @@ public void LoadBadTocYamlFileShouldGiveLineNumber()
       href: x2.md";
         var toc = _fileCreator.CreateFile(content, FileType.YamlToc);
         var ex = Assert.Throws<DocumentException>(() => TocHelper.LoadSingleToc(toc));
-        Assert.Equal("toc.yml is not a valid TOC File: (Line: 3, Col: 10, Idx: 22) - (Line: 3, Col: 10, Idx: 22): While scanning a plain scalar value, found invalid mapping.", ex.Message);
+        Assert.AreEqual("toc.yml is not a valid TOC File: (Line: 3, Col: 10, Idx: 22) - (Line: 3, Col: 10, Idx: 22): While scanning a plain scalar value, found invalid mapping.", ex.Message);
     }
 
-    [Fact]
+    [TestMethod]
     public void LoadTocYamlWithEmptyNodeShouldSucceed()
     {
         // Arrange
@@ -788,12 +788,12 @@ public void LoadTocYamlWithEmptyNodeShouldSucceed()
 
         // Assert
         var outputRawModelPath = Path.GetFullPath(Path.Combine(_outputFolder, Path.ChangeExtension(file, RawModelFileExtension)));
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<TocItemViewModel>(outputRawModelPath);
-        Assert.Single(model.Items); // empty node is removed
+        Assert.ContainsSingle(model.Items); // empty node is removed
     }
 
-    [Fact]
+    [TestMethod]
     public void WarningShouldBeFromIncludedToc()
     {
         // Arrange
@@ -818,15 +818,15 @@ public void WarningShouldBeFromIncludedToc()
         Logger.UnregisterListener(listener);
 
         // Assert
-        Assert.NotNull(listener.Items);
-        Assert.Equal(2, listener.Items.Count);
-        Assert.Equal(WarningCodes.Build.InvalidFileLink, listener.Items[0].Code);
-        Assert.Equal("~/included/toc.yml", listener.Items[0].File);
-        Assert.Equal(WarningCodes.Build.UidNotFound, listener.Items[1].Code);
-        Assert.Equal("~/included/toc.yml", listener.Items[1].File);
+        Assert.IsNotNull(listener.Items);
+        Assert.AreEqual(2, listener.Items.Count);
+        Assert.AreEqual(WarningCodes.Build.InvalidFileLink, listener.Items[0].Code);
+        Assert.AreEqual("~/included/toc.yml", listener.Items[0].File);
+        Assert.AreEqual(WarningCodes.Build.UidNotFound, listener.Items[1].Code);
+        Assert.AreEqual("~/included/toc.yml", listener.Items[1].File);
     }
 
-    [Fact]
+    [TestMethod]
     public void UrlDecodeHrefInYamlToc()
     {
         // Arrange
@@ -846,11 +846,11 @@ public void UrlDecodeHrefInYamlToc()
         Logger.UnregisterListener(listener);
 
         // Assert
-        Assert.NotNull(listener.Items);
-        Assert.Empty(listener.Items);
+        Assert.IsNotNull(listener.Items);
+        Assert.IsEmpty(listener.Items);
     }
 
-    [Fact]
+    [TestMethod]
     public void UrlDecodeHrefInMarkdownToc()
     {
         // Arrange
@@ -868,8 +868,8 @@ public void UrlDecodeHrefInMarkdownToc()
         Logger.UnregisterListener(listener);
 
         // Assert
-        Assert.NotNull(listener.Items);
-        Assert.Empty(listener.Items);
+        Assert.IsNotNull(listener.Items);
+        Assert.IsEmpty(listener.Items);
     }
     #region Helper methods
 
@@ -949,7 +949,7 @@ private static void AssertTocEqual(TocItemViewModel expected, TocItemViewModel a
             actual.Metadata.Clear();
         }
         YamlUtility.Serialize(swForActual, actual);
-        Assert.Equal(swForExpected.ToString(), swForActual.ToString());
+        Assert.AreEqual(swForExpected.ToString(), swForActual.ToString());
     }
 
     #endregion
diff --git a/test/Docfx.Build.Tests/TocRestructureTest.cs b/test/Docfx.Build.Tests/TocRestructureTest.cs
index f1308faf7c9..62d2e582340 100644
--- a/test/Docfx.Build.Tests/TocRestructureTest.cs
+++ b/test/Docfx.Build.Tests/TocRestructureTest.cs
@@ -6,13 +6,13 @@
 using Docfx.DataContracts.Common;
 using Docfx.Plugins;
 using Docfx.Tests.Common;
-using Xunit;
 
 namespace Docfx.Build.TableOfContents.Tests;
 
+[TestClass]
 public class TocRestructureTest : TestBase
 {
-    [Fact]
+    [TestMethod]
     public void TestTocRestructureWithLeafNode()
     {
         var toc = GetTocItem(@"
@@ -52,7 +52,7 @@ public void TestTocRestructureWithLeafNode()
         AssertTocEqual(expected, toc);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestTocRestructureWithContainerNode()
     {
         var toc = GetTocItem(@"
@@ -101,7 +101,7 @@ public void TestTocRestructureWithContainerNode()
         AssertTocEqual(expected, toc);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestTocRestructureWithNoMatchNode()
     {
         var layout = @"
@@ -128,7 +128,7 @@ public void TestTocRestructureWithNoMatchNode()
         AssertTocEqual(expected, toc);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestReplaceNodeWithMultipleNodesThrows()
     {
         var toc = GetTocItem(@"
@@ -147,7 +147,7 @@ public void TestReplaceNodeWithMultipleNodesThrows()
         Assert.Throws<InvalidOperationException>(() => TocRestructureUtility.Restructure(toc, restructures));
     }
 
-    [Fact]
+    [TestMethod]
     public void TestTocRestructureWithRestructureConflicts()
     {
         var toc = GetTocItem(@"
@@ -179,7 +179,7 @@ public void TestTocRestructureWithRestructureConflicts()
         AssertTocEqual(expected, toc);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestTocRestructureAppliesToAllMatchedNodes()
     {
         var toc = GetTocItem(@"
@@ -225,7 +225,7 @@ public void TestTocRestructureAppliesToAllMatchedNodes()
 
     private static void AssertTocEqual(TocItemViewModel expected, TocItemViewModel actual)
     {
-        Assert.Equal(expected.ToJsonString(), actual.ToJsonString());
+        Assert.AreEqual(expected.ToJsonString(), actual.ToJsonString());
     }
 
     private TreeItemRestructure GetRestructure(TreeItemActionType actionType, string uid, string[] childrenUids)
diff --git a/test/Docfx.Build.Tests/ValidateBookmarkTest.cs b/test/Docfx.Build.Tests/ValidateBookmarkTest.cs
index 24cc7edf5de..f0b6038f957 100644
--- a/test/Docfx.Build.Tests/ValidateBookmarkTest.cs
+++ b/test/Docfx.Build.Tests/ValidateBookmarkTest.cs
@@ -5,11 +5,10 @@
 using Docfx.Plugins;
 using Docfx.Tests.Common;
 
-using Xunit;
-
 namespace Docfx.Build.Engine.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class ValidateBookmarkTest : TestBase
 {
     private readonly string _outputFolder;
@@ -29,7 +28,7 @@ public override void Dispose()
         base.Dispose();
     }
 
-    [Fact]
+    [TestMethod]
     public void TestBasicFeature()
     {
         Manifest manifest = new()
@@ -70,8 +69,8 @@ public void TestBasicFeature()
             Logger.UnregisterListener(_listener);
         }
         var logs = _listener.Items;
-        Assert.Equal(5, logs.Count);
-        Assert.True(logs.All(l => l.Code == WarningCodes.Build.InvalidBookmark));
+        Assert.AreEqual(5, logs.Count);
+        Assert.IsTrue(logs.All(l => l.Code == WarningCodes.Build.InvalidBookmark));
         var expected = new[]
         {
             Tuple.Create("Invalid link: '[link with source info](a.md#b2)'. The file a.md doesn't contain a bookmark named 'b2'.", "b.md"),
@@ -81,10 +80,10 @@ public void TestBasicFeature()
             Tuple.Create("Invalid link: '[local link in token file](#b3)'. The file g.md doesn't contain a bookmark named 'b3'.", "token.md"),
         };
         var actual = logs.Select(l => Tuple.Create(l.Message, l.File)).ToList();
-        Assert.True(!expected.Except(actual).Any() && expected.Length == actual.Count);
+        Assert.IsTrue(!expected.Except(actual).Any() && expected.Length == actual.Count);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestNoCheck()
     {
         // Arrange
@@ -116,16 +115,16 @@ public void TestNoCheck()
 
         // Assert
         var logs = _listener.Items;
-        Assert.Single(logs);
+        Assert.ContainsSingle(logs);
         var expected = new[]
         {
             Tuple.Create("Invalid link: '<a href=\"#invalid\">test</a>'. The file test.md doesn't contain a bookmark named 'invalid'.", "test.md"),
         };
         var actual = logs.Select(l => Tuple.Create(l.Message, l.File)).ToList();
-        Assert.True(!expected.Except(actual).Any() && expected.Length == actual.Count);
+        Assert.IsTrue(!expected.Except(actual).Any() && expected.Length == actual.Count);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestLinkThatContainsNonAsciiChars()
     {
         Manifest manifest = new()
@@ -157,6 +156,6 @@ public void TestLinkThatContainsNonAsciiChars()
             Logger.UnregisterListener(_listener);
         }
         var logs = _listener.Items;
-        Assert.Empty(logs);
+        Assert.IsEmpty(logs);
     }
 }
diff --git a/test/Docfx.Build.Tests/WordCounterUnitTest.cs b/test/Docfx.Build.Tests/WordCounterUnitTest.cs
index 7b47b805dfe..6d457b8e8c1 100644
--- a/test/Docfx.Build.Tests/WordCounterUnitTest.cs
+++ b/test/Docfx.Build.Tests/WordCounterUnitTest.cs
@@ -1,23 +1,22 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.Build.ConceptualDocuments.Tests;
 
-[Trait("Related", "Conceptual")]
+[TestProperty("Related", "Conceptual")]
+[TestClass]
 public class WordCounterUnitTest
 {
-    [InlineData("", 0)]
-    [InlineData(@"<div><div class=""content""><h1>Connect and TFS information ?!</h1></div></div>", 4)]
-    [InlineData(@"<div><div class=""content""><h1>Connect and TFS information</h1></div></div>", 4)]
-    [InlineData(@"<div><div class=""content""><h1>Connect and TFS information</h1><p>Open Publishing is being developed by the Visual Studio China team. The team owns the MSDN and Technet platforms, as well as CAPS authoring tool, which is the replacement of DxStudio.</p></div></div>", 35)]
-    [InlineData(@"<div><title>Connect and TFS information</title><div class=""content""><h1>Connect and TFS information</h1><p>Open Publishing is being developed by the Visual Studio China team. The team owns the MSDN and Technet platforms, as well as CAPS authoring tool, which is the replacement of DxStudio.</p></div></div>", 35)]
-    [InlineData(@"<div><div class=""content""><h1>Connect and TFS information</h1><p>Open Publishing is being developed by the Visual Studio China team. The team owns the <a href=""http://www.msdn.com"">MSDN</a> and Technet platforms, as well as CAPS authoring tool, which is the replacement of DxStudio.</p></div></div>", 35)]
-    [Theory]
+    [DataRow("", 0)]
+    [DataRow(@"<div><div class=""content""><h1>Connect and TFS information ?!</h1></div></div>", 4)]
+    [DataRow(@"<div><div class=""content""><h1>Connect and TFS information</h1></div></div>", 4)]
+    [DataRow(@"<div><div class=""content""><h1>Connect and TFS information</h1><p>Open Publishing is being developed by the Visual Studio China team. The team owns the MSDN and Technet platforms, as well as CAPS authoring tool, which is the replacement of DxStudio.</p></div></div>", 35)]
+    [DataRow(@"<div><title>Connect and TFS information</title><div class=""content""><h1>Connect and TFS information</h1><p>Open Publishing is being developed by the Visual Studio China team. The team owns the MSDN and Technet platforms, as well as CAPS authoring tool, which is the replacement of DxStudio.</p></div></div>", 35)]
+    [DataRow(@"<div><div class=""content""><h1>Connect and TFS information</h1><p>Open Publishing is being developed by the Visual Studio China team. The team owns the <a href=""http://www.msdn.com"">MSDN</a> and Technet platforms, as well as CAPS authoring tool, which is the replacement of DxStudio.</p></div></div>", 35)]
+    [TestMethod]
     public void TestWordCounter(string html, long expectedCount)
     {
         long wordCount = WordCounter.CountWord(html);
-        Assert.Equal(expectedCount, wordCount);
+        Assert.AreEqual(expectedCount, wordCount);
     }
 }
diff --git a/test/Docfx.Build.Tests/XRefArchiveBuilderTest.cs b/test/Docfx.Build.Tests/XRefArchiveBuilderTest.cs
index 65314446a06..5c9703502d6 100644
--- a/test/Docfx.Build.Tests/XRefArchiveBuilderTest.cs
+++ b/test/Docfx.Build.Tests/XRefArchiveBuilderTest.cs
@@ -1,14 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.Build.Engine.Tests;
 
-[Trait("Related", "XRefArchive")]
+[TestProperty("Related", "XRefArchive")]
+[TestClass]
 public class XRefArchiveBuilderTest
 {
-    [Fact]
+    [TestMethod]
     public async Task TestDownload()
     {
         const string ZipFile = "test.zip";
@@ -20,15 +19,15 @@ public async Task TestDownload()
         // sorted: true
         // references: []
         // ```
-        Assert.True(await builder.DownloadAsync(new Uri("http://dotnet.github.io/docfx/xrefmap.yml"), ZipFile));
+        Assert.IsTrue(await builder.DownloadAsync(new Uri("http://dotnet.github.io/docfx/xrefmap.yml"), ZipFile));
 
         using (var xar = XRefArchive.Open(ZipFile, XRefArchiveMode.Read))
         {
             var map = xar.GetMajor();
-            Assert.Null(map.HrefUpdated);
-            Assert.True(map.Sorted);
-            Assert.NotNull(map.References);
-            Assert.Null(map.Redirections);
+            Assert.IsNull(map.HrefUpdated);
+            Assert.IsTrue(map.Sorted);
+            Assert.IsNotNull(map.References);
+            Assert.IsNull(map.Redirections);
         }
         File.Delete(ZipFile);
     }
diff --git a/test/Docfx.Build.Tests/XRefMapDownloaderTest.cs b/test/Docfx.Build.Tests/XRefMapDownloaderTest.cs
index 04f21141a85..dd40d46068c 100644
--- a/test/Docfx.Build.Tests/XRefMapDownloaderTest.cs
+++ b/test/Docfx.Build.Tests/XRefMapDownloaderTest.cs
@@ -2,22 +2,23 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using FluentAssertions;
-using Xunit;
 
 namespace Docfx.Build.Engine.Tests;
 
+[TestClass]
 public class XRefMapDownloadTest
 {
-    [Fact(Skip = "Flaky SSL connection problems on GH windows CI")]
+    [TestMethod]
+    [Ignore("Flaky SSL connection problems on GH windows CI")]
     public async Task BaseUrlIsSet()
     {
         var downloader = new XRefMapDownloader();
         var xrefs = await downloader.DownloadAsync(new Uri("https://dotnet.github.io/docfx/xrefmap.yml")) as XRefMap;
-        Assert.NotNull(xrefs);
-        Assert.Equal("https://dotnet.github.io/docfx/", xrefs.BaseUrl);
+        Assert.IsNotNull(xrefs);
+        Assert.AreEqual("https://dotnet.github.io/docfx/", xrefs.BaseUrl);
     }
 
-    [Fact]
+    [TestMethod]
     public async Task ReadLocalXRefMapWithFallback()
     {
         var basePath = Path.GetRandomFileName();
@@ -29,11 +30,11 @@ public async Task ReadLocalXRefMapWithFallback()
                                               select new Uri(u, UriKind.RelativeOrAbsolute)).GetReaderAsync(basePath, fallbackFolders);
 
         var xrefSpec = reader.Find("str");
-        Assert.NotNull(xrefSpec);
-        Assert.Equal("https://docs.python.org/3.5/library/stdtypes.html#str", xrefSpec.Href);
+        Assert.IsNotNull(xrefSpec);
+        Assert.AreEqual("https://docs.python.org/3.5/library/stdtypes.html#str", xrefSpec.Href);
     }
 
-    [Fact]
+    [TestMethod]
     public async Task ReadLocalXRefMapJsonFileTest()
     {
         // Arrange
@@ -47,7 +48,7 @@ public async Task ReadLocalXRefMapJsonFileTest()
         xrefMap.References.Should().HaveCount(1);
     }
 
-    [Fact]
+    [TestMethod]
     public async Task ReadLocalXRefMapGZippedJsonFileTest()
     {
         // Arrange
@@ -61,7 +62,7 @@ public async Task ReadLocalXRefMapGZippedJsonFileTest()
         xrefMap.References.Should().HaveCount(1);
     }
 
-    [Fact]
+    [TestMethod]
     public async Task ReadLocalXRefMapGZippedYamlFileTest()
     {
         // Arrange
@@ -78,7 +79,8 @@ public async Task ReadLocalXRefMapGZippedYamlFileTest()
     /// <summary>
     /// XrefmapDownloader test for xrefmap that has no baseUrl and href is defined by relative path.
     /// </summary>
-    [Fact(Skip = "Has dependency to external site content.")]
+    [TestMethod]
+    [Ignore("Has dependency to external site content.")]
     public async Task ReadRemoteXRefMapYamlFileTest1()
     {
         // Arrange
@@ -107,7 +109,8 @@ public async Task ReadRemoteXRefMapYamlFileTest1()
     /// <summary>
     /// XrefmapDownloader test for xrefmap that has no baseUrl, and href is defined by absolute path.
     /// </summary>
-    [Fact(Skip = "Has dependency to external site content.")]
+    [TestMethod]
+    [Ignore("Has dependency to external site content.")]
     public async Task ReadRemoteXRefMapJsonFileTest2()
     {
         // Arrange
diff --git a/test/Docfx.Build.Tests/XRefMapSerializationTest.cs b/test/Docfx.Build.Tests/XRefMapSerializationTest.cs
index afae124e4ae..79390fe8d90 100644
--- a/test/Docfx.Build.Tests/XRefMapSerializationTest.cs
+++ b/test/Docfx.Build.Tests/XRefMapSerializationTest.cs
@@ -4,13 +4,13 @@
 using System.Text;
 using Docfx.Common;
 using FluentAssertions;
-using Xunit;
 
 namespace Docfx.Build.Engine.Tests;
 
+[TestClass]
 public class XRefMapSerializationTest
 {
-    [Fact]
+    [TestMethod]
     public void XRefMapSerializationRoundTripTest()
     {
         var model = new XRefMap
diff --git a/test/Docfx.Build.UniversalReference.Tests/UniversalReferenceDocumentProcessorTest.cs b/test/Docfx.Build.UniversalReference.Tests/UniversalReferenceDocumentProcessorTest.cs
index acad455356f..6c3ed8ef49b 100644
--- a/test/Docfx.Build.UniversalReference.Tests/UniversalReferenceDocumentProcessorTest.cs
+++ b/test/Docfx.Build.UniversalReference.Tests/UniversalReferenceDocumentProcessorTest.cs
@@ -8,10 +8,9 @@
 using Docfx.Plugins;
 using Docfx.Tests.Common;
 
-using Xunit;
-
 namespace Docfx.Build.UniversalReference.Tests;
 
+[TestClass]
 public class UniversalReferenceDocumentProcessorTest : TestBase
 {
     private readonly string _outputFolder;
@@ -39,7 +38,7 @@ public UniversalReferenceDocumentProcessorTest()
 
     #region Python
 
-    [Fact]
+    [TestMethod]
     public void ProcessPythonReferencesShouldSucceed()
     {
         var fileNames = new string[] { "cntk.core.yml", "cntk.core.Value.yml", "cntk.debugging.yml" };
@@ -51,11 +50,11 @@ public void ProcessPythonReferencesShouldSucceed()
         foreach (var fileName in fileNames)
         {
             var outputRawModelPath = GetRawModelFilePath(fileName);
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void ProcessPythonModelShouldSucceed()
     {
         var moduleFileName = "cntk.core.yml";
@@ -70,60 +69,60 @@ public void ProcessPythonModelShouldSucceed()
 
         var outputModuleRawModelPath = GetRawModelFilePath(moduleFileName);
         var outputClassRawModelPath = GetRawModelFilePath(classFileName);
-        Assert.True(File.Exists(outputClassRawModelPath));
+        Assert.IsTrue(File.Exists(outputClassRawModelPath));
 
         var moduleModel = JsonUtility.Deserialize<ApiBuildOutput>(outputModuleRawModelPath);
-        Assert.NotNull(moduleModel);
-        Assert.Equal("Test UniversalReferenceDocumentProcessor", moduleModel.Metadata["meta"]);
-        Assert.Equal(
+        Assert.IsNotNull(moduleModel);
+        Assert.AreEqual("Test UniversalReferenceDocumentProcessor", moduleModel.Metadata["meta"]);
+        Assert.AreEqual(
             "<p sourcefile=\"TestData/yml/cntk.core.Value.yml\" sourcestartlinenumber=\"1\">Bases: <xref href=\"cntk.cntk_py.Value\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@cntk.cntk_py.Value\" sourcefile=\"TestData/yml/cntk.core.Value.yml\" sourcestartlinenumber=\"1\"></xref>\nInternal representation of minibatch data.</p>\n",
             moduleModel.Children[0].Value[1].Summary);
-        Assert.Equal("Class", moduleModel.Children[0].Value[1].Type);
+        Assert.AreEqual("Class", moduleModel.Children[0].Value[1].Type);
 
         var classModel = JsonUtility.Deserialize<ApiBuildOutput>(outputClassRawModelPath);
-        Assert.NotNull(classModel);
-        Assert.Equal("Test UniversalReferenceDocumentProcessor", classModel.Metadata["meta"]);
+        Assert.IsNotNull(classModel);
+        Assert.AreEqual("Test UniversalReferenceDocumentProcessor", classModel.Metadata["meta"]);
 
-        Assert.Single(classModel.SupportedLanguages);
-        Assert.Equal("python", classModel.SupportedLanguages[0]);
+        Assert.ContainsSingle(classModel.SupportedLanguages);
+        Assert.AreEqual("python", classModel.SupportedLanguages[0]);
 
-        Assert.Equal("Class", classModel.Type);
+        Assert.AreEqual("Class", classModel.Type);
 
-        Assert.Equal("Value", classModel.Name[0].Value);
-        Assert.Equal("cntk.core.Value", classModel.FullName[0].Value);
+        Assert.AreEqual("Value", classModel.Name[0].Value);
+        Assert.AreEqual("cntk.core.Value", classModel.FullName[0].Value);
 
-        Assert.Equal("https://github.com/Microsoft/CNTK", classModel.Source[0].Value.Remote.Repo);
-        Assert.Equal("cntk/core.py", classModel.Source[0].Value.Remote.Path);
-        Assert.Equal(182, classModel.Source[0].Value.StartLine);
+        Assert.AreEqual("https://github.com/Microsoft/CNTK", classModel.Source[0].Value.Remote.Repo);
+        Assert.AreEqual("cntk/core.py", classModel.Source[0].Value.Remote.Path);
+        Assert.AreEqual(182, classModel.Source[0].Value.StartLine);
 
-        Assert.Equal(6, classModel.Syntax.Parameters.Count);
-        Assert.Equal("shape", classModel.Syntax.Parameters[0].Name);
-        Assert.Equal("tuple", classModel.Syntax.Parameters[0].Type[0].Uid);
-        Assert.Equal("<p sourcefile=\"TestData/yml/cntk.core.Value.yml\" sourcestartlinenumber=\"1\">shape of the value</p>\n",
+        Assert.AreEqual(6, classModel.Syntax.Parameters.Count);
+        Assert.AreEqual("shape", classModel.Syntax.Parameters[0].Name);
+        Assert.AreEqual("tuple", classModel.Syntax.Parameters[0].Type[0].Uid);
+        Assert.AreEqual("<p sourcefile=\"TestData/yml/cntk.core.Value.yml\" sourcestartlinenumber=\"1\">shape of the value</p>\n",
             classModel.Syntax.Parameters[0].Description);
 
-        Assert.Equal("cntk.cntk_py.Value", classModel.Inheritance[0].Value[0].Type.Uid);
-        Assert.Equal("builtins.object", classModel.Inheritance[0].Value[0].Inheritance[0].Type.Uid);
+        Assert.AreEqual("cntk.cntk_py.Value", classModel.Inheritance[0].Value[0].Type.Uid);
+        Assert.AreEqual("builtins.object", classModel.Inheritance[0].Value[0].Inheritance[0].Type.Uid);
 
-        Assert.Single(classModel.Children);
-        Assert.Equal("python", classModel.Children[0].Language);
-        Assert.Equal(5, classModel.Children[0].Value.Count);
+        Assert.ContainsSingle(classModel.Children);
+        Assert.AreEqual("python", classModel.Children[0].Language);
+        Assert.AreEqual(5, classModel.Children[0].Value.Count);
 
         var firstChildrenValue = classModel.Children[0].Value[0];
-        Assert.Equal("Method", firstChildrenValue.Type);
-        Assert.Equal("cntk.core.Value.create", firstChildrenValue.Uid);
-        Assert.Equal("create", firstChildrenValue.Name[0].Value);
-        Assert.Equal("cntk.core.Value.create", firstChildrenValue.FullName[0].Value);
-        Assert.Equal("<p sourcefile=\"TestData/yml/cntk.core.Value.yml\" sourcestartlinenumber=\"1\">Creates a <xref href=\"cntk.core.Value\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@cntk.core.Value\" sourcefile=\"TestData/yml/cntk.core.Value.yml\" sourcestartlinenumber=\"1\"></xref> object.</p>\n",
+        Assert.AreEqual("Method", firstChildrenValue.Type);
+        Assert.AreEqual("cntk.core.Value.create", firstChildrenValue.Uid);
+        Assert.AreEqual("create", firstChildrenValue.Name[0].Value);
+        Assert.AreEqual("cntk.core.Value.create", firstChildrenValue.FullName[0].Value);
+        Assert.AreEqual("<p sourcefile=\"TestData/yml/cntk.core.Value.yml\" sourcestartlinenumber=\"1\">Creates a <xref href=\"cntk.core.Value\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@cntk.core.Value\" sourcefile=\"TestData/yml/cntk.core.Value.yml\" sourcestartlinenumber=\"1\"></xref> object.</p>\n",
             firstChildrenValue.Summary);
-        Assert.Equal("<p sourcefile=\"TestData/yml/cntk.core.Value.yml\" sourcestartlinenumber=\"1\"><xref href=\"cntk.core.Value\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@cntk.core.Value\" sourcefile=\"TestData/yml/cntk.core.Value.yml\" sourcestartlinenumber=\"1\"></xref> object.</p>\n",
+        Assert.AreEqual("<p sourcefile=\"TestData/yml/cntk.core.Value.yml\" sourcestartlinenumber=\"1\"><xref href=\"cntk.core.Value\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@cntk.core.Value\" sourcefile=\"TestData/yml/cntk.core.Value.yml\" sourcestartlinenumber=\"1\"></xref> object.</p>\n",
             firstChildrenValue.Syntax.Return[0].Value.Description);
-        Assert.Equal("type1", firstChildrenValue.Syntax.Return[0].Value.Type[0].Uid);
-        Assert.Equal("type2", firstChildrenValue.Syntax.Return[0].Value.Type[1].Uid);
-        Assert.Equal("type3", firstChildrenValue.Syntax.Return[0].Value.Type[2].Uid);
+        Assert.AreEqual("type1", firstChildrenValue.Syntax.Return[0].Value.Type[0].Uid);
+        Assert.AreEqual("type2", firstChildrenValue.Syntax.Return[0].Value.Type[1].Uid);
+        Assert.AreEqual("type3", firstChildrenValue.Syntax.Return[0].Value.Type[2].Uid);
     }
 
-    [Fact]
+    [TestMethod]
     public void ApplyOverwriteDocumentForPythonShouldSucceed()
     {
         var fileName = "cntk.core.Value.yml";
@@ -135,19 +134,19 @@ public void ApplyOverwriteDocumentForPythonShouldSucceed()
         BuildDocument(files);
 
         var outputRawModelPath = GetRawModelFilePath(fileName);
-        Assert.True(File.Exists(outputRawModelPath));
+        Assert.IsTrue(File.Exists(outputRawModelPath));
         var model = JsonUtility.Deserialize<ApiBuildOutput>(outputRawModelPath);
-        Assert.NotNull(model);
+        Assert.IsNotNull(model);
 
-        Assert.Equal("\n<p sourcefile=\"TestData/overwrite/cntk.core.Value.md\" sourcestartlinenumber=\"5\"><strong sourcefile=\"TestData/overwrite/cntk.core.Value.md\" sourcestartlinenumber=\"5\">conceptual</strong> of <code sourcefile=\"TestData/overwrite/cntk.core.Value.md\" sourcestartlinenumber=\"5\">cntk.core.Value</code></p>\n", model.Conceptual);
-        Assert.Equal("<p sourcefile=\"TestData/overwrite/cntk.core.Value.md\" sourcestartlinenumber=\"1\">summary of cntk.core.Value</p>\n", model.Summary);
+        Assert.AreEqual("\n<p sourcefile=\"TestData/overwrite/cntk.core.Value.md\" sourcestartlinenumber=\"5\"><strong sourcefile=\"TestData/overwrite/cntk.core.Value.md\" sourcestartlinenumber=\"5\">conceptual</strong> of <code sourcefile=\"TestData/overwrite/cntk.core.Value.md\" sourcestartlinenumber=\"5\">cntk.core.Value</code></p>\n", model.Conceptual);
+        Assert.AreEqual("<p sourcefile=\"TestData/overwrite/cntk.core.Value.md\" sourcestartlinenumber=\"1\">summary of cntk.core.Value</p>\n", model.Summary);
     }
 
     #endregion
 
     #region JavaScript
 
-    [Fact]
+    [TestMethod]
     public void ProcessJavaScriptReferencesShouldSucceed()
     {
         var fileNames = new string[] { "azure.ApplicationTokenCredentials.yml" };
@@ -159,13 +158,13 @@ public void ProcessJavaScriptReferencesShouldSucceed()
         foreach (var fileName in fileNames)
         {
             var outputRawModelPath = GetRawModelFilePath(fileName);
-            Assert.True(File.Exists(outputRawModelPath));
+            Assert.IsTrue(File.Exists(outputRawModelPath));
         }
     }
 
     #endregion
 
-    [Fact]
+    [TestMethod]
     public void ProcessItemWithEmptyUidShouldFail()
     {
         var fileNames = new string[] { "invalid.yml" };
@@ -174,8 +173,8 @@ public void ProcessItemWithEmptyUidShouldFail()
 
         using var listener = new TestListenerScope();
         BuildDocument(files);
-        Assert.NotNull(listener.Items);
-        Assert.Equal(2, listener.Items.Count);
+        Assert.IsNotNull(listener.Items);
+        Assert.AreEqual(2, listener.Items.Count);
         Assert.Contains("Uid must not be null or empty", listener.Items[1].Message);
     }
 
diff --git a/test/Docfx.Common.Tests/CollectionUtilityTest.cs b/test/Docfx.Common.Tests/CollectionUtilityTest.cs
index 20d4a1bcb9a..99bb82ba965 100644
--- a/test/Docfx.Common.Tests/CollectionUtilityTest.cs
+++ b/test/Docfx.Common.Tests/CollectionUtilityTest.cs
@@ -3,24 +3,23 @@
 
 using System.Collections.Immutable;
 
-using Xunit;
-
 namespace Docfx.Common.Tests;
 
-[Trait("Related", "CollectionUtilityTest")]
+[TestProperty("Related", "CollectionUtilityTest")]
+[TestClass]
 public class CollectionUtilityTest
 {
-    [Theory]
-    [InlineData("ABCBDAB", "BDCABA", "BCBA")]
-    [InlineData("ACCGGTCGAGTGCGCGGAAGCCGGCCGAA", "GTCGTTCGGAATGCCGTTGCTCTGTAAA", "GTCGTCGGAAGCCGGCCGAA")]
+    [TestMethod]
+    [DataRow("ABCBDAB", "BDCABA", "BCBA")]
+    [DataRow("ACCGGTCGAGTGCGCGGAAGCCGGCCGAA", "GTCGTTCGGAATGCCGTTGCTCTGTAAA", "GTCGTCGGAAGCCGGCCGAA")]
     public void TestGetLongestCommonSequence(string input1, string input2, string expected)
     {
         var inputArray = input1.ToImmutableArray();
         var actual = inputArray.GetLongestCommonSequence(input2.ToImmutableArray());
-        Assert.Equal(expected.Length, actual.Length);
+        Assert.AreEqual(expected.Length, actual.Length);
         for (int i = 0; i < expected.Length; i++)
         {
-            Assert.Equal(expected[i], actual[i]);
+            Assert.AreEqual(expected[i], actual[i]);
         }
     }
 }
diff --git a/test/Docfx.Common.Tests/CompositeDictionaryTest.cs b/test/Docfx.Common.Tests/CompositeDictionaryTest.cs
index ff8f6e735bf..3baa6e57d5e 100644
--- a/test/Docfx.Common.Tests/CompositeDictionaryTest.cs
+++ b/test/Docfx.Common.Tests/CompositeDictionaryTest.cs
@@ -1,14 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.Common.Tests;
 
-[Trait("Related", "CompositeDictionary")]
+[TestProperty("Related", "CompositeDictionary")]
+[TestClass]
 public class CompositeDictionaryTest
 {
-    [Fact]
+    [TestMethod]
     public void TestAddRemoveGetSetForCompositeDictionary()
     {
         var c = new C
@@ -27,51 +26,51 @@ public void TestAddRemoveGetSetForCompositeDictionary()
             },
         };
 
-        Assert.Equal(3, c.CD.Count);
+        Assert.AreEqual(3, c.CD.Count);
         var list = c.CD.ToList();
-        Assert.Equal("D1.a", list[0].Key);
-        Assert.Equal(1.0, list[0].Value);
-        Assert.Equal("D2.b", list[1].Key);
-        Assert.Equal(1, list[1].Value);
-        Assert.Equal("D3.c", list[2].Key);
-        Assert.Equal("x", list[2].Value);
+        Assert.AreEqual("D1.a", list[0].Key);
+        Assert.AreEqual(1.0, list[0].Value);
+        Assert.AreEqual("D2.b", list[1].Key);
+        Assert.AreEqual(1, list[1].Value);
+        Assert.AreEqual("D3.c", list[2].Key);
+        Assert.AreEqual("x", list[2].Value);
 
-        Assert.Equal<string>(new[] { "D1.a", "D2.b", "D3.c" }, c.CD.Keys);
-        Assert.Equal<object>(new object[] { 1.0, 1, "x" }, c.CD.Values);
-        Assert.True(c.CD.ContainsKey("D1.a"));
-        Assert.False(c.CD.ContainsKey("D1.b"));
-        Assert.False(c.CD.ContainsKey("a"));
+        CollectionAssert.AreEqual(new[] { "D1.a", "D2.b", "D3.c" }, c.CD.Keys.ToArray());
+        CollectionAssert.AreEqual(new object[] { 1.0, 1, "x" }, c.CD.Values.ToArray());
+        Assert.IsTrue(c.CD.ContainsKey("D1.a"));
+        Assert.IsFalse(c.CD.ContainsKey("D1.b"));
+        Assert.IsFalse(c.CD.ContainsKey("a"));
 
         c.CD.Add("D1.b", 2);
-        Assert.Equal(4, c.CD.Count);
-        Assert.Equal(2, c.D1.Count);
-        Assert.True(c.CD.ContainsKey("D1.b"));
-        Assert.Equal(2, c.CD["D1.b"]);
-        Assert.True(c.CD.TryGetValue("D1.b", out object value));
-        Assert.Equal(2, value);
-        Assert.True(c.CD.TryGetValue("D2.b", out value));
-        Assert.Equal(1, value);
+        Assert.AreEqual(4, c.CD.Count);
+        Assert.AreEqual(2, c.D1.Count);
+        Assert.IsTrue(c.CD.ContainsKey("D1.b"));
+        Assert.AreEqual(2, c.CD["D1.b"]);
+        Assert.IsTrue(c.CD.TryGetValue("D1.b", out object value));
+        Assert.AreEqual(2, value);
+        Assert.IsTrue(c.CD.TryGetValue("D2.b", out value));
+        Assert.AreEqual(1, value);
 
-        Assert.True(c.CD.Remove("D1.b"));
-        Assert.False(c.CD.Remove("D1.b"));
-        Assert.False(c.CD.Remove("x"));
-        Assert.False(c.CD.TryGetValue("D1.b", out value));
-        Assert.Null(value);
-        Assert.False(c.CD.TryGetValue("b", out value));
-        Assert.Null(value);
-        Assert.Equal(3, c.CD.Count);
-        Assert.Single(c.D1);
+        Assert.IsTrue(c.CD.Remove("D1.b"));
+        Assert.IsFalse(c.CD.Remove("D1.b"));
+        Assert.IsFalse(c.CD.Remove("x"));
+        Assert.IsFalse(c.CD.TryGetValue("D1.b", out value));
+        Assert.IsNull(value);
+        Assert.IsFalse(c.CD.TryGetValue("b", out value));
+        Assert.IsNull(value);
+        Assert.AreEqual(3, c.CD.Count);
+        Assert.ContainsSingle(c.D1);
 
-        Assert.Equal("x", c.CD["D3.c"]);
+        Assert.AreEqual("x", c.CD["D3.c"]);
         c.CD["D3.c"] = "y";
-        Assert.Equal("y", c.CD["D3.c"]);
-        Assert.Equal(3, c.CD.Count);
+        Assert.AreEqual("y", c.CD["D3.c"]);
+        Assert.AreEqual(3, c.CD.Count);
 
         c.CD.Clear();
-        Assert.Empty(c.CD);
+        Assert.IsEmpty(c.CD);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestThrowCaseForCompositeDictionary()
     {
         var c = new C
@@ -93,9 +92,9 @@ public void TestThrowCaseForCompositeDictionary()
         Assert.Throws<InvalidOperationException>(() => c.CD["z"] = 1);
         Assert.Throws<InvalidOperationException>(() => c.CD.Add("z", 1));
 
-        Assert.Throws<KeyNotFoundException>(() => c.CD["z"]);
+        Assert.Throws<KeyNotFoundException>(() => _ = c.CD["z"]);
 
-        Assert.Throws<ArgumentNullException>(() => c.CD[null]);
+        Assert.Throws<ArgumentNullException>(() => _ = c.CD[null]);
         Assert.Throws<ArgumentNullException>(() => c.CD[null] = 1);
         Assert.Throws<ArgumentNullException>(() => c.CD.Add(null, 1));
         Assert.Throws<ArgumentNullException>(() => c.CD.Remove(null));
diff --git a/test/Docfx.Common.Tests/ConvertToObjectHelperTest.cs b/test/Docfx.Common.Tests/ConvertToObjectHelperTest.cs
index bb39a7e9f56..2c6282d6965 100644
--- a/test/Docfx.Common.Tests/ConvertToObjectHelperTest.cs
+++ b/test/Docfx.Common.Tests/ConvertToObjectHelperTest.cs
@@ -5,26 +5,26 @@
 using FluentAssertions;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
-using Xunit;
 
 namespace Docfx.Common.Tests;
 
-[Trait("Related", "ConvertToObjectHelper")]
+[TestProperty("Related", "ConvertToObjectHelper")]
+[TestClass]
 public class ConvertToObjectHelperTest
 {
-    [Theory]
-    [InlineData(1, typeof(int))]
-    [InlineData(1L, typeof(long))]
-    [InlineData(1.0, typeof(double))]
-    [InlineData("string", typeof(string))]
-    [InlineData('c', typeof(string))]
+    [TestMethod]
+    [DataRow(1, typeof(int))]
+    [DataRow(1L, typeof(long))]
+    [DataRow(1.0, typeof(double))]
+    [DataRow("string", typeof(string))]
+    [DataRow('c', typeof(string))]
     public void ConvertSimpleTypeToObjectShouldWork(object value, Type expectedType)
     {
         var result = ConvertToObjectHelper.ConvertStrongTypeToObject(value);
-        Assert.Equal(expectedType, result.GetType());
+        Assert.AreEqual(expectedType, result.GetType());
     }
 
-    [Fact]
+    [TestMethod]
     public void ConvertComplexTypeToObjectShouldWork()
     {
         var complexType = new ComplexType
@@ -34,12 +34,12 @@ public void ConvertComplexTypeToObjectShouldWork()
             IntDictionary = []
         };
         var result = ConvertToObjectHelper.ConvertStrongTypeToObject(complexType);
-        Assert.Equal(typeof(Dictionary<string, object>), result.GetType());
-        Assert.Equal(typeof(object[]), ((Dictionary<string, object>)result)["List"].GetType());
-        Assert.Equal(typeof(Dictionary<string, object>), ((Dictionary<string, object>)result)["IntDictionary"].GetType());
+        Assert.AreEqual(typeof(Dictionary<string, object>), result.GetType());
+        Assert.AreEqual(typeof(object[]), ((Dictionary<string, object>)result)["List"].GetType());
+        Assert.AreEqual(typeof(Dictionary<string, object>), ((Dictionary<string, object>)result)["IntDictionary"].GetType());
     }
 
-    [Fact]
+    [TestMethod]
     public void ConvertComplexTypeWithJsonAttributeToObjectShouldUseAttributeAsPropertyName()
     {
         var complexType = new ComplexTypeWithJson
@@ -49,12 +49,12 @@ public void ConvertComplexTypeWithJsonAttributeToObjectShouldUseAttributeAsPrope
             IntDictionary = []
         };
         var result = ConvertToObjectHelper.ConvertStrongTypeToObject(complexType);
-        Assert.Equal(typeof(Dictionary<string, object>), result.GetType());
-        Assert.Equal(typeof(object[]), ((Dictionary<string, object>)result)["list"].GetType());
-        Assert.Equal(typeof(Dictionary<string, object>), ((Dictionary<string, object>)result)["dict"].GetType());
+        Assert.AreEqual(typeof(Dictionary<string, object>), result.GetType());
+        Assert.AreEqual(typeof(object[]), ((Dictionary<string, object>)result)["list"].GetType());
+        Assert.AreEqual(typeof(Dictionary<string, object>), ((Dictionary<string, object>)result)["dict"].GetType());
     }
 
-    [Fact]
+    [TestMethod]
     public void ConvertObjectWithCircularReferenceToDynamic()
     {
         var a = new Dictionary<string, object>
@@ -64,15 +64,15 @@ public void ConvertObjectWithCircularReferenceToDynamic()
         a["key1"] = a;
 
         dynamic converted = ConvertToObjectHelper.ConvertToDynamic(a);
-        Assert.Same(converted.key1, converted);
-        Assert.Equal("value", converted.key1.key);
+        Assert.AreSame(converted.key1, converted);
+        Assert.AreEqual("value", converted.key1.key);
 
         Dictionary<string, object> obj = (Dictionary<string, object>)ConvertToObjectHelper.ConvertExpandoObjectToObject(converted);
-        Assert.True(ReferenceEquals(obj["key1"], obj));
-        Assert.Equal("value", ((Dictionary<string, object>)obj["key1"])["key"]);
+        Assert.IsTrue(ReferenceEquals(obj["key1"], obj));
+        Assert.AreEqual("value", ((Dictionary<string, object>)obj["key1"])["key"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void ConvertJObjectToObject_UnexpectedType()
     {
         // Arrange
diff --git a/test/Docfx.Common.Tests/FileAbstractLayerTest.cs b/test/Docfx.Common.Tests/FileAbstractLayerTest.cs
index 8ecae824055..c2a86dfbdf7 100644
--- a/test/Docfx.Common.Tests/FileAbstractLayerTest.cs
+++ b/test/Docfx.Common.Tests/FileAbstractLayerTest.cs
@@ -2,13 +2,13 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Docfx.Tests.Common;
-using Xunit;
 
 namespace Docfx.Common.Tests;
 
+[TestClass]
 public class FileAbstractLayerTest : TestBase
 {
-    [Fact]
+    [TestMethod]
     public void TestFileAbstractLayerWithRealImplementsShouldReadFileCorrectlyWhenInputNoFallback()
     {
         var input = GetRandomFolder();
@@ -16,15 +16,15 @@ public void TestFileAbstractLayerWithRealImplementsShouldReadFileCorrectlyWhenIn
         var fal = FileAbstractLayerBuilder.Default
             .ReadFromRealFileSystem(input)
             .Create();
-        Assert.True(fal.Exists("~/temp.txt"));
-        Assert.True(fal.Exists("temp.txt"));
-        Assert.False(fal.Exists("~/temp.jpg"));
-        Assert.False(fal.Exists("temp.jpg"));
-        Assert.Equal("👍", fal.ReadAllText("temp.txt"));
-        Assert.Equal(new[] { (RelativePath)"~/temp.txt" }, fal.GetAllInputFiles());
+        Assert.IsTrue(fal.Exists("~/temp.txt"));
+        Assert.IsTrue(fal.Exists("temp.txt"));
+        Assert.IsFalse(fal.Exists("~/temp.jpg"));
+        Assert.IsFalse(fal.Exists("temp.jpg"));
+        Assert.AreEqual("👍", fal.ReadAllText("temp.txt"));
+        CollectionAssert.AreEqual(new[] { (RelativePath)"~/temp.txt" }, fal.GetAllInputFiles().ToArray());
     }
 
-    [Fact]
+    [TestMethod]
     public void TestFileAbstractLayerWithRealImplementsShouldCopyFileCorrectly()
     {
         var input = GetRandomFolder();
@@ -39,14 +39,14 @@ public void TestFileAbstractLayerWithRealImplementsShouldCopyFileCorrectly()
         var fal2 = FileAbstractLayerBuilder.Default
             .ReadFromOutput(fal)
             .Create();
-        Assert.True(fal2.Exists("copy.txt"));
-        Assert.False(fal2.Exists("temp.txt"));
-        Assert.Equal("😈", fal2.ReadAllText("copy.txt"));
-        Assert.Equal(new[] { (RelativePath)"~/copy.txt" }, fal2.GetAllInputFiles());
-        Assert.True(File.Exists(Path.Combine(output, "copy.txt")));
+        Assert.IsTrue(fal2.Exists("copy.txt"));
+        Assert.IsFalse(fal2.Exists("temp.txt"));
+        Assert.AreEqual("😈", fal2.ReadAllText("copy.txt"));
+        CollectionAssert.AreEqual(new[] { (RelativePath)"~/copy.txt" }, fal2.GetAllInputFiles().ToArray());
+        Assert.IsTrue(File.Exists(Path.Combine(output, "copy.txt")));
     }
 
-    [Fact]
+    [TestMethod]
     public void TestFileAbstractLayerWithRealImplementsShouldCreateTwiceForSameFileCorrectly()
     {
         var output = GetRandomFolder();
@@ -59,13 +59,13 @@ public void TestFileAbstractLayerWithRealImplementsShouldCreateTwiceForSameFileC
         var fal2 = FileAbstractLayerBuilder.Default
             .ReadFromOutput(fal)
             .Create();
-        Assert.True(fal2.Exists("temp.txt"));
-        Assert.Equal("😆", fal2.ReadAllText("temp.txt"));
-        Assert.Equal(new[] { (RelativePath)"~/temp.txt" }, fal2.GetAllInputFiles());
-        Assert.True(File.Exists(Path.Combine(output, "temp.txt")));
+        Assert.IsTrue(fal2.Exists("temp.txt"));
+        Assert.AreEqual("😆", fal2.ReadAllText("temp.txt"));
+        CollectionAssert.AreEqual(new[] { (RelativePath)"~/temp.txt" }, fal2.GetAllInputFiles().ToArray());
+        Assert.IsTrue(File.Exists(Path.Combine(output, "temp.txt")));
     }
 
-    [Fact]
+    [TestMethod]
     public void TestFileAbstractLayerWithRealImplementsShouldCopyThenCreateForSameFileCorrectly()
     {
         var input = GetRandomFolder();
@@ -81,10 +81,10 @@ public void TestFileAbstractLayerWithRealImplementsShouldCopyThenCreateForSameFi
         var fal2 = FileAbstractLayerBuilder.Default
             .ReadFromOutput(fal)
             .Create();
-        Assert.True(fal2.Exists("copy.txt"));
-        Assert.Equal("😁", fal2.ReadAllText("copy.txt"));
-        Assert.Equal(new[] { (RelativePath)"~/copy.txt" }, fal2.GetAllInputFiles());
-        Assert.True(File.Exists(Path.Combine(output, "copy.txt")));
-        Assert.Equal("😄", File.ReadAllText(Path.Combine(input, "temp.txt")));
+        Assert.IsTrue(fal2.Exists("copy.txt"));
+        Assert.AreEqual("😁", fal2.ReadAllText("copy.txt"));
+        CollectionAssert.AreEqual(new[] { (RelativePath)"~/copy.txt" }, fal2.GetAllInputFiles().ToArray());
+        Assert.IsTrue(File.Exists(Path.Combine(output, "copy.txt")));
+        Assert.AreEqual("😄", File.ReadAllText(Path.Combine(input, "temp.txt")));
     }
 }
diff --git a/test/Docfx.Common.Tests/FileAbstractLayerWithEnvironmentVariableTest.cs b/test/Docfx.Common.Tests/FileAbstractLayerWithEnvironmentVariableTest.cs
index 1f6a135c24a..a42b261dccb 100644
--- a/test/Docfx.Common.Tests/FileAbstractLayerWithEnvironmentVariableTest.cs
+++ b/test/Docfx.Common.Tests/FileAbstractLayerWithEnvironmentVariableTest.cs
@@ -2,14 +2,14 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Docfx.Tests.Common;
-using Xunit;
 
 namespace Docfx.Common.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class FileAbstractLayerWithEnvironmentVariableTest : TestBase
 {
-    [Fact]
+    [TestMethod]
     public void TestFileAbstractLayerWithRealImplementsShouldReadFileCorrectlyWhenInputNoFallback()
     {
         var input = GetRandomFolder();
@@ -18,16 +18,16 @@ public void TestFileAbstractLayerWithRealImplementsShouldReadFileCorrectlyWhenIn
         var fal = FileAbstractLayerBuilder.Default
             .ReadFromRealFileSystem("%input%")
             .Create();
-        Assert.True(fal.Exists("~/temp.txt"));
-        Assert.True(fal.Exists("temp.txt"));
-        Assert.False(fal.Exists("~/temp.jpg"));
-        Assert.False(fal.Exists("temp.jpg"));
-        Assert.Equal("👍", fal.ReadAllText("temp.txt"));
-        Assert.Equal(new[] { (RelativePath)"~/temp.txt" }, fal.GetAllInputFiles());
+        Assert.IsTrue(fal.Exists("~/temp.txt"));
+        Assert.IsTrue(fal.Exists("temp.txt"));
+        Assert.IsFalse(fal.Exists("~/temp.jpg"));
+        Assert.IsFalse(fal.Exists("temp.jpg"));
+        Assert.AreEqual("👍", fal.ReadAllText("temp.txt"));
+        CollectionAssert.AreEqual(new[] { (RelativePath)"~/temp.txt" }, fal.GetAllInputFiles().ToArray());
         Environment.SetEnvironmentVariable("input", null);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestFileAbstractLayerWithRealImplementsShouldCopyFileCorrectly()
     {
         var input = GetRandomFolder();
@@ -44,16 +44,16 @@ public void TestFileAbstractLayerWithRealImplementsShouldCopyFileCorrectly()
         var fal2 = FileAbstractLayerBuilder.Default
             .ReadFromOutput(fal)
             .Create();
-        Assert.True(fal2.Exists("copy.txt"));
-        Assert.False(fal2.Exists("temp.txt"));
-        Assert.Equal("😈", fal2.ReadAllText("copy.txt"));
-        Assert.Equal(new[] { (RelativePath)"~/copy.txt" }, fal2.GetAllInputFiles());
-        Assert.True(File.Exists(Path.Combine(output, "copy.txt")));
+        Assert.IsTrue(fal2.Exists("copy.txt"));
+        Assert.IsFalse(fal2.Exists("temp.txt"));
+        Assert.AreEqual("😈", fal2.ReadAllText("copy.txt"));
+        CollectionAssert.AreEqual(new[] { (RelativePath)"~/copy.txt" }, fal2.GetAllInputFiles().ToArray());
+        Assert.IsTrue(File.Exists(Path.Combine(output, "copy.txt")));
         Environment.SetEnvironmentVariable("input", null);
         Environment.SetEnvironmentVariable("output", null);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestFileAbstractLayerWithRealImplementsShouldCreateTwiceForSameFileCorrectly()
     {
         var output = GetRandomFolder();
@@ -67,14 +67,14 @@ public void TestFileAbstractLayerWithRealImplementsShouldCreateTwiceForSameFileC
         var fal2 = FileAbstractLayerBuilder.Default
             .ReadFromOutput(fal)
             .Create();
-        Assert.True(fal2.Exists("temp.txt"));
-        Assert.Equal("😆", fal2.ReadAllText("temp.txt"));
-        Assert.Equal(new[] { (RelativePath)"~/temp.txt" }, fal2.GetAllInputFiles());
-        Assert.True(File.Exists(Path.Combine(output, "temp.txt")));
+        Assert.IsTrue(fal2.Exists("temp.txt"));
+        Assert.AreEqual("😆", fal2.ReadAllText("temp.txt"));
+        CollectionAssert.AreEqual(new[] { (RelativePath)"~/temp.txt" }, fal2.GetAllInputFiles().ToArray());
+        Assert.IsTrue(File.Exists(Path.Combine(output, "temp.txt")));
         Environment.SetEnvironmentVariable("output", null);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestFileAbstractLayerWithRealImplementsShouldCopyThenCreateForSameFileCorrectly()
     {
         var input = GetRandomFolder();
@@ -92,11 +92,11 @@ public void TestFileAbstractLayerWithRealImplementsShouldCopyThenCreateForSameFi
         var fal2 = FileAbstractLayerBuilder.Default
             .ReadFromOutput(fal)
             .Create();
-        Assert.True(fal2.Exists("copy.txt"));
-        Assert.Equal("😁", fal2.ReadAllText("copy.txt"));
-        Assert.Equal(new[] { (RelativePath)"~/copy.txt" }, fal2.GetAllInputFiles());
-        Assert.True(File.Exists(Path.Combine(output, "copy.txt")));
-        Assert.Equal("😄", File.ReadAllText(Path.Combine(input, "temp.txt")));
+        Assert.IsTrue(fal2.Exists("copy.txt"));
+        Assert.AreEqual("😁", fal2.ReadAllText("copy.txt"));
+        CollectionAssert.AreEqual(new[] { (RelativePath)"~/copy.txt" }, fal2.GetAllInputFiles().ToArray());
+        Assert.IsTrue(File.Exists(Path.Combine(output, "copy.txt")));
+        Assert.AreEqual("😄", File.ReadAllText(Path.Combine(input, "temp.txt")));
         Environment.SetEnvironmentVariable("input", null);
         Environment.SetEnvironmentVariable("output", null);
     }
diff --git a/test/Docfx.Common.Tests/GitUtilityTest.cs b/test/Docfx.Common.Tests/GitUtilityTest.cs
index 7a08ac5c7ea..15220482988 100644
--- a/test/Docfx.Common.Tests/GitUtilityTest.cs
+++ b/test/Docfx.Common.Tests/GitUtilityTest.cs
@@ -2,11 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Docfx.Common.Git;
-using Xunit;
 
 namespace Docfx.Common.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class GitUtilityTest : IDisposable
 {
     private readonly string _originalBranchName;
@@ -22,26 +22,26 @@ public void Dispose()
         Environment.SetEnvironmentVariable(EnvName, _originalBranchName);
     }
 
-    [Fact]
+    [TestMethod]
     public void Environment_ForBranchName()
     {
         var info = GitUtility.TryGetFileDetail(Directory.GetCurrentDirectory());
-        Assert.Equal("special-branch", info.Branch);
+        Assert.AreEqual("special-branch", info.Branch);
     }
 
-    [Theory]
-    [InlineData("https://github.com/user/repo.git", "main", "path/to/file.cs", 0, "https://github.com/user/repo/blob/main/path/to/file.cs")]
-    [InlineData("https://github.com/user/repo.git", "main", "path/to/file.cs", 10, "https://github.com/user/repo/blob/main/path/to/file.cs#L10")]
-    [InlineData("https://bitbucket.org/user/repo.git", "main", "path/to/file.cs", 0, "https://bitbucket.org/user/repo/src/main/path/to/file.cs")]
-    [InlineData("https://bitbucket.org/user/repo.git", "main", "path/to/file.cs", 10, "https://bitbucket.org/user/repo/src/main/path/to/file.cs#lines-10")]
-    [InlineData("https://dev.azure.com/user/repo/_git/repo", "main", "path/to/file.cs", 0, "https://dev.azure.com/user/repo/_git/repo?path=path/to/file.cs&version=GBmain")]
-    [InlineData("https://dev.azure.com/user/repo/_git/repo", "0123456789abcdef0123456789abcdef01234567", "path/to/file.cs", 10, "https://dev.azure.com/user/repo/_git/repo?path=path/to/file.cs&version=GC0123456789abcdef0123456789abcdef01234567&line=10")]
-    [InlineData("https://user.visualstudio.com/repo/_git/repo", "main", "path/to/file.cs", 0, "https://user.visualstudio.com/repo/_git/repo?path=path/to/file.cs&version=GBmain")]
-    [InlineData("https://user.visualstudio.com/repo/_git/repo", "0123456789abcdef0123456789abcdef01234567", "path/to/file.cs", 10, "https://user.visualstudio.com/repo/_git/repo?path=path/to/file.cs&version=GC0123456789abcdef0123456789abcdef01234567&line=10")]
-    [InlineData("git@github.com:user/repo.git", "main", "path/to/file.cs", 0, "https://github.com/user/repo/blob/main/path/to/file.cs")]
-    [InlineData("ssh://mseng@vs-ssh.visualstudio.com:22/FakeProject/_ssh/Docfx", "main", "path/to/file.cs", 0, "https://vs-ssh.visualstudio.com/FakeProject/_ssh/Docfx?path=path/to/file.cs&version=GBmain")]
-    public static void GetSourceUrlTest(string repo, string branch, string path, int line, string result)
+    [TestMethod]
+    [DataRow("https://github.com/user/repo.git", "main", "path/to/file.cs", 0, "https://github.com/user/repo/blob/main/path/to/file.cs")]
+    [DataRow("https://github.com/user/repo.git", "main", "path/to/file.cs", 10, "https://github.com/user/repo/blob/main/path/to/file.cs#L10")]
+    [DataRow("https://bitbucket.org/user/repo.git", "main", "path/to/file.cs", 0, "https://bitbucket.org/user/repo/src/main/path/to/file.cs")]
+    [DataRow("https://bitbucket.org/user/repo.git", "main", "path/to/file.cs", 10, "https://bitbucket.org/user/repo/src/main/path/to/file.cs#lines-10")]
+    [DataRow("https://dev.azure.com/user/repo/_git/repo", "main", "path/to/file.cs", 0, "https://dev.azure.com/user/repo/_git/repo?path=path/to/file.cs&version=GBmain")]
+    [DataRow("https://dev.azure.com/user/repo/_git/repo", "0123456789abcdef0123456789abcdef01234567", "path/to/file.cs", 10, "https://dev.azure.com/user/repo/_git/repo?path=path/to/file.cs&version=GC0123456789abcdef0123456789abcdef01234567&line=10")]
+    [DataRow("https://user.visualstudio.com/repo/_git/repo", "main", "path/to/file.cs", 0, "https://user.visualstudio.com/repo/_git/repo?path=path/to/file.cs&version=GBmain")]
+    [DataRow("https://user.visualstudio.com/repo/_git/repo", "0123456789abcdef0123456789abcdef01234567", "path/to/file.cs", 10, "https://user.visualstudio.com/repo/_git/repo?path=path/to/file.cs&version=GC0123456789abcdef0123456789abcdef01234567&line=10")]
+    [DataRow("git@github.com:user/repo.git", "main", "path/to/file.cs", 0, "https://github.com/user/repo/blob/main/path/to/file.cs")]
+    [DataRow("ssh://mseng@vs-ssh.visualstudio.com:22/FakeProject/_ssh/Docfx", "main", "path/to/file.cs", 0, "https://vs-ssh.visualstudio.com/FakeProject/_ssh/Docfx?path=path/to/file.cs&version=GBmain")]
+    public void GetSourceUrlTest(string repo, string branch, string path, int line, string result)
     {
-        Assert.Equal(result, GitUtility.GetSourceUrl(new(repo, branch, path, line)));
+        Assert.AreEqual(result, GitUtility.GetSourceUrl(new(repo, branch, path, line)));
     }
 }
diff --git a/test/Docfx.Common.Tests/GitUtilityWithSourceRepoUrlTest.cs b/test/Docfx.Common.Tests/GitUtilityWithSourceRepoUrlTest.cs
index 1b949ae9a1d..3474520adef 100644
--- a/test/Docfx.Common.Tests/GitUtilityWithSourceRepoUrlTest.cs
+++ b/test/Docfx.Common.Tests/GitUtilityWithSourceRepoUrlTest.cs
@@ -2,11 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Docfx.Common.Git;
-using Xunit;
 
 namespace Docfx.Common.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class GitUtilityWithSourceRepositoryUrlTest : IDisposable
 {
     private readonly string _originalBranchName;
@@ -34,15 +34,15 @@ public void Dispose()
         Environment.SetEnvironmentVariable(DOCFX_SOURCE_REPOSITORY_URL, _originalSourceRepoUrl);
     }
 
-    [Fact]
+    [TestMethod]
     public void TryGetFileDetailTest()
     {
         var info = GitUtility.TryGetFileDetail(Directory.GetCurrentDirectory());
-        Assert.Equal(BRANCH_NAME, info.Branch);
-        Assert.Equal("https://github.com/dotnet/docfx", info.Repo);
+        Assert.AreEqual(BRANCH_NAME, info.Branch);
+        Assert.AreEqual("https://github.com/dotnet/docfx", info.Repo);
     }
 
-    [Fact]
+    [TestMethod]
     public void RawContentUrlToContentUrlTest()
     {
         string rawUrl = "https://raw.githubusercontent.com/dotnet/docfx/main/README.md";
@@ -50,15 +50,15 @@ public void RawContentUrlToContentUrlTest()
 
         var result = GitUtility.RawContentUrlToContentUrl(rawUrl);
 
-        Assert.Equal(expected, result);
+        Assert.AreEqual(expected, result);
     }
 
-    [Theory]
-    [InlineData("https://github.com/user/repo.git", "main", "path/to/file.cs", 0, $"https://github.com/{ORG_NAME}/{REPO_NAME}/blob/main/path/to/file.cs")]
-    [InlineData("https://github.com/user/repo.git", "main", "path/to/file.cs", 10, $"https://github.com/{ORG_NAME}/{REPO_NAME}/blob/main/path/to/file.cs#L10")]
-    [InlineData("git@github.com:user/repo.git", "main", "path/to/file.cs", 0, $"https://github.com/{ORG_NAME}/{REPO_NAME}/blob/main/path/to/file.cs")]
+    [TestMethod]
+    [DataRow("https://github.com/user/repo.git", "main", "path/to/file.cs", 0, $"https://github.com/{ORG_NAME}/{REPO_NAME}/blob/main/path/to/file.cs")]
+    [DataRow("https://github.com/user/repo.git", "main", "path/to/file.cs", 10, $"https://github.com/{ORG_NAME}/{REPO_NAME}/blob/main/path/to/file.cs#L10")]
+    [DataRow("git@github.com:user/repo.git", "main", "path/to/file.cs", 0, $"https://github.com/{ORG_NAME}/{REPO_NAME}/blob/main/path/to/file.cs")]
     public void GetSourceUrlTest_GitHub(string repo, string branch, string path, int line, string result)
     {
-        Assert.Equal(result, GitUtility.GetSourceUrl(new(repo, branch, path, line)));
+        Assert.AreEqual(result, GitUtility.GetSourceUrl(new(repo, branch, path, line)));
     }
 }
diff --git a/test/Docfx.Common.Tests/JObjectMergerTest.cs b/test/Docfx.Common.Tests/JObjectMergerTest.cs
index b52773d0e5c..d3884fd1540 100644
--- a/test/Docfx.Common.Tests/JObjectMergerTest.cs
+++ b/test/Docfx.Common.Tests/JObjectMergerTest.cs
@@ -5,14 +5,13 @@
 
 using Newtonsoft.Json.Linq;
 
-using Xunit;
-
 namespace Docfx.Common.Tests;
 
-[Trait("Related", "JObjectMerger")]
+[TestProperty("Related", "JObjectMerger")]
+[TestClass]
 public class JObjectMergerTest
 {
-    [Fact]
+    [TestMethod]
     public void TestJObjectMergerWithBasicScenarios()
     {
         object source = new JObject
@@ -43,11 +42,11 @@ public void TestJObjectMergerWithBasicScenarios()
                 new ReflectionEntityMerger()))
                 .Merge(ref source, overrides);
         var sourceJObj = source as JObject;
-        Assert.NotNull(sourceJObj);
-        Assert.Equal("Overrides1", sourceJObj["StringKey"]);
-        Assert.Equal("Source2", sourceJObj["AdditionalSourceKey"]);
-        Assert.Equal("Overrides2", sourceJObj["AdditionalOverridesKey"]);
-        Assert.Equal("Overrides3", sourceJObj["JObjectValue"]["CommonKey"]);
-        Assert.Equal("Overrides4", sourceJObj["JObjectValue"]["AdditionalOverridesKey"]);
+        Assert.IsNotNull(sourceJObj);
+        Assert.AreEqual("Overrides1", sourceJObj["StringKey"]);
+        Assert.AreEqual("Source2", sourceJObj["AdditionalSourceKey"]);
+        Assert.AreEqual("Overrides2", sourceJObj["AdditionalOverridesKey"]);
+        Assert.AreEqual("Overrides3", sourceJObj["JObjectValue"]["CommonKey"]);
+        Assert.AreEqual("Overrides4", sourceJObj["JObjectValue"]["AdditionalOverridesKey"]);
     }
 }
diff --git a/test/Docfx.Common.Tests/PathUtilityTest.cs b/test/Docfx.Common.Tests/PathUtilityTest.cs
index 5dba7472edd..7dd172e08a5 100644
--- a/test/Docfx.Common.Tests/PathUtilityTest.cs
+++ b/test/Docfx.Common.Tests/PathUtilityTest.cs
@@ -2,14 +2,14 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using FluentAssertions;
-using Xunit;
 
 namespace Docfx.Common.Tests;
 
+[TestClass]
 public class PathUtilityTest
 {
-    [Theory]
-    [MemberData(nameof(TestData.AdditionalTests), MemberType = typeof(TestData))]
+    [TestMethod]
+    [DynamicData(nameof(TestData.AdditionalTests), typeof(TestData))]
     public void TestMakeRelativePath(string basePath, string targetPath, string expected)
     {
         // Act
@@ -19,8 +19,8 @@ public void TestMakeRelativePath(string basePath, string targetPath, string expe
         result.Should().Be(expected);
     }
 
-    [Theory]
-    [MemberData(nameof(TestData.EscapedPaths), MemberType = typeof(TestData))]
+    [TestMethod]
+    [DynamicData(nameof(TestData.EscapedPaths), typeof(TestData))]
     public void TestMakeRelativePathWithEncodedPath(string inputPath)
     {
         // Arrange
@@ -36,17 +36,17 @@ public void TestMakeRelativePathWithEncodedPath(string inputPath)
 
     private static class TestData
     {
-        public static TheoryData<string, string, string> AdditionalTests = new()
-        {
-            { "/a/b/d",          "/a/b/file.md",            "../file.md"},            // root relative path
-            { "~/a/b/d",         "~/a/b/file.md",           "../file.md"},            // user home directory relative path
-            { "./",              @"\\UNCPath\file.md",       "//UNCPath/file.md"},     // UNC path
-            { "./",              "file:///C:/temp/test.md", "file:/C:/temp/test.md"}, // `file:` Uri path
-            { "file:///C:/temp", "file:///C:/temp/test.md", "test.md"},               // `file:` Uri relative path
-            { "/temp/dir",       "/temp/dir/subdir/",       "subdir/"},               // If target path endsWith directory separator char. resolved path should contain directory separator.
-        };
-
-        public static TheoryData<string> EscapedPaths =
+        public static IEnumerable<(string, string, string)> AdditionalTests =>
+        [
+            ( "/a/b/d",          "/a/b/file.md",            "../file.md"),            // root relative path
+            ( "~/a/b/d",         "~/a/b/file.md",           "../file.md"),            // user home directory relative path
+            ( "./",              @"\\UNCPath\file.md",       "//UNCPath/file.md"),     // UNC path
+            ( "./",              "file:///C:/temp/test.md", "file:/C:/temp/test.md"), // `file:` Uri path
+            ( "file:///C:/temp", "file:///C:/temp/test.md", "test.md"),               // `file:` Uri relative path
+            ( "/temp/dir",       "/temp/dir/subdir/",       "subdir/"),               // If target path endsWith directory separator char. resolved path should contain directory separator.
+        ];
+
+        public static IEnumerable<string> EscapedPaths =>
         [
             "EscapedHypen(%2D).md",                      // Contains escaped hypen char
             "EscapedSpace(%20)_with_NonAsciiChar(α).md", // Contains escaped space char and non-unicode char
diff --git a/test/Docfx.Common.Tests/ReflectionEntityMergerTest.cs b/test/Docfx.Common.Tests/ReflectionEntityMergerTest.cs
index 0cf58d41f20..f5e39e39d2b 100644
--- a/test/Docfx.Common.Tests/ReflectionEntityMergerTest.cs
+++ b/test/Docfx.Common.Tests/ReflectionEntityMergerTest.cs
@@ -2,14 +2,14 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Docfx.Common.EntityMergers;
-using Xunit;
 
 namespace Docfx.Common.Tests;
 
-[Trait("Related", "ReflectionEntityMerger")]
+[TestProperty("Related", "ReflectionEntityMerger")]
+[TestClass]
 public class ReflectionEntityMergerTest
 {
-    [Fact]
+    [TestMethod]
     public void TestReflectionEntityMergerWithBasicScenarios()
     {
         var sample = new BasicSample
@@ -37,13 +37,13 @@ public void TestReflectionEntityMergerWithBasicScenarios()
         new MergerFacade(
             new ReflectionEntityMerger())
             .Merge(ref sample, overrides);
-        Assert.Equal(10, sample.IntValue);
-        Assert.Equal(2, sample.NullableIntValue);
-        Assert.Equal("abc", sample.Text);
-        Assert.Equal(1, sample.Nested.IntValue);
-        Assert.Equal(22, sample.Nested.NullableIntValue);
-        Assert.Equal("Wow!", sample.Nested.Text);
-        Assert.Same(overrides.Nested.Nested, sample.Nested.Nested);
+        Assert.AreEqual(10, sample.IntValue);
+        Assert.AreEqual(2, sample.NullableIntValue);
+        Assert.AreEqual("abc", sample.Text);
+        Assert.AreEqual(1, sample.Nested.IntValue);
+        Assert.AreEqual(22, sample.Nested.NullableIntValue);
+        Assert.AreEqual("Wow!", sample.Nested.Text);
+        Assert.AreSame(overrides.Nested.Nested, sample.Nested.Nested);
     }
 
     public class BasicSample
@@ -54,7 +54,7 @@ public class BasicSample
         public BasicSample Nested { get; set; }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestReflectionEntityMergerWhenMergeNullOrDefault()
     {
         var sample = new MergeOptionSample
@@ -85,15 +85,15 @@ public void TestReflectionEntityMergerWhenMergeNullOrDefault()
             new KeyedListMerger(
                 new ReflectionEntityMerger()))
             .Merge(ref sample, overrides);
-        Assert.Equal(10, sample.IntValue);
-        Assert.Equal(2, sample.NullableIntValue);
-        Assert.Null(sample.Text);
-        Assert.Same(overrides.Array1, sample.Array1);
-        Assert.Null(sample.Array2);
-        Assert.Equal(0, sample.Nested.IntValue);
-        Assert.Equal(2, sample.Nested.NullableIntValue);
-        Assert.Equal("Wow!", sample.Nested.Text);
-        Assert.Null(sample.Nested.Nested);
+        Assert.AreEqual(10, sample.IntValue);
+        Assert.AreEqual(2, sample.NullableIntValue);
+        Assert.IsNull(sample.Text);
+        Assert.AreSame(overrides.Array1, sample.Array1);
+        Assert.IsNull(sample.Array2);
+        Assert.AreEqual(0, sample.Nested.IntValue);
+        Assert.AreEqual(2, sample.Nested.NullableIntValue);
+        Assert.AreEqual("Wow!", sample.Nested.Text);
+        Assert.IsNull(sample.Nested.Nested);
     }
 
     public class MergeOptionSample
@@ -112,7 +112,7 @@ public class MergeOptionSample
         public MergeOptionSample Nested { get; set; }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestReflectionEntityMergerWhenMergeListWithKey()
     {
         var sample = new List<ListItemSample>
@@ -134,9 +134,9 @@ public void TestReflectionEntityMergerWhenMergeListWithKey()
                 ref sample,
                 overrides,
                 new Dictionary<string, object> { { "separator", "->" }, });
-        Assert.Equal("O1", sample[0].Text);
-        Assert.Equal("O2->N2", sample[1].Text);
-        Assert.Equal("O3->N3", sample[2].Text);
+        Assert.AreEqual("O1", sample[0].Text);
+        Assert.AreEqual("O2->N2", sample[1].Text);
+        Assert.AreEqual("O3->N3", sample[2].Text);
     }
 
     public class ListItemSample
@@ -159,7 +159,7 @@ public void Merge(ref object source, object overrides, IMergeContext context)
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestMergeDictionary()
     {
         var sample = new Dictionary<string, BasicSample>
@@ -219,22 +219,22 @@ public void TestMergeDictionary()
                 ref sample,
                 overrides);
 
-        Assert.Equal(10, sample["a"].IntValue);
-        Assert.Equal(2, sample["a"].NullableIntValue);
-        Assert.Equal("abc", sample["a"].Text);
-        Assert.Equal(1, sample["a"].Nested.IntValue);
-        Assert.Equal(22, sample["a"].Nested.NullableIntValue);
-        Assert.Equal("Wow!", sample["a"].Nested.Text);
-        Assert.Same(overrides["a"].Nested.Nested, sample["a"].Nested.Nested);
+        Assert.AreEqual(10, sample["a"].IntValue);
+        Assert.AreEqual(2, sample["a"].NullableIntValue);
+        Assert.AreEqual("abc", sample["a"].Text);
+        Assert.AreEqual(1, sample["a"].Nested.IntValue);
+        Assert.AreEqual(22, sample["a"].Nested.NullableIntValue);
+        Assert.AreEqual("Wow!", sample["a"].Nested.Text);
+        Assert.AreSame(overrides["a"].Nested.Nested, sample["a"].Nested.Nested);
 
-        Assert.Equal(101, sample["b"].IntValue);
-        Assert.Null(sample["b"].NullableIntValue);
-        Assert.Equal("xyz", sample["b"].Text);
-        Assert.Equal(102, sample["b"].Nested.IntValue);
-        Assert.Equal(2, sample["b"].Nested.NullableIntValue);
-        Assert.Null(sample["b"].Nested.Text);
-        Assert.Null(sample["b"].Nested.Nested);
+        Assert.AreEqual(101, sample["b"].IntValue);
+        Assert.IsNull(sample["b"].NullableIntValue);
+        Assert.AreEqual("xyz", sample["b"].Text);
+        Assert.AreEqual(102, sample["b"].Nested.IntValue);
+        Assert.AreEqual(2, sample["b"].Nested.NullableIntValue);
+        Assert.IsNull(sample["b"].Nested.Text);
+        Assert.IsNull(sample["b"].Nested.Nested);
 
-        Assert.Same(overrides["c"], sample["c"]);
+        Assert.AreSame(overrides["c"], sample["c"]);
     }
 }
diff --git a/test/Docfx.Common.Tests/RelativePathTest.cs b/test/Docfx.Common.Tests/RelativePathTest.cs
index 5fa8fc4f60c..fdaa6e7d134 100644
--- a/test/Docfx.Common.Tests/RelativePathTest.cs
+++ b/test/Docfx.Common.Tests/RelativePathTest.cs
@@ -1,115 +1,114 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.Common.Tests;
 
-[Trait("Related", "RelativePath")]
+[TestProperty("Related", "RelativePath")]
+[TestClass]
 public class RelativePathTest
 {
-    [Fact]
+    [TestMethod]
     public void TestRelativePathWithBasicScenarios()
     {
         {
             var s = "../a/b.txt";
             var r = (RelativePath)s;
-            Assert.NotNull(r);
-            Assert.Equal(1, r.ParentDirectoryCount);
-            Assert.Equal(s, r.ToString());
-            Assert.Equal(s, r);
+            Assert.IsNotNull(r);
+            Assert.AreEqual(1, r.ParentDirectoryCount);
+            Assert.AreEqual(s, r.ToString());
+            Assert.AreEqual(s, r);
         }
         {
             var s = "a.txt";
             var r = (RelativePath)s;
-            Assert.NotNull(r);
-            Assert.Equal(0, r.ParentDirectoryCount);
-            Assert.Equal(s, r.ToString());
-            Assert.Equal(s, r);
+            Assert.IsNotNull(r);
+            Assert.AreEqual(0, r.ParentDirectoryCount);
+            Assert.AreEqual(s, r.ToString());
+            Assert.AreEqual(s, r);
         }
         {
             var s = "a.dir/";
             var r = (RelativePath)s;
-            Assert.NotNull(r);
-            Assert.Equal(0, r.ParentDirectoryCount);
-            Assert.Equal(s, r.ToString());
-            Assert.Equal(s, r);
+            Assert.IsNotNull(r);
+            Assert.AreEqual(0, r.ParentDirectoryCount);
+            Assert.AreEqual(s, r.ToString());
+            Assert.AreEqual(s, r);
         }
         {
             var s = @"a\b\.\d\..\\c.dir\";
             var r = (RelativePath)s;
-            Assert.NotNull(r);
-            Assert.Equal(0, r.ParentDirectoryCount);
-            Assert.Equal("a/b/c.dir/", r.ToString());
-            Assert.Equal("a/b/c.dir/", r);
+            Assert.IsNotNull(r);
+            Assert.AreEqual(0, r.ParentDirectoryCount);
+            Assert.AreEqual("a/b/c.dir/", r.ToString());
+            Assert.AreEqual("a/b/c.dir/", r);
         }
         {
             var s = "";
             var r = (RelativePath)s;
-            Assert.NotNull(r);
-            Assert.Equal(0, r.ParentDirectoryCount);
-            Assert.Equal(s, r.ToString());
-            Assert.Equal(s, r);
-            Assert.Same(RelativePath.Empty, r);
+            Assert.IsNotNull(r);
+            Assert.AreEqual(0, r.ParentDirectoryCount);
+            Assert.AreEqual(s, r.ToString());
+            Assert.AreEqual(s, r);
+            Assert.AreSame(RelativePath.Empty, r);
         }
         {
             var s = ".";
             var r = (RelativePath)s;
-            Assert.NotNull(r);
-            Assert.Equal(0, r.ParentDirectoryCount);
-            Assert.Equal(string.Empty, r.ToString());
-            Assert.Equal(string.Empty, r);
-            Assert.Same(RelativePath.Empty, r);
+            Assert.IsNotNull(r);
+            Assert.AreEqual(0, r.ParentDirectoryCount);
+            Assert.AreEqual(string.Empty, r.ToString());
+            Assert.AreEqual(string.Empty, r);
+            Assert.AreSame(RelativePath.Empty, r);
         }
         {
             var s = "a/../";
             var r = (RelativePath)s;
-            Assert.NotNull(r);
-            Assert.Equal(0, r.ParentDirectoryCount);
-            Assert.Equal(string.Empty, r.ToString());
-            Assert.Equal(string.Empty, r);
-            Assert.Same(RelativePath.Empty, r);
+            Assert.IsNotNull(r);
+            Assert.AreEqual(0, r.ParentDirectoryCount);
+            Assert.AreEqual(string.Empty, r.ToString());
+            Assert.AreEqual(string.Empty, r);
+            Assert.AreSame(RelativePath.Empty, r);
         }
     }
 
-    [Theory]
-    [InlineData("d/e.txt", "a/b/c/", "a/b/c/d/e.txt")]
-    [InlineData("../d/e.txt", "a/b/c/", "a/b/d/e.txt")]
-    [InlineData("d/e.txt", "a/b/c.txt", "a/b/d/e.txt")]
-    [InlineData("../e.txt", "a/b/c.txt", "a/e.txt")]
-    [InlineData("../e.txt", "../c.txt", "../../e.txt")]
-    [InlineData("../a.txt", "", "../a.txt")]
-    [InlineData("", "../a/b.txt", "../a/")]
-    [InlineData("../", "a/", "")]
-    [InlineData("", "", "")]
-    [InlineData("~/a.txt", "a/b/c/", "~/a.txt")]
-    [InlineData("d.txt", "~/a/b/c/", "~/a/b/c/d.txt")]
+    [TestMethod]
+    [DataRow("d/e.txt", "a/b/c/", "a/b/c/d/e.txt")]
+    [DataRow("../d/e.txt", "a/b/c/", "a/b/d/e.txt")]
+    [DataRow("d/e.txt", "a/b/c.txt", "a/b/d/e.txt")]
+    [DataRow("../e.txt", "a/b/c.txt", "a/e.txt")]
+    [DataRow("../e.txt", "../c.txt", "../../e.txt")]
+    [DataRow("../a.txt", "", "../a.txt")]
+    [DataRow("", "../a/b.txt", "../a/")]
+    [DataRow("../", "a/", "")]
+    [DataRow("", "", "")]
+    [DataRow("~/a.txt", "a/b/c/", "~/a.txt")]
+    [DataRow("d.txt", "~/a/b/c/", "~/a/b/c/d.txt")]
     public void TestRelativePathBasedOn(string thisPath, string basedOnPath, string expected)
     {
         var actual = ((RelativePath)thisPath).BasedOn((RelativePath)basedOnPath);
-        Assert.NotNull(actual);
-        Assert.Equal(expected, actual.ToString());
+        Assert.IsNotNull(actual);
+        Assert.AreEqual(expected, actual.ToString());
     }
 
-    [Theory]
-    [InlineData("a/b/c.txt", "d/e.txt", "../a/b/c.txt")]
-    [InlineData("a/b/c.txt", "a/d.txt", "b/c.txt")]
-    [InlineData("../../a.txt", "../b.txt", "../a.txt")]
-    [InlineData("../../a.txt", "../b/c.txt", "../../a.txt")]
-    [InlineData("a.txt", "../b.txt", null)]
-    [InlineData("a/b.txt", "", "a/b.txt")]
-    [InlineData("", "a/b.txt", "../")]
-    [InlineData("a/", "a/", "")]
-    [InlineData("", "", "")]
-    [InlineData("~/a/b.txt", "~/a/c.txt", "b.txt")]
-    [InlineData("~/a/b.txt", "a/c.txt", "~/a/b.txt")]
+    [TestMethod]
+    [DataRow("a/b/c.txt", "d/e.txt", "../a/b/c.txt")]
+    [DataRow("a/b/c.txt", "a/d.txt", "b/c.txt")]
+    [DataRow("../../a.txt", "../b.txt", "../a.txt")]
+    [DataRow("../../a.txt", "../b/c.txt", "../../a.txt")]
+    [DataRow("a.txt", "../b.txt", null)]
+    [DataRow("a/b.txt", "", "a/b.txt")]
+    [DataRow("", "a/b.txt", "../")]
+    [DataRow("a/", "a/", "")]
+    [DataRow("", "", "")]
+    [DataRow("~/a/b.txt", "~/a/c.txt", "b.txt")]
+    [DataRow("~/a/b.txt", "a/c.txt", "~/a/b.txt")]
     public void TestRelativePathMakeRelativeTo(string thisPath, string relativeToPath, string expected)
     {
         try
         {
             var actual = ((RelativePath)thisPath).MakeRelativeTo((RelativePath)relativeToPath);
-            Assert.NotNull(actual);
-            Assert.Equal(expected, actual.ToString());
+            Assert.IsNotNull(actual);
+            Assert.AreEqual(expected, actual.ToString());
         }
         catch (NotSupportedException)
         {
@@ -120,28 +119,28 @@ public void TestRelativePathMakeRelativeTo(string thisPath, string relativeToPat
         }
     }
 
-    [Theory]
-    [InlineData("a/b/c", "a/b/")]
-    [InlineData("~/a/b/c", "~/a/b/")]
-    [InlineData("~/../a/b/c", "~/../a/b/")]
-    [InlineData("~/../a/", "~/../a/")]
-    [InlineData("~/../", "~/../")]
-    [InlineData("~/a/../b", "~/")]
+    [TestMethod]
+    [DataRow("a/b/c", "a/b/")]
+    [DataRow("~/a/b/c", "~/a/b/")]
+    [DataRow("~/../a/b/c", "~/../a/b/")]
+    [DataRow("~/../a/", "~/../a/")]
+    [DataRow("~/../", "~/../")]
+    [DataRow("~/a/../b", "~/")]
     public void TestRelativePathGetDirectoryPath(string file, string expected)
     {
         var relativePath = (RelativePath)file;
         var result = relativePath.GetDirectoryPath();
-        Assert.Equal(expected, result.ToString());
+        Assert.AreEqual(expected, result.ToString());
     }
 
-    [Fact]
+    [TestMethod]
     public void TestRelativePathGetDirectoryPathWithInvalidParentDirectoryShouldFail()
     {
         var relativePath = (RelativePath)"~/..";
-        Assert.Throws<InvalidOperationException>(relativePath.GetDirectoryPath);
+        Assert.Throws<InvalidOperationException>(() => relativePath.GetDirectoryPath());
     }
 
-    [Fact]
+    [TestMethod]
     public void TestRelativePathChangeFileNameWithInvalidFileNameShouldFail()
     {
         var relativePath = (RelativePath)"~/a/b/c";
@@ -150,18 +149,18 @@ public void TestRelativePathChangeFileNameWithInvalidFileNameShouldFail()
         Assert.Throws<ArgumentException>(() => relativePath.ChangeFileName("../d/"));
     }
 
-    [Theory]
-    [InlineData("a/b/c", "d", "a/b/d")]
-    [InlineData("~/a/b/c", "d", "~/a/b/d")]
-    [InlineData("../a/b/c", "d", "../a/b/d")]
+    [TestMethod]
+    [DataRow("a/b/c", "d", "a/b/d")]
+    [DataRow("~/a/b/c", "d", "~/a/b/d")]
+    [DataRow("../a/b/c", "d", "../a/b/d")]
     public void TestRelativePathChangeFileName(string file, string changedFileName, string expected)
     {
         var relativePath = (RelativePath)file;
         var result = relativePath.ChangeFileName(changedFileName);
-        Assert.Equal(expected, result.ToString());
+        Assert.AreEqual(expected, result.ToString());
     }
 
-    [Fact]
+    [TestMethod]
     public void TestRelativePathOperatorAdd()
     {
         // a/b/c/ + d/e.txt = a/b/c/d/e.txt
@@ -169,89 +168,89 @@ public void TestRelativePathOperatorAdd()
             var r1 = (RelativePath)"a/b/c/";
             var r2 = (RelativePath)"d/e.txt";
             var r3 = r1 + r2;
-            Assert.NotNull(r3);
-            Assert.Equal(0, r3.ParentDirectoryCount);
-            Assert.Equal("a/b/c/d/e.txt", r3.ToString());
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(0, r3.ParentDirectoryCount);
+            Assert.AreEqual("a/b/c/d/e.txt", r3.ToString());
         }
         // a/b/c/ + ../d/e.txt = a/b/d/e.txt
         {
             var r1 = (RelativePath)"a/b/c/";
             var r2 = (RelativePath)"../d/e.txt";
             var r3 = r1 + r2;
-            Assert.NotNull(r3);
-            Assert.Equal(0, r3.ParentDirectoryCount);
-            Assert.Equal("a/b/d/e.txt", r3.ToString());
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(0, r3.ParentDirectoryCount);
+            Assert.AreEqual("a/b/d/e.txt", r3.ToString());
         }
         // a/b/c.txt + d/e.txt = a/b/d/e.txt
         {
             var r1 = (RelativePath)"a/b/c.txt";
             var r2 = (RelativePath)"d/e.txt";
             var r3 = r1 + r2;
-            Assert.NotNull(r3);
-            Assert.Equal(0, r3.ParentDirectoryCount);
-            Assert.Equal("a/b/d/e.txt", r3.ToString());
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(0, r3.ParentDirectoryCount);
+            Assert.AreEqual("a/b/d/e.txt", r3.ToString());
         }
         // a/b/c.txt + ../e.txt = a/e.txt
         {
             var r1 = (RelativePath)"a/b/c.txt";
             var r2 = (RelativePath)"../e.txt";
             var r3 = r1 + r2;
-            Assert.NotNull(r3);
-            Assert.Equal(0, r3.ParentDirectoryCount);
-            Assert.Equal("a/e.txt", r3.ToString());
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(0, r3.ParentDirectoryCount);
+            Assert.AreEqual("a/e.txt", r3.ToString());
         }
         // ../c.txt + ../e.txt = ../../e.txt
         {
             var r1 = (RelativePath)"../c.txt";
             var r2 = (RelativePath)"../e.txt";
             var r3 = r1 + r2;
-            Assert.NotNull(r3);
-            Assert.Equal(2, r3.ParentDirectoryCount);
-            Assert.Equal("../../e.txt", r3.ToString());
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(2, r3.ParentDirectoryCount);
+            Assert.AreEqual("../../e.txt", r3.ToString());
         }
         // "" + ../a.txt = ../a.txt
         {
             var r1 = (RelativePath)"";
             var r2 = (RelativePath)"../a.txt";
             var r3 = r1 + r2;
-            Assert.NotNull(r3);
-            Assert.Equal(1, r3.ParentDirectoryCount);
-            Assert.Equal("../a.txt", r3.ToString());
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(1, r3.ParentDirectoryCount);
+            Assert.AreEqual("../a.txt", r3.ToString());
         }
         // ../a/b.txt + "" = ../a/
         {
             var r1 = (RelativePath)"../a/b.txt";
             var r2 = (RelativePath)"";
             var r3 = r1 + r2;
-            Assert.NotNull(r3);
-            Assert.Equal(1, r3.ParentDirectoryCount);
-            Assert.Equal("../a/", r3.ToString());
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(1, r3.ParentDirectoryCount);
+            Assert.AreEqual("../a/", r3.ToString());
         }
         // a/ + ../ = ""
         {
             var r1 = (RelativePath)"a/";
             var r2 = (RelativePath)"../";
             var r3 = r1 + r2;
-            Assert.NotNull(r3);
-            Assert.Equal(0, r3.ParentDirectoryCount);
-            Assert.Equal("", r3.ToString());
-            Assert.Same(RelativePath.Empty, r3);
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(0, r3.ParentDirectoryCount);
+            Assert.AreEqual("", r3.ToString());
+            Assert.AreSame(RelativePath.Empty, r3);
         }
         // "" + "" = ""
         {
             var r1 = (RelativePath)"";
             var r2 = (RelativePath)"";
             var r3 = r1 + r2;
-            Assert.NotNull(r3);
-            Assert.Equal(0, r3.ParentDirectoryCount);
-            Assert.Equal("", r3.ToString());
-            Assert.Same(RelativePath.Empty, r1);
-            Assert.Same(RelativePath.Empty, r2);
-            Assert.Same(RelativePath.Empty, r3);
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(0, r3.ParentDirectoryCount);
+            Assert.AreEqual("", r3.ToString());
+            Assert.AreSame(RelativePath.Empty, r1);
+            Assert.AreSame(RelativePath.Empty, r2);
+            Assert.AreSame(RelativePath.Empty, r3);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestRelativePathOperatorSub()
     {
         // a/b/c.txt - d/e.txt = ../a/b/c.txt
@@ -259,86 +258,86 @@ public void TestRelativePathOperatorSub()
             var r1 = (RelativePath)"a/b/c.txt";
             var r2 = (RelativePath)"d/e.txt";
             var r3 = r1 - r2;
-            Assert.NotNull(r3);
-            Assert.Equal(1, r3.ParentDirectoryCount);
-            Assert.Equal("../a/b/c.txt", r3.ToString());
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(1, r3.ParentDirectoryCount);
+            Assert.AreEqual("../a/b/c.txt", r3.ToString());
         }
         // a/b/c.txt - a/d.txt = b/c.txt
         {
             var r1 = (RelativePath)"a/b/c.txt";
             var r2 = (RelativePath)"a/d.txt";
             var r3 = r1 - r2;
-            Assert.NotNull(r3);
-            Assert.Equal(0, r3.ParentDirectoryCount);
-            Assert.Equal("b/c.txt", r3.ToString());
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(0, r3.ParentDirectoryCount);
+            Assert.AreEqual("b/c.txt", r3.ToString());
         }
         // ../../a.txt - ../b.txt = ../a.txt
         {
             var r1 = (RelativePath)"../../a.txt";
             var r2 = (RelativePath)"../b.txt";
             var r3 = r1 - r2;
-            Assert.NotNull(r3);
-            Assert.Equal(1, r3.ParentDirectoryCount);
-            Assert.Equal("../a.txt", r3.ToString());
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(1, r3.ParentDirectoryCount);
+            Assert.AreEqual("../a.txt", r3.ToString());
         }
         // ../../a.txt - ../b/c.txt = ../../a.txt
         {
             var r1 = (RelativePath)"../../a.txt";
             var r2 = (RelativePath)"../b/c.txt";
             var r3 = r1 - r2;
-            Assert.NotNull(r3);
-            Assert.Equal(2, r3.ParentDirectoryCount);
-            Assert.Equal("../../a.txt", r3.ToString());
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(2, r3.ParentDirectoryCount);
+            Assert.AreEqual("../../a.txt", r3.ToString());
         }
         // a.txt - ../b.txt = Oop...
         {
             var r1 = (RelativePath)"a.txt";
             var r2 = (RelativePath)"../b.txt";
-            Assert.Throws<NotSupportedException>(() => r1 - r2);
+            Assert.Throws<NotSupportedException>(() => _ = r1 - r2);
         }
         // a/b.txt - "" = a/b.txt
         {
             var r1 = (RelativePath)"a/b.txt";
             var r2 = (RelativePath)"";
             var r3 = r1 - r2;
-            Assert.NotNull(r3);
-            Assert.Equal(0, r3.ParentDirectoryCount);
-            Assert.Equal("a/b.txt", r3.ToString());
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(0, r3.ParentDirectoryCount);
+            Assert.AreEqual("a/b.txt", r3.ToString());
         }
         // "" - a/b.txt = ../
         {
             var r1 = (RelativePath)"";
             var r2 = (RelativePath)"a/b.txt";
             var r3 = r1 - r2;
-            Assert.NotNull(r3);
-            Assert.Equal(1, r3.ParentDirectoryCount);
-            Assert.Equal("../", r3.ToString());
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(1, r3.ParentDirectoryCount);
+            Assert.AreEqual("../", r3.ToString());
         }
         // "a/" - "a/" = ""
         {
             var r1 = (RelativePath)"a/";
             var r2 = (RelativePath)"a/";
             var r3 = r1 - r2;
-            Assert.NotNull(r3);
-            Assert.Equal(0, r3.ParentDirectoryCount);
-            Assert.Equal("", r3.ToString());
-            Assert.Same(RelativePath.Empty, r3);
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(0, r3.ParentDirectoryCount);
+            Assert.AreEqual("", r3.ToString());
+            Assert.AreSame(RelativePath.Empty, r3);
         }
         // "" - "" = ""
         {
             var r1 = (RelativePath)"";
             var r2 = (RelativePath)"";
             var r3 = r1 - r2;
-            Assert.NotNull(r3);
-            Assert.Equal(0, r3.ParentDirectoryCount);
-            Assert.Equal("", r3.ToString());
-            Assert.Same(RelativePath.Empty, r1);
-            Assert.Same(RelativePath.Empty, r2);
-            Assert.Same(RelativePath.Empty, r3);
+            Assert.IsNotNull(r3);
+            Assert.AreEqual(0, r3.ParentDirectoryCount);
+            Assert.AreEqual("", r3.ToString());
+            Assert.AreSame(RelativePath.Empty, r1);
+            Assert.AreSame(RelativePath.Empty, r2);
+            Assert.AreSame(RelativePath.Empty, r3);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestRelativePathRebase()
     {
         // a/b/c.txt rebase from x/y.txt to d/e.txt = ../x/a/b/c.txt
@@ -347,91 +346,91 @@ public void TestRelativePathRebase()
             var from = (RelativePath)"x/y.txt";
             var to = (RelativePath)"d/e.txt";
             var r2 = r1.Rebase(from, to);
-            Assert.NotNull(r2);
-            Assert.Equal(1, r2.ParentDirectoryCount);
-            Assert.Equal("../x/a/b/c.txt", r2.ToString());
+            Assert.IsNotNull(r2);
+            Assert.AreEqual(1, r2.ParentDirectoryCount);
+            Assert.AreEqual("../x/a/b/c.txt", r2.ToString());
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestRelativePathFromWorkingFolder()
     {
         {
             var s = "~/";
             var r = (RelativePath)s;
-            Assert.NotNull(r);
-            Assert.True(r.IsFromWorkingFolder());
-            Assert.Equal(0, r.ParentDirectoryCount);
-            Assert.Equal(s, r.ToString());
-            Assert.Equal(s, r);
-            Assert.Same(RelativePath.WorkingFolder, r);
+            Assert.IsNotNull(r);
+            Assert.IsTrue(r.IsFromWorkingFolder());
+            Assert.AreEqual(0, r.ParentDirectoryCount);
+            Assert.AreEqual(s, r.ToString());
+            Assert.AreEqual(s, r);
+            Assert.AreSame(RelativePath.WorkingFolder, r);
         }
         {
             var s = "~/../a.txt";
             var r = (RelativePath)s;
-            Assert.NotNull(r);
-            Assert.True(r.IsFromWorkingFolder());
-            Assert.Equal(1, r.ParentDirectoryCount);
-            Assert.Equal(s, r.ToString());
-            Assert.Equal(s, r);
+            Assert.IsNotNull(r);
+            Assert.IsTrue(r.IsFromWorkingFolder());
+            Assert.AreEqual(1, r.ParentDirectoryCount);
+            Assert.AreEqual(s, r.ToString());
+            Assert.AreEqual(s, r);
         }
         {
             var s = "~/a.dir/";
             var r = (RelativePath)s;
-            Assert.NotNull(r);
-            Assert.True(r.IsFromWorkingFolder());
-            Assert.Equal(0, r.ParentDirectoryCount);
-            Assert.Equal(s, r.ToString());
-            Assert.Equal(s, r);
+            Assert.IsNotNull(r);
+            Assert.IsTrue(r.IsFromWorkingFolder());
+            Assert.AreEqual(0, r.ParentDirectoryCount);
+            Assert.AreEqual(s, r.ToString());
+            Assert.AreEqual(s, r);
         }
     }
 
-    [Theory]
-    [InlineData("a/b/c", "a/b/c")]
-    [InlineData("../a/b/c", "../a/b/c")]
-    [InlineData("a/b/c d", "a/b/c%20d")]
-    [InlineData("../a+b/c/d", "../a%2Bb/c/d")]
-    [InlineData("a%3fb", "a%253fb")]
+    [TestMethod]
+    [DataRow("a/b/c", "a/b/c")]
+    [DataRow("../a/b/c", "../a/b/c")]
+    [DataRow("a/b/c d", "a/b/c%20d")]
+    [DataRow("../a+b/c/d", "../a%2Bb/c/d")]
+    [DataRow("a%3fb", "a%253fb")]
     public void TestUrlEncode(string path, string expected)
     {
-        Assert.Equal(expected, ((RelativePath)path).UrlEncode());
+        Assert.AreEqual(expected, ((RelativePath)path).UrlEncode());
     }
 
-    [Theory]
-    [InlineData("a/b/c", "a/b/c")]
-    [InlineData("../a/b/c", "../a/b/c")]
-    [InlineData("a/b/c%20d", "a/b/c d")]
-    [InlineData("../a%2Bb/c/d", "../a+b/c/d")]
-    [InlineData("a%253fb", "a%3fb")]
-    [InlineData("a%2fb", "a%2fb")]
-    [InlineData("%2A%2F%3A%3F%5C", "%2A%2F%3A%3F%5C")] //*/:?\
-    [InlineData("%2a%2f%3a%3f%5c", "%2a%2f%3a%3f%5c")]
+    [TestMethod]
+    [DataRow("a/b/c", "a/b/c")]
+    [DataRow("../a/b/c", "../a/b/c")]
+    [DataRow("a/b/c%20d", "a/b/c d")]
+    [DataRow("../a%2Bb/c/d", "../a+b/c/d")]
+    [DataRow("a%253fb", "a%3fb")]
+    [DataRow("a%2fb", "a%2fb")]
+    [DataRow("%2A%2F%3A%3F%5C", "%2A%2F%3A%3F%5C")] //*/:?\
+    [DataRow("%2a%2f%3a%3f%5c", "%2a%2f%3a%3f%5c")]
     public void TestUrlDecode(string path, string expected)
     {
-        Assert.Equal(expected, ((RelativePath)path).UrlDecode());
+        Assert.AreEqual(expected, ((RelativePath)path).UrlDecode());
     }
 
-    [Theory]
-    [InlineData("a/b/c", "a/b/", true)]
-    [InlineData("~/a/b/c", "~/a/b/", true)]
-    [InlineData("a/b/c", "~/a/b/", false)]
-    [InlineData("~/a/b/c", "a/b/", false)]
-    [InlineData("a/b", "a/b", false)]
-    [InlineData("a/b/", "a/b", false)]
-    [InlineData("a/b", "a/b/", false)]
-    [InlineData("a/b/", "a/b/", true)]
-    [InlineData("a/b/c", "a/b/c", false)]
-    [InlineData("a/b/c", "a/b/c/d", false)]
-    [InlineData("a/b/c", "a/b/d", false)]
-    [InlineData("a/../b/c", "b/", true)]
-    [InlineData("../a/b", "../a", false)]
-    [InlineData("../a/b", "../", false)]
-    [InlineData("../a/b", "../../a", false)]
-    [InlineData("../../", "../", false)]
-    [InlineData("../", "../../", false)]
-    [InlineData("~/a/b", "~/../", false)]
+    [TestMethod]
+    [DataRow("a/b/c", "a/b/", true)]
+    [DataRow("~/a/b/c", "~/a/b/", true)]
+    [DataRow("a/b/c", "~/a/b/", false)]
+    [DataRow("~/a/b/c", "a/b/", false)]
+    [DataRow("a/b", "a/b", false)]
+    [DataRow("a/b/", "a/b", false)]
+    [DataRow("a/b", "a/b/", false)]
+    [DataRow("a/b/", "a/b/", true)]
+    [DataRow("a/b/c", "a/b/c", false)]
+    [DataRow("a/b/c", "a/b/c/d", false)]
+    [DataRow("a/b/c", "a/b/d", false)]
+    [DataRow("a/../b/c", "b/", true)]
+    [DataRow("../a/b", "../a", false)]
+    [DataRow("../a/b", "../", false)]
+    [DataRow("../a/b", "../../a", false)]
+    [DataRow("../../", "../", false)]
+    [DataRow("../", "../../", false)]
+    [DataRow("~/a/b", "~/../", false)]
     public void TestStartsWith(string source, string dest, bool isStartsWith)
     {
-        Assert.Equal(isStartsWith, ((RelativePath)source).InDirectory((RelativePath)dest));
+        Assert.AreEqual(isStartsWith, ((RelativePath)source).InDirectory((RelativePath)dest));
     }
 }
diff --git a/test/Docfx.Common.Tests/UriUtilityTest.cs b/test/Docfx.Common.Tests/UriUtilityTest.cs
index de4493ba204..81412f66e71 100644
--- a/test/Docfx.Common.Tests/UriUtilityTest.cs
+++ b/test/Docfx.Common.Tests/UriUtilityTest.cs
@@ -1,45 +1,44 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.Common.Tests;
 
+[TestClass]
 public class UriUtilityTest
 {
-    [InlineData("", "", "", "", "", "")]
-    [InlineData("abc", "abc", "", "", "", "abc")]
-    [InlineData("abc#def", "abc", "", "#def", "#def", "abc")]
-    [InlineData("#def", "", "", "#def", "#def", "")]
-    [InlineData("abc?def=ghi", "abc", "?def=ghi", "", "?def=ghi", "abc?def=ghi")]
-    [InlineData("?def=ghi", "", "?def=ghi", "", "?def=ghi", "?def=ghi")]
-    [InlineData("abc?def=ghi#jkl", "abc", "?def=ghi", "#jkl", "?def=ghi#jkl", "abc?def=ghi")]
-    [InlineData("?def=ghi#jkl", "", "?def=ghi", "#jkl", "?def=ghi#jkl", "?def=ghi")]
-    [InlineData("a#b#c", "a", "", "#b#c", "#b#c", "a")]
-    [Theory]
+    [DataRow("", "", "", "", "", "")]
+    [DataRow("abc", "abc", "", "", "", "abc")]
+    [DataRow("abc#def", "abc", "", "#def", "#def", "abc")]
+    [DataRow("#def", "", "", "#def", "#def", "")]
+    [DataRow("abc?def=ghi", "abc", "?def=ghi", "", "?def=ghi", "abc?def=ghi")]
+    [DataRow("?def=ghi", "", "?def=ghi", "", "?def=ghi", "?def=ghi")]
+    [DataRow("abc?def=ghi#jkl", "abc", "?def=ghi", "#jkl", "?def=ghi#jkl", "abc?def=ghi")]
+    [DataRow("?def=ghi#jkl", "", "?def=ghi", "#jkl", "?def=ghi#jkl", "?def=ghi")]
+    [DataRow("a#b#c", "a", "", "#b#c", "#b#c", "a")]
+    [TestMethod]
     public void TestUriUtility(string input, string path, string queryString, string fragment, string queryStringAndFragment, string nonFragment)
     {
-        Assert.Equal(path, UriUtility.GetPath(input));
-        Assert.Equal(queryString, UriUtility.GetQueryString(input));
-        Assert.Equal(fragment, UriUtility.GetFragment(input));
-        Assert.Equal(queryStringAndFragment, UriUtility.GetQueryStringAndFragment(input));
-        Assert.Equal(nonFragment, UriUtility.GetNonFragment(input));
+        Assert.AreEqual(path, UriUtility.GetPath(input));
+        Assert.AreEqual(queryString, UriUtility.GetQueryString(input));
+        Assert.AreEqual(fragment, UriUtility.GetFragment(input));
+        Assert.AreEqual(queryStringAndFragment, UriUtility.GetQueryStringAndFragment(input));
+        Assert.AreEqual(nonFragment, UriUtility.GetNonFragment(input));
     }
 
-    [InlineData("#target", "#source", "#source")]
-    [InlineData("", "#source", "#source")]
-    [InlineData("#target", "", "#target")]
-    [InlineData("", "", "")]
-    [InlineData("?a=1#target", "?b=2#source", "?a=1&b=2#source")]
-    [InlineData("?a=1&c=11#target", "?b=2&c=22#source", "?a=1&c=22&b=2#source")]
-    [InlineData("?a=1", "#fragment", "?a=1#fragment")]
-    [InlineData("#fragment", "?a=1", "?a=1#fragment")]
-    [InlineData("a.html", "b.html", "b.html")]
-    [InlineData("a.html?a=1&c=11#target", "b.html?b=2&c=22#source", "b.html?a=1&c=22&b=2#source")]
-    [InlineData("a.html?a=1&c=11#target", "?b=2&c=22#source", "a.html?a=1&c=22&b=2#source")]
-    [Theory]
+    [DataRow("#target", "#source", "#source")]
+    [DataRow("", "#source", "#source")]
+    [DataRow("#target", "", "#target")]
+    [DataRow("", "", "")]
+    [DataRow("?a=1#target", "?b=2#source", "?a=1&b=2#source")]
+    [DataRow("?a=1&c=11#target", "?b=2&c=22#source", "?a=1&c=22&b=2#source")]
+    [DataRow("?a=1", "#fragment", "?a=1#fragment")]
+    [DataRow("#fragment", "?a=1", "?a=1#fragment")]
+    [DataRow("a.html", "b.html", "b.html")]
+    [DataRow("a.html?a=1&c=11#target", "b.html?b=2&c=22#source", "b.html?a=1&c=22&b=2#source")]
+    [DataRow("a.html?a=1&c=11#target", "?b=2&c=22#source", "a.html?a=1&c=22&b=2#source")]
+    [TestMethod]
     public void TestMergeHref(string target, string source, string expected)
     {
-        Assert.Equal(expected, UriUtility.MergeHref(target, source));
+        Assert.AreEqual(expected, UriUtility.MergeHref(target, source));
     }
 }
diff --git a/test/Docfx.Common.Tests/YamlDeserializerWithFallbackTest.cs b/test/Docfx.Common.Tests/YamlDeserializerWithFallbackTest.cs
index db587edaf93..8aac741536e 100644
--- a/test/Docfx.Common.Tests/YamlDeserializerWithFallbackTest.cs
+++ b/test/Docfx.Common.Tests/YamlDeserializerWithFallbackTest.cs
@@ -1,41 +1,42 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
 using YamlDotNet.Core;
 
 namespace Docfx.Common.Tests;
 
+[TestClass]
 public class YamlDeserializerWithFallbackTest
 {
-    [Fact]
+    [TestMethod]
     public void TestYamlDeserializerWithFallback()
     {
         var deserializer = YamlDeserializerWithFallback.Create<string>()
             .WithFallback<List<string>>();
         {
             var obj = deserializer.Deserialize(() => new StringReader("A"));
-            Assert.NotNull(obj);
-            var a = Assert.IsType<string>(obj);
-            Assert.Equal("A", a);
+            Assert.IsNotNull(obj);
+            Assert.IsInstanceOfType<string>(obj);
+            Assert.AreEqual("A", (string)obj);
         }
         {
             var obj = deserializer.Deserialize(() => new StringReader(@"- A
 - B"));
-            Assert.NotNull(obj);
-            var a = Assert.IsType<List<string>>(obj);
-            Assert.Equal("A", a[0]);
-            Assert.Equal("B", a[1]);
+            Assert.IsNotNull(obj);
+            Assert.IsInstanceOfType<List<string>>(obj);
+            var a = (List<string>)obj;
+            Assert.AreEqual("A", a[0]);
+            Assert.AreEqual("B", a[1]);
         }
         {
             var ex = Assert.Throws<YamlException>(() => deserializer.Deserialize(() => new StringReader(@"- A
 - A: abc")));
-            Assert.Equal(2, ex.Start.Line);
-            Assert.Equal(3, ex.Start.Column);
+            Assert.AreEqual(2, ex.Start.Line);
+            Assert.AreEqual(3, ex.Start.Column);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestYamlDeserializerWithFallback_MultiFallback()
     {
         var deserializer = YamlDeserializerWithFallback.Create<int>()
@@ -43,29 +44,30 @@ public void TestYamlDeserializerWithFallback_MultiFallback()
             .WithFallback<string[]>();
         {
             var obj = deserializer.Deserialize(() => new StringReader("1"));
-            Assert.NotNull(obj);
-            var a = Assert.IsType<int>(obj);
-            Assert.Equal(1, a);
+            Assert.IsNotNull(obj);
+            Assert.IsInstanceOfType<int>(obj);
+            Assert.AreEqual(1, (int)obj);
         }
         {
             var obj = deserializer.Deserialize(() => new StringReader("A"));
-            Assert.NotNull(obj);
-            var a = Assert.IsType<string>(obj);
-            Assert.Equal("A", a);
+            Assert.IsNotNull(obj);
+            Assert.IsInstanceOfType<string>(obj);
+            Assert.AreEqual("A", (string)obj);
         }
         {
             var obj = deserializer.Deserialize(() => new StringReader(@"- A
 - B"));
-            Assert.NotNull(obj);
-            var a = Assert.IsType<string[]>(obj);
-            Assert.Equal("A", a[0]);
-            Assert.Equal("B", a[1]);
+            Assert.IsNotNull(obj);
+            Assert.IsInstanceOfType<string[]>(obj);
+            var a = (string[])obj;
+            Assert.AreEqual("A", a[0]);
+            Assert.AreEqual("B", a[1]);
         }
         {
             var ex = Assert.Throws<YamlException>(() => deserializer.Deserialize(() => new StringReader(@"- A
 - A: abc")));
-            Assert.Equal(2, ex.Start.Line);
-            Assert.Equal(3, ex.Start.Column);
+            Assert.AreEqual(2, ex.Start.Line);
+            Assert.AreEqual(3, ex.Start.Column);
         }
     }
 }
diff --git a/test/Docfx.Common.Tests/YamlSerializationTest.cs b/test/Docfx.Common.Tests/YamlSerializationTest.cs
index 74fb179a5c3..434377991a4 100644
--- a/test/Docfx.Common.Tests/YamlSerializationTest.cs
+++ b/test/Docfx.Common.Tests/YamlSerializationTest.cs
@@ -4,55 +4,55 @@
 using System.Collections.Immutable;
 using System.Collections.ObjectModel;
 using Docfx.YamlSerialization;
-using Xunit;
 using YamlDotNet.Core;
 
 namespace Docfx.Common.Tests;
 
+[TestClass]
 public class YamlSerializationTest
 {
-    [Theory]
-    [InlineData(" Add --globalMetadata, --globalMetadataFile and --fileMetadataFile\n")]
-    [InlineData("\r\n Hello\n")]
-    [InlineData("  \r\n Hello\n")]
-    [InlineData("True")]
-    [InlineData("true")]
-    [InlineData("TRUE")]
-    [InlineData("False")]
-    [InlineData("false")]
-    [InlineData("FALSE")]
-    [InlineData("Null")]
-    [InlineData("null")]
-    [InlineData("NULL")]
+    [TestMethod]
+    [DataRow(" Add --globalMetadata, --globalMetadataFile and --fileMetadataFile\n")]
+    [DataRow("\r\n Hello\n")]
+    [DataRow("  \r\n Hello\n")]
+    [DataRow("True")]
+    [DataRow("true")]
+    [DataRow("TRUE")]
+    [DataRow("False")]
+    [DataRow("false")]
+    [DataRow("FALSE")]
+    [DataRow("Null")]
+    [DataRow("null")]
+    [DataRow("NULL")]
     public void TestObjectWithStringProperty(string input)
     {
         var sw = new StringWriter();
         YamlUtility.Serialize(sw, new BasicClass { C = input });
         var yaml = sw.ToString();
         var value = YamlUtility.Deserialize<BasicClass>(new StringReader(yaml));
-        Assert.NotNull(value);
-        Assert.Equal(input, value.C);
+        Assert.IsNotNull(value);
+        Assert.AreEqual(input, value.C);
     }
 
-    [Theory]
-    [InlineData("123")]
-    [InlineData("1.23")]
-    [InlineData("0.123")]
-    [InlineData(".123")]
-    [InlineData("0.")]
-    [InlineData("-0.0")]
-    [InlineData(".5")]
-    [InlineData("+12e03")]
-    [InlineData("-2E+05")]
+    [TestMethod]
+    [DataRow("123")]
+    [DataRow("1.23")]
+    [DataRow("0.123")]
+    [DataRow(".123")]
+    [DataRow("0.")]
+    [DataRow("-0.0")]
+    [DataRow(".5")]
+    [DataRow("+12e03")]
+    [DataRow("-2E+05")]
     public void TestScalarLikeStringValueNeedDoubleQuoted(string input)
     {
         var sw = new StringWriter();
         YamlUtility.Serialize(sw, input);
         var yaml = sw.ToString();
-        Assert.Equal($"\"{input}\"", yaml.Trim());
+        Assert.AreEqual($"\"{input}\"", yaml.Trim());
     }
 
-    [Fact]
+    [TestMethod]
     public void TestNotWorkInYamlDotNet39()
     {
         const string Text = "😄";
@@ -60,60 +60,60 @@ public void TestNotWorkInYamlDotNet39()
         YamlUtility.Serialize(sw, new BasicClass { C = Text });
         var yaml = sw.ToString();
         var value = YamlUtility.Deserialize<BasicClass>(new StringReader(yaml));
-        Assert.NotNull(value);
-        Assert.Equal(Text, value.C);
+        Assert.IsNotNull(value);
+        Assert.AreEqual(Text, value.C);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestBasicClass()
     {
         var sw = new StringWriter();
         YamlUtility.Serialize(sw, new BasicClass { B = 1, C = "Good!" }, YamlMime.YamlMimePrefix + "Test-Yaml-Mime");
         var yaml = sw.ToString();
-        Assert.Equal(@"### YamlMime:Test-Yaml-Mime
+        Assert.AreEqual(@"### YamlMime:Test-Yaml-Mime
 B: 1
 C: Good!
 ".Replace("\r\n", "\n"), yaml.Replace("\r\n", "\n"));
-        Assert.Equal("YamlMime:Test-Yaml-Mime", YamlMime.ReadMime(new StringReader(yaml)));
+        Assert.AreEqual("YamlMime:Test-Yaml-Mime", YamlMime.ReadMime(new StringReader(yaml)));
         var value = YamlUtility.Deserialize<BasicClass>(new StringReader(yaml));
-        Assert.NotNull(value);
-        Assert.Equal(1, value.B);
-        Assert.Equal("Good!", value.C);
+        Assert.IsNotNull(value);
+        Assert.AreEqual(1, value.B);
+        Assert.AreEqual("Good!", value.C);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestBasicClassWithNullCharacter()
     {
         var sw = new StringWriter();
         YamlUtility.Serialize(sw, new BasicClass { B = 1, C = "~" }, YamlMime.YamlMimePrefix + "Test-Yaml-Mime");
         var yaml = sw.ToString();
-        Assert.Equal(@"### YamlMime:Test-Yaml-Mime
+        Assert.AreEqual(@"### YamlMime:Test-Yaml-Mime
 B: 1
 C: ""~""
 ".Replace("\r\n", "\n"), yaml.Replace("\r\n", "\n"));
-        Assert.Equal("YamlMime:Test-Yaml-Mime", YamlMime.ReadMime(new StringReader(yaml)));
+        Assert.AreEqual("YamlMime:Test-Yaml-Mime", YamlMime.ReadMime(new StringReader(yaml)));
         var value = YamlUtility.Deserialize<BasicClass>(new StringReader(yaml));
-        Assert.NotNull(value);
-        Assert.Equal(1, value.B);
-        Assert.Equal("~", value.C);
+        Assert.IsNotNull(value);
+        Assert.AreEqual(1, value.B);
+        Assert.AreEqual("~", value.C);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestBoolean()
     {
         var sw = new StringWriter();
         YamlUtility.Serialize(sw, new object[] { true, false }, YamlMime.YamlMimePrefix + "Test-Yaml-Mime");
         var yaml = sw.ToString();
-        Assert.Equal(@"### YamlMime:Test-Yaml-Mime
+        Assert.AreEqual(@"### YamlMime:Test-Yaml-Mime
 - true
 - false
 ".Replace("\r\n", "\n"), yaml.Replace("\r\n", "\n"));
-        Assert.Equal("YamlMime:Test-Yaml-Mime", YamlMime.ReadMime(new StringReader(yaml)));
+        Assert.AreEqual("YamlMime:Test-Yaml-Mime", YamlMime.ReadMime(new StringReader(yaml)));
         var value = YamlUtility.Deserialize<object[]>(new StringReader(yaml));
-        Assert.NotNull(value);
-        Assert.Equal(2, value.Length);
-        Assert.Equal(true, value[0]);
-        Assert.Equal(false, value[1]);
+        Assert.IsNotNull(value);
+        Assert.AreEqual(2, value.Length);
+        Assert.AreEqual(true, value[0]);
+        Assert.AreEqual(false, value[1]);
         var value2 = YamlUtility.Deserialize<object[]>(new StringReader(@"### YamlMime:Test-Yaml-Mime
 - true
 - True
@@ -122,51 +122,51 @@ public void TestBoolean()
 - False
 - FALSE
 "));
-        Assert.NotNull(value2);
-        Assert.Equal(new[] { true, true, true, false, false, false }, value2.Cast<bool>());
+        Assert.IsNotNull(value2);
+        CollectionAssert.AreEqual(new[] { true, true, true, false, false, false }, value2.Cast<bool>().ToArray());
     }
 
-    [Fact]
+    [TestMethod]
     public void TestBigInteger()
     {
         var sw = new StringWriter();
         YamlUtility.Serialize(sw, new object[] { 1234567890000L, 9876543210000L, long.MaxValue, ulong.MaxValue }, YamlMime.YamlMimePrefix + "Test-Yaml-Mime");
         var yaml = sw.ToString();
-        Assert.Equal(@"### YamlMime:Test-Yaml-Mime
+        Assert.AreEqual(@"### YamlMime:Test-Yaml-Mime
 - 1234567890000
 - 9876543210000
 - 9223372036854775807
 - 18446744073709551615
 ".Replace("\r\n", "\n"), yaml.Replace("\r\n", "\n"));
-        Assert.Equal("YamlMime:Test-Yaml-Mime", YamlMime.ReadMime(new StringReader(yaml)));
+        Assert.AreEqual("YamlMime:Test-Yaml-Mime", YamlMime.ReadMime(new StringReader(yaml)));
         var value = YamlUtility.Deserialize<object[]>(new StringReader(yaml));
-        Assert.NotNull(value);
-        Assert.Equal(4, value.Length);
-        Assert.Equal(1234567890000L, value[0]);
-        Assert.Equal(9876543210000L, value[1]);
-        Assert.Equal(long.MaxValue, value[2]);
-        Assert.Equal(ulong.MaxValue, value[3]);
+        Assert.IsNotNull(value);
+        Assert.AreEqual(4, value.Length);
+        Assert.AreEqual(1234567890000L, value[0]);
+        Assert.AreEqual(9876543210000L, value[1]);
+        Assert.AreEqual(long.MaxValue, value[2]);
+        Assert.AreEqual(ulong.MaxValue, value[3]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestYamlMime_Success()
     {
         var sw = new StringWriter();
         YamlUtility.Serialize(sw, 1, YamlMime.YamlMimePrefix + "Test-Yaml-Mime");
         var yaml = sw.ToString();
-        Assert.Equal("YamlMime:Test-Yaml-Mime", YamlMime.ReadMime(new StringReader(yaml)));
+        Assert.AreEqual("YamlMime:Test-Yaml-Mime", YamlMime.ReadMime(new StringReader(yaml)));
     }
 
-    [Fact]
+    [TestMethod]
     public void TestYamlMime_NoYamlMime()
     {
         var sw = new StringWriter();
         YamlUtility.Serialize(sw, 1, "No-Yaml-Mime");
         var yaml = sw.ToString();
-        Assert.Null(YamlMime.ReadMime(new StringReader(yaml)));
+        Assert.IsNull(YamlMime.ReadMime(new StringReader(yaml)));
     }
 
-    [Fact]
+    [TestMethod]
     public void TestListOfBasicClass()
     {
         var sw = new StringWriter();
@@ -176,12 +176,12 @@ public void TestListOfBasicClass()
              select new BasicClass { B = i, C = $"Good{i}!" }).ToList());
         var yaml = sw.ToString();
         var values = YamlUtility.Deserialize<List<BasicClass>>(new StringReader(yaml));
-        Assert.NotNull(values);
-        Assert.Equal(10, values.Count);
+        Assert.IsNotNull(values);
+        Assert.AreEqual(10, values.Count);
         for (int i = 0; i < values.Count; i++)
         {
-            Assert.Equal(i, values[i].B);
-            Assert.Equal($"Good{i}!", values[i].C);
+            Assert.AreEqual(i, values[i].B);
+            Assert.AreEqual($"Good{i}!", values[i].C);
         }
     }
 
@@ -191,7 +191,7 @@ public class BasicClass
         public string C { get; set; }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestClassWithExtensibleMembersBySerializeThenDeserialize()
     {
         var sw = new StringWriter();
@@ -218,7 +218,7 @@ public void TestClassWithExtensibleMembersBySerializeThenDeserialize()
                 }
             });
         var yaml = sw.ToString();
-        Assert.Equal(@"B: 1
+        Assert.AreEqual(@"B: 1
 C: Good!
 s.a: aaa
 s.b: bbb
@@ -229,21 +229,21 @@ public void TestClassWithExtensibleMembersBySerializeThenDeserialize()
 bar: bar
 ".Replace("\r\n", "\n"), yaml.Replace("\r\n", "\n"));
         var value = YamlUtility.Deserialize<ClassWithExtensibleMembers>(new StringReader(yaml));
-        Assert.NotNull(value);
-        Assert.Equal(1, value.B);
-        Assert.Equal("Good!", value.C);
-        Assert.Equal(2, value.StringExtensions.Count);
-        Assert.Equal("aaa", value.StringExtensions["a"]);
-        Assert.Equal("bbb", value.StringExtensions["b"]);
-        Assert.Equal(2, value.IntegerExtensions.Count);
-        Assert.Equal(1, value.IntegerExtensions["x"]);
-        Assert.Equal(2, value.IntegerExtensions["y"]);
-        Assert.Equal(2, value.ObjectExtensions.Count);
-        Assert.Equal(new[] { "foo1" }, (List<object>)value.ObjectExtensions["foo"]);
-        Assert.Equal("bar", (string)value.ObjectExtensions["bar"]);
+        Assert.IsNotNull(value);
+        Assert.AreEqual(1, value.B);
+        Assert.AreEqual("Good!", value.C);
+        Assert.AreEqual(2, value.StringExtensions.Count);
+        Assert.AreEqual("aaa", value.StringExtensions["a"]);
+        Assert.AreEqual("bbb", value.StringExtensions["b"]);
+        Assert.AreEqual(2, value.IntegerExtensions.Count);
+        Assert.AreEqual(1, value.IntegerExtensions["x"]);
+        Assert.AreEqual(2, value.IntegerExtensions["y"]);
+        Assert.AreEqual(2, value.ObjectExtensions.Count);
+        CollectionAssert.AreEqual(new[] { "foo1" }, ((List<object>)value.ObjectExtensions["foo"]).ToArray());
+        Assert.AreEqual("bar", (string)value.ObjectExtensions["bar"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestClassWithExtensibleMembersByDeserializeThenSerialize()
     {
         var yaml = @"B: 1
@@ -257,25 +257,25 @@ public void TestClassWithExtensibleMembersByDeserializeThenSerialize()
 bar: bar
 ".Replace("\r\n", "\n");
         var value = YamlUtility.Deserialize<ClassWithExtensibleMembers>(new StringReader(yaml));
-        Assert.NotNull(value);
-        Assert.Equal(1, value.B);
-        Assert.Equal("Good!", value.C);
-        Assert.Equal(2, value.StringExtensions.Count);
-        Assert.Equal("aaa", value.StringExtensions["a"]);
-        Assert.Equal("bbb", value.StringExtensions["b"]);
-        Assert.Equal(2, value.IntegerExtensions.Count);
-        Assert.Equal(1, value.IntegerExtensions["x"]);
-        Assert.Equal(2, value.IntegerExtensions["y"]);
-        Assert.Equal(2, value.ObjectExtensions.Count);
-        Assert.Equal(new[] { "foo1" }, (List<object>)value.ObjectExtensions["foo"]);
-        Assert.Equal("bar", (string)value.ObjectExtensions["bar"]);
+        Assert.IsNotNull(value);
+        Assert.AreEqual(1, value.B);
+        Assert.AreEqual("Good!", value.C);
+        Assert.AreEqual(2, value.StringExtensions.Count);
+        Assert.AreEqual("aaa", value.StringExtensions["a"]);
+        Assert.AreEqual("bbb", value.StringExtensions["b"]);
+        Assert.AreEqual(2, value.IntegerExtensions.Count);
+        Assert.AreEqual(1, value.IntegerExtensions["x"]);
+        Assert.AreEqual(2, value.IntegerExtensions["y"]);
+        Assert.AreEqual(2, value.ObjectExtensions.Count);
+        CollectionAssert.AreEqual(new[] { "foo1" }, ((List<object>)value.ObjectExtensions["foo"]).ToArray());
+        Assert.AreEqual("bar", (string)value.ObjectExtensions["bar"]);
 
         var sw = new StringWriter();
         YamlUtility.Serialize(sw, value);
-        Assert.Equal(yaml, sw.ToString().Replace("\r\n", "\n"));
+        Assert.AreEqual(yaml, sw.ToString().Replace("\r\n", "\n"));
     }
 
-    [Fact]
+    [TestMethod]
     public void TestListOfClassWithExtensibleMembers()
     {
         var sw = new StringWriter();
@@ -304,21 +304,21 @@ public void TestListOfClassWithExtensibleMembers()
              }).ToList());
         var yaml = sw.ToString();
         var values = YamlUtility.Deserialize<List<ClassWithExtensibleMembers>>(new StringReader(yaml));
-        Assert.NotNull(values);
-        Assert.Equal(10, values.Count);
+        Assert.IsNotNull(values);
+        Assert.AreEqual(10, values.Count);
         for (int i = 0; i < values.Count; i++)
         {
-            Assert.Equal(i, values[i].B);
-            Assert.Equal($"Good{i}!", values[i].C);
-            Assert.Equal(2, values[i].StringExtensions.Count);
-            Assert.Equal($"aaa{i}", values[i].StringExtensions[$"a{i}"]);
-            Assert.Equal($"bbb{i}", values[i].StringExtensions[$"b{i}"]);
-            Assert.Equal(2, values[i].IntegerExtensions.Count);
-            Assert.Equal(i + 1, values[i].IntegerExtensions[$"x{i}"]);
-            Assert.Equal(i + 2, values[i].IntegerExtensions[$"y{i}"]);
-            Assert.Equal(2, values[i].ObjectExtensions.Count);
-            Assert.Equal(new[] { $"foo{i}" }, (List<object>)values[i].ObjectExtensions[$"foo{i}"]);
-            Assert.Equal($"bar{i}", (string)values[i].ObjectExtensions[$"bar{i}"]);
+            Assert.AreEqual(i, values[i].B);
+            Assert.AreEqual($"Good{i}!", values[i].C);
+            Assert.AreEqual(2, values[i].StringExtensions.Count);
+            Assert.AreEqual($"aaa{i}", values[i].StringExtensions[$"a{i}"]);
+            Assert.AreEqual($"bbb{i}", values[i].StringExtensions[$"b{i}"]);
+            Assert.AreEqual(2, values[i].IntegerExtensions.Count);
+            Assert.AreEqual(i + 1, values[i].IntegerExtensions[$"x{i}"]);
+            Assert.AreEqual(i + 2, values[i].IntegerExtensions[$"y{i}"]);
+            Assert.AreEqual(2, values[i].ObjectExtensions.Count);
+            CollectionAssert.AreEqual(new[] { $"foo{i}" }, ((List<object>)values[i].ObjectExtensions[$"foo{i}"]).ToArray());
+            Assert.AreEqual($"bar{i}", (string)values[i].ObjectExtensions[$"bar{i}"]);
         }
     }
 
@@ -332,7 +332,7 @@ public class ClassWithExtensibleMembers : BasicClass
         public Dictionary<string, object> ObjectExtensions { get; } = [];
     }
 
-    [Fact]
+    [TestMethod]
     public void TestInternalClass()
     {
         YamlUtility.Serialize(new StringWriter(), new InternalClass { });
@@ -344,7 +344,7 @@ internal class InternalClass
         public string A { get; set; }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestClassWithInvalidExtensibleMember()
     {
         Assert.Throws<YamlException>(() => YamlUtility.Serialize(new StringWriter(), new ClassWithInvalidExtensibleMember { }));
@@ -358,7 +358,7 @@ public class ClassWithInvalidExtensibleMember
         public string StringExtensions { get; set; }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestClassWithInterfaceMember()
     {
         var sw = new StringWriter();
@@ -373,7 +373,7 @@ public void TestClassWithInterfaceMember()
             ReadOnlyDictionary = new SortedDictionary<string, string> { ["k2"] = "v2" },
             Set = new SortedSet<string> { "s" },
         });
-        Assert.Equal(@"List:
+        Assert.AreEqual(@"List:
 - a
 ReadOnlyList:
 - b
@@ -392,23 +392,23 @@ public void TestClassWithInterfaceMember()
 ".Replace("\r\n", "\n"), sw.ToString().Replace("\r\n", "\n"));
 
         var obj = YamlUtility.Deserialize<ClassWithInterfaceMember>(new StringReader(sw.ToString()));
-        Assert.NotNull(obj);
-        Assert.Single(obj.List);
-        Assert.Equal("a", obj.List[0]);
-        Assert.Single(obj.ReadOnlyList);
-        Assert.Equal("b", obj.ReadOnlyList[0]);
-        Assert.Single(obj.Collection);
-        Assert.Equal("c", obj.Collection.First());
-        Assert.Single(obj.ReadOnlyCollection);
-        Assert.Equal("d", obj.ReadOnlyCollection.First());
-        Assert.Single(obj.Enumerable);
-        Assert.Equal(1, obj.Enumerable.First());
-        Assert.Single(obj.Dictionary);
-        Assert.Equal(new KeyValuePair<string, string>("k1", "v1"), obj.Dictionary.First());
-        Assert.Single(obj.ReadOnlyDictionary);
-        Assert.Equal(new KeyValuePair<string, string>("k2", "v2"), obj.ReadOnlyDictionary.First());
-        Assert.Single(obj.Set);
-        Assert.Equal("s", obj.Set.First());
+        Assert.IsNotNull(obj);
+        Assert.ContainsSingle(obj.List);
+        Assert.AreEqual("a", obj.List[0]);
+        Assert.ContainsSingle(obj.ReadOnlyList);
+        Assert.AreEqual("b", obj.ReadOnlyList[0]);
+        Assert.ContainsSingle(obj.Collection);
+        Assert.AreEqual("c", obj.Collection.First());
+        Assert.ContainsSingle(obj.ReadOnlyCollection);
+        Assert.AreEqual("d", obj.ReadOnlyCollection.First());
+        Assert.ContainsSingle(obj.Enumerable);
+        Assert.AreEqual(1, obj.Enumerable.First());
+        Assert.ContainsSingle(obj.Dictionary);
+        Assert.AreEqual(new KeyValuePair<string, string>("k1", "v1"), obj.Dictionary.First());
+        Assert.ContainsSingle(obj.ReadOnlyDictionary);
+        Assert.AreEqual(new KeyValuePair<string, string>("k2", "v2"), obj.ReadOnlyDictionary.First());
+        Assert.ContainsSingle(obj.Set);
+        Assert.AreEqual("s", obj.Set.First());
     }
 
     public class ClassWithInterfaceMember
diff --git a/test/Docfx.Dotnet.Tests/ApiFilterUnitTest.cs b/test/Docfx.Dotnet.Tests/ApiFilterUnitTest.cs
index 0a1f3a32b08..955decae218 100644
--- a/test/Docfx.Dotnet.Tests/ApiFilterUnitTest.cs
+++ b/test/Docfx.Dotnet.Tests/ApiFilterUnitTest.cs
@@ -2,17 +2,17 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.CodeAnalysis;
-using Xunit;
 
 namespace Docfx.Dotnet.Tests;
 
-[Trait("Related", "Filter")]
-[Collection("docfx STA")]
+[TestProperty("Related", "Filter")]
+[DoNotParallelize]
+[TestClass]
 public class ApiFilterUnitTest
 {
     private static readonly Dictionary<string, string> EmptyMSBuildProperties = [];
 
-    [Fact]
+    [TestMethod]
     public void TestApiFilter()
     {
         string code = @"
@@ -115,40 +115,40 @@ public EnumDisplayAttribute(string description = null)
 ";
         string configFile = "TestData/filterconfig.yml";
         MetadataItem output = Verify(code, new() { FilterConfigFile = configFile });
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var @namespace = output.Items[0];
-        Assert.NotNull(@namespace);
-        Assert.Equal("Test1", @namespace.Name);
-        Assert.Equal(5, @namespace.Items.Count);
+        Assert.IsNotNull(@namespace);
+        Assert.AreEqual("Test1", @namespace.Name);
+        Assert.AreEqual(5, @namespace.Items.Count);
         {
             var class1 = @namespace.Items[0];
-            Assert.Equal("Test1.Class1", class1.Name);
-            Assert.Single(class1.Items);
+            Assert.AreEqual("Test1.Class1", class1.Name);
+            Assert.ContainsSingle(class1.Items);
             var method = class1.Items[0];
-            Assert.Equal("Test1.Class1.Func1(System.Int32)", method.Name);
+            Assert.AreEqual("Test1.Class1.Func1(System.Int32)", method.Name);
         }
         {
             var class3 = @namespace.Items[1];
-            Assert.Equal("Test1.Class3", class3.Name);
-            Assert.Equal(2, class3.Items.Count);
-            Assert.Equal("Test1.Class3.Func2", class3.Items[0].Name);
-            Assert.Equal("Test1.Class3.Func2(System.Int32)", class3.Items[1].Name);
+            Assert.AreEqual("Test1.Class3", class3.Name);
+            Assert.AreEqual(2, class3.Items.Count);
+            Assert.AreEqual("Test1.Class3.Func2", class3.Items[0].Name);
+            Assert.AreEqual("Test1.Class3.Func2(System.Int32)", class3.Items[1].Name);
         }
         {
             var class4 = @namespace.Items[2];
-            Assert.Equal("Test1.Class3.Class4", class4.Name);
-            Assert.Empty(class4.Items);
+            Assert.AreEqual("Test1.Class3.Class4", class4.Name);
+            Assert.IsEmpty(class4.Items);
         }
         {
             var class6 = @namespace.Items[3];
-            Assert.Equal("Test1.Class6", class6.Name);
-            Assert.Equal(2, class6.Items.Count);
-            Assert.Equal("Test1.Class6.D", class6.Items[0].Name);
-            Assert.Equal("Test1.Class6.Test(System.String)", class6.Items[1].Name);
+            Assert.AreEqual("Test1.Class6", class6.Name);
+            Assert.AreEqual(2, class6.Items.Count);
+            Assert.AreEqual("Test1.Class6.D", class6.Items[0].Name);
+            Assert.AreEqual("Test1.Class6.Test(System.String)", class6.Items[1].Name);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestAttributeFilter()
     {
         string code = @"
@@ -171,11 +171,11 @@ public void Func1(int i)
         MetadataItem output = Verify(code, new() { FilterConfigFile = configFile });
         var @namespace = output.Items[0];
         var class1 = @namespace.Items[0];
-        Assert.Single(class1.Attributes);
-        Assert.Equal("System.SerializableAttribute", class1.Attributes[0].Type);
+        Assert.ContainsSingle(class1.Attributes);
+        Assert.AreEqual("System.SerializableAttribute", class1.Attributes[0].Type);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestDefaultFilter()
     {
         string code = @"
@@ -203,13 +203,13 @@ public interface Interface1
 }";
         MetadataItem output = Verify(code);
         var @namespace = output.Items[0];
-        Assert.Single(@namespace.Items);
+        Assert.ContainsSingle(@namespace.Items);
         var class1 = @namespace.Items[0];
-        Assert.Single(class1.Attributes);
-        Assert.Equal("System.SerializableAttribute", class1.Attributes[0].Type);
+        Assert.ContainsSingle(class1.Attributes);
+        Assert.AreEqual("System.SerializableAttribute", class1.Attributes[0].Type);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestFilterBugIssue2547()
     {
         string code = @"using System;
@@ -240,11 +240,11 @@ public class Test2
 }";
         MetadataItem output = Verify(code);
         var @namespace = output.Items[0];
-        Assert.NotNull(@namespace);
-        Assert.Equal(3, @namespace.Items.Count);
+        Assert.IsNotNull(@namespace);
+        Assert.AreEqual(3, @namespace.Items.Count);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestSymbolFilterOptions()
     {
         var code = @"
@@ -273,16 +273,16 @@ interface IClass1 { }
 }";
         var output = Verify(code, new(), new() { IncludeApi = IncludeApi, IncludeAttribute = IncludeAttribute });
         var class1 = output.Items[0].Items[0];
-        Assert.Equal(
+        CollectionAssert.AreEqual(
             new[]
             {
                 "System.SerializableAttribute",
                 "System.Runtime.InteropServices.ComVisibleAttribute",
                 "Test1.A2",
             },
-            class1.Attributes.Select(a => a.Type));
-        Assert.Equal(new[] { "Test1.Class1.M2" }, class1.Items.Select(m => m.Name));
-        Assert.Equal(new[] { "System.Object" }, class1.Inheritance);
+            class1.Attributes.Select(a => a.Type).ToArray());
+        CollectionAssert.AreEqual(new[] { "Test1.Class1.M2" }, class1.Items.Select(m => m.Name).ToArray());
+        CollectionAssert.AreEqual(new[] { "System.Object" }, class1.Inheritance.ToArray());
 
         SymbolIncludeState IncludeAttribute(ISymbol symbol)
         {
@@ -304,7 +304,7 @@ SymbolIncludeState IncludeApi(ISymbol symbol)
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestExcludeInterface_ExcludesExplicitInterfaceImplementations()
     {
         var code = @"
@@ -326,10 +326,10 @@ public interface IClass1
             new() { IncludeApi = symbol => symbol.Name is "IClass1" ? SymbolIncludeState.Exclude : default });
 
         var class1 = output.Items[0].Items[0];
-        Assert.Empty(class1.Items);
+        Assert.IsEmpty(class1.Items);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestDocsSampleFilter()
     {
         var code = @"
@@ -350,27 +350,27 @@ public class NestedClass : Class1
         MetadataItem output = Verify(code, new() { FilterConfigFile = configFile });
 
         var namespaces = output.Items;
-        Assert.Single(namespaces);
+        Assert.ContainsSingle(namespaces);
 
         var @namespace = namespaces[0];
-        Assert.NotNull(@namespace);
-        Assert.Equal("Microsoft.DevDiv.SpecialCase", @namespace.Name);
-        Assert.Single(@namespace.Items);
+        Assert.IsNotNull(@namespace);
+        Assert.AreEqual("Microsoft.DevDiv.SpecialCase", @namespace.Name);
+        Assert.ContainsSingle(@namespace.Items);
 
         var nestedClass = @namespace.Items[0];
-        Assert.Equal("Microsoft.DevDiv.SpecialCase.NestedClass", nestedClass.Name);
+        Assert.AreEqual("Microsoft.DevDiv.SpecialCase.NestedClass", nestedClass.Name);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestExtendedSymbolKindFlags()
     {
-        Assert.True((ExtendedSymbolKind.Type | ExtendedSymbolKind.Member).Contains(new SymbolFilterData { Kind = ExtendedSymbolKind.Interface }));
+        Assert.IsTrue((ExtendedSymbolKind.Type | ExtendedSymbolKind.Member).Contains(new SymbolFilterData { Kind = ExtendedSymbolKind.Interface }));
     }
 
     private static MetadataItem Verify(string code, ExtractMetadataConfig config = null, DotnetApiOptions options = null, IDictionary<string, string> msbuildProperties = null)
     {
         var compilation = CompilationHelper.CreateCompilationFromCSharpCode(code, msbuildProperties ?? EmptyMSBuildProperties, "test.dll");
-        Assert.Empty(compilation.GetDeclarationDiagnostics());
+        Assert.IsEmpty(compilation.GetDeclarationDiagnostics());
         return compilation.Assembly.GenerateMetadataItem(compilation, config, options);
     }
 }
diff --git a/test/Docfx.Dotnet.Tests/DefinitionMergeUnitTest.cs b/test/Docfx.Dotnet.Tests/DefinitionMergeUnitTest.cs
index d89ad42c991..be50336d894 100644
--- a/test/Docfx.Dotnet.Tests/DefinitionMergeUnitTest.cs
+++ b/test/Docfx.Dotnet.Tests/DefinitionMergeUnitTest.cs
@@ -1,13 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.Dotnet.Tests;
 
+[TestClass]
 public class DefinitionMergeUnitTest
 {
-    [Fact]
+    [TestMethod]
     public void InterfaceWithTemplateDoesNotCrash()
     {
         // arrange
@@ -35,6 +34,6 @@ public void Function<T>()
         var output = compilation.Assembly.GenerateMetadataItem(compilation);
 
         // assert
-        Assert.NotNull(output);
+        Assert.IsNotNull(output);
     }
 }
diff --git a/test/Docfx.Dotnet.Tests/GenerateMetadataFromAssemblyTest.cs b/test/Docfx.Dotnet.Tests/GenerateMetadataFromAssemblyTest.cs
index 9ef41b066c9..1d788b2ebe0 100644
--- a/test/Docfx.Dotnet.Tests/GenerateMetadataFromAssemblyTest.cs
+++ b/test/Docfx.Dotnet.Tests/GenerateMetadataFromAssemblyTest.cs
@@ -2,69 +2,69 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Docfx.DataContracts.ManagedReference;
-using Xunit;
 
 namespace Docfx.Dotnet.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class GenerateMetadataFromAssemblyTest
 {
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataFromAssembly()
     {
         {
             var (compilation, assembly) = CompilationHelper.CreateCompilationFromAssembly("TestData/CatLibrary.dll");
-            Assert.Empty(compilation.GetDeclarationDiagnostics());
+            Assert.IsEmpty(compilation.GetDeclarationDiagnostics());
 
             var output = assembly.GenerateMetadataItem(compilation);
             var @class = output.Items[0].Items[2];
-            Assert.NotNull(@class);
-            Assert.Equal("Cat<T, K>", @class.DisplayNames.First().Value);
-            Assert.Equal("Cat<T, K>", @class.DisplayNamesWithType.First().Value);
-            Assert.Equal("CatLibrary.Cat<T, K>", @class.DisplayQualifiedNames.First().Value);
+            Assert.IsNotNull(@class);
+            Assert.AreEqual("Cat<T, K>", @class.DisplayNames.First().Value);
+            Assert.AreEqual("Cat<T, K>", @class.DisplayNamesWithType.First().Value);
+            Assert.AreEqual("CatLibrary.Cat<T, K>", @class.DisplayQualifiedNames.First().Value);
         }
 
         {
             var (compilation, assembly) = CompilationHelper.CreateCompilationFromAssembly("TestData/CatLibrary2.dll");
-            Assert.Empty(compilation.GetDeclarationDiagnostics());
+            Assert.IsEmpty(compilation.GetDeclarationDiagnostics());
 
             var output = assembly.GenerateMetadataItem(compilation);
             var @class = output.Items[0].Items[0];
-            Assert.NotNull(@class);
-            Assert.Equal("CarLibrary2.Cat2", @class.Name);
-            Assert.Equal(new[] { "System.Object", "CatLibrary.Cat{CatLibrary.Dog{System.String},System.Int32}" }, @class.Inheritance);
+            Assert.IsNotNull(@class);
+            Assert.AreEqual("CarLibrary2.Cat2", @class.Name);
+            CollectionAssert.AreEqual(new[] { "System.Object", "CatLibrary.Cat{CatLibrary.Dog{System.String},System.Int32}" }, @class.Inheritance.ToArray());
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataFromAssemblyWithReferences()
     {
         var (compilation, assembly) = CompilationHelper.CreateCompilationFromAssembly("TestData/TupleLibrary.dll");
-        Assert.Empty(compilation.GetDeclarationDiagnostics());
+        Assert.IsEmpty(compilation.GetDeclarationDiagnostics());
 
         var output = assembly.GenerateMetadataItem(compilation);
         var @class = output.Items[0].Items[0];
-        Assert.NotNull(@class);
-        Assert.Equal("XmlTasks", @class.DisplayNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("XmlTasks", @class.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-        Assert.Equal("TupleLibrary.XmlTasks", @class.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(@class);
+        Assert.AreEqual("XmlTasks", @class.DisplayNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("XmlTasks", @class.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("TupleLibrary.XmlTasks", @class.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
 
         {
             var method = @class.Items.Single(i => i.Name == "TupleLibrary.XmlTasks.ToNamespace(System.String,System.String)");
-            Assert.Equal("ToNamespace(string, string)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("XmlTasks.ToNamespace(string, string)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("TupleLibrary.XmlTasks.ToNamespace(string, string)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("ToNamespace(string, string)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("XmlTasks.ToNamespace(string, string)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("TupleLibrary.XmlTasks.ToNamespace(string, string)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
 
-            Assert.Equal("public (string, string) ToNamespace(string prefix, string uri)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("public (string, string) ToNamespace(string prefix, string uri)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
 
         {
             var method = @class.Items.Single(i => i.Name == "TupleLibrary.XmlTasks.XmlPeek(System.String,System.ValueTuple{System.String,System.String}[])");
-            Assert.Equal("XmlPeek(string, params (string, string)[])", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("XmlTasks.XmlPeek(string, params (string, string)[])", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("TupleLibrary.XmlTasks.XmlPeek(string, params (string, string)[])", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("XmlPeek(string, params (string, string)[])", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("XmlTasks.XmlPeek(string, params (string, string)[])", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("TupleLibrary.XmlTasks.XmlPeek(string, params (string, string)[])", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
 
-            Assert.Equal("public string XmlPeek(string xpath, params (string, string)[] namespaces)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("public string XmlPeek(string xpath, params (string, string)[] namespaces)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 }
diff --git a/test/Docfx.Dotnet.Tests/GenerateMetadataFromCSUnitTest.cs b/test/Docfx.Dotnet.Tests/GenerateMetadataFromCSUnitTest.cs
index fbad40a99f4..b51da661c42 100644
--- a/test/Docfx.Dotnet.Tests/GenerateMetadataFromCSUnitTest.cs
+++ b/test/Docfx.Dotnet.Tests/GenerateMetadataFromCSUnitTest.cs
@@ -5,11 +5,11 @@
 using Docfx.DataContracts.ManagedReference;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Emit;
-using Xunit;
 
 namespace Docfx.Dotnet.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class GenerateMetadataFromCSUnitTest
 {
     private static readonly Dictionary<string, string> EmptyMSBuildProperties = [];
@@ -21,8 +21,8 @@ private static MetadataItem Verify(string code, ExtractMetadataConfig config = n
         return compilation.Assembly.GenerateMetadataItem(compilation, config, extensionMethods: extensionMethods);
     }
 
-    [Fact]
-    [Trait("Related", "Attribute")]
+    [TestMethod]
+    [TestProperty("Related", "Attribute")]
     public void TestGenerateMetadataAsyncWithFuncVoidReturn()
     {
         string code = @"
@@ -51,33 +51,33 @@ public void Func1(int i)
 ";
         MetadataItem output = Verify(code);
         var @class = output.Items[0].Items[0];
-        Assert.NotNull(@class);
-        Assert.Equal("Class1", @class.DisplayNames.First().Value);
-        Assert.Equal("Class1", @class.DisplayNamesWithType.First().Value);
-        Assert.Equal("Test1.Class1", @class.DisplayQualifiedNames.First().Value);
-        Assert.Equal("This is a test", @class.Summary);
-        Assert.Equal("Test1.Class1.Func1(System.Int32)", @class.SeeAlsos[0].LinkId);
-        Assert.Equal(@"[Serializable]
+        Assert.IsNotNull(@class);
+        Assert.AreEqual("Class1", @class.DisplayNames.First().Value);
+        Assert.AreEqual("Class1", @class.DisplayNamesWithType.First().Value);
+        Assert.AreEqual("Test1.Class1", @class.DisplayQualifiedNames.First().Value);
+        Assert.AreEqual("This is a test", @class.Summary);
+        Assert.AreEqual("Test1.Class1.Func1(System.Int32)", @class.SeeAlsos[0].LinkId);
+        Assert.AreEqual(@"[Serializable]
 public class Class1", @class.Syntax.Content[SyntaxLanguage.CSharp]);
 
         var function = output.Items[0].Items[0].Items[0];
-        Assert.NotNull(function);
-        Assert.Equal("Func1(int)", function.DisplayNames.First().Value);
-        Assert.Equal("Class1.Func1(int)", function.DisplayNamesWithType.First().Value);
-        Assert.Equal("Test1.Class1.Func1(int)", function.DisplayQualifiedNames.First().Value);
-        Assert.Equal("Test1.Class1.Func1(System.Int32)", function.Name);
-        Assert.Equal("This is a function", function.Summary);
-        Assert.Equal("System.Int32", function.SeeAlsos[0].LinkId);
-        Assert.Equal("This is a param as <xref href=\"System.Int32\" data-throw-if-not-resolved=\"false\"></xref>", function.Syntax.Parameters[0].Description);
-        Assert.Single(output.Items);
+        Assert.IsNotNull(function);
+        Assert.AreEqual("Func1(int)", function.DisplayNames.First().Value);
+        Assert.AreEqual("Class1.Func1(int)", function.DisplayNamesWithType.First().Value);
+        Assert.AreEqual("Test1.Class1.Func1(int)", function.DisplayQualifiedNames.First().Value);
+        Assert.AreEqual("Test1.Class1.Func1(System.Int32)", function.Name);
+        Assert.AreEqual("This is a function", function.Summary);
+        Assert.AreEqual("System.Int32", function.SeeAlsos[0].LinkId);
+        Assert.AreEqual("This is a param as <xref href=\"System.Int32\" data-throw-if-not-resolved=\"false\"></xref>", function.Syntax.Parameters[0].Description);
+        Assert.ContainsSingle(output.Items);
         var parameter = function.Syntax.Parameters[0];
-        Assert.Equal("i", parameter.Name);
-        Assert.Equal("System.Int32", parameter.Type);
+        Assert.AreEqual("i", parameter.Name);
+        Assert.AreEqual("System.Int32", parameter.Type);
         var returnValue = function.Syntax.Return;
-        Assert.Null(returnValue);
+        Assert.IsNull(returnValue);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataAsyncWithNamespace()
     {
         string code = @"
@@ -90,17 +90,17 @@ public class Class1
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
-        Assert.Equal("Test1.Test2", ns.DisplayNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("Test1.Test2", ns.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-        Assert.Equal("Test1.Test2", ns.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(ns);
+        Assert.AreEqual("Test1.Test2", ns.DisplayNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Test2", ns.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Test2", ns.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
     }
 
-    [Trait("Related", "Generic")]
-    [Trait("Related", "Reference")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestProperty("Related", "Reference")]
+    [TestMethod]
     public void TestGenerateMetadataWithGenericClass()
     {
         string code = @"
@@ -125,124 +125,124 @@ public sealed class Class1<T> where T : struct, IEnumerable<T>
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var type = output.Items[0].Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("Class1<T>", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Class1<T>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Class1<T>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Class1`1", type.Name);
-            Assert.Equal("public sealed class Class1<T> where T : struct, IEnumerable<T>", type.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.NotNull(type.Syntax.TypeParameters);
-            Assert.Single(type.Syntax.TypeParameters);
-            Assert.Equal("T", type.Syntax.TypeParameters[0].Name);
-            Assert.Null(type.Syntax.TypeParameters[0].Type);
-            Assert.Equal("The type", type.Syntax.TypeParameters[0].Description);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Class1<T>", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Class1<T>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Class1<T>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Class1`1", type.Name);
+            Assert.AreEqual("public sealed class Class1<T> where T : struct, IEnumerable<T>", type.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(type.Syntax.TypeParameters);
+            Assert.ContainsSingle(type.Syntax.TypeParameters);
+            Assert.AreEqual("T", type.Syntax.TypeParameters[0].Name);
+            Assert.IsNull(type.Syntax.TypeParameters[0].Type);
+            Assert.AreEqual("The type", type.Syntax.TypeParameters[0].Description);
         }
         {
             var function = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(function);
-            Assert.Equal("Func1<TResult>(T?, IEnumerable<T>)", function.DisplayNames.First().Value);
-            Assert.Equal("Class1<T>.Func1<TResult>(T?, IEnumerable<T>)", function.DisplayNamesWithType.First().Value);
-            Assert.Equal("Test1.Class1<T>.Func1<TResult>(T?, System.Collections.Generic.IEnumerable<T>)", function.DisplayQualifiedNames.First().Value);
-            Assert.Equal("Test1.Class1`1.Func1``1(System.Nullable{`0},System.Collections.Generic.IEnumerable{`0})", function.Name);
+            Assert.IsNotNull(function);
+            Assert.AreEqual("Func1<TResult>(T?, IEnumerable<T>)", function.DisplayNames.First().Value);
+            Assert.AreEqual("Class1<T>.Func1<TResult>(T?, IEnumerable<T>)", function.DisplayNamesWithType.First().Value);
+            Assert.AreEqual("Test1.Class1<T>.Func1<TResult>(T?, System.Collections.Generic.IEnumerable<T>)", function.DisplayQualifiedNames.First().Value);
+            Assert.AreEqual("Test1.Class1`1.Func1``1(System.Nullable{`0},System.Collections.Generic.IEnumerable{`0})", function.Name);
 
             var parameterX = function.Syntax.Parameters[0];
-            Assert.Equal("x", parameterX.Name);
-            Assert.Equal("System.Nullable{{T}}", parameterX.Type);
+            Assert.AreEqual("x", parameterX.Name);
+            Assert.AreEqual("System.Nullable{{T}}", parameterX.Type);
 
             var parameterY = function.Syntax.Parameters[1];
-            Assert.Equal("y", parameterY.Name);
-            Assert.Equal("System.Collections.Generic.IEnumerable{{T}}", parameterY.Type);
+            Assert.AreEqual("y", parameterY.Name);
+            Assert.AreEqual("System.Collections.Generic.IEnumerable{{T}}", parameterY.Type);
 
             var returnValue = function.Syntax.Return;
-            Assert.NotNull(returnValue);
-            Assert.NotNull(returnValue.Type);
-            Assert.Equal("System.Nullable{{TResult}}", returnValue.Type);
-            Assert.Equal("public TResult? Func1<TResult>(T? x, IEnumerable<T> y) where TResult : struct", function.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(returnValue);
+            Assert.IsNotNull(returnValue.Type);
+            Assert.AreEqual("System.Nullable{{TResult}}", returnValue.Type);
+            Assert.AreEqual("public TResult? Func1<TResult>(T? x, IEnumerable<T> y) where TResult : struct", function.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var property = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(property);
-            Assert.Equal("Items", property.DisplayNames.First().Value);
-            Assert.Equal("Class1<T>.Items", property.DisplayNamesWithType.First().Value);
-            Assert.Equal("Test1.Class1<T>.Items", property.DisplayQualifiedNames.First().Value);
-            Assert.Equal("Test1.Class1`1.Items", property.Name);
-            Assert.Empty(property.Syntax.Parameters);
+            Assert.IsNotNull(property);
+            Assert.AreEqual("Items", property.DisplayNames.First().Value);
+            Assert.AreEqual("Class1<T>.Items", property.DisplayNamesWithType.First().Value);
+            Assert.AreEqual("Test1.Class1<T>.Items", property.DisplayQualifiedNames.First().Value);
+            Assert.AreEqual("Test1.Class1`1.Items", property.Name);
+            Assert.IsEmpty(property.Syntax.Parameters);
             var returnValue = property.Syntax.Return;
-            Assert.NotNull(returnValue.Type);
-            Assert.Equal("System.Collections.Generic.IEnumerable{{T}}", returnValue.Type);
-            Assert.Equal("public IEnumerable<T> Items { get; set; }", property.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(returnValue.Type);
+            Assert.AreEqual("System.Collections.Generic.IEnumerable{{T}}", returnValue.Type);
+            Assert.AreEqual("public IEnumerable<T> Items { get; set; }", property.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var event1 = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(event1);
-            Assert.Equal("Event1", event1.DisplayNames.First().Value);
-            Assert.Equal("Class1<T>.Event1", event1.DisplayNamesWithType.First().Value);
-            Assert.Equal("Test1.Class1<T>.Event1", event1.DisplayQualifiedNames.First().Value);
-            Assert.Equal("Test1.Class1`1.Event1", event1.Name);
-            Assert.Null(event1.Syntax.Parameters);
-            Assert.Equal("EventHandler", event1.Syntax.Return.Type);
-            Assert.Equal("public event EventHandler Event1", event1.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(event1);
+            Assert.AreEqual("Event1", event1.DisplayNames.First().Value);
+            Assert.AreEqual("Class1<T>.Event1", event1.DisplayNamesWithType.First().Value);
+            Assert.AreEqual("Test1.Class1<T>.Event1", event1.DisplayQualifiedNames.First().Value);
+            Assert.AreEqual("Test1.Class1`1.Event1", event1.Name);
+            Assert.IsNull(event1.Syntax.Parameters);
+            Assert.AreEqual("EventHandler", event1.Syntax.Return.Type);
+            Assert.AreEqual("public event EventHandler Event1", event1.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var operator1 = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(operator1);
-            Assert.Equal("operator ==(Class1<T>, Class1<T>)", operator1.DisplayNames.First().Value);
-            Assert.Equal("Class1<T>.operator ==(Class1<T>, Class1<T>)", operator1.DisplayNamesWithType.First().Value);
-            Assert.Equal("Test1.Class1<T>.operator ==(Test1.Class1<T>, Test1.Class1<T>)", operator1.DisplayQualifiedNames.First().Value);
-            Assert.Equal("Test1.Class1`1.op_Equality(Test1.Class1{`0},Test1.Class1{`0})", operator1.Name);
-            Assert.NotNull(operator1.Syntax.Parameters);
+            Assert.IsNotNull(operator1);
+            Assert.AreEqual("operator ==(Class1<T>, Class1<T>)", operator1.DisplayNames.First().Value);
+            Assert.AreEqual("Class1<T>.operator ==(Class1<T>, Class1<T>)", operator1.DisplayNamesWithType.First().Value);
+            Assert.AreEqual("Test1.Class1<T>.operator ==(Test1.Class1<T>, Test1.Class1<T>)", operator1.DisplayQualifiedNames.First().Value);
+            Assert.AreEqual("Test1.Class1`1.op_Equality(Test1.Class1{`0},Test1.Class1{`0})", operator1.Name);
+            Assert.IsNotNull(operator1.Syntax.Parameters);
 
             var parameterX = operator1.Syntax.Parameters[0];
-            Assert.Equal("x", parameterX.Name);
-            Assert.Equal("Test1.Class1`1", parameterX.Type);
+            Assert.AreEqual("x", parameterX.Name);
+            Assert.AreEqual("Test1.Class1`1", parameterX.Type);
 
             var parameterY = operator1.Syntax.Parameters[1];
-            Assert.Equal("y", parameterY.Name);
-            Assert.Equal("Test1.Class1`1", parameterY.Type);
+            Assert.AreEqual("y", parameterY.Name);
+            Assert.AreEqual("Test1.Class1`1", parameterY.Type);
 
-            Assert.NotNull(operator1.Syntax.Return);
-            Assert.Equal("System.Boolean", operator1.Syntax.Return.Type);
+            Assert.IsNotNull(operator1.Syntax.Return);
+            Assert.AreEqual("System.Boolean", operator1.Syntax.Return.Type);
 
-            Assert.Equal("public static bool operator ==(Class1<T> x, Class1<T> y)", operator1.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("public static bool operator ==(Class1<T> x, Class1<T> y)", operator1.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var property = output.Items[0].Items[0].Items[4];
-            Assert.NotNull(property);
-            Assert.Equal("Items2", property.DisplayNames.First().Value);
-            Assert.Equal("Class1<T>.Items2", property.DisplayNamesWithType.First().Value);
-            Assert.Equal("Test1.Class1<T>.Items2", property.DisplayQualifiedNames.First().Value);
-            Assert.Equal("Test1.Class1`1.Items2", property.Name);
-            Assert.Empty(property.Syntax.Parameters);
+            Assert.IsNotNull(property);
+            Assert.AreEqual("Items2", property.DisplayNames.First().Value);
+            Assert.AreEqual("Class1<T>.Items2", property.DisplayNamesWithType.First().Value);
+            Assert.AreEqual("Test1.Class1<T>.Items2", property.DisplayQualifiedNames.First().Value);
+            Assert.AreEqual("Test1.Class1`1.Items2", property.Name);
+            Assert.IsEmpty(property.Syntax.Parameters);
             var returnValue = property.Syntax.Return;
-            Assert.NotNull(returnValue.Type);
-            Assert.Equal("System.Collections.Generic.IEnumerable{{T}}", returnValue.Type);
-            Assert.Equal("public IEnumerable<T> Items2 { get; }", property.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(returnValue.Type);
+            Assert.AreEqual("System.Collections.Generic.IEnumerable{{T}}", returnValue.Type);
+            Assert.AreEqual("public IEnumerable<T> Items2 { get; }", property.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         // check references
         {
-            Assert.NotNull(output.References);
-            Assert.True(output.References.Count > 0);
+            Assert.IsNotNull(output.References);
+            Assert.IsTrue(output.References.Count > 0);
 
-            Assert.True(output.References.ContainsKey("Test1.Class1`1"));
+            Assert.IsTrue(output.References.ContainsKey("Test1.Class1`1"));
             var reference = output.References["Test1.Class1`1"];
-            Assert.True(reference.IsDefinition);
-            Assert.Equal("Test1", reference.Parent);
-            Assert.True(output.References.ContainsKey("Test1"));
+            Assert.IsTrue(reference.IsDefinition);
+            Assert.AreEqual("Test1", reference.Parent);
+            Assert.IsTrue(output.References.ContainsKey("Test1"));
             reference = output.References["Test1"];
-            Assert.True(reference.IsDefinition);
-            Assert.Null(reference.Parent);
+            Assert.IsTrue(reference.IsDefinition);
+            Assert.IsNull(reference.Parent);
 
-            Assert.True(output.References.ContainsKey("System.Collections.Generic.Dictionary`2"));
-            Assert.NotNull(output.References["System.Collections.Generic.Dictionary`2"]);
-            Assert.True(output.Items[0].Items[0].References.ContainsKey("System.Collections.Generic.Dictionary`2"));
-            Assert.Null(output.Items[0].Items[0].References["System.Collections.Generic.Dictionary`2"]);
+            Assert.IsTrue(output.References.ContainsKey("System.Collections.Generic.Dictionary`2"));
+            Assert.IsNotNull(output.References["System.Collections.Generic.Dictionary`2"]);
+            Assert.IsTrue(output.Items[0].Items[0].References.ContainsKey("System.Collections.Generic.Dictionary`2"));
+            Assert.IsNull(output.Items[0].Items[0].References["System.Collections.Generic.Dictionary`2"]);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithInterface()
     {
         string code = @"
@@ -257,49 +257,49 @@ public interface IFoo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var method = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(method);
-            Assert.Equal("Bar(int)", method.DisplayNames.First().Value);
-            Assert.Equal("IFoo.Bar(int)", method.DisplayNamesWithType.First().Value);
-            Assert.Equal("Test1.IFoo.Bar(int)", method.DisplayQualifiedNames.First().Value);
-            Assert.Equal("Test1.IFoo.Bar(System.Int32)", method.Name);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("Bar(int)", method.DisplayNames.First().Value);
+            Assert.AreEqual("IFoo.Bar(int)", method.DisplayNamesWithType.First().Value);
+            Assert.AreEqual("Test1.IFoo.Bar(int)", method.DisplayQualifiedNames.First().Value);
+            Assert.AreEqual("Test1.IFoo.Bar(System.Int32)", method.Name);
             var parameter = method.Syntax.Parameters[0];
-            Assert.Equal("x", parameter.Name);
-            Assert.Equal("System.Int32", parameter.Type);
+            Assert.AreEqual("x", parameter.Name);
+            Assert.AreEqual("System.Int32", parameter.Type);
             var returnValue = method.Syntax.Return;
-            Assert.NotNull(returnValue);
-            Assert.NotNull(returnValue.Type);
-            Assert.Equal("System.String", returnValue.Type);
+            Assert.IsNotNull(returnValue);
+            Assert.IsNotNull(returnValue.Type);
+            Assert.AreEqual("System.String", returnValue.Type);
         }
         {
             var property = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(property);
-            Assert.Equal("Count", property.DisplayNames.First().Value);
-            Assert.Equal("IFoo.Count", property.DisplayNamesWithType.First().Value);
-            Assert.Equal("Test1.IFoo.Count", property.DisplayQualifiedNames.First().Value);
-            Assert.Equal("Test1.IFoo.Count", property.Name);
-            Assert.Empty(property.Syntax.Parameters);
+            Assert.IsNotNull(property);
+            Assert.AreEqual("Count", property.DisplayNames.First().Value);
+            Assert.AreEqual("IFoo.Count", property.DisplayNamesWithType.First().Value);
+            Assert.AreEqual("Test1.IFoo.Count", property.DisplayQualifiedNames.First().Value);
+            Assert.AreEqual("Test1.IFoo.Count", property.Name);
+            Assert.IsEmpty(property.Syntax.Parameters);
             var returnValue = property.Syntax.Return;
-            Assert.NotNull(returnValue);
-            Assert.NotNull(returnValue.Type);
-            Assert.Equal("System.Int32", returnValue.Type);
+            Assert.IsNotNull(returnValue);
+            Assert.IsNotNull(returnValue.Type);
+            Assert.AreEqual("System.Int32", returnValue.Type);
         }
         {
             var @event = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(@event);
-            Assert.Equal("FooBar", @event.DisplayNames.First().Value);
-            Assert.Equal("IFoo.FooBar", @event.DisplayNamesWithType.First().Value);
-            Assert.Equal("Test1.IFoo.FooBar", @event.DisplayQualifiedNames.First().Value);
-            Assert.Equal("Test1.IFoo.FooBar", @event.Name);
-            Assert.Equal("event EventHandler FooBar", @event.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Null(@event.Syntax.Parameters);
-            Assert.Equal("EventHandler", @event.Syntax.Return.Type);
+            Assert.IsNotNull(@event);
+            Assert.AreEqual("FooBar", @event.DisplayNames.First().Value);
+            Assert.AreEqual("IFoo.FooBar", @event.DisplayNamesWithType.First().Value);
+            Assert.AreEqual("Test1.IFoo.FooBar", @event.DisplayQualifiedNames.First().Value);
+            Assert.AreEqual("Test1.IFoo.FooBar", @event.Name);
+            Assert.AreEqual("event EventHandler FooBar", @event.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNull(@event.Syntax.Parameters);
+            Assert.AreEqual("EventHandler", @event.Syntax.Return.Type);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithInterfaceAndInherits()
     {
         string code = @"
@@ -311,31 +311,31 @@ public interface IFooBar : IBar { }
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
 
         var iFoo = output.Items[0].Items[0];
-        Assert.NotNull(iFoo);
-        Assert.Equal("IFoo", iFoo.DisplayNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("IFoo", iFoo.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-        Assert.Equal("Test1.IFoo", iFoo.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("public interface IFoo", iFoo.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(iFoo);
+        Assert.AreEqual("IFoo", iFoo.DisplayNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("IFoo", iFoo.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.IFoo", iFoo.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("public interface IFoo", iFoo.Syntax.Content[SyntaxLanguage.CSharp]);
 
         var iBar = output.Items[0].Items[1];
-        Assert.NotNull(iBar);
-        Assert.Equal("IBar", iBar.DisplayNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("IBar", iBar.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-        Assert.Equal("Test1.IBar", iBar.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("public interface IBar : IFoo", iBar.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(iBar);
+        Assert.AreEqual("IBar", iBar.DisplayNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("IBar", iBar.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.IBar", iBar.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("public interface IBar : IFoo", iBar.Syntax.Content[SyntaxLanguage.CSharp]);
 
         var iFooBar = output.Items[0].Items[2];
-        Assert.NotNull(iFooBar);
-        Assert.Equal("IFooBar", iFooBar.DisplayNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("IFooBar", iFooBar.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-        Assert.Equal("Test1.IFooBar", iFooBar.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("public interface IFooBar : IBar, IFoo", iFooBar.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(iFooBar);
+        Assert.AreEqual("IFooBar", iFooBar.DisplayNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("IFooBar", iFooBar.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.IFooBar", iFooBar.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("public interface IFooBar : IBar, IFoo", iFooBar.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithInternalInterfaceAndInherits()
     {
         string code = @"
@@ -346,18 +346,18 @@ internal interface IFoo { }
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
 
         var foo = output.Items[0].Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Foo", foo.DisplayNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("Foo", foo.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-        Assert.Equal("Test1.Foo", foo.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("public class Foo", foo.Syntax.Content[SyntaxLanguage.CSharp]);
-        Assert.Null(foo.Implements);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Foo", foo.DisplayNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Foo", foo.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo", foo.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("public class Foo", foo.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNull(foo.Implements);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithProtectedInterfaceAndInherits()
     {
         string code = @"
@@ -370,19 +370,19 @@ public class SubFoo : IFoo { }
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
 
         var subFoo = output.Items[0].Items[2];
-        Assert.NotNull(subFoo);
-        Assert.Equal("Foo.SubFoo", subFoo.DisplayNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("Foo.SubFoo", subFoo.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-        Assert.Equal("Test1.Foo.SubFoo", subFoo.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("public class Foo.SubFoo : Foo.IFoo", subFoo.Syntax.Content[SyntaxLanguage.CSharp]);
-        Assert.NotNull(subFoo.Implements);
-        Assert.Equal("Test1.Foo.IFoo", subFoo.Implements[0]);
+        Assert.IsNotNull(subFoo);
+        Assert.AreEqual("Foo.SubFoo", subFoo.DisplayNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Foo.SubFoo", subFoo.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo.SubFoo", subFoo.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("public class Foo.SubFoo : Foo.IFoo", subFoo.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(subFoo.Implements);
+        Assert.AreEqual("Test1.Foo.IFoo", subFoo.Implements[0]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithPublicInterfaceNestedInternal()
     {
         string code = @"
@@ -396,21 +396,21 @@ public class Foo : FooInternal.IFoo { }
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
 
         var foo = output.Items[0].Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Foo", foo.DisplayNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("Foo", foo.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-        Assert.Equal("Test1.Foo", foo.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("public class Foo", foo.Syntax.Content[SyntaxLanguage.CSharp]);
-        Assert.Null(foo.Implements);
-    }
-
-    [Trait("Related", "Generic")]
-    [Trait("Related", "Inheritance")]
-    [Trait("Related", "Reference")]
-    [Fact]
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Foo", foo.DisplayNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Foo", foo.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo", foo.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("public class Foo", foo.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNull(foo.Implements);
+    }
+
+    [TestProperty("Related", "Generic")]
+    [TestProperty("Related", "Inheritance")]
+    [TestProperty("Related", "Reference")]
+    [TestMethod]
     public void TestGenerateMetadataWithClassAndInherits()
     {
         string code = @"
@@ -425,111 +425,111 @@ public interface IFooBar : IFoo, IBar { }
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
 
         var foo = output.Items[0].Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Foo<T>", foo.DisplayNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("Foo<T>", foo.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-        Assert.Equal("Test1.Foo<T>", foo.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("public class Foo<T> : IFoo", foo.Syntax.Content[SyntaxLanguage.CSharp]);
-        Assert.NotNull(foo.Implements);
-        Assert.Single(foo.Implements);
-        Assert.Equal(new[] { "Test1.IFoo" }, foo.Implements);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Foo<T>", foo.DisplayNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Foo<T>", foo.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo<T>", foo.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("public class Foo<T> : IFoo", foo.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(foo.Implements);
+        Assert.ContainsSingle(foo.Implements);
+        CollectionAssert.AreEqual(new[] { "Test1.IFoo" }, foo.Implements.ToArray());
 
         var bar = output.Items[0].Items[1];
-        Assert.NotNull(bar);
-        Assert.Equal("Bar<T>", bar.DisplayNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("Bar<T>", bar.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-        Assert.Equal("Test1.Bar<T>", bar.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("public class Bar<T> : Foo<T[]>, IFoo, IBar", bar.Syntax.Content[SyntaxLanguage.CSharp]);
-        Assert.Equal(new[] { "System.Object", "Test1.Foo{{T}[]}" }, bar.Inheritance);
-        Assert.Equal(new[] { "Test1.IFoo", "Test1.IBar" }, bar.Implements);
+        Assert.IsNotNull(bar);
+        Assert.AreEqual("Bar<T>", bar.DisplayNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Bar<T>", bar.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Bar<T>", bar.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("public class Bar<T> : Foo<T[]>, IFoo, IBar", bar.Syntax.Content[SyntaxLanguage.CSharp]);
+        CollectionAssert.AreEqual(new[] { "System.Object", "Test1.Foo{{T}[]}" }, bar.Inheritance.ToArray());
+        CollectionAssert.AreEqual(new[] { "Test1.IFoo", "Test1.IBar" }, bar.Implements.ToArray());
 
         var fooBar = output.Items[0].Items[2];
-        Assert.NotNull(fooBar);
-        Assert.Equal("FooBar", fooBar.DisplayNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("FooBar", fooBar.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-        Assert.Equal("Test1.FooBar", fooBar.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("public class FooBar : Bar<string>, IFooBar, IFoo, IBar", fooBar.Syntax.Content[SyntaxLanguage.CSharp]);
-        Assert.Equal(new[] { "System.Object", "Test1.Foo{System.String[]}", "Test1.Bar{System.String}" }, fooBar.Inheritance);
-        Assert.Equal(new[] { "Test1.IFoo", "Test1.IBar", "Test1.IFooBar" }.OrderBy(s => s), fooBar.Implements.OrderBy(s => s));
+        Assert.IsNotNull(fooBar);
+        Assert.AreEqual("FooBar", fooBar.DisplayNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("FooBar", fooBar.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.FooBar", fooBar.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("public class FooBar : Bar<string>, IFooBar, IFoo, IBar", fooBar.Syntax.Content[SyntaxLanguage.CSharp]);
+        CollectionAssert.AreEqual(new[] { "System.Object", "Test1.Foo{System.String[]}", "Test1.Bar{System.String}" }, fooBar.Inheritance.ToArray());
+        CollectionAssert.AreEqual(new[] { "Test1.IFoo", "Test1.IBar", "Test1.IFooBar" }.OrderBy(s => s).ToArray(), fooBar.Implements.OrderBy(s => s).ToArray());
 
-        Assert.NotNull(output.References);
-        Assert.Equal(19, output.References.Count);
+        Assert.IsNotNull(output.References);
+        Assert.AreEqual(19, output.References.Count);
         {
             var item = output.References["System.Object"];
-            Assert.Equal("System", item.Parent);
-            Assert.NotNull(item);
-            Assert.Single(item.NameParts[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("System", item.Parent);
+            Assert.IsNotNull(item);
+            Assert.ContainsSingle(item.NameParts[SyntaxLanguage.CSharp]);
 
-            Assert.Equal("System.Object", item.NameParts[SyntaxLanguage.CSharp][0].Name);
-            Assert.Equal("object", string.Concat(item.NameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName)));
-            Assert.Equal("object", string.Concat(item.NameWithTypeParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName)));
-            Assert.Equal("object", string.Concat(item.QualifiedNameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName)));
+            Assert.AreEqual("System.Object", item.NameParts[SyntaxLanguage.CSharp][0].Name);
+            Assert.AreEqual("object", string.Concat(item.NameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName)));
+            Assert.AreEqual("object", string.Concat(item.NameWithTypeParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName)));
+            Assert.AreEqual("object", string.Concat(item.QualifiedNameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName)));
         }
         {
             var item = output.References["Test1.Bar{System.String}"];
-            Assert.NotNull(item);
-            Assert.Equal("Test1.Bar`1", item.Definition);
-            Assert.Equal("Test1", item.Parent);
-
-            Assert.Equal(
-                ["Test1.Bar`1", null, "System.String", null],
-                item.NameParts[SyntaxLanguage.CSharp].Select(p => p.Name));
-            Assert.Equal(
-                ["Bar", "<", "string", ">"],
-                item.NameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName));
-            Assert.Equal(
-                ["Bar", "<", "string", ">"],
-                item.NameWithTypeParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName));
-            Assert.Equal(
-                ["Test1", ".", "Bar", "<", "string", ">"],
-                item.QualifiedNameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName));
+            Assert.IsNotNull(item);
+            Assert.AreEqual("Test1.Bar`1", item.Definition);
+            Assert.AreEqual("Test1", item.Parent);
+
+            CollectionAssert.AreEqual(
+                new[] { "Test1.Bar`1", null, "System.String", null },
+                item.NameParts[SyntaxLanguage.CSharp].Select(p => p.Name).ToArray());
+            CollectionAssert.AreEqual(
+                new[] { "Bar", "<", "string", ">" },
+                item.NameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName).ToArray());
+            CollectionAssert.AreEqual(
+                new[] { "Bar", "<", "string", ">" },
+                item.NameWithTypeParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName).ToArray());
+            CollectionAssert.AreEqual(
+                new[] { "Test1", ".", "Bar", "<", "string", ">" },
+                item.QualifiedNameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName).ToArray());
         }
         {
             var item = output.References["Test1.Foo{{T}[]}"];
-            Assert.NotNull(item);
-            Assert.Equal("Test1.Foo`1", item.Definition);
-            Assert.Equal("Test1", item.Parent);
-
-            Assert.Equal(6, item.NameParts[SyntaxLanguage.CSharp].Count);
-
-            Assert.Equal(
-                ["Test1.Foo`1", null, null, null, null, null],
-                item.NameParts[SyntaxLanguage.CSharp].Select(p => p.Name));
-            Assert.Equal(
-                ["Foo", "<", "T", "[", "]", ">"],
-                item.NameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName));
-            Assert.Equal(
-                ["Foo", "<", "T", "[", "]", ">"],
-                item.NameWithTypeParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName));
-            Assert.Equal(
-                ["Test1", ".", "Foo", "<", "T", "[", "]", ">"],
-                item.QualifiedNameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName));
+            Assert.IsNotNull(item);
+            Assert.AreEqual("Test1.Foo`1", item.Definition);
+            Assert.AreEqual("Test1", item.Parent);
+
+            Assert.AreEqual(6, item.NameParts[SyntaxLanguage.CSharp].Count);
+
+            CollectionAssert.AreEqual(
+                new string[] { "Test1.Foo`1", null, null, null, null, null },
+                item.NameParts[SyntaxLanguage.CSharp].Select(p => p.Name).ToArray());
+            CollectionAssert.AreEqual(
+                new string[] { "Foo", "<", "T", "[", "]", ">" },
+                item.NameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName).ToArray());
+            CollectionAssert.AreEqual(
+                new string[] { "Foo", "<", "T", "[", "]", ">" },
+                item.NameWithTypeParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName).ToArray());
+            CollectionAssert.AreEqual(
+                new string[] { "Test1", ".", "Foo", "<", "T", "[", "]", ">" },
+                item.QualifiedNameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName).ToArray());
         }
         {
             var item = output.References["Test1.Foo{System.String[]}"];
-            Assert.NotNull(item);
-            Assert.Equal("Test1.Foo`1", item.Definition);
-            Assert.Equal("Test1", item.Parent);
-
-            Assert.Equal(
-                ["Test1.Foo`1", null, "System.String", null, null, null],
-                item.NameParts[SyntaxLanguage.CSharp].Select(p => p.Name));
-            Assert.Equal(
-                ["Foo", "<", "string", "[", "]", ">"],
-                item.NameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName));
-            Assert.Equal(
-                ["Foo", "<", "string", "[", "]", ">"],
-                item.NameWithTypeParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName));
-            Assert.Equal(
-                ["Test1", ".", "Foo", "<", "string", "[", "]", ">"],
-                item.QualifiedNameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName));
-        }
-    }
-
-    [Fact]
+            Assert.IsNotNull(item);
+            Assert.AreEqual("Test1.Foo`1", item.Definition);
+            Assert.AreEqual("Test1", item.Parent);
+
+            CollectionAssert.AreEqual(
+                new[] { "Test1.Foo`1", null, "System.String", null, null, null },
+                item.NameParts[SyntaxLanguage.CSharp].Select(p => p.Name).ToArray());
+            CollectionAssert.AreEqual(
+                new[] { "Foo", "<", "string", "[", "]", ">" },
+                item.NameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName).ToArray());
+            CollectionAssert.AreEqual(
+                new[] { "Foo", "<", "string", "[", "]", ">" },
+                item.NameWithTypeParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName).ToArray());
+            CollectionAssert.AreEqual(
+                new[] { "Test1", ".", "Foo", "<", "string", "[", "]", ">" },
+                item.QualifiedNameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName).ToArray());
+        }
+    }
+
+    [TestMethod]
     public void TestGenerateMetadataWithEnum()
     {
         string code = @"
@@ -541,38 +541,38 @@ public enum XYZ:int{X,Y,Z}
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var type = output.Items[0].Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("ABC", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("ABC", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.ABC", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.ABC", type.Name);
-            Assert.Equal("public enum ABC", type.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("ABC", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("ABC", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.ABC", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.ABC", type.Name);
+            Assert.AreEqual("public enum ABC", type.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var type = output.Items[0].Items[1];
-            Assert.NotNull(type);
-            Assert.Equal("YN", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("YN", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.YN", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.YN", type.Name);
-            Assert.Equal("public enum YN : byte", type.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("YN", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("YN", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.YN", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.YN", type.Name);
+            Assert.AreEqual("public enum YN : byte", type.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var type = output.Items[0].Items[2];
-            Assert.NotNull(type);
-            Assert.Equal("XYZ", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("XYZ", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.XYZ", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.XYZ", type.Name);
-            Assert.Equal("public enum XYZ", type.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("XYZ", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("XYZ", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.XYZ", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.XYZ", type.Name);
+            Assert.AreEqual("public enum XYZ", type.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Trait("Related", "Inheritance")]
-    [Fact]
+    [TestProperty("Related", "Inheritance")]
+    [TestMethod]
     public void TestGenerateMetadataWithStruct()
     {
         string code = @"
@@ -589,32 +589,32 @@ public struct Bar<T> : IEnumerable<T>
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var type = output.Items[0].Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("Foo", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo", type.Name);
-            Assert.Equal("public struct Foo", type.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Null(type.Implements);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Foo", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo", type.Name);
+            Assert.AreEqual("public struct Foo", type.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNull(type.Implements);
         }
         {
             var type = output.Items[0].Items[1];
-            Assert.NotNull(type);
-            Assert.Equal("Bar<T>", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar<T>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar<T>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar`1", type.Name);
-            Assert.Equal("public struct Bar<T> : IEnumerable<T>, IEnumerable", type.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal(new[] { "System.Collections.Generic.IEnumerable{{T}}", "System.Collections.IEnumerable" }, type.Implements);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Bar<T>", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar<T>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar<T>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar`1", type.Name);
+            Assert.AreEqual("public struct Bar<T> : IEnumerable<T>, IEnumerable", type.Syntax.Content[SyntaxLanguage.CSharp]);
+            CollectionAssert.AreEqual(new[] { "System.Collections.Generic.IEnumerable{{T}}", "System.Collections.IEnumerable" }, type.Implements.ToArray());
         }
         // inheritance of Foo
         {
             var inheritedMembers = output.Items[0].Items[0].InheritedMembers;
-            Assert.NotNull(inheritedMembers);
-            Assert.Equal(
+            Assert.IsNotNull(inheritedMembers);
+            CollectionAssert.AreEqual(
                 new string[]
                 {
                     "System.ValueType.ToString",
@@ -623,13 +623,13 @@ public struct Bar<T> : IEnumerable<T>
                     "System.Object.Equals(System.Object,System.Object)",
                     "System.Object.ReferenceEquals(System.Object,System.Object)",
                     "System.Object.GetType",
-                }.OrderBy(s => s),
-                inheritedMembers.OrderBy(s => s));
+                }.OrderBy(s => s).ToArray(),
+                inheritedMembers.OrderBy(s => s).ToArray());
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestMethod]
     public void TestGenerateMetadataWithDelegate()
     {
         string code = @"
@@ -644,83 +644,83 @@ namespace Test1
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var type = output.Items[0].Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("Foo", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo", type.Name);
-            Assert.Equal("public delegate void Foo()", type.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Null(type.Syntax.Parameters);
-            Assert.Null(type.Syntax.Return);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Foo", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo", type.Name);
+            Assert.AreEqual("public delegate void Foo()", type.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNull(type.Syntax.Parameters);
+            Assert.IsNull(type.Syntax.Return);
         }
         {
             var type = output.Items[0].Items[1];
-            Assert.NotNull(type);
-            Assert.Equal("Bar<T>", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar<T>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar<T>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar`1", type.Name);
-            Assert.Equal("public delegate T Bar<T>(IEnumerable<T> x = null) where T : class", type.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Bar<T>", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar<T>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar<T>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar`1", type.Name);
+            Assert.AreEqual("public delegate T Bar<T>(IEnumerable<T> x = null) where T : class", type.Syntax.Content[SyntaxLanguage.CSharp]);
 
-            Assert.NotNull(type.Syntax.Parameters);
-            Assert.Single(type.Syntax.Parameters);
-            Assert.Equal("x", type.Syntax.Parameters[0].Name);
-            Assert.Equal("System.Collections.Generic.IEnumerable{{T}}", type.Syntax.Parameters[0].Type);
-            Assert.NotNull(type.Syntax.Return);
-            Assert.Equal("{T}", type.Syntax.Return.Type);
+            Assert.IsNotNull(type.Syntax.Parameters);
+            Assert.ContainsSingle(type.Syntax.Parameters);
+            Assert.AreEqual("x", type.Syntax.Parameters[0].Name);
+            Assert.AreEqual("System.Collections.Generic.IEnumerable{{T}}", type.Syntax.Parameters[0].Type);
+            Assert.IsNotNull(type.Syntax.Return);
+            Assert.AreEqual("{T}", type.Syntax.Return.Type);
         }
         {
             var type = output.Items[0].Items[2];
-            Assert.NotNull(type);
-            Assert.Equal("FooBar", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("FooBar", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.FooBar", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.FooBar", type.Name);
-            Assert.Equal("public delegate void FooBar(ref int x, out string y, in bool z, params byte[] w)", type.Syntax.Content[SyntaxLanguage.CSharp]);
-
-            Assert.NotNull(type.Syntax.Parameters);
-            Assert.Equal(4, type.Syntax.Parameters.Count);
-            Assert.Equal("x", type.Syntax.Parameters[0].Name);
-            Assert.Equal("System.Int32", type.Syntax.Parameters[0].Type);
-            Assert.Equal("y", type.Syntax.Parameters[1].Name);
-            Assert.Equal("System.String", type.Syntax.Parameters[1].Type);
-            Assert.Equal("z", type.Syntax.Parameters[2].Name);
-            Assert.Equal("System.Boolean", type.Syntax.Parameters[2].Type);
-            Assert.Equal("w", type.Syntax.Parameters[3].Name);
-            Assert.Equal("System.Byte[]", type.Syntax.Parameters[3].Type);
-            Assert.Null(type.Syntax.Return);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("FooBar", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("FooBar", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.FooBar", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.FooBar", type.Name);
+            Assert.AreEqual("public delegate void FooBar(ref int x, out string y, in bool z, params byte[] w)", type.Syntax.Content[SyntaxLanguage.CSharp]);
+
+            Assert.IsNotNull(type.Syntax.Parameters);
+            Assert.AreEqual(4, type.Syntax.Parameters.Count);
+            Assert.AreEqual("x", type.Syntax.Parameters[0].Name);
+            Assert.AreEqual("System.Int32", type.Syntax.Parameters[0].Type);
+            Assert.AreEqual("y", type.Syntax.Parameters[1].Name);
+            Assert.AreEqual("System.String", type.Syntax.Parameters[1].Type);
+            Assert.AreEqual("z", type.Syntax.Parameters[2].Name);
+            Assert.AreEqual("System.Boolean", type.Syntax.Parameters[2].Type);
+            Assert.AreEqual("w", type.Syntax.Parameters[3].Name);
+            Assert.AreEqual("System.Byte[]", type.Syntax.Parameters[3].Type);
+            Assert.IsNull(type.Syntax.Return);
         }
         {
             var type = output.Items[0].Items[3];
-            Assert.NotNull(type);
-            Assert.Equal("Ref", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Ref", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Ref", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Ref", type.Name);
-            Assert.Equal("public delegate ref int Ref()", type.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Ref", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Ref", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Ref", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Ref", type.Name);
+            Assert.AreEqual("public delegate ref int Ref()", type.Syntax.Content[SyntaxLanguage.CSharp]);
 
-            Assert.Null(type.Syntax.Parameters);
-            Assert.Equal("System.Int32", type.Syntax.Return.Type);
+            Assert.IsNull(type.Syntax.Parameters);
+            Assert.AreEqual("System.Int32", type.Syntax.Return.Type);
         }
         {
             var type = output.Items[0].Items[4];
-            Assert.NotNull(type);
-            Assert.Equal("RefReadonly", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("RefReadonly", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.RefReadonly", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.RefReadonly", type.Name);
-            Assert.Equal("public delegate ref readonly int RefReadonly()", type.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("RefReadonly", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("RefReadonly", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.RefReadonly", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.RefReadonly", type.Name);
+            Assert.AreEqual("public delegate ref readonly int RefReadonly()", type.Syntax.Content[SyntaxLanguage.CSharp]);
 
-            Assert.Null(type.Syntax.Parameters);
-            Assert.Equal("System.Int32", type.Syntax.Return.Type);
+            Assert.IsNull(type.Syntax.Parameters);
+            Assert.AreEqual("System.Int32", type.Syntax.Return.Type);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestMethod]
     public void TestGenerateMetadataWithMethod()
     {
         string code = @"
@@ -752,136 +752,136 @@ public interface IFooBar
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         // Foo<T>
         {
             var method = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(method);
-            Assert.Equal("M1()", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.M1()", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.M1()", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.M1", method.Name);
-            Assert.Equal("public abstract void M1()", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M1()", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.M1()", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.M1()", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.M1", method.Name);
+            Assert.AreEqual("public abstract void M1()", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(method);
-            Assert.Equal("M2<TArg>(TArg)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.M2<TArg>(TArg)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.M2<TArg>(TArg)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.M2``1(``0)", method.Name);
-            Assert.Equal("protected virtual Foo<T> M2<TArg>(TArg arg) where TArg : Foo<T>", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M2<TArg>(TArg)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.M2<TArg>(TArg)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.M2<TArg>(TArg)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.M2``1(``0)", method.Name);
+            Assert.AreEqual("protected virtual Foo<T> M2<TArg>(TArg arg) where TArg : Foo<T>", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(method);
-            Assert.Equal("M3<TResult>(string)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.M3<TResult>(string)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.M3<TResult>(string)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.M3``1(System.String)", method.Name);
-            Assert.Equal("public static TResult M3<TResult>(string x) where TResult : class", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M3<TResult>(string)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.M3<TResult>(string)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.M3<TResult>(string)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.M3``1(System.String)", method.Name);
+            Assert.AreEqual("public static TResult M3<TResult>(string x) where TResult : class", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(method);
-            Assert.Equal("M4(int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.M4(int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.M4(int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.M4(System.Int32)", method.Name);
-            Assert.Equal("public void M4(int x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M4(int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.M4(int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.M4(int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.M4(System.Int32)", method.Name);
+            Assert.AreEqual("public void M4(int x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[4];
-            Assert.NotNull(method);
-            Assert.Equal("M5(ref int, out string, in bool)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.M5(ref int, out string, in bool)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.M5(ref int, out string, in bool)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.M5(System.Int32@,System.String@,System.Boolean@)", method.Name);
-            Assert.Equal("public void M5(ref int x, out string y, in bool z)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M5(ref int, out string, in bool)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.M5(ref int, out string, in bool)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.M5(ref int, out string, in bool)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.M5(System.Int32@,System.String@,System.Boolean@)", method.Name);
+            Assert.AreEqual("public void M5(ref int x, out string y, in bool z)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[5];
-            Assert.NotNull(method);
-            Assert.Equal("M6()", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.M6()", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.M6()", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.M6", method.Name);
-            Assert.Equal("public ref int M6()", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M6()", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.M6()", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.M6()", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.M6", method.Name);
+            Assert.AreEqual("public ref int M6()", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[6];
-            Assert.NotNull(method);
-            Assert.Equal("M7()", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.M7()", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.M7()", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.M7", method.Name);
-            Assert.Equal("public ref readonly int M7()", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M7()", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.M7()", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.M7()", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.M7", method.Name);
+            Assert.AreEqual("public ref readonly int M7()", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         // Bar
         {
             var method = output.Items[0].Items[1].Items[0];
-            Assert.NotNull(method);
-            Assert.Equal("M1()", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar.M1()", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.M1()", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.M1", method.Name);
-            Assert.Equal("public override void M1()", method.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo{System.String}.M1", method.Overridden);
-            Assert.Equal("Test1.IFooBar.M1", method.Implements[0]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M1()", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar.M1()", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.M1()", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.M1", method.Name);
+            Assert.AreEqual("public override void M1()", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo{System.String}.M1", method.Overridden);
+            Assert.AreEqual("Test1.IFooBar.M1", method.Implements[0]);
         }
         {
             var method = output.Items[0].Items[1].Items[1];
-            Assert.NotNull(method);
-            Assert.Equal("M2<TArg>(TArg)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar.M2<TArg>(TArg)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.M2<TArg>(TArg)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.M2``1(``0)", method.Name);
-            Assert.Equal("protected override sealed Foo<T> M2<TArg>(TArg arg) where TArg : Foo<string>", method.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo{System.String}.M2``1({TArg})", method.Overridden);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M2<TArg>(TArg)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar.M2<TArg>(TArg)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.M2<TArg>(TArg)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.M2``1(``0)", method.Name);
+            Assert.AreEqual("protected override sealed Foo<T> M2<TArg>(TArg arg) where TArg : Foo<string>", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo{System.String}.M2``1({TArg})", method.Overridden);
         }
         {
             var method = output.Items[0].Items[1].Items[2];
-            Assert.NotNull(method);
-            Assert.Equal("M8<TArg>(TArg)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar.M8<TArg>(TArg)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.M8<TArg>(TArg)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.M8``1(``0)", method.Name);
-            Assert.Equal("public int M8<TArg>(TArg arg) where TArg : struct, new()", method.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.M8``1({TArg})", method.Implements[0]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M8<TArg>(TArg)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar.M8<TArg>(TArg)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.M8<TArg>(TArg)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.M8``1(``0)", method.Name);
+            Assert.AreEqual("public int M8<TArg>(TArg arg) where TArg : struct, new()", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.M8``1({TArg})", method.Implements[0]);
         }
         // IFooBar
         {
             var method = output.Items[0].Items[2].Items[0];
-            Assert.NotNull(method);
-            Assert.Equal("M1()", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("IFooBar.M1()", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.M1()", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.M1", method.Name);
-            Assert.Equal("void M1()", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M1()", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("IFooBar.M1()", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.M1()", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.M1", method.Name);
+            Assert.AreEqual("void M1()", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[2].Items[1];
-            Assert.NotNull(method);
-            Assert.Equal("M2<TArg>(TArg)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("IFooBar.M2<TArg>(TArg)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.M2<TArg>(TArg)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.M2``1(``0)", method.Name);
-            Assert.Equal("Foo<T> M2<TArg>(TArg arg) where TArg : Foo<string>", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M2<TArg>(TArg)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("IFooBar.M2<TArg>(TArg)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.M2<TArg>(TArg)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.M2``1(``0)", method.Name);
+            Assert.AreEqual("Foo<T> M2<TArg>(TArg arg) where TArg : Foo<string>", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[2].Items[2];
-            Assert.NotNull(method);
-            Assert.Equal("M8<TArg>(TArg)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("IFooBar.M8<TArg>(TArg)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.M8<TArg>(TArg)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.M8``1(``0)", method.Name);
-            Assert.Equal("int M8<TArg>(TArg arg) where TArg : struct, new()", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M8<TArg>(TArg)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("IFooBar.M8<TArg>(TArg)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.M8<TArg>(TArg)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.M8``1(``0)", method.Name);
+            Assert.AreEqual("int M8<TArg>(TArg arg) where TArg : struct, new()", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Trait("Related", "EII")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestProperty("Related", "EII")]
+    [TestMethod]
     public void TestGenerateMetadataWithEii()
     {
         string code = @"
@@ -915,112 +915,112 @@ T Bar<TArg>(TArg[] x)
 }
 ";
         MetadataItem output = Verify(code, new() { IncludePrivateMembers = true });
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var type = output.Items[0].Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("Foo<T>", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1", type.Name);
-            Assert.Equal("public class Foo<T> : IFoo, IFoo<string>, IFoo<T> where T : class", type.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Foo<T>", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1", type.Name);
+            Assert.AreEqual("public class Foo<T> : IFoo, IFoo<string>, IFoo<T> where T : class", type.Syntax.Content[SyntaxLanguage.CSharp]);
             Assert.Contains("Test1.IFoo", type.Implements);
             Assert.Contains("Test1.IFoo{System.String}", type.Implements);
             Assert.Contains("Test1.IFoo{{T}}", type.Implements);
         }
         {
             var method = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(method);
-            Assert.True(method.IsExplicitInterfaceImplementation);
-            Assert.Equal("IFoo.Bar(ref int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.IFoo.Bar(ref int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.Test1.IFoo.Bar(ref int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.Test1#IFoo#Bar(System.Int32@)", method.Name);
-            Assert.Equal("object IFoo.Bar(ref int x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFoo.Bar(System.Int32@)", method.Implements[0]);
+            Assert.IsNotNull(method);
+            Assert.IsTrue(method.IsExplicitInterfaceImplementation);
+            Assert.AreEqual("IFoo.Bar(ref int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.IFoo.Bar(ref int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.Test1.IFoo.Bar(ref int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.Test1#IFoo#Bar(System.Int32@)", method.Name);
+            Assert.AreEqual("object IFoo.Bar(ref int x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFoo.Bar(System.Int32@)", method.Implements[0]);
         }
         {
             var method = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(method);
-            Assert.True(method.IsExplicitInterfaceImplementation);
-            Assert.Equal("IFoo<string>.Bar<TArg>(TArg[])", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.IFoo<string>.Bar<TArg>(TArg[])", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.Test1.IFoo<string>.Bar<TArg>(TArg[])", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.Test1#IFoo{System#String}#Bar``1(``0[])", method.Name);
-            Assert.Equal("string IFoo<string>.Bar<TArg>(TArg[] x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFoo{System.String}.Bar``1({TArg}[])", method.Implements[0]);
+            Assert.IsNotNull(method);
+            Assert.IsTrue(method.IsExplicitInterfaceImplementation);
+            Assert.AreEqual("IFoo<string>.Bar<TArg>(TArg[])", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.IFoo<string>.Bar<TArg>(TArg[])", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.Test1.IFoo<string>.Bar<TArg>(TArg[])", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.Test1#IFoo{System#String}#Bar``1(``0[])", method.Name);
+            Assert.AreEqual("string IFoo<string>.Bar<TArg>(TArg[] x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFoo{System.String}.Bar``1({TArg}[])", method.Implements[0]);
         }
         {
             var method = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(method);
-            Assert.True(method.IsExplicitInterfaceImplementation);
-            Assert.Equal("IFoo<T>.Bar<TArg>(TArg[])", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.IFoo<T>.Bar<TArg>(TArg[])", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.Test1.IFoo<T>.Bar<TArg>(TArg[])", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.Test1#IFoo{T}#Bar``1(``0[])", method.Name);
-            Assert.Equal("T IFoo<T>.Bar<TArg>(TArg[] x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFoo{{T}}.Bar``1({TArg}[])", method.Implements[0]);
+            Assert.IsNotNull(method);
+            Assert.IsTrue(method.IsExplicitInterfaceImplementation);
+            Assert.AreEqual("IFoo<T>.Bar<TArg>(TArg[])", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.IFoo<T>.Bar<TArg>(TArg[])", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.Test1.IFoo<T>.Bar<TArg>(TArg[])", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.Test1#IFoo{T}#Bar``1(``0[])", method.Name);
+            Assert.AreEqual("T IFoo<T>.Bar<TArg>(TArg[] x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFoo{{T}}.Bar``1({TArg}[])", method.Implements[0]);
         }
         {
             var p = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(p);
-            Assert.True(p.IsExplicitInterfaceImplementation);
-            Assert.Equal("IFoo<string>.P", p.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.IFoo<string>.P", p.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.Test1.IFoo<string>.P", p.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.Test1#IFoo{System#String}#P", p.Name);
-            Assert.Equal("string IFoo<string>.P { get; set; }", p.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFoo{System.String}.P", p.Implements[0]);
+            Assert.IsNotNull(p);
+            Assert.IsTrue(p.IsExplicitInterfaceImplementation);
+            Assert.AreEqual("IFoo<string>.P", p.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.IFoo<string>.P", p.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.Test1.IFoo<string>.P", p.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.Test1#IFoo{System#String}#P", p.Name);
+            Assert.AreEqual("string IFoo<string>.P { get; set; }", p.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFoo{System.String}.P", p.Implements[0]);
         }
         {
             var p = output.Items[0].Items[0].Items[4];
-            Assert.NotNull(p);
-            Assert.True(p.IsExplicitInterfaceImplementation);
-            Assert.Equal("IFoo<T>.P", p.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.IFoo<T>.P", p.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.Test1.IFoo<T>.P", p.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.Test1#IFoo{T}#P", p.Name);
-            Assert.Equal("T IFoo<T>.P { get; set; }", p.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFoo{{T}}.P", p.Implements[0]);
+            Assert.IsNotNull(p);
+            Assert.IsTrue(p.IsExplicitInterfaceImplementation);
+            Assert.AreEqual("IFoo<T>.P", p.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.IFoo<T>.P", p.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.Test1.IFoo<T>.P", p.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.Test1#IFoo{T}#P", p.Name);
+            Assert.AreEqual("T IFoo<T>.P { get; set; }", p.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFoo{{T}}.P", p.Implements[0]);
         }
         {
             var p = output.Items[0].Items[0].Items[5];
-            Assert.NotNull(p);
-            Assert.True(p.IsExplicitInterfaceImplementation);
-            Assert.Equal("IFoo<string>.this[string]", p.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.IFoo<string>.this[string]", p.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.Test1.IFoo<string>.this[string]", p.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.Test1#IFoo{System#String}#Item(System.String)", p.Name);
-            Assert.Equal("int IFoo<string>.this[string x] { get; }", p.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFoo{System.String}.Item(System.String)", p.Implements[0]);
+            Assert.IsNotNull(p);
+            Assert.IsTrue(p.IsExplicitInterfaceImplementation);
+            Assert.AreEqual("IFoo<string>.this[string]", p.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.IFoo<string>.this[string]", p.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.Test1.IFoo<string>.this[string]", p.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.Test1#IFoo{System#String}#Item(System.String)", p.Name);
+            Assert.AreEqual("int IFoo<string>.this[string x] { get; }", p.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFoo{System.String}.Item(System.String)", p.Implements[0]);
         }
         {
             var p = output.Items[0].Items[0].Items[6];
-            Assert.NotNull(p);
-            Assert.True(p.IsExplicitInterfaceImplementation);
-            Assert.Equal("IFoo<T>.this[T]", p.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.IFoo<T>.this[T]", p.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.Test1.IFoo<T>.this[T]", p.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.Test1#IFoo{T}#Item(`0)", p.Name);
-            Assert.Equal("int IFoo<T>.this[T x] { get; }", p.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFoo{{T}}.Item({T})", p.Implements[0]);
+            Assert.IsNotNull(p);
+            Assert.IsTrue(p.IsExplicitInterfaceImplementation);
+            Assert.AreEqual("IFoo<T>.this[T]", p.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.IFoo<T>.this[T]", p.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.Test1.IFoo<T>.this[T]", p.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.Test1#IFoo{T}#Item(`0)", p.Name);
+            Assert.AreEqual("int IFoo<T>.this[T x] { get; }", p.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFoo{{T}}.Item({T})", p.Implements[0]);
         }
         {
             var e = output.Items[0].Items[0].Items[7];
-            Assert.NotNull(e);
-            Assert.True(e.IsExplicitInterfaceImplementation);
-            Assert.Equal("IFoo.E", e.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.IFoo.E", e.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.Test1.IFoo.E", e.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.Test1#IFoo#E", e.Name);
-            Assert.Equal("event EventHandler IFoo.E", e.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFoo.E", e.Implements[0]);
+            Assert.IsNotNull(e);
+            Assert.IsTrue(e.IsExplicitInterfaceImplementation);
+            Assert.AreEqual("IFoo.E", e.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.IFoo.E", e.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.Test1.IFoo.E", e.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.Test1#IFoo#E", e.Name);
+            Assert.AreEqual("event EventHandler IFoo.E", e.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFoo.E", e.Implements[0]);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Trait("Related", "EII")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestProperty("Related", "EII")]
+    [TestMethod]
     public void TestGenerateMetadataWithEditorBrowsableNeverEii()
     {
         string code = @"
@@ -1046,38 +1046,38 @@ event EventHandler IInterface.Event { add {} remove {} }
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.Equal(2, ns.Items.Count);
+        Assert.AreEqual(2, ns.Items.Count);
         {
             var type = ns.Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("IInterface", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test.IInterface", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test.IInterface", type.Name);
-            Assert.Equal("public interface IInterface", type.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Null(type.Implements);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("IInterface", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test.IInterface", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test.IInterface", type.Name);
+            Assert.AreEqual("public interface IInterface", type.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNull(type.Implements);
 
             // Verify member with EditorBrowsable.Never should be filtered out
-            Assert.Empty(type.Items);
+            Assert.IsEmpty(type.Items);
         }
         {
             var type = ns.Items[1];
-            Assert.NotNull(type);
-            Assert.Equal("Class", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test.Class", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test.Class", type.Name);
-            Assert.Equal("public class Class : IInterface", type.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test.IInterface", type.Implements[0]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Class", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test.Class", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test.Class", type.Name);
+            Assert.AreEqual("public class Class : IInterface", type.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test.IInterface", type.Implements[0]);
 
             // Verify EII member with EditorBrowsable.Never should be filtered out
-            Assert.Empty(type.Items);
+            Assert.IsEmpty(type.Items);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Trait("Related", "Extension Method")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestProperty("Related", "Extension Method")]
+    [TestMethod]
     public void TestGenerateMetadataWithExtensionMethod()
     {
         string code = @"
@@ -1114,79 +1114,79 @@ public static void Rain(this Doll d, Doll another)
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         // FooImple<T>
         {
             var method = output.Items[0].Items[1].Items[0];
-            Assert.NotNull(method);
-            Assert.Equal("M1<U>(T, U)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("FooImple<T>.M1<U>(T, U)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.FooImple<T>.M1<U>(T, U)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.FooImple`1.M1``1(`0,``0)", method.Name);
-            Assert.Equal("public void M1<U>(T a, U b)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M1<U>(T, U)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("FooImple<T>.M1<U>(T, U)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.FooImple<T>.M1<U>(T, U)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.FooImple`1.M1``1(`0,``0)", method.Name);
+            Assert.AreEqual("public void M1<U>(T a, U b)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         var extensionMethods = output.Items[0].Items[1].ExtensionMethods;
-        Assert.Equal(2, extensionMethods.Count);
+        Assert.AreEqual(2, extensionMethods.Count);
         {
-            Assert.Equal("Test1.FooImple`1.Test1.Extension.Eat``1", extensionMethods[0]);
+            Assert.AreEqual("Test1.FooImple`1.Test1.Extension.Eat``1", extensionMethods[0]);
             var reference = output.References[extensionMethods[0]];
-            Assert.False(reference.IsDefinition);
-            Assert.Equal("Test1.Extension.Eat``1(Test1.FooImple{``0})", reference.Definition);
-            Assert.Equal("Eat<T>(FooImple<T>)", string.Concat(reference.NameParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
-            Assert.Equal("Extension.Eat<T>(FooImple<T>)", string.Concat(reference.NameWithTypeParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
+            Assert.IsFalse(reference.IsDefinition);
+            Assert.AreEqual("Test1.Extension.Eat``1(Test1.FooImple{``0})", reference.Definition);
+            Assert.AreEqual("Eat<T>(FooImple<T>)", string.Concat(reference.NameParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
+            Assert.AreEqual("Extension.Eat<T>(FooImple<T>)", string.Concat(reference.NameWithTypeParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
         }
         {
-            Assert.Equal("Test1.Foo{`0[]}.Test1.Extension.Play``2({T}[],{Way})", extensionMethods[1]);
+            Assert.AreEqual("Test1.Foo{`0[]}.Test1.Extension.Play``2({T}[],{Way})", extensionMethods[1]);
             var reference = output.References[extensionMethods[1]];
-            Assert.False(reference.IsDefinition);
-            Assert.Equal("Test1.Extension.Play``2(Test1.Foo{``0},``0,``1)", reference.Definition);
-            Assert.Equal("Play<T[], Way>(Foo<T[]>, T[], Way)", string.Concat(reference.NameParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
-            Assert.Equal("Extension.Play<T[], Way>(Foo<T[]>, T[], Way)", string.Concat(reference.NameWithTypeParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
+            Assert.IsFalse(reference.IsDefinition);
+            Assert.AreEqual("Test1.Extension.Play``2(Test1.Foo{``0},``0,``1)", reference.Definition);
+            Assert.AreEqual("Play<T[], Way>(Foo<T[]>, T[], Way)", string.Concat(reference.NameParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
+            Assert.AreEqual("Extension.Play<T[], Way>(Foo<T[]>, T[], Way)", string.Concat(reference.NameWithTypeParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
         }
         // FooImple2<T>
         extensionMethods = output.Items[0].Items[2].ExtensionMethods;
-        Assert.Single(extensionMethods);
+        Assert.ContainsSingle(extensionMethods);
         {
-            Assert.Equal("Test1.Foo{System.Object}.Test1.Extension.Play``2(System.Object,{Way})", extensionMethods[0]);
+            Assert.AreEqual("Test1.Foo{System.Object}.Test1.Extension.Play``2(System.Object,{Way})", extensionMethods[0]);
             var reference = output.References[extensionMethods[0]];
-            Assert.False(reference.IsDefinition);
-            Assert.Equal("Test1.Extension.Play``2(Test1.Foo{``0},``0,``1)", reference.Definition);
-            Assert.Equal("Play<dynamic, Way>(Foo<dynamic>, dynamic, Way)", string.Concat(reference.NameParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
-            Assert.Equal("Extension.Play<dynamic, Way>(Foo<dynamic>, dynamic, Way)", string.Concat(reference.NameWithTypeParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
+            Assert.IsFalse(reference.IsDefinition);
+            Assert.AreEqual("Test1.Extension.Play``2(Test1.Foo{``0},``0,``1)", reference.Definition);
+            Assert.AreEqual("Play<dynamic, Way>(Foo<dynamic>, dynamic, Way)", string.Concat(reference.NameParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
+            Assert.AreEqual("Extension.Play<dynamic, Way>(Foo<dynamic>, dynamic, Way)", string.Concat(reference.NameWithTypeParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
         }
         // FooImple3<T>
         extensionMethods = output.Items[0].Items[3].ExtensionMethods;
-        Assert.Single(extensionMethods);
+        Assert.ContainsSingle(extensionMethods);
         {
-            Assert.Equal("Test1.Foo{Test1.Foo{`0[]}}.Test1.Extension.Play``2(Test1.Foo{{T}[]},{Way})", extensionMethods[0]);
+            Assert.AreEqual("Test1.Foo{Test1.Foo{`0[]}}.Test1.Extension.Play``2(Test1.Foo{{T}[]},{Way})", extensionMethods[0]);
             var reference = output.References[extensionMethods[0]];
-            Assert.False(reference.IsDefinition);
-            Assert.Equal("Test1.Extension.Play``2(Test1.Foo{``0},``0,``1)", reference.Definition);
-            Assert.Equal("Play<Foo<T[]>, Way>(Foo<Foo<T[]>>, Foo<T[]>, Way)", string.Concat(reference.NameParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
-            Assert.Equal("Extension.Play<Foo<T[]>, Way>(Foo<Foo<T[]>>, Foo<T[]>, Way)", string.Concat(reference.NameWithTypeParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
+            Assert.IsFalse(reference.IsDefinition);
+            Assert.AreEqual("Test1.Extension.Play``2(Test1.Foo{``0},``0,``1)", reference.Definition);
+            Assert.AreEqual("Play<Foo<T[]>, Way>(Foo<Foo<T[]>>, Foo<T[]>, Way)", string.Concat(reference.NameParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
+            Assert.AreEqual("Extension.Play<Foo<T[]>, Way>(Foo<Foo<T[]>>, Foo<T[]>, Way)", string.Concat(reference.NameWithTypeParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
         }
         // Doll
         extensionMethods = output.Items[0].Items[4].ExtensionMethods;
-        Assert.Equal(2, extensionMethods.Count);
+        Assert.AreEqual(2, extensionMethods.Count);
         {
-            Assert.Equal("Test1.Doll.Test1.Extension.Rain", extensionMethods[0]);
+            Assert.AreEqual("Test1.Doll.Test1.Extension.Rain", extensionMethods[0]);
             var reference = output.References[extensionMethods[0]];
-            Assert.False(reference.IsDefinition);
-            Assert.Equal("Test1.Extension.Rain(Test1.Doll)", reference.Definition);
-            Assert.Equal("Rain(Doll)", string.Concat(reference.NameParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
-            Assert.Equal("Extension.Rain(Doll)", string.Concat(reference.NameWithTypeParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
+            Assert.IsFalse(reference.IsDefinition);
+            Assert.AreEqual("Test1.Extension.Rain(Test1.Doll)", reference.Definition);
+            Assert.AreEqual("Rain(Doll)", string.Concat(reference.NameParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
+            Assert.AreEqual("Extension.Rain(Doll)", string.Concat(reference.NameWithTypeParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
         }
         {
-            Assert.Equal("Test1.Doll.Test1.Extension.Rain(Test1.Doll)", extensionMethods[1]);
+            Assert.AreEqual("Test1.Doll.Test1.Extension.Rain(Test1.Doll)", extensionMethods[1]);
             var reference = output.References[extensionMethods[1]];
-            Assert.False(reference.IsDefinition);
-            Assert.Equal("Test1.Extension.Rain(Test1.Doll,Test1.Doll)", reference.Definition);
-            Assert.Equal("Rain(Doll, Doll)", string.Concat(reference.NameParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
-            Assert.Equal("Extension.Rain(Doll, Doll)", string.Concat(reference.NameWithTypeParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
+            Assert.IsFalse(reference.IsDefinition);
+            Assert.AreEqual("Test1.Extension.Rain(Test1.Doll,Test1.Doll)", reference.Definition);
+            Assert.AreEqual("Rain(Doll, Doll)", string.Concat(reference.NameParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
+            Assert.AreEqual("Extension.Rain(Doll, Doll)", string.Concat(reference.NameWithTypeParts[SyntaxLanguage.CSharp].Select(n => n.DisplayName)));
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithOperator()
     {
         string code = @"
@@ -1229,249 +1229,249 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         // unary
         {
             var method = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(method);
-            Assert.Equal("operator +(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator +(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator +(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_UnaryPlus(Test1.Foo)", method.Name);
-            Assert.Equal("public static Foo operator +(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator +(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator +(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator +(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_UnaryPlus(Test1.Foo)", method.Name);
+            Assert.AreEqual("public static Foo operator +(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(method);
-            Assert.Equal("operator -(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator -(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator -(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_UnaryNegation(Test1.Foo)", method.Name);
-            Assert.Equal("public static Foo operator -(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator -(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator -(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator -(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_UnaryNegation(Test1.Foo)", method.Name);
+            Assert.AreEqual("public static Foo operator -(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(method);
-            Assert.Equal("operator !(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator !(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator !(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_LogicalNot(Test1.Foo)", method.Name);
-            Assert.Equal("public static Foo operator !(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator !(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator !(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator !(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_LogicalNot(Test1.Foo)", method.Name);
+            Assert.AreEqual("public static Foo operator !(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(method);
-            Assert.Equal("operator ~(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator ~(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator ~(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_OnesComplement(Test1.Foo)", method.Name);
-            Assert.Equal("public static Foo operator ~(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator ~(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator ~(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator ~(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_OnesComplement(Test1.Foo)", method.Name);
+            Assert.AreEqual("public static Foo operator ~(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[4];
-            Assert.NotNull(method);
-            Assert.Equal("operator ++(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator ++(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator ++(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_Increment(Test1.Foo)", method.Name);
-            Assert.Equal("public static Foo operator ++(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator ++(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator ++(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator ++(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_Increment(Test1.Foo)", method.Name);
+            Assert.AreEqual("public static Foo operator ++(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[5];
-            Assert.NotNull(method);
-            Assert.Equal("operator --(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator --(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator --(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_Decrement(Test1.Foo)", method.Name);
-            Assert.Equal("public static Foo operator --(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator --(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator --(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator --(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_Decrement(Test1.Foo)", method.Name);
+            Assert.AreEqual("public static Foo operator --(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[6];
-            Assert.NotNull(method);
-            Assert.Equal("operator true(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator true(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator true(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_True(Test1.Foo)", method.Name);
-            Assert.Equal("public static Foo operator true(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator true(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator true(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator true(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_True(Test1.Foo)", method.Name);
+            Assert.AreEqual("public static Foo operator true(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[7];
-            Assert.NotNull(method);
-            Assert.Equal("operator false(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator false(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator false(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_False(Test1.Foo)", method.Name);
-            Assert.Equal("public static Foo operator false(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator false(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator false(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator false(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_False(Test1.Foo)", method.Name);
+            Assert.AreEqual("public static Foo operator false(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         // binary
         {
             var method = output.Items[0].Items[0].Items[8];
-            Assert.NotNull(method);
-            Assert.Equal("operator +(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator +(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator +(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_Addition(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("public static Foo operator +(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator +(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator +(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator +(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_Addition(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("public static Foo operator +(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[9];
-            Assert.NotNull(method);
-            Assert.Equal("operator -(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator -(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator -(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_Subtraction(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("public static Foo operator -(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator -(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator -(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator -(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_Subtraction(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("public static Foo operator -(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[10];
-            Assert.NotNull(method);
-            Assert.Equal("operator *(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator *(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator *(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_Multiply(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("public static Foo operator *(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator *(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator *(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator *(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_Multiply(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("public static Foo operator *(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[11];
-            Assert.NotNull(method);
-            Assert.Equal("operator /(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator /(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator /(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_Division(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("public static Foo operator /(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator /(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator /(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator /(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_Division(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("public static Foo operator /(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[12];
-            Assert.NotNull(method);
-            Assert.Equal("operator %(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator %(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator %(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_Modulus(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("public static Foo operator %(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator %(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator %(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator %(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_Modulus(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("public static Foo operator %(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[13];
-            Assert.NotNull(method);
-            Assert.Equal("operator &(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator &(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator &(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_BitwiseAnd(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("public static Foo operator &(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator &(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator &(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator &(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_BitwiseAnd(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("public static Foo operator &(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[14];
-            Assert.NotNull(method);
-            Assert.Equal("operator |(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator |(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator |(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_BitwiseOr(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("public static Foo operator |(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator |(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator |(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator |(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_BitwiseOr(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("public static Foo operator |(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[15];
-            Assert.NotNull(method);
-            Assert.Equal("operator ^(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator ^(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator ^(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_ExclusiveOr(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("public static Foo operator ^(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator ^(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator ^(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator ^(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_ExclusiveOr(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("public static Foo operator ^(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[16];
-            Assert.NotNull(method);
-            Assert.Equal("operator >>(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator >>(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator >>(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_RightShift(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("public static Foo operator >>(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator >>(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator >>(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator >>(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_RightShift(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("public static Foo operator >>(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[17];
-            Assert.NotNull(method);
-            Assert.Equal("operator <<(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator <<(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator <<(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_LeftShift(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("public static Foo operator <<(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator <<(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator <<(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator <<(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_LeftShift(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("public static Foo operator <<(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         // comparison
         {
             var method = output.Items[0].Items[0].Items[18];
-            Assert.NotNull(method);
-            Assert.Equal("operator ==(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator ==(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator ==(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_Equality(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("public static bool operator ==(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator ==(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator ==(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator ==(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_Equality(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("public static bool operator ==(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[19];
-            Assert.NotNull(method);
-            Assert.Equal("operator !=(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator !=(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator !=(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_Inequality(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("public static bool operator !=(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator !=(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator !=(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator !=(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_Inequality(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("public static bool operator !=(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[20];
-            Assert.NotNull(method);
-            Assert.Equal("operator >(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator >(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator >(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_GreaterThan(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("public static bool operator >(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator >(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator >(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator >(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_GreaterThan(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("public static bool operator >(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[21];
-            Assert.NotNull(method);
-            Assert.Equal("operator <(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator <(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator <(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_LessThan(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("public static bool operator <(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator <(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator <(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator <(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_LessThan(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("public static bool operator <(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[22];
-            Assert.NotNull(method);
-            Assert.Equal("operator >=(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator >=(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator >=(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_GreaterThanOrEqual(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("public static bool operator >=(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator >=(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator >=(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator >=(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_GreaterThanOrEqual(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("public static bool operator >=(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[23];
-            Assert.NotNull(method);
-            Assert.Equal("operator <=(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.operator <=(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.operator <=(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_LessThanOrEqual(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("public static bool operator <=(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("operator <=(Foo, int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.operator <=(Foo, int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.operator <=(Test1.Foo, int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_LessThanOrEqual(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("public static bool operator <=(Foo x, int y)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         // conversion
         {
             var method = output.Items[0].Items[0].Items[24];
-            Assert.NotNull(method);
-            Assert.Equal("implicit operator Foo(int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.implicit operator Foo(int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.implicit operator Test1.Foo(int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_Implicit(System.Int32)~Test1.Foo", method.Name);
-            Assert.Equal("public static implicit operator Foo(int x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("implicit operator Foo(int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.implicit operator Foo(int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.implicit operator Test1.Foo(int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_Implicit(System.Int32)~Test1.Foo", method.Name);
+            Assert.AreEqual("public static implicit operator Foo(int x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var method = output.Items[0].Items[0].Items[25];
-            Assert.NotNull(method);
-            Assert.Equal("explicit operator int(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.explicit operator int(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.explicit operator int(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.op_Explicit(Test1.Foo)~System.Int32", method.Name);
-            Assert.Equal("public static explicit operator int(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("explicit operator int(Foo)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.explicit operator int(Foo)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.explicit operator int(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.op_Explicit(Test1.Foo)~System.Int32", method.Name);
+            Assert.AreEqual("public static explicit operator int(Foo x)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestMethod]
     public void TestGenerateMetadataWithConstructor()
     {
         string code = @"
@@ -1492,56 +1492,56 @@ protected Bar(int x){}
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var constructor = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(constructor);
-            Assert.Equal("Foo()", constructor.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.Foo()", constructor.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.Foo()", constructor.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.#ctor", constructor.Name);
-            Assert.Equal("public Foo()", constructor.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(constructor);
+            Assert.AreEqual("Foo()", constructor.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.Foo()", constructor.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.Foo()", constructor.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.#ctor", constructor.Name);
+            Assert.AreEqual("public Foo()", constructor.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var constructor = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(constructor);
-            Assert.Equal("Foo(int)", constructor.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.Foo(int)", constructor.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.Foo(int)", constructor.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.#ctor(System.Int32)", constructor.Name);
-            Assert.Equal("public Foo(int x)", constructor.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(constructor);
+            Assert.AreEqual("Foo(int)", constructor.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.Foo(int)", constructor.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.Foo(int)", constructor.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.#ctor(System.Int32)", constructor.Name);
+            Assert.AreEqual("public Foo(int x)", constructor.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var constructor = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(constructor);
-            Assert.Equal("Foo(string)", constructor.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.Foo(string)", constructor.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.Foo(string)", constructor.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.#ctor(System.String)", constructor.Name);
-            Assert.Equal("protected Foo(string x)", constructor.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(constructor);
+            Assert.AreEqual("Foo(string)", constructor.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.Foo(string)", constructor.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.Foo(string)", constructor.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.#ctor(System.String)", constructor.Name);
+            Assert.AreEqual("protected Foo(string x)", constructor.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var constructor = output.Items[0].Items[1].Items[0];
-            Assert.NotNull(constructor);
-            Assert.Equal("Bar()", constructor.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar.Bar()", constructor.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.Bar()", constructor.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.#ctor", constructor.Name);
-            Assert.Equal("public Bar()", constructor.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(constructor);
+            Assert.AreEqual("Bar()", constructor.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar.Bar()", constructor.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.Bar()", constructor.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.#ctor", constructor.Name);
+            Assert.AreEqual("public Bar()", constructor.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var constructor = output.Items[0].Items[1].Items[1];
-            Assert.NotNull(constructor);
-            Assert.Equal("Bar(int)", constructor.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar.Bar(int)", constructor.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.Bar(int)", constructor.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.#ctor(System.Int32)", constructor.Name);
-            Assert.Equal("protected Bar(int x)", constructor.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(constructor);
+            Assert.AreEqual("Bar(int)", constructor.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar.Bar(int)", constructor.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.Bar(int)", constructor.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.#ctor(System.Int32)", constructor.Name);
+            Assert.AreEqual("protected Bar(int x)", constructor.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestMethod]
     public void TestGenerateMetadataWithField()
     {
         string code = @"
@@ -1564,83 +1564,83 @@ public enum Bar
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var field = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(field);
-            Assert.Equal("X", field.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.X", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.X", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.X", field.Name);
-            Assert.Equal("public volatile int X", field.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("X", field.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.X", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.X", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.X", field.Name);
+            Assert.AreEqual("public volatile int X", field.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var field = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(field);
-            Assert.Equal("Y", field.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.Y", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.Y", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.Y", field.Name);
-            Assert.Equal("protected static readonly Foo<T> Y", field.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("Y", field.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.Y", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.Y", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.Y", field.Name);
+            Assert.AreEqual("protected static readonly Foo<T> Y", field.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var field = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(field);
-            Assert.Equal("Z", field.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.Z", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.Z", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.Z", field.Name);
-            Assert.Equal("protected const string Z = \"\"", field.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("Z", field.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.Z", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.Z", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.Z", field.Name);
+            Assert.AreEqual("protected const string Z = \"\"", field.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var field = output.Items[0].Items[1].Items[0];
-            Assert.NotNull(field);
-            Assert.Equal("Black", field.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar.Black", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.Black", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.Black", field.Name);
-            Assert.Equal("Black = 0", field.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("Black", field.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar.Black", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.Black", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.Black", field.Name);
+            Assert.AreEqual("Black = 0", field.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var field = output.Items[0].Items[1].Items[1];
-            Assert.NotNull(field);
-            Assert.Equal("Red", field.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar.Red", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.Red", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.Red", field.Name);
-            Assert.Equal("Red = 1", field.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("Red", field.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar.Red", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.Red", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.Red", field.Name);
+            Assert.AreEqual("Red = 1", field.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var field = output.Items[0].Items[1].Items[2];
-            Assert.NotNull(field);
-            Assert.Equal("Blue", field.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar.Blue", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.Blue", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.Blue", field.Name);
-            Assert.Equal("Blue = 2", field.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("Blue", field.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar.Blue", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.Blue", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.Blue", field.Name);
+            Assert.AreEqual("Blue = 2", field.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var field = output.Items[0].Items[1].Items[3];
-            Assert.NotNull(field);
-            Assert.Equal("Green", field.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar.Green", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.Green", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.Green", field.Name);
-            Assert.Equal("Green = 4", field.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("Green", field.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar.Green", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.Green", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.Green", field.Name);
+            Assert.AreEqual("Green = 4", field.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var field = output.Items[0].Items[1].Items[4];
-            Assert.NotNull(field);
-            Assert.Equal("White", field.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar.White", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.White", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.White", field.Name);
-            Assert.Equal("White = 7", field.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("White", field.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar.White", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.White", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.White", field.Name);
+            Assert.AreEqual("White = 7", field.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestMethod]
     public void TestGenerateMetadataWithCSharpCodeAndEvent()
     {
         string code = @"
@@ -1668,94 +1668,94 @@ public interface IFooBar<T> where T : EventArgs
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var a = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(a);
-            Assert.Equal("A", a.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.A", a.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.A", a.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.A", a.Name);
-            Assert.Equal("public event EventHandler A", a.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(a);
+            Assert.AreEqual("A", a.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.A", a.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.A", a.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.A", a.Name);
+            Assert.AreEqual("public event EventHandler A", a.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var b = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(b);
-            Assert.Equal("B", b.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.B", b.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.B", b.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.B", b.Name);
-            Assert.Equal("protected static event EventHandler B", b.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(b);
+            Assert.AreEqual("B", b.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.B", b.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.B", b.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.B", b.Name);
+            Assert.AreEqual("protected static event EventHandler B", b.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var c = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(c);
-            Assert.Equal("C", c.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.C", c.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.C", c.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.C", c.Name);
-            Assert.Equal("protected abstract event EventHandler<T> C", c.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(c);
+            Assert.AreEqual("C", c.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.C", c.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.C", c.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.C", c.Name);
+            Assert.AreEqual("protected abstract event EventHandler<T> C", c.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var d = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(d);
-            Assert.Equal("D", d.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.D", d.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.D", d.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.D", d.Name);
-            Assert.Equal("public virtual event EventHandler<T> D", d.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(d);
+            Assert.AreEqual("D", d.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.D", d.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.D", d.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.D", d.Name);
+            Assert.AreEqual("public virtual event EventHandler<T> D", d.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var a = output.Items[0].Items[1].Items[0];
-            Assert.NotNull(a);
-            Assert.Equal("A", a.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar<T>.A", a.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar<T>.A", a.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar`1.A", a.Name);
-            Assert.Equal("public event EventHandler A", a.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(a);
+            Assert.AreEqual("A", a.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar<T>.A", a.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar<T>.A", a.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar`1.A", a.Name);
+            Assert.AreEqual("public event EventHandler A", a.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var c = output.Items[0].Items[1].Items[1];
-            Assert.NotNull(c);
-            Assert.Equal("C", c.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar<T>.C", c.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar<T>.C", c.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar`1.C", c.Name);
-            Assert.Equal("protected override sealed event EventHandler<T> C", c.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo{{T}}.C", c.Overridden);
+            Assert.IsNotNull(c);
+            Assert.AreEqual("C", c.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar<T>.C", c.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar<T>.C", c.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar`1.C", c.Name);
+            Assert.AreEqual("protected override sealed event EventHandler<T> C", c.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo{{T}}.C", c.Overridden);
         }
         {
             var d = output.Items[0].Items[1].Items[2];
-            Assert.NotNull(d);
-            Assert.Equal("D", d.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar<T>.D", d.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar<T>.D", d.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar`1.D", d.Name);
-            Assert.Equal("public override event EventHandler<T> D", d.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo{{T}}.D", d.Overridden);
+            Assert.IsNotNull(d);
+            Assert.AreEqual("D", d.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar<T>.D", d.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar<T>.D", d.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar`1.D", d.Name);
+            Assert.AreEqual("public override event EventHandler<T> D", d.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo{{T}}.D", d.Overridden);
         }
         {
             var a = output.Items[0].Items[2].Items[0];
-            Assert.NotNull(a);
-            Assert.Equal("A", a.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("IFooBar<T>.A", a.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar<T>.A", a.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar`1.A", a.Name);
-            Assert.Equal("event EventHandler A", a.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(a);
+            Assert.AreEqual("A", a.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("IFooBar<T>.A", a.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar<T>.A", a.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar`1.A", a.Name);
+            Assert.AreEqual("event EventHandler A", a.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var d = output.Items[0].Items[2].Items[1];
-            Assert.NotNull(d);
-            Assert.Equal("D", d.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("IFooBar<T>.D", d.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar<T>.D", d.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar`1.D", d.Name);
-            Assert.Equal("event EventHandler<T> D", d.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(d);
+            Assert.AreEqual("D", d.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("IFooBar<T>.D", d.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar<T>.D", d.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar`1.D", d.Name);
+            Assert.AreEqual("event EventHandler<T> D", d.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestMethod]
     public void TestGenerateMetadataWithProperty()
     {
         string code = @"
@@ -1787,139 +1787,139 @@ public interface IFooBar
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var a = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(a);
-            Assert.Equal("A", a.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.A", a.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.A", a.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.A", a.Name);
-            Assert.Equal("public int A { get; set; }", a.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(a);
+            Assert.AreEqual("A", a.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.A", a.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.A", a.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.A", a.Name);
+            Assert.AreEqual("public int A { get; set; }", a.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var b = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(b);
-            Assert.Equal("B", b.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.B", b.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.B", b.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.B", b.Name);
-            Assert.Equal("public virtual int B { get; }", b.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(b);
+            Assert.AreEqual("B", b.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.B", b.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.B", b.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.B", b.Name);
+            Assert.AreEqual("public virtual int B { get; }", b.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var c = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(c);
-            Assert.Equal("C", c.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.C", c.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.C", c.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.C", c.Name);
-            Assert.Equal("public abstract int C { set; }", c.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(c);
+            Assert.AreEqual("C", c.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.C", c.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.C", c.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.C", c.Name);
+            Assert.AreEqual("public abstract int C { set; }", c.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var d = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(d);
-            Assert.Equal("D", d.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.D", d.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.D", d.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.D", d.Name);
-            Assert.Equal("protected int D { get; }", d.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(d);
+            Assert.AreEqual("D", d.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.D", d.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.D", d.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.D", d.Name);
+            Assert.AreEqual("protected int D { get; }", d.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var e = output.Items[0].Items[0].Items[4];
-            Assert.NotNull(e);
-            Assert.Equal("E", e.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.E", e.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.E", e.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.E", e.Name);
-            Assert.Equal("public T E { get; protected set; }", e.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(e);
+            Assert.AreEqual("E", e.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.E", e.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.E", e.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.E", e.Name);
+            Assert.AreEqual("public T E { get; protected set; }", e.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var f = output.Items[0].Items[0].Items[5];
-            Assert.NotNull(f);
-            Assert.Equal("F", f.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.F", f.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.F", f.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.F", f.Name);
-            Assert.Equal("protected static int F { get; set; }", f.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(f);
+            Assert.AreEqual("F", f.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.F", f.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.F", f.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.F", f.Name);
+            Assert.AreEqual("protected static int F { get; set; }", f.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var g = output.Items[0].Items[0].Items[6];
-            Assert.NotNull(g);
-            Assert.Equal("G", g.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.G", g.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.G", g.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.G", g.Name);
-            Assert.Equal("public ref int G { get; }", g.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(g);
+            Assert.AreEqual("G", g.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.G", g.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.G", g.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.G", g.Name);
+            Assert.AreEqual("public ref int G { get; }", g.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var h = output.Items[0].Items[0].Items[7];
-            Assert.NotNull(h);
-            Assert.Equal("H", h.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.H", h.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.H", h.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.H", h.Name);
-            Assert.Equal("public ref readonly int H { get; }", h.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(h);
+            Assert.AreEqual("H", h.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.H", h.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.H", h.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.H", h.Name);
+            Assert.AreEqual("public ref readonly int H { get; }", h.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var a = output.Items[0].Items[1].Items[0];
-            Assert.NotNull(a);
-            Assert.Equal("A", a.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar.A", a.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.A", a.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.A", a.Name);
-            Assert.Equal("public virtual int A { get; set; }", a.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(a);
+            Assert.AreEqual("A", a.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar.A", a.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.A", a.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.A", a.Name);
+            Assert.AreEqual("public virtual int A { get; set; }", a.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var b = output.Items[0].Items[1].Items[1];
-            Assert.NotNull(b);
-            Assert.Equal("B", b.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar.B", b.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.B", b.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.B", b.Name);
-            Assert.Equal("public override int B { get; }", b.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo{System.String}.B", b.Overridden);
+            Assert.IsNotNull(b);
+            Assert.AreEqual("B", b.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar.B", b.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.B", b.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.B", b.Name);
+            Assert.AreEqual("public override int B { get; }", b.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo{System.String}.B", b.Overridden);
         }
         {
             var c = output.Items[0].Items[1].Items[2];
-            Assert.NotNull(c);
-            Assert.Equal("C", c.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar.C", c.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.C", c.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.C", c.Name);
-            Assert.Equal("public override sealed int C { set; }", c.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo{System.String}.C", c.Overridden);
+            Assert.IsNotNull(c);
+            Assert.AreEqual("C", c.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar.C", c.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.C", c.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.C", c.Name);
+            Assert.AreEqual("public override sealed int C { set; }", c.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo{System.String}.C", c.Overridden);
         }
         {
             var a = output.Items[0].Items[2].Items[0];
-            Assert.NotNull(a);
-            Assert.Equal("A", a.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("IFooBar.A", a.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.A", a.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.A", a.Name);
-            Assert.Equal("int A { get; set; }", a.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(a);
+            Assert.AreEqual("A", a.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("IFooBar.A", a.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.A", a.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.A", a.Name);
+            Assert.AreEqual("int A { get; set; }", a.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var b = output.Items[0].Items[2].Items[1];
-            Assert.NotNull(b);
-            Assert.Equal("B", b.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("IFooBar.B", b.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.B", b.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.B", b.Name);
-            Assert.Equal("int B { get; }", b.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(b);
+            Assert.AreEqual("B", b.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("IFooBar.B", b.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.B", b.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.B", b.Name);
+            Assert.AreEqual("int B { get; }", b.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var c = output.Items[0].Items[2].Items[2];
-            Assert.NotNull(c);
-            Assert.Equal("C", c.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("IFooBar.C", c.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.C", c.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.C", c.Name);
-            Assert.Equal("int C { set; }", c.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(c);
+            Assert.AreEqual("C", c.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("IFooBar.C", c.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.C", c.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.C", c.Name);
+            Assert.AreEqual("int C { set; }", c.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestMethod]
     public void TestGenerateMetadataWithIndexer()
     {
         string code = @"
@@ -1950,126 +1950,126 @@ public interface IFooBar
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         // Foo<T>
         {
             var indexer = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(indexer);
-            Assert.Equal("this[int]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.this[int]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.this[int]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.Item(System.Int32)", indexer.Name);
-            Assert.Equal("public int this[int x] { get; set; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(indexer);
+            Assert.AreEqual("this[int]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.this[int]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.this[int]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.Item(System.Int32)", indexer.Name);
+            Assert.AreEqual("public int this[int x] { get; set; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var indexer = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(indexer);
-            Assert.Equal("this[string]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.this[string]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.this[string]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.Item(System.String)", indexer.Name);
-            Assert.Equal("public virtual int this[string x] { get; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(indexer);
+            Assert.AreEqual("this[string]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.this[string]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.this[string]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.Item(System.String)", indexer.Name);
+            Assert.AreEqual("public virtual int this[string x] { get; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var indexer = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(indexer);
-            Assert.Equal("this[object]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.this[object]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.this[object]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.Item(System.Object)", indexer.Name);
-            Assert.Equal("public abstract int this[object x] { set; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(indexer);
+            Assert.AreEqual("this[object]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.this[object]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.this[object]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.Item(System.Object)", indexer.Name);
+            Assert.AreEqual("public abstract int this[object x] { set; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var indexer = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(indexer);
-            Assert.Equal("this[DateTime]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.this[DateTime]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.this[System.DateTime]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.Item(System.DateTime)", indexer.Name);
-            Assert.Equal("protected int this[DateTime x] { get; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(indexer);
+            Assert.AreEqual("this[DateTime]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.this[DateTime]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.this[System.DateTime]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.Item(System.DateTime)", indexer.Name);
+            Assert.AreEqual("protected int this[DateTime x] { get; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var indexer = output.Items[0].Items[0].Items[4];
-            Assert.NotNull(indexer);
-            Assert.Equal("this[T]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.this[T]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.this[T]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.Item(`0)", indexer.Name);
-            Assert.Equal("public int this[T t] { get; protected set; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(indexer);
+            Assert.AreEqual("this[T]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.this[T]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.this[T]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.Item(`0)", indexer.Name);
+            Assert.AreEqual("public int this[T t] { get; protected set; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var indexer = output.Items[0].Items[0].Items[5];
-            Assert.NotNull(indexer);
-            Assert.Equal("this[int, T]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo<T>.this[int, T]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo<T>.this[int, T]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo`1.Item(System.Int32,`0)", indexer.Name);
-            Assert.Equal("protected int this[int x, T t] { get; set; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(indexer);
+            Assert.AreEqual("this[int, T]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo<T>.this[int, T]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo<T>.this[int, T]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo`1.Item(System.Int32,`0)", indexer.Name);
+            Assert.AreEqual("protected int this[int x, T t] { get; set; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         // Bar
         {
             var indexer = output.Items[0].Items[1].Items[0];
-            Assert.NotNull(indexer);
-            Assert.Equal("this[int]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar.this[int]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.this[int]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.Item(System.Int32)", indexer.Name);
-            Assert.Equal("public virtual int this[int x] { get; set; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.Item(System.Int32)", indexer.Implements[0]);
+            Assert.IsNotNull(indexer);
+            Assert.AreEqual("this[int]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar.this[int]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.this[int]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.Item(System.Int32)", indexer.Name);
+            Assert.AreEqual("public virtual int this[int x] { get; set; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.Item(System.Int32)", indexer.Implements[0]);
         }
         {
             var indexer = output.Items[0].Items[1].Items[1];
-            Assert.NotNull(indexer);
-            Assert.Equal("this[string]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar.this[string]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.this[string]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.Item(System.String)", indexer.Name);
-            Assert.Equal("public override int this[string x] { get; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo{System.String}.Item(System.String)", indexer.Overridden);
-            Assert.Equal("Test1.IFooBar.Item(System.String)", indexer.Implements[0]);
+            Assert.IsNotNull(indexer);
+            Assert.AreEqual("this[string]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar.this[string]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.this[string]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.Item(System.String)", indexer.Name);
+            Assert.AreEqual("public override int this[string x] { get; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo{System.String}.Item(System.String)", indexer.Overridden);
+            Assert.AreEqual("Test1.IFooBar.Item(System.String)", indexer.Implements[0]);
         }
         {
             var indexer = output.Items[0].Items[1].Items[2];
-            Assert.NotNull(indexer);
-            Assert.Equal("this[object]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar.this[object]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.this[object]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Bar.Item(System.Object)", indexer.Name);
-            Assert.Equal("public override sealed int this[object x] { set; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo{System.String}.Item(System.Object)", indexer.Overridden);
-            Assert.Equal("Test1.IFooBar.Item(System.Object)", indexer.Implements[0]);
+            Assert.IsNotNull(indexer);
+            Assert.AreEqual("this[object]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar.this[object]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.this[object]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Bar.Item(System.Object)", indexer.Name);
+            Assert.AreEqual("public override sealed int this[object x] { set; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo{System.String}.Item(System.Object)", indexer.Overridden);
+            Assert.AreEqual("Test1.IFooBar.Item(System.Object)", indexer.Implements[0]);
         }
         // IFooBar
         {
             var indexer = output.Items[0].Items[2].Items[0];
-            Assert.NotNull(indexer);
-            Assert.Equal("this[int]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("IFooBar.this[int]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.this[int]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.Item(System.Int32)", indexer.Name);
-            Assert.Equal("int this[int x] { get; set; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(indexer);
+            Assert.AreEqual("this[int]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("IFooBar.this[int]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.this[int]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.Item(System.Int32)", indexer.Name);
+            Assert.AreEqual("int this[int x] { get; set; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var indexer = output.Items[0].Items[2].Items[1];
-            Assert.NotNull(indexer);
-            Assert.Equal("this[string]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("IFooBar.this[string]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.this[string]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.Item(System.String)", indexer.Name);
-            Assert.Equal("int this[string x] { get; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(indexer);
+            Assert.AreEqual("this[string]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("IFooBar.this[string]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.this[string]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.Item(System.String)", indexer.Name);
+            Assert.AreEqual("int this[string x] { get; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var indexer = output.Items[0].Items[2].Items[2];
-            Assert.NotNull(indexer);
-            Assert.Equal("this[object]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("IFooBar.this[object]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.this[object]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.IFooBar.Item(System.Object)", indexer.Name);
-            Assert.Equal("int this[object x] { set; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(indexer);
+            Assert.AreEqual("this[object]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("IFooBar.this[object]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.this[object]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.IFooBar.Item(System.Object)", indexer.Name);
+            Assert.AreEqual("int this[object x] { set; }", indexer.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithMethodUsingDefaultValue()
     {
         string code = @"
@@ -2090,15 +2090,15 @@ public void Test(
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var method = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(method);
-            Assert.Equal(@"public void Test(int a = 1, uint b = 1, short c = 1, ushort d = 1, long e = 1, ulong f = 1, byte g = 1, sbyte h = 1, char i = '1', string j = ""1"", bool k = true, object l = null)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual(@"public void Test(int a = 1, uint b = 1, short c = 1, ushort d = 1, long e = 1, ulong f = 1, byte g = 1, sbyte h = 1, char i = '1', string j = ""1"", bool k = true, object l = null)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataAsyncWithAssemblyInfoAndCrossReference()
     {
         string referenceCode = @"
@@ -2139,19 +2139,19 @@ public void Func1(Test1.Class1 i)
         Directory.CreateDirectory(nameof(TestGenerateMetadataAsyncWithAssemblyInfoAndCrossReference));
         var referencedAssembly = CreateAssemblyFromCSharpCode(referenceCode, $"{nameof(TestGenerateMetadataAsyncWithAssemblyInfoAndCrossReference)}/reference.dll");
         var compilation = CreateCompilationFromCSharpCode(code, references: MetadataReference.CreateFromFile(referencedAssembly.Location));
-        Assert.Equal("test.dll", compilation.AssemblyName);
+        Assert.AreEqual("test.dll", compilation.AssemblyName);
         MetadataItem output = Verify(code);
-        Assert.Null(output.AssemblyNameList);
-        Assert.Null(output.NamespaceName);
-        Assert.Equal("test.dll", output.Items[0].AssemblyNameList.First());
-        Assert.Null(output.Items[0].NamespaceName);
-        Assert.Equal("test.dll", output.Items[0].Items[0].AssemblyNameList.First());
-        Assert.Equal("Test2", output.Items[0].Items[0].NamespaceName);
+        Assert.IsNull(output.AssemblyNameList);
+        Assert.IsNull(output.NamespaceName);
+        Assert.AreEqual("test.dll", output.Items[0].AssemblyNameList.First());
+        Assert.IsNull(output.Items[0].NamespaceName);
+        Assert.AreEqual("test.dll", output.Items[0].Items[0].AssemblyNameList.First());
+        Assert.AreEqual("Test2", output.Items[0].Items[0].NamespaceName);
     }
 
-    [Fact]
-    [Trait("Related", "Multilanguage")]
-    [Trait("Related", "Generic")]
+    [TestMethod]
+    [TestProperty("Related", "Multilanguage")]
+    [TestProperty("Related", "Generic")]
     public void TestGenerateMetadataAsyncWithMultilanguage()
     {
         string code = @"
@@ -2171,56 +2171,56 @@ public int this[int index]
 ";
         MetadataItem output = Verify(code);
         var type = output.Items[0].Items[0];
-        Assert.NotNull(type);
-        Assert.Equal("Foo<T>", type.DisplayNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("Foo(Of T)", type.DisplayNames[SyntaxLanguage.VB]);
-        Assert.Equal("Foo<T>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-        Assert.Equal("Foo(Of T)", type.DisplayNamesWithType[SyntaxLanguage.VB]);
-        Assert.Equal("Test1.Foo<T>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("Test1.Foo(Of T)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-        Assert.Equal("Test1.Foo`1", type.Name);
+        Assert.IsNotNull(type);
+        Assert.AreEqual("Foo<T>", type.DisplayNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Foo(Of T)", type.DisplayNames[SyntaxLanguage.VB]);
+        Assert.AreEqual("Foo<T>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Foo(Of T)", type.DisplayNamesWithType[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo<T>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo(Of T)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo`1", type.Name);
 
         {
             var method = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(method);
-            Assert.Equal("Bar<K>(int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Bar(Of K)(Integer)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Foo<T>.Bar<K>(int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo(Of T).Bar(Of K)(Integer)", method.DisplayNamesWithType[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo<T>.Bar<K>(int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo(Of T).Bar(Of K)(Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.Bar``1(System.Int32)", method.Name);
-            Assert.Single(method.Syntax.Parameters);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("Bar<K>(int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Bar(Of K)(Integer)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Foo<T>.Bar<K>(int)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo(Of T).Bar(Of K)(Integer)", method.DisplayNamesWithType[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo<T>.Bar<K>(int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo(Of T).Bar(Of K)(Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.Bar``1(System.Int32)", method.Name);
+            Assert.ContainsSingle(method.Syntax.Parameters);
             var parameter = method.Syntax.Parameters[0];
-            Assert.Equal("i", parameter.Name);
-            Assert.Equal("System.Int32", parameter.Type);
+            Assert.AreEqual("i", parameter.Name);
+            Assert.AreEqual("System.Int32", parameter.Type);
             var returnValue = method.Syntax.Return;
-            Assert.Null(returnValue);
+            Assert.IsNull(returnValue);
         }
 
         {
             var indexer = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(indexer);
-            Assert.Equal("this[int]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("this[](Integer)", indexer.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Foo<T>.this[int]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo(Of T).this[](Integer)", indexer.DisplayNamesWithType[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo<T>.this[int]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo(Of T).this[](Integer)", indexer.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.Item(System.Int32)", indexer.Name);
-            Assert.Single(indexer.Syntax.Parameters);
+            Assert.IsNotNull(indexer);
+            Assert.AreEqual("this[int]", indexer.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("this[](Integer)", indexer.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Foo<T>.this[int]", indexer.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo(Of T).this[](Integer)", indexer.DisplayNamesWithType[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo<T>.this[int]", indexer.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo(Of T).this[](Integer)", indexer.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.Item(System.Int32)", indexer.Name);
+            Assert.ContainsSingle(indexer.Syntax.Parameters);
             var parameter = indexer.Syntax.Parameters[0];
-            Assert.Equal("index", parameter.Name);
-            Assert.Equal("System.Int32", parameter.Type);
+            Assert.AreEqual("index", parameter.Name);
+            Assert.AreEqual("System.Int32", parameter.Type);
             var returnValue = indexer.Syntax.Return;
-            Assert.NotNull(returnValue);
-            Assert.Equal("System.Int32", returnValue.Type);
+            Assert.IsNotNull(returnValue);
+            Assert.AreEqual("System.Int32", returnValue.Type);
         }
     }
 
-    [Fact]
-    [Trait("Related", "Generic")]
-    [Trait("Related", "Inheritance")]
+    [TestMethod]
+    [TestProperty("Related", "Generic")]
+    [TestProperty("Related", "Inheritance")]
     public void TestGenerateMetadataAsyncWithGenericInheritance()
     {
         string code = @"
@@ -2240,35 +2240,35 @@ public class Foo<T1, T2, T3>
         MetadataItem output = Verify(code);
         {
             var type = output.Items[0].Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("Foo<T>", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo(Of T)", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Foo<T>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo(Of T)", type.DisplayNamesWithType[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo<T>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo(Of T)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1", type.Name);
-            Assert.Equal(2, type.Inheritance.Count);
-            Assert.Equal("System.Collections.Generic.Dictionary{System.String,{T}}", type.Inheritance[1]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Foo<T>", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo(Of T)", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Foo<T>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo(Of T)", type.DisplayNamesWithType[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo<T>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo(Of T)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1", type.Name);
+            Assert.AreEqual(2, type.Inheritance.Count);
+            Assert.AreEqual("System.Collections.Generic.Dictionary{System.String,{T}}", type.Inheritance[1]);
         }
         {
             var type = output.Items[0].Items[1];
-            Assert.NotNull(type);
-            Assert.Equal("Foo<T1, T2, T3>", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo(Of T1, T2, T3)", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Foo<T1, T2, T3>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo(Of T1, T2, T3)", type.DisplayNamesWithType[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo<T1, T2, T3>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo(Of T1, T2, T3)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`3", type.Name);
-            Assert.Equal(2, type.Inheritance.Count);
-            Assert.Equal("System.Collections.Generic.List{{T3}}", type.Inheritance[1]);
-        }
-    }
-
-    [Trait("Related", "Dynamic")]
-    [Trait("Related", "Multilanguage")]
-    [Fact]
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Foo<T1, T2, T3>", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo(Of T1, T2, T3)", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Foo<T1, T2, T3>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo(Of T1, T2, T3)", type.DisplayNamesWithType[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo<T1, T2, T3>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo(Of T1, T2, T3)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`3", type.Name);
+            Assert.AreEqual(2, type.Inheritance.Count);
+            Assert.AreEqual("System.Collections.Generic.List{{T3}}", type.Inheritance[1]);
+        }
+    }
+
+    [TestProperty("Related", "Dynamic")]
+    [TestProperty("Related", "Multilanguage")]
+    [TestMethod]
     public void TestGenerateMetadataWithDynamic()
     {
         string code = @"
@@ -2284,64 +2284,64 @@ public abstract class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var field = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(field);
-            Assert.Equal("F", field.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("F", field.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Foo.F", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.F", field.DisplayNamesWithType[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.F", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.F", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.F", field.Name);
-            Assert.Equal("public dynamic F", field.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Public F As Object", field.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("F", field.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("F", field.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Foo.F", field.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.F", field.DisplayNamesWithType[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.F", field.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.F", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.F", field.Name);
+            Assert.AreEqual("public dynamic F", field.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Public F As Object", field.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(method);
-            Assert.Equal("M(dynamic)", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("M(Object)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Foo.M(dynamic)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.M(Object)", method.DisplayNamesWithType[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.M(dynamic)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.M(Object)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.M(System.Object)", method.Name);
-            Assert.Equal("public dynamic M(dynamic arg)", method.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Public Function M(arg As Object) As Object", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M(dynamic)", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("M(Object)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Foo.M(dynamic)", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.M(Object)", method.DisplayNamesWithType[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.M(dynamic)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.M(Object)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.M(System.Object)", method.Name);
+            Assert.AreEqual("public dynamic M(dynamic arg)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Public Function M(arg As Object) As Object", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(method);
-            Assert.Equal("P", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("P", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Foo.P", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.P", method.DisplayNamesWithType[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.P", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.P", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.P", method.Name);
-            Assert.Equal("public dynamic P { get; protected set; }", method.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Public Property P As Object", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("P", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("P", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Foo.P", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.P", method.DisplayNamesWithType[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.P", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.P", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.P", method.Name);
+            Assert.AreEqual("public dynamic P { get; protected set; }", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Public Property P As Object", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(method);
-            Assert.Equal("this[dynamic]", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("this[](Object)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Foo.this[dynamic]", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo.this[](Object)", method.DisplayNamesWithType[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.this[dynamic]", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo.this[](Object)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.Item(System.Object)", method.Name);
-            Assert.Equal("public dynamic this[dynamic index] { get; }", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("this[dynamic]", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("this[](Object)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Foo.this[dynamic]", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo.this[](Object)", method.DisplayNamesWithType[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.this[dynamic]", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo.this[](Object)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.Item(System.Object)", method.Name);
+            Assert.AreEqual("public dynamic this[dynamic index] { get; }", method.Syntax.Content[SyntaxLanguage.CSharp]);
             // TODO: https://github.com/dotnet/roslyn/issues/14684
-            Assert.Equal("Public ReadOnly Default Property this[](index As Object) As Object", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.AreEqual("Public ReadOnly Default Property this[](index As Object) As Object", method.Syntax.Content[SyntaxLanguage.VB]);
         }
     }
 
-    [Fact]
-    [Trait("Related", "Multilanguage")]
+    [TestMethod]
+    [TestProperty("Related", "Multilanguage")]
     public void TestGenerateMetadataWithStaticClass()
     {
         string code = @"
@@ -2356,22 +2356,22 @@ public static class Foo
         MetadataItem output = Verify(code);
         {
             var type = output.Items[0].Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("Foo", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo", type.Name);
-            Assert.Single(type.Inheritance);
-            Assert.Equal("System.Object", type.Inheritance[0]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Foo", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo", type.Name);
+            Assert.ContainsSingle(type.Inheritance);
+            Assert.AreEqual("System.Object", type.Inheritance[0]);
 
-            Assert.Equal("public static class Foo", type.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Public Module Foo", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.AreEqual("public static class Foo", type.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Public Module Foo", type.Syntax.Content[SyntaxLanguage.VB]);
         }
     }
 
-    [Fact]
-    [Trait("Related", "Generic")]
+    [TestMethod]
+    [TestProperty("Related", "Generic")]
     public void TestGenerateMetadataAsyncWithNestedGeneric()
     {
         string code = @"
@@ -2388,47 +2388,47 @@ public class FooBar { }
         MetadataItem output = Verify(code);
         {
             var type = output.Items[0].Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("Foo<T1, T2>", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo(Of T1, T2)", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Foo<T1, T2>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo(Of T1, T2)", type.DisplayNamesWithType[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo<T1, T2>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo(Of T1, T2)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`2", type.Name);
-            Assert.Single(type.Inheritance);
-            Assert.Equal("System.Object", type.Inheritance[0]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Foo<T1, T2>", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo(Of T1, T2)", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Foo<T1, T2>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo(Of T1, T2)", type.DisplayNamesWithType[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo<T1, T2>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo(Of T1, T2)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`2", type.Name);
+            Assert.ContainsSingle(type.Inheritance);
+            Assert.AreEqual("System.Object", type.Inheritance[0]);
         }
         {
             var type = output.Items[0].Items[1];
-            Assert.NotNull(type);
-            Assert.Equal("Foo<T1, T2>.Bar<T3>", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo(Of T1, T2).Bar(Of T3)", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Foo<T1, T2>.Bar<T3>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo(Of T1, T2).Bar(Of T3)", type.DisplayNamesWithType[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo<T1, T2>.Bar<T3>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo(Of T1, T2).Bar(Of T3)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`2.Bar`1", type.Name);
-            Assert.Single(type.Inheritance);
-            Assert.Equal("System.Object", type.Inheritance[0]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Foo<T1, T2>.Bar<T3>", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo(Of T1, T2).Bar(Of T3)", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Foo<T1, T2>.Bar<T3>", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo(Of T1, T2).Bar(Of T3)", type.DisplayNamesWithType[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo<T1, T2>.Bar<T3>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo(Of T1, T2).Bar(Of T3)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`2.Bar`1", type.Name);
+            Assert.ContainsSingle(type.Inheritance);
+            Assert.AreEqual("System.Object", type.Inheritance[0]);
         }
         {
             var type = output.Items[0].Items[2];
-            Assert.NotNull(type);
-            Assert.Equal("Foo<T1, T2>.FooBar", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo(Of T1, T2).FooBar", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Foo<T1, T2>.FooBar", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Foo(Of T1, T2).FooBar", type.DisplayNamesWithType[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo<T1, T2>.FooBar", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.Foo(Of T1, T2).FooBar", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`2.FooBar", type.Name);
-            Assert.Single(type.Inheritance);
-            Assert.Equal("System.Object", type.Inheritance[0]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Foo<T1, T2>.FooBar", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo(Of T1, T2).FooBar", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Foo<T1, T2>.FooBar", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Foo(Of T1, T2).FooBar", type.DisplayNamesWithType[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo<T1, T2>.FooBar", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.Foo(Of T1, T2).FooBar", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`2.FooBar", type.Name);
+            Assert.ContainsSingle(type.Inheritance);
+            Assert.AreEqual("System.Object", type.Inheritance[0]);
         }
     }
 
-    [Fact]
-    [Trait("Related", "Attribute")]
+    [TestMethod]
+    [TestProperty("Related", "Attribute")]
     public void TestGenerateMetadataAsyncWithAttributes()
     {
         string code = @"
@@ -2457,11 +2457,11 @@ public TestAttribute([Test(3), Test(4)] object obj){}
 ";
         MetadataItem output = Verify(code);
         var @class = output.Items[0].Items[0];
-        Assert.NotNull(@class);
-        Assert.Equal("TestAttribute", @class.DisplayNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("TestAttribute", @class.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-        Assert.Equal("Test1.TestAttribute", @class.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-        Assert.Equal(@"[Serializable]
+        Assert.IsNotNull(@class);
+        Assert.AreEqual("TestAttribute", @class.DisplayNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("TestAttribute", @class.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.TestAttribute", @class.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual(@"[Serializable]
 [AttributeUsage(AttributeTargets.All, Inherited = true, AllowMultiple = true)]
 [TypeConverter(typeof(TestAttribute))]
 [TypeConverter(typeof(TestAttribute[]))]
@@ -2471,67 +2471,67 @@ public TestAttribute([Test(3), Test(4)] object obj){}
 [Test(new Type[] { typeof(Func<>), typeof(Func<,>), typeof(Func<string, string>) })]
 public class TestAttribute : Attribute", @class.Syntax.Content[SyntaxLanguage.CSharp]);
 
-        Assert.NotNull(@class.Attributes);
-        Assert.Equal(5, @class.Attributes.Count);
-
-        Assert.Equal("System.SerializableAttribute", @class.Attributes[0].Type);
-        Assert.Equal("System.SerializableAttribute.#ctor", @class.Attributes[0].Constructor);
-        Assert.NotNull(@class.Attributes[0].Arguments);
-        Assert.Empty(@class.Attributes[0].Arguments);
-        Assert.Null(@class.Attributes[0].NamedArguments);
-
-        Assert.Equal("System.AttributeUsageAttribute", @class.Attributes[1].Type);
-        Assert.Equal("System.AttributeUsageAttribute.#ctor(System.AttributeTargets)", @class.Attributes[1].Constructor);
-        Assert.NotNull(@class.Attributes[1].Arguments);
-        Assert.Single(@class.Attributes[1].Arguments);
-        Assert.Equal("System.AttributeTargets", @class.Attributes[1].Arguments[0].Type);
-        Assert.Equal(32767, @class.Attributes[1].Arguments[0].Value);
-        Assert.NotNull(@class.Attributes[1].NamedArguments);
-        Assert.Equal(2, @class.Attributes[1].NamedArguments.Count);
-        Assert.Equal("Inherited", @class.Attributes[1].NamedArguments[0].Name);
-        Assert.Equal("System.Boolean", @class.Attributes[1].NamedArguments[0].Type);
-        Assert.Equal(true, @class.Attributes[1].NamedArguments[0].Value);
-        Assert.Equal("AllowMultiple", @class.Attributes[1].NamedArguments[1].Name);
-        Assert.Equal("System.Boolean", @class.Attributes[1].NamedArguments[1].Type);
-        Assert.Equal(true, @class.Attributes[1].NamedArguments[1].Value);
-
-        Assert.Equal("System.ComponentModel.TypeConverterAttribute", @class.Attributes[2].Type);
-        Assert.Equal("System.ComponentModel.TypeConverterAttribute.#ctor(System.Type)", @class.Attributes[2].Constructor);
-        Assert.NotNull(@class.Attributes[2].Arguments);
-        Assert.Single(@class.Attributes[2].Arguments);
-        Assert.Equal("System.Type", @class.Attributes[2].Arguments[0].Type);
-        Assert.Equal("Test1.TestAttribute", @class.Attributes[2].Arguments[0].Value);
-        Assert.Null(@class.Attributes[2].NamedArguments);
-
-        Assert.Equal("System.ComponentModel.TypeConverterAttribute", @class.Attributes[3].Type);
-        Assert.Equal("System.ComponentModel.TypeConverterAttribute.#ctor(System.Type)", @class.Attributes[3].Constructor);
-        Assert.NotNull(@class.Attributes[3].Arguments);
-        Assert.Single(@class.Attributes[3].Arguments);
-        Assert.Equal("System.Type", @class.Attributes[3].Arguments[0].Type);
-        Assert.Equal("Test1.TestAttribute[]", @class.Attributes[3].Arguments[0].Value);
-        Assert.Null(@class.Attributes[3].NamedArguments);
-
-        Assert.Equal("Test1.TestAttribute", @class.Attributes[4].Type);
-        Assert.Equal("Test1.TestAttribute.#ctor(System.Object)", @class.Attributes[4].Constructor);
-        Assert.NotNull(@class.Attributes[4].Arguments);
-        Assert.Single(@class.Attributes[4].Arguments);
-        Assert.Equal("System.String", @class.Attributes[4].Arguments[0].Type);
-        Assert.Equal("test", @class.Attributes[4].Arguments[0].Value);
-        Assert.Null(@class.Attributes[4].NamedArguments);
+        Assert.IsNotNull(@class.Attributes);
+        Assert.AreEqual(5, @class.Attributes.Count);
+
+        Assert.AreEqual("System.SerializableAttribute", @class.Attributes[0].Type);
+        Assert.AreEqual("System.SerializableAttribute.#ctor", @class.Attributes[0].Constructor);
+        Assert.IsNotNull(@class.Attributes[0].Arguments);
+        Assert.IsEmpty(@class.Attributes[0].Arguments);
+        Assert.IsNull(@class.Attributes[0].NamedArguments);
+
+        Assert.AreEqual("System.AttributeUsageAttribute", @class.Attributes[1].Type);
+        Assert.AreEqual("System.AttributeUsageAttribute.#ctor(System.AttributeTargets)", @class.Attributes[1].Constructor);
+        Assert.IsNotNull(@class.Attributes[1].Arguments);
+        Assert.ContainsSingle(@class.Attributes[1].Arguments);
+        Assert.AreEqual("System.AttributeTargets", @class.Attributes[1].Arguments[0].Type);
+        Assert.AreEqual(32767, @class.Attributes[1].Arguments[0].Value);
+        Assert.IsNotNull(@class.Attributes[1].NamedArguments);
+        Assert.AreEqual(2, @class.Attributes[1].NamedArguments.Count);
+        Assert.AreEqual("Inherited", @class.Attributes[1].NamedArguments[0].Name);
+        Assert.AreEqual("System.Boolean", @class.Attributes[1].NamedArguments[0].Type);
+        Assert.AreEqual(true, @class.Attributes[1].NamedArguments[0].Value);
+        Assert.AreEqual("AllowMultiple", @class.Attributes[1].NamedArguments[1].Name);
+        Assert.AreEqual("System.Boolean", @class.Attributes[1].NamedArguments[1].Type);
+        Assert.AreEqual(true, @class.Attributes[1].NamedArguments[1].Value);
+
+        Assert.AreEqual("System.ComponentModel.TypeConverterAttribute", @class.Attributes[2].Type);
+        Assert.AreEqual("System.ComponentModel.TypeConverterAttribute.#ctor(System.Type)", @class.Attributes[2].Constructor);
+        Assert.IsNotNull(@class.Attributes[2].Arguments);
+        Assert.ContainsSingle(@class.Attributes[2].Arguments);
+        Assert.AreEqual("System.Type", @class.Attributes[2].Arguments[0].Type);
+        Assert.AreEqual("Test1.TestAttribute", @class.Attributes[2].Arguments[0].Value);
+        Assert.IsNull(@class.Attributes[2].NamedArguments);
+
+        Assert.AreEqual("System.ComponentModel.TypeConverterAttribute", @class.Attributes[3].Type);
+        Assert.AreEqual("System.ComponentModel.TypeConverterAttribute.#ctor(System.Type)", @class.Attributes[3].Constructor);
+        Assert.IsNotNull(@class.Attributes[3].Arguments);
+        Assert.ContainsSingle(@class.Attributes[3].Arguments);
+        Assert.AreEqual("System.Type", @class.Attributes[3].Arguments[0].Type);
+        Assert.AreEqual("Test1.TestAttribute[]", @class.Attributes[3].Arguments[0].Value);
+        Assert.IsNull(@class.Attributes[3].NamedArguments);
+
+        Assert.AreEqual("Test1.TestAttribute", @class.Attributes[4].Type);
+        Assert.AreEqual("Test1.TestAttribute.#ctor(System.Object)", @class.Attributes[4].Constructor);
+        Assert.IsNotNull(@class.Attributes[4].Arguments);
+        Assert.ContainsSingle(@class.Attributes[4].Arguments);
+        Assert.AreEqual("System.String", @class.Attributes[4].Arguments[0].Type);
+        Assert.AreEqual("test", @class.Attributes[4].Arguments[0].Value);
+        Assert.IsNull(@class.Attributes[4].NamedArguments);
 
         var ctor = @class.Items[0];
-        Assert.NotNull(ctor);
-        Assert.Equal(@"[Test(1)]
+        Assert.IsNotNull(ctor);
+        Assert.AreEqual(@"[Test(1)]
 [Test(2)]
 public TestAttribute(object obj)", ctor.Syntax.Content[SyntaxLanguage.CSharp]);
 
         var property = @class.Items[1];
-        Assert.NotNull(property);
-        Assert.Equal(@"[Test(5)]
+        Assert.IsNotNull(property);
+        Assert.AreEqual(@"[Test(5)]
 public object Property { get; set; }", property.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithDefaultParameterEnumFlagsValues()
     {
         string code = @"
@@ -2549,15 +2549,15 @@ public void Undefined(AttributeTargets targets = (AttributeTargets)0) { }
         MetadataItem output = Verify(code);
 
         var defined = output.Items[0].Items[0].Items[0];
-        Assert.NotNull(defined);
-        Assert.Equal("public void Defined(Base64FormattingOptions options = Base64FormattingOptions.None)", defined.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(defined);
+        Assert.AreEqual("public void Defined(Base64FormattingOptions options = Base64FormattingOptions.None)", defined.Syntax.Content[SyntaxLanguage.CSharp]);
 
         var undefined = output.Items[0].Items[0].Items[1];
-        Assert.NotNull(undefined);
-        Assert.Equal("public void Undefined(AttributeTargets targets = (AttributeTargets)0)", undefined.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(undefined);
+        Assert.AreEqual("public void Undefined(AttributeTargets targets = (AttributeTargets)0)", undefined.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithDefaultParameterEnumValues()
     {
         string code = @"
@@ -2575,15 +2575,15 @@ public void Undefined(ConsoleKey key = ConsoleKey.None) { }
         MetadataItem output = Verify(code);
 
         var defined = output.Items[0].Items[0].Items[0];
-        Assert.NotNull(defined);
-        Assert.Equal("public void Defined(ConsoleSpecialKey key = ConsoleSpecialKey.ControlC)", defined.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(defined);
+        Assert.AreEqual("public void Defined(ConsoleSpecialKey key = ConsoleSpecialKey.ControlC)", defined.Syntax.Content[SyntaxLanguage.CSharp]);
 
         var undefined = output.Items[0].Items[0].Items[1];
-        Assert.NotNull(undefined);
-        Assert.Equal("public void Undefined(ConsoleKey key = ConsoleKey.None)", undefined.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(undefined);
+        Assert.AreEqual("public void Undefined(ConsoleKey key = ConsoleKey.None)", undefined.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithDefaultParameterNullablePrimitive()
     {
         string code = @"
@@ -2602,19 +2602,19 @@ public void PrimitiveValue(int? i = 123) { }
         MetadataItem output = Verify(code);
 
         var primitiveNull = output.Items[0].Items[0].Items[0];
-        Assert.NotNull(primitiveNull);
-        Assert.Equal("public void PrimitiveNull(int? i = null)", primitiveNull.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(primitiveNull);
+        Assert.AreEqual("public void PrimitiveNull(int? i = null)", primitiveNull.Syntax.Content[SyntaxLanguage.CSharp]);
 
         var primitiveDefault = output.Items[0].Items[0].Items[1];
-        Assert.NotNull(primitiveDefault);
-        Assert.Equal("public void PrimitiveDefault(int? i = 0)", primitiveDefault.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(primitiveDefault);
+        Assert.AreEqual("public void PrimitiveDefault(int? i = 0)", primitiveDefault.Syntax.Content[SyntaxLanguage.CSharp]);
 
         var primitiveValue = output.Items[0].Items[0].Items[2];
-        Assert.NotNull(primitiveValue);
-        Assert.Equal("public void PrimitiveValue(int? i = 123)", primitiveValue.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(primitiveValue);
+        Assert.AreEqual("public void PrimitiveValue(int? i = 123)", primitiveValue.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithDefaultParameterNullableEnum()
     {
         string code = @"
@@ -2635,27 +2635,27 @@ public void EnumUndefinedValue(ConsoleKey? key = (ConsoleKey)999) { }
         MetadataItem output = Verify(code);
 
         var flagsNull = output.Items[0].Items[0].Items[0];
-        Assert.NotNull(flagsNull);
-        Assert.Equal("public void EnumNull(ConsoleSpecialKey? key = null)", flagsNull.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(flagsNull);
+        Assert.AreEqual("public void EnumNull(ConsoleSpecialKey? key = null)", flagsNull.Syntax.Content[SyntaxLanguage.CSharp]);
 
         var flagsDefault = output.Items[0].Items[0].Items[1];
-        Assert.NotNull(flagsDefault);
-        Assert.Equal("public void EnumDefault(ConsoleSpecialKey? key = ConsoleSpecialKey.ControlC)", flagsDefault.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(flagsDefault);
+        Assert.AreEqual("public void EnumDefault(ConsoleSpecialKey? key = ConsoleSpecialKey.ControlC)", flagsDefault.Syntax.Content[SyntaxLanguage.CSharp]);
 
         var flagsValue = output.Items[0].Items[0].Items[2];
-        Assert.NotNull(flagsValue);
-        Assert.Equal("public void EnumValue(ConsoleSpecialKey? key = ConsoleSpecialKey.ControlBreak)", flagsValue.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(flagsValue);
+        Assert.AreEqual("public void EnumValue(ConsoleSpecialKey? key = ConsoleSpecialKey.ControlBreak)", flagsValue.Syntax.Content[SyntaxLanguage.CSharp]);
 
         var enumUndefinedDefault = output.Items[0].Items[0].Items[3];
-        Assert.NotNull(enumUndefinedDefault);
-        Assert.Equal("public void EnumUndefinedDefault(ConsoleKey? key = ConsoleKey.None)", enumUndefinedDefault.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(enumUndefinedDefault);
+        Assert.AreEqual("public void EnumUndefinedDefault(ConsoleKey? key = ConsoleKey.None)", enumUndefinedDefault.Syntax.Content[SyntaxLanguage.CSharp]);
 
         var enumUndefinedValue = output.Items[0].Items[0].Items[4];
-        Assert.NotNull(enumUndefinedValue);
-        Assert.Equal("public void EnumUndefinedValue(ConsoleKey? key = (ConsoleKey)999)", enumUndefinedValue.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(enumUndefinedValue);
+        Assert.AreEqual("public void EnumUndefinedValue(ConsoleKey? key = (ConsoleKey)999)", enumUndefinedValue.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithDefaultParameterNullableEnumFlags()
     {
         string code = @"
@@ -2676,27 +2676,27 @@ public void FlagsUndefinedValue(AttributeTargets? targets = (AttributeTargets)65
         MetadataItem output = Verify(code);
 
         var enumNull = output.Items[0].Items[0].Items[0];
-        Assert.NotNull(enumNull);
-        Assert.Equal("public void FlagsNull(Base64FormattingOptions? options = null)", enumNull.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(enumNull);
+        Assert.AreEqual("public void FlagsNull(Base64FormattingOptions? options = null)", enumNull.Syntax.Content[SyntaxLanguage.CSharp]);
 
         var enumDefault = output.Items[0].Items[0].Items[1];
-        Assert.NotNull(enumDefault);
-        Assert.Equal("public void FlagsDefault(Base64FormattingOptions? options = Base64FormattingOptions.None)", enumDefault.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(enumDefault);
+        Assert.AreEqual("public void FlagsDefault(Base64FormattingOptions? options = Base64FormattingOptions.None)", enumDefault.Syntax.Content[SyntaxLanguage.CSharp]);
 
         var enumValue = output.Items[0].Items[0].Items[2];
-        Assert.NotNull(enumValue);
-        Assert.Equal("public void FlagsValue(Base64FormattingOptions? options = Base64FormattingOptions.InsertLineBreaks)", enumValue.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(enumValue);
+        Assert.AreEqual("public void FlagsValue(Base64FormattingOptions? options = Base64FormattingOptions.InsertLineBreaks)", enumValue.Syntax.Content[SyntaxLanguage.CSharp]);
 
         var flagsUndefinedDefault = output.Items[0].Items[0].Items[3];
-        Assert.NotNull(flagsUndefinedDefault);
-        Assert.Equal("public void FlagsUndefinedDefault(AttributeTargets? targets = (AttributeTargets)0)", flagsUndefinedDefault.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(flagsUndefinedDefault);
+        Assert.AreEqual("public void FlagsUndefinedDefault(AttributeTargets? targets = (AttributeTargets)0)", flagsUndefinedDefault.Syntax.Content[SyntaxLanguage.CSharp]);
 
         var flagsUndefinedValue = output.Items[0].Items[0].Items[4];
-        Assert.NotNull(flagsUndefinedValue);
-        Assert.Equal("public void FlagsUndefinedValue(AttributeTargets? targets = (AttributeTargets)65536)", flagsUndefinedValue.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsNotNull(flagsUndefinedValue);
+        Assert.AreEqual("public void FlagsUndefinedValue(AttributeTargets? targets = (AttributeTargets)65536)", flagsUndefinedValue.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithDefaultParameterValueAttribute()
     {
         string code = @"
@@ -2717,16 +2717,16 @@ public void Uint([Optional][DefaultParameterValue(0)]uint i) { }
 ";
         MetadataItem output = Verify(code);
 
-        Assert.Collection(
-            output.Items[0].Items[0].Items,
-            item => Assert.Equal("public void Double(double i = 0)", item.Syntax.Content[SyntaxLanguage.CSharp]),
-            item => Assert.Equal("public void Float(float i = 0)", item.Syntax.Content[SyntaxLanguage.CSharp]),
-            item => Assert.Equal("public void Decimal(decimal i = 0)", item.Syntax.Content[SyntaxLanguage.CSharp]),
-            item => Assert.Equal("public void Long(long i = 0)", item.Syntax.Content[SyntaxLanguage.CSharp]),
-            item => Assert.Equal("public void Uint(uint i = default)", item.Syntax.Content[SyntaxLanguage.CSharp]));
+        var metadataItems = output.Items[0].Items[0].Items;
+        Assert.AreEqual(5, metadataItems.Count);
+        Assert.AreEqual("public void Double(double i = 0)", metadataItems[0].Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("public void Float(float i = 0)", metadataItems[1].Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("public void Decimal(decimal i = 0)", metadataItems[2].Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("public void Long(long i = 0)", metadataItems[3].Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("public void Uint(uint i = default)", metadataItems[4].Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithFieldHasDefaultValue()
     {
         string code = @"
@@ -2739,16 +2739,16 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var field = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(field);
-            Assert.Equal("public const ushort Test = 123", field.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("public const ushort Test = 123", field.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Fact]
-    [Trait("Related", "Multilanguage")]
+    [TestMethod]
+    [TestProperty("Related", "Multilanguage")]
     public void TestGenerateMetadataWithFieldHasDefaultValue_SpecialCharacter()
     {
         string code = @"
@@ -2761,18 +2761,18 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var field = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(field);
-            Assert.Equal(@"public const char Test = '\udbff'", field.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Equal("Public Const Test As Char = ChrW(&HDBFF)", field.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual(@"public const char Test = '\udbff'", field.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Public Const Test As Char = ChrW(&HDBFF)", field.Syntax.Content[SyntaxLanguage.VB]);
         }
     }
 
-    [Fact]
-    [Trait("Related", "ExtensionMethod")]
-    [Trait("Related", "Multilanguage")]
+    [TestMethod]
+    [TestProperty("Related", "ExtensionMethod")]
+    [TestProperty("Related", "Multilanguage")]
     public void TestGenerateMetadataAsyncWithExtensionMethods()
     {
         string code = @"
@@ -2785,18 +2785,18 @@ public static void Method1(this object obj) {}
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var method = ns.Items[0].Items[0];
-        Assert.NotNull(method);
-        Assert.True(method.IsExtensionMethod);
-        Assert.Equal("public static void Method1(this object obj)", method.Syntax.Content[SyntaxLanguage.CSharp]);
-        Assert.Equal("Public Shared Sub Method1(obj As Object)", method.Syntax.Content[SyntaxLanguage.VB]);
+        Assert.IsNotNull(method);
+        Assert.IsTrue(method.IsExtensionMethod);
+        Assert.AreEqual("public static void Method1(this object obj)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Public Shared Sub Method1(obj As Object)", method.Syntax.Content[SyntaxLanguage.VB]);
     }
 
-    [Fact]
-    [Trait("Related", "Generic")]
+    [TestMethod]
+    [TestProperty("Related", "Generic")]
     public void TestGenerateMetadataAsyncWithInheritedFromGenericClass()
     {
         string code = @"
@@ -2810,35 +2810,35 @@ public interface I2<T> : I1<string>, I1<T> {}
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var i1 = ns.Items[0];
-        Assert.NotNull(i1);
-        Assert.Equal("Test1.I1`1", i1.Name);
-        Assert.Single(i1.Items);
-        Assert.Null(i1.InheritedMembers);
+        Assert.IsNotNull(i1);
+        Assert.AreEqual("Test1.I1`1", i1.Name);
+        Assert.ContainsSingle(i1.Items);
+        Assert.IsNull(i1.InheritedMembers);
         var m1 = i1.Items[0];
-        Assert.Equal("Test1.I1`1.M1(`0)", m1.Name);
+        Assert.AreEqual("Test1.I1`1.M1(`0)", m1.Name);
 
         var i2 = ns.Items[1];
-        Assert.NotNull(i2);
-        Assert.Equal("Test1.I2`1", i2.Name);
-        Assert.Empty(i2.Items);
-        Assert.Equal(2, i2.InheritedMembers.Count);
-        Assert.Equal(new[] { "Test1.I1{System.String}.M1(System.String)", "Test1.I1{{T}}.M1({T})" }, i2.InheritedMembers);
+        Assert.IsNotNull(i2);
+        Assert.AreEqual("Test1.I2`1", i2.Name);
+        Assert.IsEmpty(i2.Items);
+        Assert.AreEqual(2, i2.InheritedMembers.Count);
+        CollectionAssert.AreEqual(new[] { "Test1.I1{System.String}.M1(System.String)", "Test1.I1{{T}}.M1({T})" }, i2.InheritedMembers.ToArray());
 
         var r1 = output.References["Test1.I1{System.String}.M1(System.String)"];
-        Assert.False(r1.IsDefinition);
-        Assert.Equal("Test1.I1`1.M1(`0)", r1.Definition);
+        Assert.IsFalse(r1.IsDefinition);
+        Assert.AreEqual("Test1.I1`1.M1(`0)", r1.Definition);
 
         var r2 = output.References["Test1.I1{{T}}.M1({T})"];
-        Assert.False(r1.IsDefinition);
-        Assert.Equal("Test1.I1`1.M1(`0)", r1.Definition);
+        Assert.IsFalse(r1.IsDefinition);
+        Assert.AreEqual("Test1.I1`1.M1(`0)", r1.Definition);
     }
 
-    [Fact]
-    [Trait("Related", "Generic")]
+    [TestMethod]
+    [TestProperty("Related", "Generic")]
     public void TestCSharpFeature_Default_7_1Class()
     {
         string code = @"
@@ -2851,20 +2851,20 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar(System.Int32)", bar.Name);
-        Assert.Equal("public int Bar(int x = 0)", bar.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo.Bar(System.Int32)", bar.Name);
+        Assert.AreEqual("public int Bar(int x = 0)", bar.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithTupleParameter()
     {
         string code = @"
@@ -2879,23 +2879,23 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Equal(2, foo.Items.Count);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.AreEqual(2, foo.Items.Count);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar(System.ValueTuple{System.String,System.String})", bar.Name);
-        Assert.Equal("public int Bar((string prefix, string uri) @namespace)", bar.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo.Bar(System.ValueTuple{System.String,System.String})", bar.Name);
+        Assert.AreEqual("public int Bar((string prefix, string uri) @namespace)", bar.Syntax.Content[SyntaxLanguage.CSharp]);
         var m = foo.Items[1];
-        Assert.Equal("Test1.Foo.M", m.Name);
-        Assert.Equal("public (int x, int y) M()", m.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo.M", m.Name);
+        Assert.AreEqual("public (int x, int y) M()", m.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithUnnamedTupleParameter()
     {
         string code = @"
@@ -2908,20 +2908,20 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar(System.ValueTuple{System.String,System.String})", bar.Name);
-        Assert.Equal("public int Bar((string, string) @namespace)", bar.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo.Bar(System.ValueTuple{System.String,System.String})", bar.Name);
+        Assert.AreEqual("public int Bar((string, string) @namespace)", bar.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithPartiallyUnnamedTupleParameter()
     {
         string code = @"
@@ -2934,20 +2934,20 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar(System.ValueTuple{System.String,System.String})", bar.Name);
-        Assert.Equal("public int Bar((string, string uri) @namespace)", bar.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo.Bar(System.ValueTuple{System.String,System.String})", bar.Name);
+        Assert.AreEqual("public int Bar((string, string uri) @namespace)", bar.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithTupleArrayParameter()
     {
         string code = @"
@@ -2960,20 +2960,20 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar(System.ValueTuple{System.String,System.String}[])", bar.Name);
-        Assert.Equal("public int Bar((string prefix, string uri)[] namespaces)", bar.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo.Bar(System.ValueTuple{System.String,System.String}[])", bar.Name);
+        Assert.AreEqual("public int Bar((string prefix, string uri)[] namespaces)", bar.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithTupleEnumerableParameter()
     {
         string code = @"
@@ -2988,20 +2988,20 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar(System.Collections.Generic.IEnumerable{System.ValueTuple{System.String,System.String}})", bar.Name);
-        Assert.Equal("public int Bar(IEnumerable<(string prefix, string uri)> namespaces)", bar.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo.Bar(System.Collections.Generic.IEnumerable{System.ValueTuple{System.String,System.String}})", bar.Name);
+        Assert.AreEqual("public int Bar(IEnumerable<(string prefix, string uri)> namespaces)", bar.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithTupleResult()
     {
         string code = @"
@@ -3014,20 +3014,20 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar", bar.Name);
-        Assert.Equal("public (string prefix, string uri) Bar()", bar.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo.Bar", bar.Name);
+        Assert.AreEqual("public (string prefix, string uri) Bar()", bar.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithUnnamedTupleResult()
     {
         string code = @"
@@ -3040,20 +3040,20 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar", bar.Name);
-        Assert.Equal("public (string, string) Bar()", bar.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo.Bar", bar.Name);
+        Assert.AreEqual("public (string, string) Bar()", bar.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithPartiallyUnnamedTupleResult()
     {
         string code = @"
@@ -3066,20 +3066,20 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar", bar.Name);
-        Assert.Equal("public (string, string uri) Bar()", bar.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo.Bar", bar.Name);
+        Assert.AreEqual("public (string, string uri) Bar()", bar.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithEnumerableTupleResult()
     {
         string code = @"
@@ -3094,16 +3094,16 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar", bar.Name);
-        Assert.Equal("public IEnumerable<(string prefix, string uri)> Bar()", bar.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo.Bar", bar.Name);
+        Assert.AreEqual("public IEnumerable<(string prefix, string uri)> Bar()", bar.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
     private static Compilation CreateCompilationFromCSharpCode(string code, IDictionary<string, string> msbuildProperties = null, params MetadataReference[] references)
@@ -3121,12 +3121,12 @@ private static Assembly CreateAssemblyFromCSharpCode(string code, string assembl
             result = compilation.Emit(stream);
         }
 
-        Assert.True(result.Success, string.Join(',', result.Diagnostics.Select(s => s.GetMessage())));
+        Assert.IsTrue(result.Success, string.Join(',', result.Diagnostics.Select(s => s.GetMessage())));
         return Assembly.LoadFile(Path.GetFullPath(assemblyName));
     }
 
-    [Fact]
-    [Trait("Related", "NativeInteger")]
+    [TestMethod]
+    [TestProperty("Related", "NativeInteger")]
     public void TestGenerateMetadataWithMethodUsingNativeInteger()
     {
         string code = @"
@@ -3144,16 +3144,16 @@ public void Test(
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var method = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(method);
-            Assert.Equal("public void Test(IntPtr a, UIntPtr b, nint c, nuint d, nint e = -1, nuint f = 1)", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("public void Test(IntPtr a, UIntPtr b, nint c, nuint d, nint e = -1, nuint f = 1)", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Fact]
-    [Trait("Related", "FunctionPointer")]
+    [TestMethod]
+    [TestProperty("Related", "FunctionPointer")]
     public void TestGenerateMetadataWithImplicitManagedFunctionPointer()
     {
         string code = @"
@@ -3172,40 +3172,40 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var fnptr = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<void> a", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<void> a", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<int, void> b", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<int, void> b", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<ref int, void> c", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<ref int, void> c", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<out int, void> d", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<out int, void> d", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[4];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<in int, void> e", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<in int, void> e", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[5];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<int*, void> f", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<int*, void> f", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[6];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<ref readonly int> g", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<ref readonly int> g", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Fact]
-    [Trait("Related", "FunctionPointer")]
+    [TestMethod]
+    [TestProperty("Related", "FunctionPointer")]
     public void TestGenerateMetadataWithExplicitManagedFunctionPointer()
     {
         string code = @"
@@ -3224,40 +3224,40 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var fnptr = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<void> a", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<void> a", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<int, void> b", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<int, void> b", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<ref int, void> c", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<ref int, void> c", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<out int, void> d", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<out int, void> d", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[4];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<in int, void> e", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<in int, void> e", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[5];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<int*, void> f", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<int*, void> f", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[6];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<ref readonly int> g", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<ref readonly int> g", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Fact]
-    [Trait("Related", "FunctionPointer")]
+    [TestMethod]
+    [TestProperty("Related", "FunctionPointer")]
     public void TestGenerateMetadataWithUnmanagedFunctionPointer()
     {
         string code = @"
@@ -3276,40 +3276,40 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var fnptr = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged<void> a", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged<void> a", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged<int, void> b", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged<int, void> b", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged<ref int, void> c", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged<ref int, void> c", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged<out int, void> d", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged<out int, void> d", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[4];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged<in int, void> e", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged<in int, void> e", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[5];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged<int*, void> f", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged<int*, void> f", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[6];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged<ref readonly int> g", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged<ref readonly int> g", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Fact]
-    [Trait("Related", "FunctionPointer")]
+    [TestMethod]
+    [TestProperty("Related", "FunctionPointer")]
     public void TestGenerateMetadataWithSingleCallConvFunctionPointer()
     {
         string code = @"
@@ -3328,40 +3328,40 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var fnptr = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged[Stdcall]<void> a", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged[Stdcall]<void> a", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged[Stdcall]<int, void> b", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged[Stdcall]<int, void> b", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged[Stdcall]<ref int, void> c", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged[Stdcall]<ref int, void> c", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged[Stdcall]<out int, void> d", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged[Stdcall]<out int, void> d", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[4];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged[Stdcall]<in int, void> e", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged[Stdcall]<in int, void> e", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[5];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged[Stdcall]<int*, void> f", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged[Stdcall]<int*, void> f", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[6];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged[Stdcall]<ref readonly int> g", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged[Stdcall]<ref readonly int> g", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Fact]
-    [Trait("Related", "FunctionPointer")]
+    [TestMethod]
+    [TestProperty("Related", "FunctionPointer")]
     public void TestGenerateMetadataWithMultiCallConvFunctionPointer()
     {
         string code = @"
@@ -3380,40 +3380,40 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var fnptr = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged[Stdcall, Thiscall]<void> a", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged[Stdcall, Thiscall]<void> a", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged[Stdcall, Thiscall]<int, void> b", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged[Stdcall, Thiscall]<int, void> b", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged[Stdcall, Thiscall]<ref int, void> c", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged[Stdcall, Thiscall]<ref int, void> c", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged[Stdcall, Thiscall]<out int, void> d", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged[Stdcall, Thiscall]<out int, void> d", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[4];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged[Stdcall, Thiscall]<in int, void> e", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged[Stdcall, Thiscall]<in int, void> e", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[5];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged[Stdcall, Thiscall]<int*, void> f", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged[Stdcall, Thiscall]<int*, void> f", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[6];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate* unmanaged[Stdcall, Thiscall]<ref readonly int> g", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate* unmanaged[Stdcall, Thiscall]<ref readonly int> g", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Fact]
-    [Trait("Related", "FunctionPointer")]
+    [TestMethod]
+    [TestProperty("Related", "FunctionPointer")]
     public void TestGenerateMetadataWithNestedFunctionPointer()
     {
         string code = @"
@@ -3429,28 +3429,28 @@ public class Foo
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var fnptr = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<delegate*<void>> a", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<delegate*<void>> a", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<delegate* unmanaged<void>> b", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<delegate* unmanaged<void>> b", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<delegate* unmanaged[Stdcall]<void>> c", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<delegate* unmanaged[Stdcall]<void>> c", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
 
             fnptr = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(fnptr);
-            Assert.Equal("public delegate*<delegate* unmanaged[Stdcall, Thiscall]<void>> d", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(fnptr);
+            Assert.AreEqual("public delegate*<delegate* unmanaged[Stdcall, Thiscall]<void>> d", fnptr.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Trait("Related", "ReadonlyMember")]
-    [Fact]
+    [TestProperty("Related", "ReadonlyMember")]
+    [TestMethod]
     public void TestGenerateMetadataWithReadonlyMember()
     {
         string code = @"
@@ -3473,65 +3473,65 @@ public readonly void M() {}
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var method = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(method);
-            Assert.Equal("M()", method.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("S.M()", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.S.M()", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.S.M", method.Name);
-            Assert.Equal("public readonly void M()", method.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M()", method.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("S.M()", method.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.S.M()", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.S.M", method.Name);
+            Assert.AreEqual("public readonly void M()", method.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var property = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(property);
-            Assert.Equal("P1", property.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("S.P1", property.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.S.P1", property.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.S.P1", property.Name);
-            Assert.Equal("public readonly int P1 { get; set; }", property.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(property);
+            Assert.AreEqual("P1", property.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("S.P1", property.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.S.P1", property.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.S.P1", property.Name);
+            Assert.AreEqual("public readonly int P1 { get; set; }", property.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var property = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(property);
-            Assert.Equal("P2", property.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("S.P2", property.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.S.P2", property.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.S.P2", property.Name);
-            Assert.Equal("public readonly int P2 { get; }", property.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(property);
+            Assert.AreEqual("P2", property.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("S.P2", property.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.S.P2", property.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.S.P2", property.Name);
+            Assert.AreEqual("public readonly int P2 { get; }", property.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var property = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(property);
-            Assert.Equal("P3", property.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("S.P3", property.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.S.P3", property.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.S.P3", property.Name);
-            Assert.Equal("public readonly int P3 { set; }", property.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(property);
+            Assert.AreEqual("P3", property.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("S.P3", property.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.S.P3", property.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.S.P3", property.Name);
+            Assert.AreEqual("public readonly int P3 { set; }", property.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var property = output.Items[0].Items[0].Items[4];
-            Assert.NotNull(property);
-            Assert.Equal("P4", property.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("S.P4", property.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.S.P4", property.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.S.P4", property.Name);
-            Assert.Equal("public int P4 { readonly get; set; }", property.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(property);
+            Assert.AreEqual("P4", property.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("S.P4", property.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.S.P4", property.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.S.P4", property.Name);
+            Assert.AreEqual("public int P4 { readonly get; set; }", property.Syntax.Content[SyntaxLanguage.CSharp]);
         }
         {
             var property = output.Items[0].Items[0].Items[5];
-            Assert.NotNull(property);
-            Assert.Equal("P5", property.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("S.P5", property.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.S.P5", property.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.S.P5", property.Name);
-            Assert.Equal("public int P5 { get; readonly set; }", property.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNotNull(property);
+            Assert.AreEqual("P5", property.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("S.P5", property.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.S.P5", property.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.S.P5", property.Name);
+            Assert.AreEqual("public int P5 { get; readonly set; }", property.Syntax.Content[SyntaxLanguage.CSharp]);
         }
     }
 
-    [Trait("Related", "ReadonlyStruct")]
-    [Fact]
+    [TestProperty("Related", "ReadonlyStruct")]
+    [TestMethod]
     public void TestGenerateMetadataWithReadonlyStruct()
     {
         string code = @"
@@ -3543,21 +3543,21 @@ public readonly struct S
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var type = output.Items[0].Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("S", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("S", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.S", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.S", type.Name);
-            Assert.Equal("public readonly struct S", type.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Null(type.Implements);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("S", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("S", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.S", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.S", type.Name);
+            Assert.AreEqual("public readonly struct S", type.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNull(type.Implements);
         }
     }
 
-    [Trait("Related", "RefStruct")]
-    [Fact]
+    [TestProperty("Related", "RefStruct")]
+    [TestMethod]
     public void TestGenerateMetadataWithRefStruct()
     {
         string code = @"
@@ -3569,20 +3569,20 @@ public ref struct S
 }
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var type = output.Items[0].Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("S", type.DisplayNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("S", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.S", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-            Assert.Equal("Test1.S", type.Name);
-            Assert.Equal("public ref struct S", type.Syntax.Content[SyntaxLanguage.CSharp]);
-            Assert.Null(type.Implements);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("S", type.DisplayNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("S", type.DisplayNamesWithType[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.S", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+            Assert.AreEqual("Test1.S", type.Name);
+            Assert.AreEqual("public ref struct S", type.Syntax.Content[SyntaxLanguage.CSharp]);
+            Assert.IsNull(type.Implements);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithCastOperatorOverloads()
     {
         var code =
@@ -3603,46 +3603,46 @@ public class Bar
         var output = Verify(code);
         var type = output.Items[0].Items[0];
 
-        Assert.Equal([
+        CollectionAssert.AreEqual(new[] {
             "Test.Bar.op_Implicit(System.UInt32)~Test.Bar",
             "Test.Bar.op_Implicit(System.String)~Test.Bar",
             "Test.Bar.op_CheckedExplicit(Test.Bar)~System.UInt32",
             "Test.Bar.op_CheckedExplicit(Test.Bar)~System.String[]"
-        ], type.Items.Select(item => item.Name));
+        }, type.Items.Select(item => item.Name).ToArray());
 
-        Assert.Equal([
+        CollectionAssert.AreEqual(new[] {
             "implicit operator Bar(uint)",
             "implicit operator Bar(string)",
             "explicit operator checked uint(Bar)",
             "explicit operator checked string[](Bar)"
-        ], type.Items.Select(item => item.DisplayNames[SyntaxLanguage.CSharp]));
+        }, type.Items.Select(item => item.DisplayNames[SyntaxLanguage.CSharp]).ToArray());
 
-        Assert.Equal([
+        CollectionAssert.AreEqual(new[] {
             "Bar.implicit operator Bar(uint)",
             "Bar.implicit operator Bar(string)",
             "Bar.explicit operator checked uint(Bar)",
             "Bar.explicit operator checked string[](Bar)"
-        ], type.Items.Select(item => item.DisplayNamesWithType[SyntaxLanguage.CSharp]));
+        }, type.Items.Select(item => item.DisplayNamesWithType[SyntaxLanguage.CSharp]).ToArray());
 
-        Assert.Equal([
+        CollectionAssert.AreEqual(new[] {
             "Test.Bar.implicit operator Test.Bar(uint)",
             "Test.Bar.implicit operator Test.Bar(string)",
             "Test.Bar.explicit operator checked uint(Test.Bar)",
             "Test.Bar.explicit operator checked string[](Test.Bar)"
-        ], type.Items.Select(item => item.DisplayQualifiedNames[SyntaxLanguage.CSharp]));
+        }, type.Items.Select(item => item.DisplayQualifiedNames[SyntaxLanguage.CSharp]).ToArray());
 
-        Assert.Equal([
+        CollectionAssert.AreEqual(new[] {
             "Test.Bar.op_Implicit*",
             "Test.Bar.op_Implicit*",
             "Test.Bar.op_CheckedExplicit*",
             "Test.Bar.op_CheckedExplicit*"
-        ], type.Items.Select(item => item.Overload));
+        }, type.Items.Select(item => item.Overload).ToArray());
 
-        Assert.Equal("implicit operator", string.Concat(output.References["Test.Bar.op_Implicit*"].NameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName)));
-        Assert.Equal("explicit operator checked", string.Concat(output.References["Test.Bar.op_CheckedExplicit*"].NameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName)));
+        Assert.AreEqual("implicit operator", string.Concat(output.References["Test.Bar.op_Implicit*"].NameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName)));
+        Assert.AreEqual("explicit operator checked", string.Concat(output.References["Test.Bar.op_CheckedExplicit*"].NameParts[SyntaxLanguage.CSharp].Select(p => p.DisplayName)));
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithPrivateMembers()
     {
         var code =
@@ -3663,16 +3663,16 @@ internal interface IFoo { }
 
         var output = Verify(code, new() { IncludePrivateMembers = true });
         var foo = output.Items[0].Items[0];
-        Assert.Equal("internal class Foo : IFoo", foo.Syntax.Content[SyntaxLanguage.CSharp]);
-        Assert.Equal([
+        Assert.AreEqual("internal class Foo : IFoo", foo.Syntax.Content[SyntaxLanguage.CSharp]);
+        CollectionAssert.AreEqual(new[] {
             "internal void M1()",
             "protected internal void M2()",
             "private protected void M3()",
             "private void M4()"
-        ], foo.Items.Select(item => item.Syntax.Content[SyntaxLanguage.CSharp]));
+        }, foo.Items.Select(item => item.Syntax.Content[SyntaxLanguage.CSharp]).ToArray());
     }
 
-    [Fact]
+    [TestMethod]
     public void TestAllowCompilationErrors()
     {
         var code =
@@ -3685,10 +3685,10 @@ public class Foo : Bar {}
 
         var output = Verify(code, new() { AllowCompilationErrors = true });
         var foo = output.Items[0].Items[0];
-        Assert.Equal("public class Foo : Bar", foo.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("public class Foo : Bar", foo.Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestIncludeExplicitInterfaceImplementations()
     {
         var code =
@@ -3702,11 +3702,11 @@ public interface IFoo { void Bar(); }
 
         var output = Verify(code, new() { IncludeExplicitInterfaceImplementations = true });
         var foo = output.Items[0].Items[0];
-        Assert.Equal("public class Foo : IFoo", foo.Syntax.Content[SyntaxLanguage.CSharp]);
-        Assert.Equal("void IFoo.Bar()", foo.Items[0].Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("public class Foo : IFoo", foo.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("void IFoo.Bar()", foo.Items[0].Syntax.Content[SyntaxLanguage.CSharp]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestExcludeDocumentationComment()
     {
         var code =
@@ -3723,11 +3723,11 @@ public void F1() {}
 
         var output = Verify(code);
         var foo = output.Items[0].Items[0];
-        Assert.Equal("public class Foo", foo.Syntax.Content[SyntaxLanguage.CSharp]);
-        Assert.Empty(foo.Items);
+        Assert.AreEqual("public class Foo", foo.Syntax.Content[SyntaxLanguage.CSharp]);
+        Assert.IsEmpty(foo.Items);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestDefineConstantsMSBuildProperty()
     {
         var code =
@@ -3747,17 +3747,17 @@ public void F1() {}
         {
             var output = Verify(code, msbuildProperties: new Dictionary<string, string> { ["DefineConstants"] = "TEST;DUMMY" });
             var foo = output.Items[0].Items[0];
-            Assert.Equal("Test.Foo.F1", foo.Items[0].Name);
+            Assert.AreEqual("Test.Foo.F1", foo.Items[0].Name);
         }
         // Test without DefineConstants
         {
             var output = Verify(code, msbuildProperties: EmptyMSBuildProperties);
             var foo = output.Items[0].Items[0];
-            Assert.Empty(foo.Items);
+            Assert.IsEmpty(foo.Items);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithReference()
     {
         string code = @"
diff --git a/test/Docfx.Dotnet.Tests/GenerateMetadataFromVBUnitTest.cs b/test/Docfx.Dotnet.Tests/GenerateMetadataFromVBUnitTest.cs
index 41c5d2d378d..1c007865a6d 100644
--- a/test/Docfx.Dotnet.Tests/GenerateMetadataFromVBUnitTest.cs
+++ b/test/Docfx.Dotnet.Tests/GenerateMetadataFromVBUnitTest.cs
@@ -3,12 +3,12 @@
 
 using Docfx.DataContracts.ManagedReference;
 using Microsoft.CodeAnalysis;
-using Xunit;
 
 namespace Docfx.Dotnet.Tests;
 
-[Trait("EntityType", "Model")]
-[Collection("docfx STA")]
+[TestProperty("EntityType", "Model")]
+[DoNotParallelize]
+[TestClass]
 public class GenerateMetadataFromVBUnitTest
 {
     private static readonly Dictionary<string, string> EmptyMSBuildProperties = [];
@@ -19,8 +19,8 @@ private static MetadataItem Verify(string code, ExtractMetadataConfig config = n
         return compilation.Assembly.GenerateMetadataItem(compilation, config);
     }
 
-    [Trait("Related", "Generic")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestMethod]
     public void TestGenerateMetadataWithClass()
     {
         string code = @"
@@ -38,42 +38,42 @@ End Class
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var type = output.Items[0].Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("Class1", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Class1", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Class1", type.Name);
-            Assert.Equal("Public Class Class1", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Class1", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Class1", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Class1", type.Name);
+            Assert.AreEqual("Public Class Class1", type.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var type = output.Items[0].Items[1];
-            Assert.NotNull(type);
-            Assert.Equal("Class2(Of T)", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Class2(Of T)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Class2`1", type.Name);
-            Assert.Equal("Public Class Class2(Of T) Inherits List(Of T) Implements IList(Of T), ICollection(Of T), IReadOnlyList(Of T), IReadOnlyCollection(Of T), IEnumerable(Of T), IList, ICollection, IEnumerable", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Class2(Of T)", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Class2(Of T)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Class2`1", type.Name);
+            Assert.AreEqual("Public Class Class2(Of T) Inherits List(Of T) Implements IList(Of T), ICollection(Of T), IReadOnlyList(Of T), IReadOnlyCollection(Of T), IEnumerable(Of T), IList, ICollection, IEnumerable", type.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var type = output.Items[0].Items[2];
-            Assert.NotNull(type);
-            Assert.Equal("Class3(Of T1, T2)", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Class3(Of T1, T2)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Class3`2", type.Name);
-            Assert.Equal("Public Class Class3(Of T1, T2 As T1)", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Class3(Of T1, T2)", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Class3(Of T1, T2)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Class3`2", type.Name);
+            Assert.AreEqual("Public Class Class3(Of T1, T2 As T1)", type.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var type = output.Items[0].Items[3];
-            Assert.NotNull(type);
-            Assert.Equal("Class4(Of T1, T2)", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Class4(Of T1, T2)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Class4`2", type.Name);
-            Assert.Equal("Public Class Class4(Of T1 As {Structure, IEnumerable(Of T2)}, T2 As {Class, New})", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Class4(Of T1, T2)", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Class4(Of T1, T2)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Class4`2", type.Name);
+            Assert.AreEqual("Public Class Class4(Of T1 As {Structure, IEnumerable(Of T2)}, T2 As {Class, New})", type.Syntax.Content[SyntaxLanguage.VB]);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithEnum()
     {
         string code = @"
@@ -87,35 +87,35 @@ End Enum
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var type = output.Items[0].Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("Enum1", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Enum1", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Enum1", type.Name);
-            Assert.Equal("Public Enum Enum1", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Enum1", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Enum1", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Enum1", type.Name);
+            Assert.AreEqual("Public Enum Enum1", type.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var type = output.Items[0].Items[1];
-            Assert.NotNull(type);
-            Assert.Equal("Enum2", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Enum2", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Enum2", type.Name);
-            Assert.Equal("Public Enum Enum2 As Byte", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Enum2", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Enum2", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Enum2", type.Name);
+            Assert.AreEqual("Public Enum Enum2 As Byte", type.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var type = output.Items[0].Items[2];
-            Assert.NotNull(type);
-            Assert.Equal("Enum3", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Enum3", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Enum3", type.Name);
-            Assert.Equal("Public Enum Enum3", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("Enum3", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Enum3", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Enum3", type.Name);
+            Assert.AreEqual("Public Enum Enum3", type.Syntax.Content[SyntaxLanguage.VB]);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestMethod]
     public void TestGenerateMetadataWithInterface()
     {
         string code = @"
@@ -130,35 +130,35 @@ End Interface
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var type = output.Items[0].Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("IA", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IA", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IA", type.Name);
-            Assert.Equal("Public Interface IA", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("IA", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IA", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IA", type.Name);
+            Assert.AreEqual("Public Interface IA", type.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var type = output.Items[0].Items[1];
-            Assert.NotNull(type);
-            Assert.Equal("IB(Of T)", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IB(Of T)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IB`1", type.Name);
-            Assert.Equal("Public Interface IB(Of T As Class)", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("IB(Of T)", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IB(Of T)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IB`1", type.Name);
+            Assert.AreEqual("Public Interface IB(Of T As Class)", type.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var type = output.Items[0].Items[2];
-            Assert.NotNull(type);
-            Assert.Equal("IC(Of TItem)", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IC(Of TItem)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IC`1", type.Name);
-            Assert.Equal("Public Interface IC(Of TItem As {IA, New}) Inherits IA, IB(Of TItem())", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("IC(Of TItem)", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IC(Of TItem)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IC`1", type.Name);
+            Assert.AreEqual("Public Interface IC(Of TItem As {IA, New}) Inherits IA, IB(Of TItem())", type.Syntax.Content[SyntaxLanguage.VB]);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestMethod]
     public void TestGenerateMetadataWithStructure()
     {
         string code = @"
@@ -177,34 +177,34 @@ End Interface
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var type = output.Items[0].Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("S1", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.S1", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.S1", type.Name);
-            Assert.Equal("Public Structure S1", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("S1", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.S1", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.S1", type.Name);
+            Assert.AreEqual("Public Structure S1", type.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var type = output.Items[0].Items[1];
-            Assert.NotNull(type);
-            Assert.Equal("S2(Of T)", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.S2(Of T)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.S2`1", type.Name);
-            Assert.Equal("Public Structure S2(Of T As Class)", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("S2(Of T)", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.S2(Of T)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.S2`1", type.Name);
+            Assert.AreEqual("Public Structure S2(Of T As Class)", type.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var type = output.Items[0].Items[2];
-            Assert.NotNull(type);
-            Assert.Equal("S3(Of T1, T2)", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.S3(Of T1, T2)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.S3`2", type.Name);
-            Assert.Equal("Public Structure S3(Of T1 As {Class, IA, New}, T2 As IB(Of T1)) Implements IA, IB(Of T1())", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("S3(Of T1, T2)", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.S3(Of T1, T2)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.S3`2", type.Name);
+            Assert.AreEqual("Public Structure S3(Of T1 As {Class, IA, New}, T2 As IB(Of T1)) Implements IA, IB(Of T1())", type.Syntax.Content[SyntaxLanguage.VB]);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithInternalInterfaceAndInherits()
     {
         string code = @"
@@ -216,18 +216,18 @@ Internal Interface IFoo
     End Interface
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
 
         var foo = output.Items[0].Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Foo", foo.DisplayNames[SyntaxLanguage.VB]);
-        Assert.Equal("Foo", foo.DisplayNamesWithType[SyntaxLanguage.VB]);
-        Assert.Equal("Test1.Foo", foo.DisplayQualifiedNames[SyntaxLanguage.VB]);
-        Assert.Equal("Public Class Foo", foo.Syntax.Content[SyntaxLanguage.VB]);
-        Assert.Null(foo.Implements);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Foo", foo.DisplayNames[SyntaxLanguage.VB]);
+        Assert.AreEqual("Foo", foo.DisplayNamesWithType[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo", foo.DisplayQualifiedNames[SyntaxLanguage.VB]);
+        Assert.AreEqual("Public Class Foo", foo.Syntax.Content[SyntaxLanguage.VB]);
+        Assert.IsNull(foo.Implements);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithProtectedInterfaceAndInherits()
     {
         string code = @"
@@ -242,19 +242,19 @@ End Class
 
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
 
         var subFoo = output.Items[0].Items[2];
-        Assert.NotNull(subFoo);
-        Assert.Equal("Foo.SubFoo", subFoo.DisplayNames[SyntaxLanguage.VB]);
-        Assert.Equal("Foo.SubFoo", subFoo.DisplayNamesWithType[SyntaxLanguage.VB]);
-        Assert.Equal("Test1.Foo.SubFoo", subFoo.DisplayQualifiedNames[SyntaxLanguage.VB]);
-        Assert.Equal("Public Class Foo.SubFoo Implements Foo.IFoo", subFoo.Syntax.Content[SyntaxLanguage.VB]);
-        Assert.NotNull(subFoo.Implements);
-        Assert.Equal("Test1.Foo.IFoo", subFoo.Implements[0]);
+        Assert.IsNotNull(subFoo);
+        Assert.AreEqual("Foo.SubFoo", subFoo.DisplayNames[SyntaxLanguage.VB]);
+        Assert.AreEqual("Foo.SubFoo", subFoo.DisplayNamesWithType[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo.SubFoo", subFoo.DisplayQualifiedNames[SyntaxLanguage.VB]);
+        Assert.AreEqual("Public Class Foo.SubFoo Implements Foo.IFoo", subFoo.Syntax.Content[SyntaxLanguage.VB]);
+        Assert.IsNotNull(subFoo.Implements);
+        Assert.AreEqual("Test1.Foo.IFoo", subFoo.Implements[0]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithPublicInterfaceNestedInternal()
     {
         string code = @"
@@ -268,19 +268,19 @@ Implements FooInternal.IFoo
     End Class
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
 
         var foo = output.Items[0].Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Foo", foo.DisplayNames[SyntaxLanguage.VB]);
-        Assert.Equal("Foo", foo.DisplayNamesWithType[SyntaxLanguage.VB]);
-        Assert.Equal("Test1.Foo", foo.DisplayQualifiedNames[SyntaxLanguage.VB]);
-        Assert.Equal("Public Class Foo", foo.Syntax.Content[SyntaxLanguage.VB]);
-        Assert.Null(foo.Implements);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Foo", foo.DisplayNames[SyntaxLanguage.VB]);
+        Assert.AreEqual("Foo", foo.DisplayNamesWithType[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo", foo.DisplayQualifiedNames[SyntaxLanguage.VB]);
+        Assert.AreEqual("Public Class Foo", foo.Syntax.Content[SyntaxLanguage.VB]);
+        Assert.IsNull(foo.Implements);
     }
 
-    [Trait("Related", "Generic")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestMethod]
     public void TestGenerateMetadataWithDelegate()
     {
         string code = @"
@@ -291,34 +291,34 @@ Public Delegate Function D3(Of T1 As Class, T2 As {T1, New})(ByRef x As T1) As T
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var type = output.Items[0].Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("D1", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.D1", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.D1", type.Name);
-            Assert.Equal("Public Delegate Sub D1()", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("D1", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.D1", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.D1", type.Name);
+            Assert.AreEqual("Public Delegate Sub D1()", type.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var type = output.Items[0].Items[1];
-            Assert.NotNull(type);
-            Assert.Equal("D2(Of T)", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.D2(Of T)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.D2`1", type.Name);
-            Assert.Equal("Public Delegate Sub D2(Of T As Class)(x As Integer())", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("D2(Of T)", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.D2(Of T)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.D2`1", type.Name);
+            Assert.AreEqual("Public Delegate Sub D2(Of T As Class)(x As Integer())", type.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var type = output.Items[0].Items[2];
-            Assert.NotNull(type);
-            Assert.Equal("D3(Of T1, T2)", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.D3(Of T1, T2)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.D3`2", type.Name);
-            Assert.Equal("Public Delegate Function D3(Of T1 As Class, T2 As {T1, New})(ByRef x As T1) As T2", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("D3(Of T1, T2)", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.D3(Of T1, T2)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.D3`2", type.Name);
+            Assert.AreEqual("Public Delegate Function D3(Of T1 As Class, T2 As {T1, New})(ByRef x As T1) As T2", type.Syntax.Content[SyntaxLanguage.VB]);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithModule()
     {
         string code = @"
@@ -328,20 +328,20 @@ End Module
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var type = output.Items[0].Items[0];
-            Assert.NotNull(type);
-            Assert.Equal("M1", type.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.M1", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.M1", type.Name);
-            Assert.Equal("Public Module M1", type.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(type);
+            Assert.AreEqual("M1", type.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.M1", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.M1", type.Name);
+            Assert.AreEqual("Public Module M1", type.Syntax.Content[SyntaxLanguage.VB]);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Trait("Related", "Inheritance")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestProperty("Related", "Inheritance")]
+    [TestMethod]
     public void TestGenerateMetadataWithMethod()
     {
         string code = @"
@@ -374,95 +374,95 @@ End Interface
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         // Foo<T>
         {
             var method = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(method);
-            Assert.Equal("M1(Integer, ParamArray Integer())", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).M1(Integer, ParamArray Integer())", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.M1(System.Int32,System.Int32[])", method.Name);
-            Assert.Equal("Public Overridable Sub M1(x As Integer, ParamArray y As Integer())", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M1(Integer, ParamArray Integer())", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).M1(Integer, ParamArray Integer())", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.M1(System.Int32,System.Int32[])", method.Name);
+            Assert.AreEqual("Public Overridable Sub M1(x As Integer, ParamArray y As Integer())", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(method);
-            Assert.Equal("M2(Of T1, T2)(T1, ByRef T2())", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).M2(Of T1, T2)(T1, ByRef T2())", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.M2``2(``0,``1[]@)", method.Name);
-            Assert.Equal("Public MustOverride Sub M2(Of T1 As Class, T2 As Foo(Of T1))(x As T1, ByRef y As T2())", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M2(Of T1, T2)(T1, ByRef T2())", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).M2(Of T1, T2)(T1, ByRef T2())", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.M2``2(``0,``1[]@)", method.Name);
+            Assert.AreEqual("Public MustOverride Sub M2(Of T1 As Class, T2 As Foo(Of T1))(x As T1, ByRef y As T2())", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(method);
-            Assert.Equal("M3()", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).M3()", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.M3", method.Name);
-            Assert.Equal("Public Sub M3()", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M3()", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).M3()", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.M3", method.Name);
+            Assert.AreEqual("Public Sub M3()", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(method);
-            Assert.Equal("M4(Of T1)(T)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).M4(Of T1)(T)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.M4``1(`0)", method.Name);
-            Assert.Equal("Protected Shared Function M4(Of T1 As Class)(x As T) As T1", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M4(Of T1)(T)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).M4(Of T1)(T)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.M4``1(`0)", method.Name);
+            Assert.AreEqual("Protected Shared Function M4(Of T1 As Class)(x As T) As T1", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         // Bar
         {
             var method = output.Items[0].Items[1].Items[0];
-            Assert.NotNull(method);
-            Assert.Equal("M1(Integer, Integer())", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.M1(Integer, Integer())", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.M1(System.Int32,System.Int32[])", method.Name);
-            Assert.Equal("Public Overrides Sub M1(x As Integer, y As Integer())", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M1(Integer, Integer())", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.M1(Integer, Integer())", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.M1(System.Int32,System.Int32[])", method.Name);
+            Assert.AreEqual("Public Overrides Sub M1(x As Integer, y As Integer())", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[1].Items[1];
-            Assert.NotNull(method);
-            Assert.Equal("M2(Of T1, T2)(T1, ByRef T2())", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.M2(Of T1, T2)(T1, ByRef T2())", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.M2``2(``0,``1[]@)", method.Name);
-            Assert.Equal("Public NotOverridable Overrides Sub M2(Of T1 As Class, T2 As Foo(Of T1))(x As T1, ByRef y As T2())", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M2(Of T1, T2)(T1, ByRef T2())", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.M2(Of T1, T2)(T1, ByRef T2())", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.M2``2(``0,``1[]@)", method.Name);
+            Assert.AreEqual("Public NotOverridable Overrides Sub M2(Of T1 As Class, T2 As Foo(Of T1))(x As T1, ByRef y As T2())", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[1].Items[2];
-            Assert.NotNull(method);
-            Assert.Equal("M3()", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.M3()", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.M3", method.Name);
-            Assert.Equal("Public Sub M3()", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M3()", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.M3()", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.M3", method.Name);
+            Assert.AreEqual("Public Sub M3()", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         // IFooBar
         {
             var method = output.Items[0].Items[2].Items[0];
-            Assert.NotNull(method);
-            Assert.Equal("M1(Integer, ParamArray Integer())", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.M1(Integer, ParamArray Integer())", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.M1(System.Int32,System.Int32[])", method.Name);
-            Assert.Equal("Sub M1(x As Integer, ParamArray y As Integer())", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M1(Integer, ParamArray Integer())", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.M1(Integer, ParamArray Integer())", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.M1(System.Int32,System.Int32[])", method.Name);
+            Assert.AreEqual("Sub M1(x As Integer, ParamArray y As Integer())", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[2].Items[1];
-            Assert.NotNull(method);
-            Assert.Equal("M2(Of T1, T2)(T1, ByRef T2())", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.M2(Of T1, T2)(T1, ByRef T2())", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.M2``2(``0,``1[]@)", method.Name);
-            Assert.Equal("Sub M2(Of T1 As Class, T2 As Foo(Of T1))(x As T1, ByRef y As T2())", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M2(Of T1, T2)(T1, ByRef T2())", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.M2(Of T1, T2)(T1, ByRef T2())", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.M2``2(``0,``1[]@)", method.Name);
+            Assert.AreEqual("Sub M2(Of T1 As Class, T2 As Foo(Of T1))(x As T1, ByRef y As T2())", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[2].Items[2];
-            Assert.NotNull(method);
-            Assert.Equal("M3()", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.M3()", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.M3", method.Name);
-            Assert.Equal("Sub M3()", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("M3()", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.M3()", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.M3", method.Name);
+            Assert.AreEqual("Sub M3()", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         // inheritance of Foo<T>
         {
             var inheritedMembers = output.Items[0].Items[0].InheritedMembers;
-            Assert.NotNull(inheritedMembers);
-            Assert.Equal(
+            Assert.IsNotNull(inheritedMembers);
+            CollectionAssert.AreEqual(
                 new string[]
                 {
                     "System.Object.ToString",
@@ -473,14 +473,14 @@ End Namespace
                     "System.Object.GetType",
                     "System.Object.Finalize",
                     "System.Object.MemberwiseClone",
-                }.OrderBy(s => s),
-                inheritedMembers.OrderBy(s => s));
+                }.OrderBy(s => s).ToArray(),
+                inheritedMembers.OrderBy(s => s).ToArray());
         }
         // inheritance of Bar
         {
             var inheritedMembers = output.Items[0].Items[1].InheritedMembers;
-            Assert.NotNull(inheritedMembers);
-            Assert.Equal(
+            Assert.IsNotNull(inheritedMembers);
+            CollectionAssert.AreEqual(
                 new string[]
                 {
                     "Test1.Foo{System.String}.M4``1(System.String)",
@@ -492,12 +492,12 @@ End Namespace
                     "System.Object.GetType",
                     "System.Object.Finalize",
                     "System.Object.MemberwiseClone",
-                }.OrderBy(s => s),
-                inheritedMembers.OrderBy(s => s));
+                }.OrderBy(s => s).ToArray(),
+                inheritedMembers.OrderBy(s => s).ToArray());
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithOperator()
     {
         string code = @"
@@ -579,199 +579,199 @@ End Class
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         // unary
         {
             var method = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(method);
-            Assert.Equal("+(Foo)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.+(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_UnaryPlus(Test1.Foo)", method.Name);
-            Assert.Equal("Public Shared Operator +(x As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("+(Foo)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.+(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_UnaryPlus(Test1.Foo)", method.Name);
+            Assert.AreEqual("Public Shared Operator +(x As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(method);
-            Assert.Equal("-(Foo)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.-(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_UnaryNegation(Test1.Foo)", method.Name);
-            Assert.Equal("Public Shared Operator -(x As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("-(Foo)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.-(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_UnaryNegation(Test1.Foo)", method.Name);
+            Assert.AreEqual("Public Shared Operator -(x As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(method);
-            Assert.Equal("Not(Foo)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.Not(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_OnesComplement(Test1.Foo)", method.Name);
-            Assert.Equal("Public Shared Operator Not(x As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("Not(Foo)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.Not(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_OnesComplement(Test1.Foo)", method.Name);
+            Assert.AreEqual("Public Shared Operator Not(x As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(method);
-            Assert.Equal("IsTrue(Foo)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.IsTrue(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_True(Test1.Foo)", method.Name);
-            Assert.Equal("Public Shared Operator IsTrue(x As Foo) As Boolean", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("IsTrue(Foo)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.IsTrue(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_True(Test1.Foo)", method.Name);
+            Assert.AreEqual("Public Shared Operator IsTrue(x As Foo) As Boolean", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[4];
-            Assert.NotNull(method);
-            Assert.Equal("IsFalse(Foo)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.IsFalse(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_False(Test1.Foo)", method.Name);
-            Assert.Equal("Public Shared Operator IsFalse(x As Foo) As Boolean", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("IsFalse(Foo)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.IsFalse(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_False(Test1.Foo)", method.Name);
+            Assert.AreEqual("Public Shared Operator IsFalse(x As Foo) As Boolean", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         // binary
         {
             var method = output.Items[0].Items[0].Items[5];
-            Assert.NotNull(method);
-            Assert.Equal("+(Foo, Foo)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.+(Test1.Foo, Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_Addition(Test1.Foo,Test1.Foo)", method.Name);
-            Assert.Equal("Public Shared Operator +(x As Foo, y As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("+(Foo, Foo)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.+(Test1.Foo, Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_Addition(Test1.Foo,Test1.Foo)", method.Name);
+            Assert.AreEqual("Public Shared Operator +(x As Foo, y As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[6];
-            Assert.NotNull(method);
-            Assert.Equal("-(Foo, Foo)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.-(Test1.Foo, Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_Subtraction(Test1.Foo,Test1.Foo)", method.Name);
-            Assert.Equal("Public Shared Operator -(x As Foo, y As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("-(Foo, Foo)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.-(Test1.Foo, Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_Subtraction(Test1.Foo,Test1.Foo)", method.Name);
+            Assert.AreEqual("Public Shared Operator -(x As Foo, y As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[7];
-            Assert.NotNull(method);
-            Assert.Equal("*(Foo, Foo)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.*(Test1.Foo, Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_Multiply(Test1.Foo,Test1.Foo)", method.Name);
-            Assert.Equal("Public Shared Operator *(x As Foo, y As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("*(Foo, Foo)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.*(Test1.Foo, Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_Multiply(Test1.Foo,Test1.Foo)", method.Name);
+            Assert.AreEqual("Public Shared Operator *(x As Foo, y As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[8];
-            Assert.NotNull(method);
-            Assert.Equal("/(Foo, Foo)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo./(Test1.Foo, Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_Division(Test1.Foo,Test1.Foo)", method.Name);
-            Assert.Equal("Public Shared Operator /(x As Foo, y As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("/(Foo, Foo)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo./(Test1.Foo, Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_Division(Test1.Foo,Test1.Foo)", method.Name);
+            Assert.AreEqual("Public Shared Operator /(x As Foo, y As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[9];
-            Assert.NotNull(method);
-            Assert.Equal("Mod(Foo, Foo)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.Mod(Test1.Foo, Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_Modulus(Test1.Foo,Test1.Foo)", method.Name);
-            Assert.Equal("Public Shared Operator Mod(x As Foo, y As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("Mod(Foo, Foo)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.Mod(Test1.Foo, Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_Modulus(Test1.Foo,Test1.Foo)", method.Name);
+            Assert.AreEqual("Public Shared Operator Mod(x As Foo, y As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[10];
-            Assert.NotNull(method);
-            Assert.Equal("And(Foo, Foo)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.And(Test1.Foo, Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_BitwiseAnd(Test1.Foo,Test1.Foo)", method.Name);
-            Assert.Equal("Public Shared Operator And(x As Foo, y As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("And(Foo, Foo)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.And(Test1.Foo, Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_BitwiseAnd(Test1.Foo,Test1.Foo)", method.Name);
+            Assert.AreEqual("Public Shared Operator And(x As Foo, y As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[11];
-            Assert.NotNull(method);
-            Assert.Equal("Or(Foo, Foo)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.Or(Test1.Foo, Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_BitwiseOr(Test1.Foo,Test1.Foo)", method.Name);
-            Assert.Equal("Public Shared Operator Or(x As Foo, y As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("Or(Foo, Foo)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.Or(Test1.Foo, Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_BitwiseOr(Test1.Foo,Test1.Foo)", method.Name);
+            Assert.AreEqual("Public Shared Operator Or(x As Foo, y As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[12];
-            Assert.NotNull(method);
-            Assert.Equal("Xor(Foo, Foo)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.Xor(Test1.Foo, Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_ExclusiveOr(Test1.Foo,Test1.Foo)", method.Name);
-            Assert.Equal("Public Shared Operator Xor(x As Foo, y As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("Xor(Foo, Foo)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.Xor(Test1.Foo, Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_ExclusiveOr(Test1.Foo,Test1.Foo)", method.Name);
+            Assert.AreEqual("Public Shared Operator Xor(x As Foo, y As Foo) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[13];
-            Assert.NotNull(method);
-            Assert.Equal(">>(Foo, Integer)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.>>(Test1.Foo, Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_RightShift(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("Public Shared Operator >>(x As Foo, y As Integer) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual(">>(Foo, Integer)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.>>(Test1.Foo, Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_RightShift(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("Public Shared Operator >>(x As Foo, y As Integer) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[14];
-            Assert.NotNull(method);
-            Assert.Equal("<<(Foo, Integer)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.<<(Test1.Foo, Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_LeftShift(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("Public Shared Operator <<(x As Foo, y As Integer) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("<<(Foo, Integer)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.<<(Test1.Foo, Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_LeftShift(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("Public Shared Operator <<(x As Foo, y As Integer) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         // comparison
         {
             var method = output.Items[0].Items[0].Items[15];
-            Assert.NotNull(method);
-            Assert.Equal("=(Foo, Integer)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.=(Test1.Foo, Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_Equality(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("Public Shared Operator =(x As Foo, y As Integer) As Boolean", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("=(Foo, Integer)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.=(Test1.Foo, Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_Equality(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("Public Shared Operator =(x As Foo, y As Integer) As Boolean", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[16];
-            Assert.NotNull(method);
-            Assert.Equal("<>(Foo, Integer)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.<>(Test1.Foo, Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_Inequality(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("Public Shared Operator <>(x As Foo, y As Integer) As Boolean", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("<>(Foo, Integer)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.<>(Test1.Foo, Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_Inequality(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("Public Shared Operator <>(x As Foo, y As Integer) As Boolean", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[17];
-            Assert.NotNull(method);
-            Assert.Equal(">(Foo, Integer)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.>(Test1.Foo, Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_GreaterThan(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("Public Shared Operator >(x As Foo, y As Integer) As Boolean", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual(">(Foo, Integer)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.>(Test1.Foo, Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_GreaterThan(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("Public Shared Operator >(x As Foo, y As Integer) As Boolean", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[18];
-            Assert.NotNull(method);
-            Assert.Equal("<(Foo, Integer)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.<(Test1.Foo, Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_LessThan(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("Public Shared Operator <(x As Foo, y As Integer) As Boolean", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("<(Foo, Integer)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.<(Test1.Foo, Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_LessThan(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("Public Shared Operator <(x As Foo, y As Integer) As Boolean", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[19];
-            Assert.NotNull(method);
-            Assert.Equal(">=(Foo, Integer)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.>=(Test1.Foo, Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_GreaterThanOrEqual(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("Public Shared Operator >=(x As Foo, y As Integer) As Boolean", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual(">=(Foo, Integer)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.>=(Test1.Foo, Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_GreaterThanOrEqual(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("Public Shared Operator >=(x As Foo, y As Integer) As Boolean", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[20];
-            Assert.NotNull(method);
-            Assert.Equal("<=(Foo, Integer)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.<=(Test1.Foo, Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_LessThanOrEqual(Test1.Foo,System.Int32)", method.Name);
-            Assert.Equal("Public Shared Operator <=(x As Foo, y As Integer) As Boolean", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("<=(Foo, Integer)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.<=(Test1.Foo, Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_LessThanOrEqual(Test1.Foo,System.Int32)", method.Name);
+            Assert.AreEqual("Public Shared Operator <=(x As Foo, y As Integer) As Boolean", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         // conversion
         {
             var method = output.Items[0].Items[0].Items[21];
-            Assert.NotNull(method);
-            Assert.Equal("CType(Integer)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.CType(Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_Implicit(System.Int32)~Test1.Foo", method.Name);
-            Assert.Equal("Public Shared Widening Operator CType(x As Integer) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("CType(Integer)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.CType(Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_Implicit(System.Int32)~Test1.Foo", method.Name);
+            Assert.AreEqual("Public Shared Widening Operator CType(x As Integer) As Foo", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[0].Items[22];
-            Assert.NotNull(method);
-            Assert.Equal("CType(Foo)", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.CType(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo.op_Explicit(Test1.Foo)~System.Int32", method.Name);
-            Assert.Equal("Public Shared Narrowing Operator CType(x As Foo) As Integer", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("CType(Foo)", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.CType(Test1.Foo)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo.op_Explicit(Test1.Foo)~System.Int32", method.Name);
+            Assert.AreEqual("Public Shared Narrowing Operator CType(x As Foo) As Integer", method.Syntax.Content[SyntaxLanguage.VB]);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestMethod]
     public void TestGenerateMetadataWithConstructor()
     {
         string code = @"
@@ -791,37 +791,37 @@ End Class
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         // Foo<T>
         {
             var method = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(method);
-            Assert.Equal("New(T())", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).New(T())", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.#ctor(`0[])", method.Name);
-            Assert.Equal("Protected Sub New(x As T())", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("New(T())", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).New(T())", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.#ctor(`0[])", method.Name);
+            Assert.AreEqual("Protected Sub New(x As T())", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         // Bar
         {
             var method = output.Items[0].Items[1].Items[0];
-            Assert.NotNull(method);
-            Assert.Equal("New()", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.New()", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.#ctor", method.Name);
-            Assert.Equal("Protected Sub New()", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("New()", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.New()", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.#ctor", method.Name);
+            Assert.AreEqual("Protected Sub New()", method.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var method = output.Items[0].Items[1].Items[1];
-            Assert.NotNull(method);
-            Assert.Equal("New(String())", method.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.New(String())", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.#ctor(System.String[])", method.Name);
-            Assert.Equal("Public Sub New(x As String())", method.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(method);
+            Assert.AreEqual("New(String())", method.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.New(String())", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.#ctor(System.String[])", method.Name);
+            Assert.AreEqual("Public Sub New(x As String())", method.Syntax.Content[SyntaxLanguage.VB]);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestMethod]
     public void TestGenerateMetadataWithField()
     {
         string code = @"
@@ -841,75 +841,75 @@ End Enum
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var field = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(field);
-            Assert.Equal("X", field.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).X", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.X", field.Name);
-            Assert.Equal("Public X As Integer", field.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("X", field.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).X", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.X", field.Name);
+            Assert.AreEqual("Public X As Integer", field.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var field = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(field);
-            Assert.Equal("Y", field.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).Y", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.Y", field.Name);
-            Assert.Equal("Protected Shared ReadOnly Y As Foo(Of T)", field.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("Y", field.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).Y", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.Y", field.Name);
+            Assert.AreEqual("Protected Shared ReadOnly Y As Foo(Of T)", field.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var field = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(field);
-            Assert.Equal("Z", field.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).Z", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.Z", field.Name);
-            Assert.Equal(@"Protected Const Z As String = """"", field.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("Z", field.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).Z", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.Z", field.Name);
+            Assert.AreEqual(@"Protected Const Z As String = """"", field.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var field = output.Items[0].Items[1].Items[0];
-            Assert.NotNull(field);
-            Assert.Equal("Black", field.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.Black", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.Black", field.Name);
-            Assert.Equal("Black = 0", field.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("Black", field.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.Black", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.Black", field.Name);
+            Assert.AreEqual("Black = 0", field.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var field = output.Items[0].Items[1].Items[1];
-            Assert.NotNull(field);
-            Assert.Equal("Red", field.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.Red", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.Red", field.Name);
-            Assert.Equal("Red = 1", field.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("Red", field.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.Red", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.Red", field.Name);
+            Assert.AreEqual("Red = 1", field.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var field = output.Items[0].Items[1].Items[2];
-            Assert.NotNull(field);
-            Assert.Equal("Blue", field.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.Blue", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.Blue", field.Name);
-            Assert.Equal("Blue = 2", field.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("Blue", field.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.Blue", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.Blue", field.Name);
+            Assert.AreEqual("Blue = 2", field.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var field = output.Items[0].Items[1].Items[3];
-            Assert.NotNull(field);
-            Assert.Equal("Green", field.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.Green", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.Green", field.Name);
-            Assert.Equal("Green = 4", field.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("Green", field.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.Green", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.Green", field.Name);
+            Assert.AreEqual("Green = 4", field.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var field = output.Items[0].Items[1].Items[4];
-            Assert.NotNull(field);
-            Assert.Equal("White", field.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.White", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.White", field.Name);
-            Assert.Equal("White = 7", field.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(field);
+            Assert.AreEqual("White", field.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.White", field.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.White", field.Name);
+            Assert.AreEqual("White = 7", field.Syntax.Content[SyntaxLanguage.VB]);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestMethod]
     public void TestGenerateMetadataWithEvent()
     {
         string code = @"
@@ -934,43 +934,43 @@ End Interface
 End Namespace
 ";
         MetadataItem output = Verify(code, new() { IncludePrivateMembers = true });
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         {
             var a = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(a);
-            Assert.Equal("A", a.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).A", a.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.A", a.Name);
-            Assert.Equal("Public Event A As EventHandler", a.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(a);
+            Assert.AreEqual("A", a.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).A", a.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.A", a.Name);
+            Assert.AreEqual("Public Event A As EventHandler", a.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var b = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(b);
-            Assert.Equal("B", b.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).B", b.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.B", b.Name);
-            Assert.Equal("Protected Shared Event B As EventHandler", b.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(b);
+            Assert.AreEqual("B", b.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).B", b.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.B", b.Name);
+            Assert.AreEqual("Protected Shared Event B As EventHandler", b.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var c = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(c);
-            Assert.Equal("C", c.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).C", c.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.C", c.Name);
-            Assert.Equal("Event C As EventHandler(Of T)", c.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(c);
+            Assert.AreEqual("C", c.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).C", c.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.C", c.Name);
+            Assert.AreEqual("Event C As EventHandler(Of T)", c.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var a = output.Items[0].Items[1].Items[0];
-            Assert.NotNull(a);
-            Assert.Equal("Bar", a.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar(Of TEventArgs).Bar", a.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar`1.Bar", a.Name);
-            Assert.Equal("Event Bar As EventHandler(Of TEventArgs)", a.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(a);
+            Assert.AreEqual("Bar", a.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar(Of TEventArgs).Bar", a.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar`1.Bar", a.Name);
+            Assert.AreEqual("Event Bar As EventHandler(Of TEventArgs)", a.Syntax.Content[SyntaxLanguage.VB]);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestMethod]
     public void TestGenerateMetadataWithProperty()
     {
         string code = @"
@@ -1026,110 +1026,110 @@ End Interface
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         // Foo
         {
             var a = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(a);
-            Assert.Equal("A", a.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).A", a.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.A", a.Name);
-            Assert.Equal("Public Property A As Integer", a.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(a);
+            Assert.AreEqual("A", a.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).A", a.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.A", a.Name);
+            Assert.AreEqual("Public Property A As Integer", a.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var b = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(b);
-            Assert.Equal("B", b.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).B", b.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.B", b.Name);
-            Assert.Equal("Public Overridable ReadOnly Property B As Integer", b.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(b);
+            Assert.AreEqual("B", b.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).B", b.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.B", b.Name);
+            Assert.AreEqual("Public Overridable ReadOnly Property B As Integer", b.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var c = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(c);
-            Assert.Equal("C", c.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).C", c.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.C", c.Name);
-            Assert.Equal("Public MustOverride WriteOnly Property C As Integer", c.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(c);
+            Assert.AreEqual("C", c.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).C", c.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.C", c.Name);
+            Assert.AreEqual("Public MustOverride WriteOnly Property C As Integer", c.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var d = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(d);
-            Assert.Equal("D", d.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).D", d.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.D", d.Name);
-            Assert.Equal("Protected Property D As Integer", d.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(d);
+            Assert.AreEqual("D", d.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).D", d.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.D", d.Name);
+            Assert.AreEqual("Protected Property D As Integer", d.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var e = output.Items[0].Items[0].Items[4];
-            Assert.NotNull(e);
-            Assert.Equal("E", e.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).E", e.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.E", e.Name);
-            Assert.Equal("Public Property E As T", e.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(e);
+            Assert.AreEqual("E", e.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).E", e.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.E", e.Name);
+            Assert.AreEqual("Public Property E As T", e.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var f = output.Items[0].Items[0].Items[5];
-            Assert.NotNull(f);
-            Assert.Equal("F", f.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).F", f.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.F", f.Name);
-            Assert.Equal("Protected Shared Property F As Integer", f.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(f);
+            Assert.AreEqual("F", f.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).F", f.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.F", f.Name);
+            Assert.AreEqual("Protected Shared Property F As Integer", f.Syntax.Content[SyntaxLanguage.VB]);
         }
         // Bar
         {
             var a = output.Items[0].Items[1].Items[0];
-            Assert.NotNull(a);
-            Assert.Equal("A", a.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.A", a.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.A", a.Name);
-            Assert.Equal("Public Overridable Property A As Integer", a.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(a);
+            Assert.AreEqual("A", a.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.A", a.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.A", a.Name);
+            Assert.AreEqual("Public Overridable Property A As Integer", a.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var b = output.Items[0].Items[1].Items[1];
-            Assert.NotNull(b);
-            Assert.Equal("B", b.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.B", b.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.B", b.Name);
-            Assert.Equal("Public Overrides ReadOnly Property B As Integer", b.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(b);
+            Assert.AreEqual("B", b.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.B", b.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.B", b.Name);
+            Assert.AreEqual("Public Overrides ReadOnly Property B As Integer", b.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var c = output.Items[0].Items[1].Items[2];
-            Assert.NotNull(c);
-            Assert.Equal("C", c.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.C", c.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.C", c.Name);
-            Assert.Equal("Public Overrides WriteOnly Property C As Integer", c.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(c);
+            Assert.AreEqual("C", c.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.C", c.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.C", c.Name);
+            Assert.AreEqual("Public Overrides WriteOnly Property C As Integer", c.Syntax.Content[SyntaxLanguage.VB]);
         }
         // IFooBar
         {
             var a = output.Items[0].Items[2].Items[0];
-            Assert.NotNull(a);
-            Assert.Equal("A", a.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.A", a.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.A", a.Name);
-            Assert.Equal("Property A As Integer", a.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(a);
+            Assert.AreEqual("A", a.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.A", a.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.A", a.Name);
+            Assert.AreEqual("Property A As Integer", a.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var b = output.Items[0].Items[2].Items[1];
-            Assert.NotNull(b);
-            Assert.Equal("B", b.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.B", b.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.B", b.Name);
-            Assert.Equal("ReadOnly Property B As Integer", b.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(b);
+            Assert.AreEqual("B", b.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.B", b.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.B", b.Name);
+            Assert.AreEqual("ReadOnly Property B As Integer", b.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var c = output.Items[0].Items[2].Items[2];
-            Assert.NotNull(c);
-            Assert.Equal("C", c.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.C", c.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.C", c.Name);
-            Assert.Equal("WriteOnly Property C As Integer", c.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(c);
+            Assert.AreEqual("C", c.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.C", c.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.C", c.Name);
+            Assert.AreEqual("WriteOnly Property C As Integer", c.Syntax.Content[SyntaxLanguage.VB]);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestMethod]
     public void TestGenerateMetadataWithIndex()
     {
         string code = @"
@@ -1198,111 +1198,111 @@ End Interface
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         // Foo
         {
             var a = output.Items[0].Items[0].Items[0];
-            Assert.NotNull(a);
-            Assert.Equal("A(Integer)", a.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).A(Integer)", a.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.A(System.Int32)", a.Name);
-            Assert.Equal("Public Property A(x As Integer) As Integer", a.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(a);
+            Assert.AreEqual("A(Integer)", a.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).A(Integer)", a.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.A(System.Int32)", a.Name);
+            Assert.AreEqual("Public Property A(x As Integer) As Integer", a.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var b = output.Items[0].Items[0].Items[1];
-            Assert.NotNull(b);
-            Assert.Equal("B(String)", b.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).B(String)", b.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.B(System.String)", b.Name);
-            Assert.Equal("Public Overridable ReadOnly Property B(x As String) As Integer", b.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(b);
+            Assert.AreEqual("B(String)", b.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).B(String)", b.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.B(System.String)", b.Name);
+            Assert.AreEqual("Public Overridable ReadOnly Property B(x As String) As Integer", b.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var c = output.Items[0].Items[0].Items[2];
-            Assert.NotNull(c);
-            Assert.Equal("C(Object)", c.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).C(Object)", c.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.C(System.Object)", c.Name);
-            Assert.Equal("Public MustOverride WriteOnly Property C(x As Object) As Integer", c.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(c);
+            Assert.AreEqual("C(Object)", c.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).C(Object)", c.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.C(System.Object)", c.Name);
+            Assert.AreEqual("Public MustOverride WriteOnly Property C(x As Object) As Integer", c.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var d = output.Items[0].Items[0].Items[3];
-            Assert.NotNull(d);
-            Assert.Equal("D(Date)", d.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).D(Date)", d.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.D(System.DateTime)", d.Name);
-            Assert.Equal("Protected Property D(x As Date) As Integer", d.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(d);
+            Assert.AreEqual("D(Date)", d.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).D(Date)", d.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.D(System.DateTime)", d.Name);
+            Assert.AreEqual("Protected Property D(x As Date) As Integer", d.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var e = output.Items[0].Items[0].Items[4];
-            Assert.NotNull(e);
-            Assert.Equal("E(T)", e.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).E(T)", e.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.E(`0)", e.Name);
-            Assert.Equal("Public Property E(t As T) As Integer", e.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(e);
+            Assert.AreEqual("E(T)", e.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).E(T)", e.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.E(`0)", e.Name);
+            Assert.AreEqual("Public Property E(t As T) As Integer", e.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var f = output.Items[0].Items[0].Items[5];
-            Assert.NotNull(f);
-            Assert.Equal("F(Integer, T)", f.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo(Of T).F(Integer, T)", f.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Foo`1.F(System.Int32,`0)", f.Name);
-            Assert.Equal("Protected Shared Property F(x As Integer, t As T) As Integer", f.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(f);
+            Assert.AreEqual("F(Integer, T)", f.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo(Of T).F(Integer, T)", f.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Foo`1.F(System.Int32,`0)", f.Name);
+            Assert.AreEqual("Protected Shared Property F(x As Integer, t As T) As Integer", f.Syntax.Content[SyntaxLanguage.VB]);
         }
         // Bar
         {
             var a = output.Items[0].Items[1].Items[0];
-            Assert.NotNull(a);
-            Assert.Equal("A(Integer)", a.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.A(Integer)", a.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.A(System.Int32)", a.Name);
-            Assert.Equal("Public Overridable Property A(x As Integer) As Integer", a.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(a);
+            Assert.AreEqual("A(Integer)", a.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.A(Integer)", a.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.A(System.Int32)", a.Name);
+            Assert.AreEqual("Public Overridable Property A(x As Integer) As Integer", a.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var b = output.Items[0].Items[1].Items[1];
-            Assert.NotNull(b);
-            Assert.Equal("B(String)", b.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.B(String)", b.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.B(System.String)", b.Name);
-            Assert.Equal("Public Overrides ReadOnly Property B(x As String) As Integer", b.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(b);
+            Assert.AreEqual("B(String)", b.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.B(String)", b.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.B(System.String)", b.Name);
+            Assert.AreEqual("Public Overrides ReadOnly Property B(x As String) As Integer", b.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var c = output.Items[0].Items[1].Items[2];
-            Assert.NotNull(c);
-            Assert.Equal("C(Object)", c.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.C(Object)", c.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.Bar.C(System.Object)", c.Name);
-            Assert.Equal("Public Overrides WriteOnly Property C(x As Object) As Integer", c.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(c);
+            Assert.AreEqual("C(Object)", c.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.C(Object)", c.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.Bar.C(System.Object)", c.Name);
+            Assert.AreEqual("Public Overrides WriteOnly Property C(x As Object) As Integer", c.Syntax.Content[SyntaxLanguage.VB]);
         }
         // IFooBar
         {
             var a = output.Items[0].Items[2].Items[0];
-            Assert.NotNull(a);
-            Assert.Equal("A(Integer)", a.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.A(Integer)", a.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.A(System.Int32)", a.Name);
-            Assert.Equal("Property A(x As Integer) As Integer", a.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(a);
+            Assert.AreEqual("A(Integer)", a.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.A(Integer)", a.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.A(System.Int32)", a.Name);
+            Assert.AreEqual("Property A(x As Integer) As Integer", a.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var b = output.Items[0].Items[2].Items[1];
-            Assert.NotNull(b);
-            Assert.Equal("B(String)", b.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.B(String)", b.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.B(System.String)", b.Name);
-            Assert.Equal("ReadOnly Property B(x As String) As Integer", b.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(b);
+            Assert.AreEqual("B(String)", b.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.B(String)", b.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.B(System.String)", b.Name);
+            Assert.AreEqual("ReadOnly Property B(x As String) As Integer", b.Syntax.Content[SyntaxLanguage.VB]);
         }
         {
             var c = output.Items[0].Items[2].Items[2];
-            Assert.NotNull(c);
-            Assert.Equal("C(Object)", c.DisplayNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.C(Object)", c.DisplayQualifiedNames[SyntaxLanguage.VB]);
-            Assert.Equal("Test1.IFooBar.C(System.Object)", c.Name);
-            Assert.Equal("WriteOnly Property C(x As Object) As Integer", c.Syntax.Content[SyntaxLanguage.VB]);
+            Assert.IsNotNull(c);
+            Assert.AreEqual("C(Object)", c.DisplayNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.C(Object)", c.DisplayQualifiedNames[SyntaxLanguage.VB]);
+            Assert.AreEqual("Test1.IFooBar.C(System.Object)", c.Name);
+            Assert.AreEqual("WriteOnly Property C(x As Object) As Integer", c.Syntax.Content[SyntaxLanguage.VB]);
         }
     }
 
-    [Trait("Related", "Generic")]
-    [Trait("Related", "Multilanguage")]
-    [Fact]
+    [TestProperty("Related", "Generic")]
+    [TestProperty("Related", "Multilanguage")]
+    [TestMethod]
     public void TestGenerateMetadataAsyncWithMultilanguage()
     {
         string code = @"
@@ -1315,30 +1315,30 @@ End Namespace
 ";
         MetadataItem output = Verify(code);
         var type = output.Items[0].Items[0];
-        Assert.NotNull(type);
-        Assert.Equal("Foo<T>", type.DisplayNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("Foo(Of T)", type.DisplayNames[SyntaxLanguage.VB]);
-        Assert.Equal("Test1.Foo<T>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("Test1.Foo(Of T)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
-        Assert.Equal("Test1.Foo`1", type.Name);
+        Assert.IsNotNull(type);
+        Assert.AreEqual("Foo<T>", type.DisplayNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Foo(Of T)", type.DisplayNames[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo<T>", type.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo(Of T)", type.DisplayQualifiedNames[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo`1", type.Name);
 
         var method = output.Items[0].Items[0].Items[0];
-        Assert.NotNull(method);
-        Assert.Equal("Bar<K>(int)", method.DisplayNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("Bar(Of K)(Integer)", method.DisplayNames[SyntaxLanguage.VB]);
-        Assert.Equal("Test1.Foo<T>.Bar<K>(int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
-        Assert.Equal("Test1.Foo(Of T).Bar(Of K)(Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
-        Assert.Equal("Test1.Foo`1.Bar``1(System.Int32)", method.Name);
-        Assert.Single(output.Items);
+        Assert.IsNotNull(method);
+        Assert.AreEqual("Bar<K>(int)", method.DisplayNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Bar(Of K)(Integer)", method.DisplayNames[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo<T>.Bar<K>(int)", method.DisplayQualifiedNames[SyntaxLanguage.CSharp]);
+        Assert.AreEqual("Test1.Foo(Of T).Bar(Of K)(Integer)", method.DisplayQualifiedNames[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo`1.Bar``1(System.Int32)", method.Name);
+        Assert.ContainsSingle(output.Items);
         var parameter = method.Syntax.Parameters[0];
-        Assert.Equal("i", parameter.Name);
-        Assert.Equal("System.Int32", parameter.Type);
+        Assert.AreEqual("i", parameter.Name);
+        Assert.AreEqual("System.Int32", parameter.Type);
         var returnValue = method.Syntax.Return;
-        Assert.Null(returnValue);
+        Assert.IsNull(returnValue);
     }
 
-    [Trait("Related", "Attribute")]
-    [Fact]
+    [TestProperty("Related", "Attribute")]
+    [TestMethod]
     public void TestGenerateMetadataWithAttribute()
     {
         string code = @"
@@ -1364,10 +1364,10 @@ End Class
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var type = output.Items[0].Items[0];
-        Assert.NotNull(type);
-        Assert.Equal(@"<Serializable>
+        Assert.IsNotNull(type);
+        Assert.AreEqual(@"<Serializable>
 <AttributeUsage(AttributeTargets.All, Inherited:=True, AllowMultiple:=True)>
 <TypeConverter(GetType(TestAttribute))>
 <Test(""test"")>
@@ -1376,14 +1376,14 @@ End Namespace
 <Test(New Type() { GetType(Func(Of )), GetType(Func(Of ,)), GetType(Func(Of String, String)) })>
 Public Class TestAttribute Inherits Attribute", type.Syntax.Content[SyntaxLanguage.VB]);
         var ctor = type.Items[0];
-        Assert.NotNull(type);
-        Assert.Equal(@"<Test(1)>
+        Assert.IsNotNull(type);
+        Assert.AreEqual(@"<Test(1)>
 <Test(2)>
 Public Sub New(o As Object)", ctor.Syntax.Content[SyntaxLanguage.VB]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithTupleParameter()
     {
         string code = @"
@@ -1395,20 +1395,20 @@ End Class
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar(System.ValueTuple{System.String,System.String})", bar.Name);
-        Assert.Equal("Public Sub Bar(tuple As (prefix As String, uri As String))", bar.Syntax.Content[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo.Bar(System.ValueTuple{System.String,System.String})", bar.Name);
+        Assert.AreEqual("Public Sub Bar(tuple As (prefix As String, uri As String))", bar.Syntax.Content[SyntaxLanguage.VB]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithUnnamedTupleParameter()
     {
         string code = @"
@@ -1420,20 +1420,20 @@ End Class
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar(System.ValueTuple{System.String,System.String})", bar.Name);
-        Assert.Equal("Public Sub Bar(tuple As (String, String))", bar.Syntax.Content[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo.Bar(System.ValueTuple{System.String,System.String})", bar.Name);
+        Assert.AreEqual("Public Sub Bar(tuple As (String, String))", bar.Syntax.Content[SyntaxLanguage.VB]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithPartiallyUnnamedTupleParameter()
     {
         string code = @"
@@ -1445,20 +1445,20 @@ End Class
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar(System.ValueTuple{System.String,System.String})", bar.Name);
-        Assert.Equal("Public Sub Bar(tuple As (String, uri As String))", bar.Syntax.Content[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo.Bar(System.ValueTuple{System.String,System.String})", bar.Name);
+        Assert.AreEqual("Public Sub Bar(tuple As (String, uri As String))", bar.Syntax.Content[SyntaxLanguage.VB]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithTupleArrayParameter()
     {
         string code = @"
@@ -1470,20 +1470,20 @@ End Class
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar(System.ValueTuple{System.String,System.String}[])", bar.Name);
-        Assert.Equal("Public Sub Bar(tuples As (String, String)())", bar.Syntax.Content[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo.Bar(System.ValueTuple{System.String,System.String}[])", bar.Name);
+        Assert.AreEqual("Public Sub Bar(tuples As (String, String)())", bar.Syntax.Content[SyntaxLanguage.VB]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithTupleEnumerableParameter()
     {
         string code = @"
@@ -1497,20 +1497,20 @@ End Class
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar(System.Collections.Generic.IEnumerable{System.ValueTuple{System.String,System.String}})", bar.Name);
-        Assert.Equal("Public Sub Bar(tuples As IEnumerable(Of (prefix As String, uri As String)))", bar.Syntax.Content[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo.Bar(System.Collections.Generic.IEnumerable{System.ValueTuple{System.String,System.String}})", bar.Name);
+        Assert.AreEqual("Public Sub Bar(tuples As IEnumerable(Of (prefix As String, uri As String)))", bar.Syntax.Content[SyntaxLanguage.VB]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithTupleResult()
     {
         string code = @"
@@ -1523,20 +1523,20 @@ End Class
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar", bar.Name);
-        Assert.Equal("Public Function Bar() As (prefix As String, uri As String)", bar.Syntax.Content[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo.Bar", bar.Name);
+        Assert.AreEqual("Public Function Bar() As (prefix As String, uri As String)", bar.Syntax.Content[SyntaxLanguage.VB]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithUnnamedTupleResult()
     {
         string code = @"
@@ -1549,20 +1549,20 @@ End Class
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar", bar.Name);
-        Assert.Equal("Public Function Bar() As (String, String)", bar.Syntax.Content[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo.Bar", bar.Name);
+        Assert.AreEqual("Public Function Bar() As (String, String)", bar.Syntax.Content[SyntaxLanguage.VB]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithPartiallyUnnamedTupleResult()
     {
         string code = @"
@@ -1575,20 +1575,20 @@ End Class
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar", bar.Name);
-        Assert.Equal("Public Function Bar() As (String, uri As String)", bar.Syntax.Content[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo.Bar", bar.Name);
+        Assert.AreEqual("Public Function Bar() As (String, uri As String)", bar.Syntax.Content[SyntaxLanguage.VB]);
     }
 
-    [Fact]
-    [Trait("Related", "ValueTuple")]
+    [TestMethod]
+    [TestProperty("Related", "ValueTuple")]
     public void TestGenerateMetadataAsyncWithEnumerableTupleResult()
     {
         string code = @"
@@ -1603,19 +1603,19 @@ End Class
 End Namespace
 ";
         MetadataItem output = Verify(code);
-        Assert.Single(output.Items);
+        Assert.ContainsSingle(output.Items);
         var ns = output.Items[0];
-        Assert.NotNull(ns);
+        Assert.IsNotNull(ns);
         var foo = ns.Items[0];
-        Assert.NotNull(foo);
-        Assert.Equal("Test1.Foo", foo.Name);
-        Assert.Single(foo.Items);
+        Assert.IsNotNull(foo);
+        Assert.AreEqual("Test1.Foo", foo.Name);
+        Assert.ContainsSingle(foo.Items);
         var bar = foo.Items[0];
-        Assert.Equal("Test1.Foo.Bar", bar.Name);
-        Assert.Equal("Public Function Bar() As IEnumerable(Of (prefix As String, uri As String))", bar.Syntax.Content[SyntaxLanguage.VB]);
+        Assert.AreEqual("Test1.Foo.Bar", bar.Name);
+        Assert.AreEqual("Public Function Bar() As IEnumerable(Of (prefix As String, uri As String))", bar.Syntax.Content[SyntaxLanguage.VB]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestDefineConstantsMSBuildProperty()
     {
         var code =
@@ -1634,17 +1634,17 @@ End Namespace
         {
             var output = Verify(code, msbuildProperties: new Dictionary<string, string> { ["DefineConstants"] = "TEST=DUMMYVALUE;DUMMY=DUMMYVALUE" });
             var foo = output.Items[0].Items[0];
-            Assert.Equal("Test.Foo.F1", foo.Items[0].Name);
+            Assert.AreEqual("Test.Foo.F1", foo.Items[0].Name);
         }
         // Test without DefineConstants
         {
             var output = Verify(code, msbuildProperties: EmptyMSBuildProperties);
             var foo = output.Items[0].Items[0];
-            Assert.Empty(foo.Items);
+            Assert.IsEmpty(foo.Items);
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGenerateMetadataWithReference()
     {
         string code = @"
diff --git a/test/Docfx.Dotnet.Tests/SymbolUrlResolverUnitTest.cs b/test/Docfx.Dotnet.Tests/SymbolUrlResolverUnitTest.cs
index 2fe299a1a5e..2c3d2419465 100644
--- a/test/Docfx.Dotnet.Tests/SymbolUrlResolverUnitTest.cs
+++ b/test/Docfx.Dotnet.Tests/SymbolUrlResolverUnitTest.cs
@@ -3,13 +3,13 @@
 
 using System.Text.RegularExpressions;
 using Microsoft.CodeAnalysis;
-using Xunit;
 
 namespace Docfx.Dotnet.Tests;
 
+[TestClass]
 public class SymbolUrlResolverUnitTest
 {
-    [Fact]
+    [TestMethod]
     public void GetMicrosoftLearnUrlFromCommentIdTest()
     {
         var failures = new List<(string, Uri, Uri[])>();
@@ -54,44 +54,44 @@ public void GetMicrosoftLearnUrlFromCommentIdTest()
         //
         // - When UID differs only by case, mslearn appends _1 to disambiguate.
         // - When > 180 chars, type name is used over fully-qualified names to reduce URL length.
-        Assert.Equal(56, failures.Count);
+        Assert.AreEqual(56, failures.Count);
     }
 
-    [Theory]
-    [InlineData("A.b[]", "a-b()")]
-    [InlineData("a b", "a-b")]
-    [InlineData("a\"b", "ab")]
-    [InlineData("a%b", "ab")]
-    [InlineData("a^b", "ab")]
-    [InlineData("a\\b", "ab")]
-    [InlineData("Dictionary<string, List<int>>*", "dictionary(string-list(int))*")]
-    [InlineData("a'b'c", "abc")]
-    [InlineData("{a|b_c'}", "((a-b-c))")]
-    [InlineData("---&&$$##List<string> test(int a`, int a@, string b*)---&&$$##", "list(string)-test(int-a-int-a@-string-b*)")]
-    [InlineData(
+    [TestMethod]
+    [DataRow("A.b[]", "a-b()")]
+    [DataRow("a b", "a-b")]
+    [DataRow("a\"b", "ab")]
+    [DataRow("a%b", "ab")]
+    [DataRow("a^b", "ab")]
+    [DataRow("a\\b", "ab")]
+    [DataRow("Dictionary<string, List<int>>*", "dictionary(string-list(int))*")]
+    [DataRow("a'b'c", "abc")]
+    [DataRow("{a|b_c'}", "((a-b-c))")]
+    [DataRow("---&&$$##List<string> test(int a`, int a@, string b*)---&&$$##", "list(string)-test(int-a-int-a@-string-b*)")]
+    [DataRow(
         "Microsoft.StreamProcessing.Streamable.AggregateByKey``4(Microsoft.StreamProcessing.IStreamable{Microsoft.StreamProcessing.Empty,``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},Microsoft.StreamProcessing.Aggregates.IAggregate{``0,``22,``23}},Microsoft.StreamProcessing.Aggregates.IAggregate{``0,``30,``31}},System.Linq.Expressions.Expression{System.Func{``3,``5,``7,``9,``11,``13,``15,``17,``19,``21,``23,``25,``27,``29,``31,``32}})",
         "microsoft-streamprocessing-streamable-aggregatebykey-4(microsoft-streamprocessing-istreamable((microsoft-streamprocessing-empty-0))-system-linq-expressions-expression((system-func((-0-1))))-microsoft-streamprocessing-aggregates-iaggregate((-0-22-23))))-microsoft-streamprocessing-aggregates-iaggregate((-0-30-31))))-system-linq-expressions-expression((system-func((-3-5-7-9-11-13-15-17-19-21-23-25-27-29-31-32)))))")]
-    public static void GetUrlFragmentFromUidTest(string uid, string expectedFragment)
+    public void GetUrlFragmentFromUidTest(string uid, string expectedFragment)
     {
-        Assert.Equal(expectedFragment, SymbolUrlResolver.GetUrlFragmentFromUid(uid));
+        Assert.AreEqual(expectedFragment, SymbolUrlResolver.GetUrlFragmentFromUid(uid));
     }
 
-    [Fact]
-    public static void GetPdbSourceLinkUrlTest()
+    [TestMethod]
+    public void GetPdbSourceLinkUrlTest()
     {
         var (compilation, assembly) = CompilationHelper.CreateCompilationFromAssembly($"{typeof(DotnetApiCatalog).Assembly.GetName().Name}.dll");
 
         var type = assembly.GetTypeByMetadataName(typeof(DotnetApiCatalog).FullName);
-        Assert.NotNull(type);
+        Assert.IsNotNull(type);
         var compilationLink = ReplaceSHA(SymbolUrlResolver.GetPdbSourceLinkUrl(compilation, type));
-        Assert.True(compilationLink?.StartsWith("https://github.com/"));
-        Assert.True(compilationLink?.EndsWith(".cs"));
+        Assert.IsTrue(compilationLink?.StartsWith("https://github.com/"));
+        Assert.IsTrue(compilationLink?.EndsWith(".cs"));
 
         var method = type.GetMembers(nameof(DotnetApiCatalog.GenerateManagedReferenceYamlFiles)).FirstOrDefault();
-        Assert.NotNull(method);
+        Assert.IsNotNull(method);
         var methodLink = ReplaceSHA(SymbolUrlResolver.GetPdbSourceLinkUrl(compilation, method));
-        Assert.True(compilationLink?.StartsWith("https://github.com/"));
-        Assert.True(compilationLink?.EndsWith(".cs"));
+        Assert.IsTrue(compilationLink?.StartsWith("https://github.com/"));
+        Assert.IsTrue(compilationLink?.EndsWith(".cs"));
 
         static string ReplaceSHA(string value)
         {
diff --git a/test/Docfx.Dotnet.Tests/XmlCommentUnitTest.cs b/test/Docfx.Dotnet.Tests/XmlCommentUnitTest.cs
index 9906c514222..4987c7e5e48 100644
--- a/test/Docfx.Dotnet.Tests/XmlCommentUnitTest.cs
+++ b/test/Docfx.Dotnet.Tests/XmlCommentUnitTest.cs
@@ -1,55 +1,52 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.Dotnet.Tests;
 
+[TestClass]
 public class XmlCommentUnitTest
 {
     private static void Verify(string comment, string summary)
     {
-        Assert.Equal(
-            summary,
-            XmlComment.Parse($"<summary>{comment}</summary>").Summary,
-            ignoreLineEndingDifferences: true);
+        Assert.AreEqual(
+            summary.ReplaceLineEndings(),
+            XmlComment.Parse($"<summary>{comment}</summary>").Summary.ReplaceLineEndings());
     }
 
-    [Fact]
-    public static void SeeLangword()
+    [TestMethod]
+    public void SeeLangword()
     {
         Verify("<see langword=\"if\" />", "<a href=\"https://learn.microsoft.com/dotnet/csharp/language-reference/statements/selection-statements#the-if-statement\">if</a>");
         Verify("<see langword=\"undefined-langword\" />", "<code>undefined-langword</code>");
     }
 
-    [Fact]
-    public static void ParaNewLine()
+    [TestMethod]
+    public void ParaNewLine()
     {
-        Assert.Equal(
+        Assert.AreEqual(
             """
             a
             <p>b</p>
             <p>c</p>
-            """,
+            """.ReplaceLineEndings(),
             XmlComment.Parse("""
                 <summary>
                 a
                 <para>b</para>
                 <para>c</para>
                 </summary>
-                """).Summary,
-            ignoreLineEndingDifferences: true);
+                """).Summary.ReplaceLineEndings());
     }
 
-    [Fact]
-    public static void Issue8122()
+    [TestMethod]
+    public void Issue8122()
     {
         var comment = XmlComment.Parse("<seealso href=\"#\">Foo's</seealso>");
-        Assert.Equal("Foo's", comment.SeeAlsos[0].AltText);
+        Assert.AreEqual("Foo's", comment.SeeAlsos[0].AltText);
     }
 
-    [Fact]
-    public static void Issue4165()
+    [TestMethod]
+    public void Issue4165()
     {
         var comment = XmlComment.Parse(
             """
@@ -58,18 +55,18 @@ public static void Issue4165()
               <param name="args">arg2</param>
             </doc>
             """);
-        Assert.Equal("arg1", comment.Parameters["args"]);
+        Assert.AreEqual("arg1", comment.Parameters["args"]);
     }
 
-    [Fact]
-    public static void Issue8965()
+    [TestMethod]
+    public void Issue8965()
     {
         Verify("<seealso href=\"https://github.com\"><em>See also on MDN</em></seealso>", "<a href=\"https://github.com\">\n  <em>See also on MDN</em>\n</a>");
         Verify("<see href=\"https://github.com\"><em>See also on MDN</em></see>", "<a href=\"https://github.com\">\n  <em>See also on MDN</em>\n</a>");
     }
 
-    [Fact]
-    public static void BasicCodeBlock()
+    [TestMethod]
+    public void BasicCodeBlock()
     {
         var comment = XmlComment.Parse(
             """
@@ -83,19 +80,18 @@ public int Main(string[] args)
             </remarks>
             """);
 
-        Assert.Equal(
+        Assert.AreEqual(
             """
             <pre><code class="lang-csharp">public int Main(string[] args)
             {
                 Console.HelloWorld();
             }</code></pre>
-            """,
-            comment.Remarks,
-            ignoreLineEndingDifferences: true);
+            """.ReplaceLineEndings(),
+            comment.Remarks.ReplaceLineEndings());
     }
 
-    [Fact]
-    public static void ExternalCodeBlockCSharp()
+    [TestMethod]
+    public void ExternalCodeBlockCSharp()
     {
         var example = """
             using System;
@@ -122,7 +118,7 @@ public int Main(string[] args)
             """,
             new() { ResolveCode = _ => example });
 
-        Assert.Equal(
+        Assert.AreEqual(
             """
             <pre><code class="lang-cs">static class Program
             {
@@ -131,12 +127,11 @@ public int Main(string[] args)
                     Console.HelloWorld();
                 }
             }</code></pre>
-            """,
-            comment.Remarks,
-            ignoreLineEndingDifferences: true);
+            """.ReplaceLineEndings(),
+            comment.Remarks.ReplaceLineEndings());
     }
 
-    [Fact]
+    [TestMethod]
     public void ExternalCodeBlockXaml()
     {
         var example = """
@@ -162,20 +157,19 @@ public void ExternalCodeBlockXaml()
 
         var commentModel = XmlComment.Parse(input, new() { ResolveCode = _ => example });
 
-        Assert.Equal(
+        Assert.AreEqual(
             """
             This is an example using source reference in a xaml file.
             <pre><code class="lang-xaml">&lt;Grid&gt;
               &lt;TextBlock Text="Hello World" /&gt;
             &lt;/Grid&gt;</code></pre>
-            """,
-            commentModel.Examples.Single(),
-            ignoreLineEndingDifferences: true);
+            """.ReplaceLineEndings(),
+            commentModel.Examples.Single().ReplaceLineEndings());
     }
 
-    [Theory]
-    [InlineData("<example><code source='Example.cs' region='SDK_CustomProcessor' /></example>")]
-    [InlineData("""
+    [TestMethod]
+    [DataRow("<example><code source='Example.cs' region='SDK_CustomProcessor' /></example>")]
+    [DataRow("""
         <example>
           <code source='Example.cs' region='SDK_CustomProcessor' />
         </example>
@@ -193,17 +187,17 @@ public void Issue9462(string input)
                 #endregion
                 """
         });
-        Assert.Equal(
+
+        Assert.AreEqual(
             """
             <pre><code class="lang-cs">using System;
             using System.Collections.Generic;</code></pre>
-            """,
-            commentModel.Examples.Single(),
-            ignoreLineEndingDifferences: true);
+            """.ReplaceLineEndings(),
+            commentModel.Examples.Single().ReplaceLineEndings());
     }
 
-    [Fact]
-    public static void MarkdownCodeBlock()
+    [TestMethod]
+    public void MarkdownCodeBlock()
     {
         var comment = XmlComment.Parse(
             """
@@ -232,14 +226,14 @@ function main()
             </doc>
             """);
 
-        Assert.Equal("""
+        Assert.AreEqual("""
             public int Main(string[] args)
             {
                 Console.HelloWorld();
             }
-            """, comment.Summary, ignoreLineEndingDifferences: true);
+            """.ReplaceLineEndings(), comment.Summary.ReplaceLineEndings());
 
-        Assert.Equal("""
+        Assert.AreEqual("""
             For example:
 
                 public int Main(string[] args)
@@ -253,17 +247,17 @@ function main()
                 return 0
             }
             ```
-            """, comment.Remarks, ignoreLineEndingDifferences: true);
+            """.ReplaceLineEndings(), comment.Remarks.ReplaceLineEndings());
     }
 
-    [Fact]
-    public static void MarkdownCodeInline()
+    [TestMethod]
+    public void MarkdownCodeInline()
     {
         Verify("Inline `&lt;angle brackets&gt;`", "Inline `<angle brackets>`");
     }
 
-    [Fact]
-    public static void Issue9216()
+    [TestMethod]
+    public void Issue9216()
     {
         Verify(
             """
@@ -278,7 +272,7 @@ public static void Issue9216()
             """);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestXmlCommentParser()
     {
         var input = """
@@ -371,22 +365,22 @@ Check empty code.
         var commentModel = XmlComment.Parse(input);
 
         var summary = commentModel.Summary;
-        Assert.Equal("""
+        Assert.AreEqual("""
             Partial classes <xref href="System.AccessViolationException" data-throw-if-not-resolved="false"></xref><xref href="System.AccessViolationException" data-throw-if-not-resolved="false"></xref>can not cross assemblies, Test <a href="https://learn.microsoft.com/dotnet/csharp/language-reference/keywords/null">null</a>
 
             ```
             Classes in assemblies are by definition complete.
             ```
-            """, summary, ignoreLineEndingDifferences: true);
+            """.ReplaceLineEndings(), summary.ReplaceLineEndings());
 
         var returns = commentModel.Returns;
-        Assert.Equal("Task<xref href=\"System.AccessViolationException\" data-throw-if-not-resolved=\"false\"></xref> returns", returns);
+        Assert.AreEqual("Task<xref href=\"System.AccessViolationException\" data-throw-if-not-resolved=\"false\"></xref> returns", returns);
 
         var paramInput = commentModel.Parameters["input"];
-        Assert.Equal("This is <xref href=\"System.AccessViolationException\" data-throw-if-not-resolved=\"false\"></xref>the input", paramInput);
+        Assert.AreEqual("This is <xref href=\"System.AccessViolationException\" data-throw-if-not-resolved=\"false\"></xref>the input", paramInput);
 
         var remarks = commentModel.Remarks;
-        Assert.Equal("""
+        Assert.AreEqual("""
             <a href="https://example.org">https://example.org</a>
             <a href="https://example.org">example</a>
             <p>This is <code class="paramref">ref</code> a sample of exception node</p>
@@ -401,16 +395,16 @@ the second line.
                     </li><li>item2 in bullet list</li><li>
                     loose text <i>not</i> wrapped in description
                 </li></ul>
-            """, remarks, ignoreLineEndingDifferences: true);
+            """.ReplaceLineEndings(), remarks.ReplaceLineEndings());
 
         var exceptions = commentModel.Exceptions;
-        Assert.Single(exceptions);
-        Assert.Equal("System.Xml.XmlException", exceptions[0].Type);
-        Assert.Equal(@"This is a sample of exception node. Ref <a href=""http://exception.com"">Exception</a>", exceptions[0].Description);
+        Assert.ContainsSingle(exceptions);
+        Assert.AreEqual("System.Xml.XmlException", exceptions[0].Type);
+        Assert.AreEqual(@"This is a sample of exception node. Ref <a href=""http://exception.com"">Exception</a>", exceptions[0].Description);
 
-        Assert.Collection(
-            commentModel.Examples,
-            e => Assert.Equal(
+        Assert.AreEqual(4, commentModel.Examples.Count);
+
+        Assert.AreEqual(
                 """
                 This sample shows how to call the <see cref="M: Docfx.EntityModel.XmlCommentParser.GetExceptions(System.String, Docfx.EntityModel.XmlCommentParserContext)"></see> method.
                 <pre><code class="lang-csharp">class TestClass
@@ -420,36 +414,38 @@ static int Main()
                          return GetExceptions(null, null).Count();
                      }
                  }</code></pre>
-                """, e, ignoreLineEndingDifferences: true),
-            e => Assert.Equal(
+                """.ReplaceLineEndings(), commentModel.Examples[0].ReplaceLineEndings());
+
+        Assert.AreEqual(
                 """
                 This is another example
-                """, e, ignoreLineEndingDifferences: true),
-            e => Assert.Equal(
+                """.ReplaceLineEndings(), commentModel.Examples[1].ReplaceLineEndings());
+
+        Assert.AreEqual(
                 """
                 Check empty code.
                 <pre><code class="lang-csharp"></code></pre>
-                """, e, ignoreLineEndingDifferences: true),
-            e => Assert.Equal(
+                """.ReplaceLineEndings(), commentModel.Examples[2].ReplaceLineEndings());
+
+        Assert.AreEqual(
                 """
                 This is an example using source reference.
                 <pre><code class="lang-cs"></code></pre>
-                """, e, ignoreLineEndingDifferences: true)
-            );
+                """.ReplaceLineEndings(), commentModel.Examples[3].ReplaceLineEndings());
 
         commentModel = XmlComment.Parse(input);
 
         var seeAlsos = commentModel.SeeAlsos;
-        Assert.Equal(3, seeAlsos.Count);
-        Assert.Equal("System.IO.WaitForChangedResult", seeAlsos[0].LinkId);
-        Assert.Null(seeAlsos[0].AltText);
-        Assert.Equal("http://www.bing.com", seeAlsos[1].LinkId);
-        Assert.Equal("Hello Bing", seeAlsos[1].AltText);
-        Assert.Equal("http://www.bing.com", seeAlsos[2].AltText);
-        Assert.Equal("http://www.bing.com", seeAlsos[2].LinkId);
+        Assert.AreEqual(3, seeAlsos.Count);
+        Assert.AreEqual("System.IO.WaitForChangedResult", seeAlsos[0].LinkId);
+        Assert.IsNull(seeAlsos[0].AltText);
+        Assert.AreEqual("http://www.bing.com", seeAlsos[1].LinkId);
+        Assert.AreEqual("Hello Bing", seeAlsos[1].AltText);
+        Assert.AreEqual("http://www.bing.com", seeAlsos[2].AltText);
+        Assert.AreEqual("http://www.bing.com", seeAlsos[2].LinkId);
     }
 
-    [Fact]
+    [TestMethod]
     public void SeeAltText()
     {
         string input = """
@@ -469,31 +465,31 @@ public void SeeAltText()
         var commentModel = XmlComment.Parse(input);
 
         var summary = commentModel.Summary;
-        Assert.Equal("""
+        Assert.AreEqual("""
             Class summary <xref href="System.AccessViolationException?text=Exception+type" data-throw-if-not-resolved="false"></xref>
-            """, summary, ignoreLineEndingDifferences: true);
+            """.ReplaceLineEndings(), summary.ReplaceLineEndings());
 
         var returns = commentModel.Returns;
-        Assert.Equal("Returns an <xref href=\"System.AccessViolationException?text=Exception\" data-throw-if-not-resolved=\"false\"></xref>.", returns);
+        Assert.AreEqual("Returns an <xref href=\"System.AccessViolationException?text=Exception\" data-throw-if-not-resolved=\"false\"></xref>.", returns);
 
         var paramInput = commentModel.Parameters["input"];
-        Assert.Equal("This is an <xref href=\"System.AccessViolationException?text=Exception\" data-throw-if-not-resolved=\"false\"></xref>.", paramInput);
+        Assert.AreEqual("This is an <xref href=\"System.AccessViolationException?text=Exception\" data-throw-if-not-resolved=\"false\"></xref>.", paramInput);
 
         var remarks = commentModel.Remarks;
-        Assert.Equal("""
+        Assert.AreEqual("""
             See <xref href="System.Int?text=Integer" data-throw-if-not-resolved="false"></xref>.
-            """, remarks, ignoreLineEndingDifferences: true);
+            """.ReplaceLineEndings(), remarks.ReplaceLineEndings());
     }
 
-    [Fact]
+    [TestMethod]
     public void ParseXmlCommentWithoutRootNode()
     {
         var input = "<summary>A</summary>";
         var commentModel = XmlComment.Parse(input, new XmlCommentParserContext());
-        Assert.Equal("A", commentModel.Summary);
+        Assert.AreEqual("A", commentModel.Summary);
     }
 
-    [Fact]
+    [TestMethod]
     public void Issue9495()
     {
         var comment = XmlComment.Parse(
@@ -518,7 +514,8 @@ public void Issue9495()
             ]]></code>
             </example>
             """);
-        Assert.Equal(
+
+        Assert.AreEqual(
             """
             <pre><code class="lang-csharp">options.UseRelativeLinks = true;</code></pre>
 
@@ -534,10 +531,10 @@ public void Issue9495()
                  }
               }
             }</code></pre>
-            """, comment.Examples[0], ignoreLineEndingDifferences: true);
+            """.ReplaceLineEndings(), comment.Examples[0].ReplaceLineEndings());
     }
 
-    [Fact]
+    [TestMethod]
     public void Issue10385()
     {
         var comment = XmlComment.Parse(
@@ -558,7 +555,8 @@ public sealed class Issue10385
             </code>
             </remarks>
             """);
-        Assert.Equal(
+
+        Assert.AreEqual(
             """
             <p>
             Paragraph.
@@ -572,7 +570,7 @@ public sealed class Issue10385
 
                 public int CCC {get;set;}
             }</code></pre>
-            """, comment.Remarks, ignoreLineEndingDifferences: true);
+            """.ReplaceLineEndings(), comment.Remarks.ReplaceLineEndings());
     }
 
 
diff --git a/test/Docfx.Glob.Tests/GlobFileTest.cs b/test/Docfx.Glob.Tests/GlobFileTest.cs
index 6ea1062ed69..d44d0158840 100644
--- a/test/Docfx.Glob.Tests/GlobFileTest.cs
+++ b/test/Docfx.Glob.Tests/GlobFileTest.cs
@@ -2,10 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Docfx.Tests.Common;
-using Xunit;
 
 namespace Docfx.Glob.Tests;
 
+[TestClass]
 public class GlobFileTest : TestBase
 {
     private readonly string _workingDirectory;
@@ -15,7 +15,7 @@ public GlobFileTest()
         _workingDirectory = GetRandomFolder();
     }
 
-    [Fact]
+    [TestMethod]
     public void TestGlobGetFilesShouldAbleToGetFiles()
     {
         // - Root/
@@ -53,32 +53,32 @@ public void TestGlobGetFilesShouldAbleToGetFiles()
             _workingDirectory,
             ["**.md"],
             null).ToArray();
-        Assert.Equal(3, result.Length);
+        Assert.AreEqual(3, result.Length);
         result = FileGlob.GetFiles(
             _workingDirectory,
             null,
             ["**.md"]).ToArray();
-        Assert.Empty(result);
+        Assert.IsEmpty(result);
         result = FileGlob.GetFiles(
             _workingDirectory,
             ["**"],
             ["**.md"]).ToArray();
-        Assert.Equal(6, result.Length);
+        Assert.AreEqual(6, result.Length);
         result = FileGlob.GetFiles(
              _workingDirectory,
              ["**.md"],
              ["**{J,L}/**"]).ToArray();
-        Assert.Single(result);
+        Assert.ContainsSingle(result);
         result = FileGlob.GetFiles(
              _workingDirectory,
              ["**.md", "**.csproj"],
              ["**J/**", "**/M/**"]).ToArray();
-        Assert.Single(result);
+        Assert.ContainsSingle(result);
         result = FileGlob.GetFiles(
              _workingDirectory + "/Root",
              ["[EJ]/*.{md,cs,csproj}"],
              ["**.cs"]).ToArray();
-        Assert.Equal(2, result.Length);
+        Assert.AreEqual(2, result.Length);
     }
 
     private static void CreateFilesOrFolders(string cwd, params string[] items)
diff --git a/test/Docfx.Glob.Tests/GlobMatcherTest.cs b/test/Docfx.Glob.Tests/GlobMatcherTest.cs
index 5f8fe66a00a..5aabc49c5c6 100644
--- a/test/Docfx.Glob.Tests/GlobMatcherTest.cs
+++ b/test/Docfx.Glob.Tests/GlobMatcherTest.cs
@@ -1,201 +1,200 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.Glob.Tests;
 
+[TestClass]
 public class GlobMatcherTest
 {
-    [Theory]
-    [Trait("Related", "Glob")]
-    [InlineData("!!!!", false, "")]
-    [InlineData("!!!!!abc", true, "abc")]
-    [InlineData("abc", false, "abc")]
+    [TestMethod]
+    [TestProperty("Related", "Glob")]
+    [DataRow("!!!!", false, "")]
+    [DataRow("!!!!!abc", true, "abc")]
+    [DataRow("abc", false, "abc")]
     public void TestNegateGlobShouldAllowMultipleNegateChars(string pattern, bool expectedNegate, string expected)
     {
         var negate = GlobMatcher.ParseNegate(ref pattern);
-        Assert.Equal(expectedNegate, negate);
-        Assert.Equal(expected, pattern);
+        Assert.AreEqual(expectedNegate, negate);
+        Assert.AreEqual(expected, pattern);
     }
 
-    [Theory]
-    [Trait("Related", "Glob")]
-    [InlineData(@"a\{b,c\}d", new string[] { "a{b,c}d" })]
-    [InlineData("a{b,c}d", new string[] { "abd", "acd" })]
-    [InlineData("a{b,c,d}e{d}{}", new string[] { "abed", "aced", "aded" })]
-    [InlineData("{{a,b}}", new string[] { "a", "b" })]
-    [InlineData("z{a,b{,c}d", new string[] { })]
-    [InlineData(@"a\{b,c}d", new string[] { })]
+    [TestMethod]
+    [TestProperty("Related", "Glob")]
+    [DataRow(@"a\{b,c\}d", new string[] { "a{b,c}d" })]
+    [DataRow("a{b,c}d", new string[] { "abd", "acd" })]
+    [DataRow("a{b,c,d}e{d}{}", new string[] { "abed", "aced", "aded" })]
+    [DataRow("{{a,b}}", new string[] { "a", "b" })]
+    [DataRow("z{a,b{,c}d", new string[] { })]
+    [DataRow(@"a\{b,c}d", new string[] { })]
     public void TestGroupedGlobShouldExpand(string source, string[] expected)
     {
         var result = GlobMatcher.ExpandGroup(source);
-        Assert.Equal(expected, result);
+        CollectionAssert.AreEqual(expected, result);
     }
 
-    [Theory]
-    [Trait("Related", "Glob")]
-    [InlineData("", new string[]
+    [TestMethod]
+    [TestProperty("Related", "Glob")]
+    [DataRow("", new string[]
     {
         ""
     }, true)]
 
-    [InlineData("\\a", new string[]
+    [DataRow("\\a", new string[]
     {
         "a"
     }, true)]
-    [InlineData("a*", new string[]
+    [DataRow("a*", new string[]
     {
         "a", "abc", "abd", "abe"
     }, true)]
-    [InlineData(".a*", new string[]
+    [DataRow(".a*", new string[]
     {
         ".a", ".abc", ".abd", ".abe"
     }, true)]
-    [InlineData("b*/", new string[]
+    [DataRow("b*/", new string[]
     {
         "bdir/"
     }, true)]
-    [InlineData("**/a/*/b.cs", new string[]
+    [DataRow("**/a/*/b.cs", new string[]
     {
         "b/a/a/a/b.cs"
     }, true)]
     // ** is a shortcut for **/*
-    [InlineData("**", new string[]
+    [DataRow("**", new string[]
     {
         "a", "b", "abc", "bdir/cfile"
     }, true)]
 
-    [InlineData("A/**", new string[]
+    [DataRow("A/**", new string[]
     {
         "A/"
     }, false)]
     // ** is a shortcut for **/*
-    [InlineData("**/*", new string[]
+    [DataRow("**/*", new string[]
     {
       "a", "ab", "bdir/cfile", "a/b/c"
     }, true)]
 
-    [InlineData("**/*", new string[]
+    [DataRow("**/*", new string[]
     {
        "abc/"
     }, false)]
     // To match folders, / should be explicitly specified
-    [InlineData("**/", new string[]
+    [DataRow("**/", new string[]
     {
         "bdir/", "bdir/cdir/"
     }, true)]
-    [InlineData("[a-c]b*", new string[]
+    [DataRow("[a-c]b*", new string[]
     {
         "abc", "abd", "abe", "bb", "cb"
     }, true)]
-    [InlineData("[a-y]*[^c]", new string[]
+    [DataRow("[a-y]*[^c]", new string[]
     {
         "abd", "abe", "bb", "bcd"
     }, true)]
-    [InlineData("!abc", new string[]
+    [DataRow("!abc", new string[]
     {
         "d", "dd", "def"
     }, true)]
-    [InlineData("[^a-c]*", new string[]
+    [DataRow("[^a-c]*", new string[]
     {
         "d", "dd", "def"
     }, true)]
 
-    [InlineData("a\\*b/*", new string[]
+    [DataRow("a\\*b/*", new string[]
     {
         "a*b/ooo"
     }, true)]
 
-    [InlineData("a\\*?/*", new string[]
+    [DataRow("a\\*?/*", new string[]
     {
         "a*b/ooo"
     }, true)]
-    [InlineData("a[\\\\b]c", new string[]
+    [DataRow("a[\\\\b]c", new string[]
     {
         "abc"
     }, true)]
-    [InlineData("*.\\*", new string[]
+    [DataRow("*.\\*", new string[]
     {
         "r.*"
     }, true)]
-    [InlineData("a******?c", new string[]
+    [DataRow("a******?c", new string[]
     {
         "abc"
     }, true)]
-    [InlineData("?******??", new string[]
+    [DataRow("?******??", new string[]
     {
         "abc"
     }, true)]
-    [InlineData("*******??", new string[]
+    [DataRow("*******??", new string[]
     {
         "abc"
     }, true)]
-    [InlineData("***?***?c", new string[]
+    [DataRow("***?***?c", new string[]
     {
         "abc", "a/b/dec", "a/bcdc"
     }, true)]
-    [InlineData("***?***?c", new string[]
+    [DataRow("***?***?c", new string[]
     {
         "a/b/c/dc"
     }, false)]
-    [InlineData("*******c", new string[]
+    [DataRow("*******c", new string[]
     {
         "abc", "a/bc", "a/b/c"
     }, true)]
-    [InlineData("*******?", new string[]
+    [DataRow("*******?", new string[]
     {
         "abc", "a/b/c"
     }, true)]
-    [InlineData("[a[]", new string[]
+    [DataRow("[a[]", new string[]
     {
         "[", "a"
     }, true)]
-    [InlineData("[(]", new string[]
+    [DataRow("[(]", new string[]
     {
         "("
     }, true)]
-    [InlineData("[]]", new string[]
+    [DataRow("[]]", new string[]
     {
         "]"
     }, true)]
-    [InlineData("[", new string[]
+    [DataRow("[", new string[]
     {
         "["
     }, true)]
-    [InlineData("[abc[]]a", new string[]
+    [DataRow("[abc[]]a", new string[]
     {
         "a]a", "b]a", "[]a"
     }, true)]
-    [InlineData("[\\w]a", new string[]
+    [DataRow("[\\w]a", new string[]
     {
         "aa", "ba"
     }, true)]
-    [InlineData("[abc[]]a", new string[]
+    [DataRow("[abc[]]a", new string[]
     {
         "]"
     }, false)]
-    [InlineData(@"\[*", new string[]
+    [DataRow(@"\[*", new string[]
     {
         "[abc"
     }, true)]
-    [InlineData("b*/", new string[]
+    [DataRow("b*/", new string[]
     {
         "bfile"
     }, false)]
-    [InlineData("**", new string[]
+    [DataRow("**", new string[]
     {
         ".a", "a/.b", ".a/b"
     }, false)]
-    [InlineData("a/*", new string[]
+    [DataRow("a/*", new string[]
     {
         "a/"
     }, false)]
-    [InlineData("a/*", new string[]
+    [DataRow("a/*", new string[]
     {
         "a/.a"
     }, false)]
-    [InlineData("*.cs", new string[]
+    [DataRow("*.cs", new string[]
     {
         "acs"
     }, false)]
@@ -205,28 +204,28 @@ public void TestGlobMatchWithoutDotMatchShouldMatchNonDotFiles(string pattern, s
         foreach (var file in files)
         {
             var match = glob.Match(file);
-            Assert.Equal(expected, match);
+            Assert.AreEqual(expected, match);
         }
     }
 
-    [Theory]
-    [InlineData("a/*", new string[]
+    [TestMethod]
+    [DataRow("a/*", new string[]
     {
         "a/.a"
     }, true)]
-    [InlineData("*/", new string[]
+    [DataRow("*/", new string[]
     {
         ".a/"
     }, true)]
-    [InlineData("**", new string[]
+    [DataRow("**", new string[]
     {
         ".a/.a"
     }, true)]
-    [InlineData("**J/**", new string[]
+    [DataRow("**J/**", new string[]
     {
         "M", "M/JA", "a/b/c", "a/b/c.csproj"
     }, false)]
-    [InlineData("**/A/**", new string[]
+    [DataRow("**/A/**", new string[]
     {
         "A/B/C"
     }, true)]
@@ -236,42 +235,42 @@ public void TestGlobMatchWithDotMatchShouldMatchDotFiles(string pattern, string[
         foreach (var file in files)
         {
             var match = glob.Match(file);
-            Assert.Equal(expected, match);
+            Assert.AreEqual(expected, match);
         }
     }
 
-    [Theory]
-    [InlineData("**", new string[]
+    [TestMethod]
+    [DataRow("**", new string[]
     {
         ".a/.a"
     }, true)]
-    [InlineData("**.csproj", new string[]
+    [DataRow("**.csproj", new string[]
     {
         ".a/", "a/", "a/a/", "a/.a/"
     }, true)]
-    [InlineData("E/*.md", new string[]
+    [DataRow("E/*.md", new string[]
     {
         "E/"
     }, true)]
-    [InlineData("*.cs", new string[]
+    [DataRow("*.cs", new string[]
     {
         "a", "a.c"
     }, false)]
-    [InlineData("**.md", new string[]
+    [DataRow("**.md", new string[]
     {
         "Root/"
     }, true)]
-    [InlineData("**", new string[]
+    [DataRow("**", new string[]
     {
         "Root/"
     }, true)]
     // partial match must match folder ends with "/"
-    [InlineData("**.md", new string[] {
+    [DataRow("**.md", new string[] {
         "a", "a/b"
     }, false)]
 
     // partial match must match folder ends with "/"
-    [InlineData("b/", new string[] {
+    [DataRow("b/", new string[] {
         "b/c/a"
     }, false)]
     public void TestGlobPartialMatchShouldMatchFolder(string pattern, string[] folders, bool expected)
@@ -280,7 +279,7 @@ public void TestGlobPartialMatchShouldMatchFolder(string pattern, string[] folde
         foreach (var file in folders)
         {
             var match = glob.Match(file, true);
-            Assert.Equal(expected, match);
+            Assert.AreEqual(expected, match);
         }
     }
 }
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/AggregatorTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/AggregatorTest.cs
index f1493d29427..e691466aad6 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/AggregatorTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/AggregatorTest.cs
@@ -5,23 +5,23 @@
 using Markdig;
 using Markdig.Syntax;
 using Markdig.Syntax.Inlines;
-using Xunit;
 
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class AggregatorTest
 {
-    [Theory]
-    [InlineData(
+    [TestMethod]
+    [DataRow(
 "# Test",
 @"<h1>Test</h1>
 ")]
-    [InlineData(
+    [DataRow(
 @"# Test
 - - -",
 @"<h2>Test</h2>
 ")]
-    [InlineData(
+    [DataRow(
 @"# Test1
 # Test2
 - - -
@@ -33,7 +33,7 @@ public class AggregatorTest
 <h2>Test3</h2>
 <h1>Test4</h1>
 ")]
-    [InlineData(
+    [DataRow(
 @"# Test1
 ## Test2
 - - -
@@ -51,15 +51,15 @@ public void TestAggregateHead1_Hr_To_Head2(string content, string expected)
         TestAggregator(content, expected, new Head1HrAggregateToHead2());
     }
 
-    [Theory]
-    [InlineData(
+    [TestMethod]
+    [DataRow(
 @"P1
 
 P2",
 @"<p>P1
 P2</p>
 ")]
-    [InlineData(
+    [DataRow(
 @"P1
 
 P2
@@ -69,7 +69,7 @@ public void TestAggregateHead1_Hr_To_Head2(string content, string expected)
 P2
 P3</p>
 ")]
-    [InlineData(
+    [DataRow(
 @"P1
 
 P2
@@ -135,6 +135,6 @@ private static void TestAggregator(string content, string expected, IBlockAggreg
         var pipeline = pipelineBuilder.Build();
         var html = Markdown.ToHtml(content, pipeline);
 
-        Assert.Equal(expected.Replace("\r\n", "\n"), html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), html);
     }
 }
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/ChromelessFormsTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/ChromelessFormsTest.cs
index dd724f8008b..f449c99e9a3 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/ChromelessFormsTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/ChromelessFormsTest.cs
@@ -1,13 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class ChromelessFormsTest
 {
-    [Fact]
+    [TestMethod]
     public void ChromelessFormsTestWithoutModel()
     {
         var content = @"::: form action=""create-resource"" submitText=""Create"" :::";
@@ -20,7 +19,7 @@ public void ChromelessFormsTestWithoutModel()
         TestUtility.VerifyMarkup(content, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void ChromelessFormsTestWithModel()
     {
         var content = @"::: form model=""./devsandbox/ChromelessFormsTest.md"" action=""create-resource"" submitText=""Do it"" :::";
@@ -33,7 +32,7 @@ public void ChromelessFormsTestWithModel()
         TestUtility.VerifyMarkup(content, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void ChromelessFormsAttributeStartQuotationsRequired()
     {
         var content = @"::: form submitText=something"" :::";
@@ -41,7 +40,7 @@ public void ChromelessFormsAttributeStartQuotationsRequired()
         TestUtility.VerifyMarkup(content, null, ["invalid-form"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void ChromelessFormsAttributeEndQuotationsRequired()
     {
         var content = @"::: form submitText=""something :::";
@@ -49,7 +48,7 @@ public void ChromelessFormsAttributeEndQuotationsRequired()
         TestUtility.VerifyMarkup(content, null, ["invalid-form"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void ChromelessFormsAttributeValueRequired()
     {
         var content = "::: form submitText :::";
@@ -57,7 +56,7 @@ public void ChromelessFormsAttributeValueRequired()
         TestUtility.VerifyMarkup(content, null, ["invalid-form"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void ChromelessFormsAttributeValueSingleQuote()
     {
         var content = @"::: form submitText=""<script> >.< </script>"" action=""create-Resource"" :::";
@@ -69,7 +68,7 @@ public void ChromelessFormsAttributeValueSingleQuote()
         TestUtility.VerifyMarkup(content, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void ChromelessFormsTestActionRequired()
     {
         var content = @"::: form submitText=""Do it"" :::";
@@ -77,7 +76,7 @@ public void ChromelessFormsTestActionRequired()
         TestUtility.VerifyMarkup(content, null, ["invalid-form"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void ChromelessFormsTestSubmitTextRequired()
     {
         var content = @"::: form action=""create-Resource"" :::";
@@ -85,7 +84,7 @@ public void ChromelessFormsTestSubmitTextRequired()
         TestUtility.VerifyMarkup(content, null, ["invalid-form"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void ChromelessFormsTestMultipleForms()
     {
         var content = @"
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/CodeSnippetTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/CodeSnippetTest.cs
index c9918f38e13..fa25d83a143 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/CodeSnippetTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/CodeSnippetTest.cs
@@ -1,13 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class CodeSnippetTest
 {
-    [Fact]
+    [TestMethod]
     public void CodeSnippetNotFound()
     {
         var source = "[!code-csharp[name](Program1.cs)]";
@@ -28,7 +27,7 @@ public void CodeSnippetNotFound()
             });
     }
 
-    [Fact]
+    [TestMethod]
     public void CodeSnippetGeneral()
     {
         //arrange
@@ -50,7 +49,7 @@ public void CodeSnippetGeneral()
         });
     }
 
-    [Fact]
+    [TestMethod]
     public void NotebookCodeSnippetGeneral()
     {
         var content = @"{
@@ -80,7 +79,7 @@ public void NotebookCodeSnippetGeneral()
         });
     }
 
-    [Fact]
+    [TestMethod]
     public void NotebookCodeSnippetTagNotFound()
     {
         var content = @"{
@@ -113,7 +112,7 @@ public void NotebookCodeSnippetTagNotFound()
             });
     }
 
-    [Fact]
+    [TestMethod]
     public void NotebookCodeSnippetMultipleTagFound()
     {
         //arrange
@@ -159,7 +158,7 @@ public void NotebookCodeSnippetMultipleTagFound()
             });
     }
 
-    [Fact]
+    [TestMethod]
     public void CodeSnippetShouldNotWorkInParagraph()
     {
         var source = "text [!code[test](CodeSnippet.cs)]";
@@ -169,7 +168,7 @@ public void CodeSnippetShouldNotWorkInParagraph()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void CodeSnippetTagsShouldMatchCaseInsensitive()
     {
         var content = "\t// <tag1>\t\nline1\n// <tag2>\nline2\n// </tag2>\nline3\n// </TAG1>\n// <unmatched>\n";
@@ -184,7 +183,7 @@ public void CodeSnippetTagsShouldMatchCaseInsensitive()
         });
     }
 
-    [Fact]
+    [TestMethod]
     public void CodeSnippetTagsShouldSucceedWhenDuplicateWithoutWarning()
     {
         var content = @"// <tag1>
@@ -209,7 +208,7 @@ public void CodeSnippetTagsShouldSucceedWhenDuplicateWithoutWarning()
         });
     }
 
-    [Fact]
+    [TestMethod]
     public void CodeSnippetTagsShouldSucceedWhenDuplicateWithWarningWhenReferenced()
     {
         var content = @"// <tag1>
@@ -234,7 +233,7 @@ public void CodeSnippetTagsShouldSucceedWhenDuplicateWithWarningWhenReferenced()
         });
     }
 
-    [Fact]
+    [TestMethod]
     public void CodeSnippetTagsShouldSucceedWhenReferencedFileContainsRegionWithoutName()
     {
         var content = @"#region
@@ -263,8 +262,8 @@ static void Main()
         });
     }
 
-    [Fact]
-    [Trait("Related", "Markdown")]
+    [TestMethod]
+    [TestProperty("Related", "Markdown")]
     public void TestFencesBlockLevel()
     {
         var root = @"
@@ -291,10 +290,10 @@ public void TestFencesBlockLevel()
         });
     }
 
-    [Theory]
-    [Trait("Related", "Markdown")]
+    [TestMethod]
+    [TestProperty("Related", "Markdown")]
     #region Inline Data
-    [InlineData("[!code-csharp[Main](Program.cs)]", @"<pre><code class=""lang-csharp"" name=""Main"">namespace ConsoleApplication1
+    [DataRow("[!code-csharp[Main](Program.cs)]", @"<pre><code class=""lang-csharp"" name=""Main"">namespace ConsoleApplication1
 {
     // &lt;namespace&gt;
     using System;
@@ -325,13 +324,13 @@ public static void Foo()
     #endregion
 }
 </code></pre>")]
-    [InlineData(@"[!code[Main](Program.cs#L12-L16 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">static void Main(string[] args)
+    [DataRow(@"[!code[Main](Program.cs#L12-L16 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">static void Main(string[] args)
 {
     string s = &quot;\ntest&quot;;
     int i = 100;
 }
 </code></pre>")]
-    [InlineData(@"[!code[Main](Program.cs#L12-L100 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">        static void Main(string[] args)
+    [DataRow(@"[!code[Main](Program.cs#L12-L100 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">        static void Main(string[] args)
         {
             string s = &quot;\ntest&quot;;
             int i = 100;
@@ -351,17 +350,17 @@ public static void Foo()
     #endregion
 }
 </code></pre>")]
-    [InlineData(@"[!code-csharp[Main](Program.cs#namespace ""This is root"")]", @"<pre><code class=""lang-csharp"" name=""Main"" title=""This is root"">using System;
+    [DataRow(@"[!code-csharp[Main](Program.cs#namespace ""This is root"")]", @"<pre><code class=""lang-csharp"" name=""Main"" title=""This is root"">using System;
 
 using System.Collections.Generic;
 using System.IO;
 </code></pre>")]
-    [InlineData(@"[!code-csharp[Main](Program.cs#NAMESPACE ""This is root"")]", @"<pre><code class=""lang-csharp"" name=""Main"" title=""This is root"">using System;
+    [DataRow(@"[!code-csharp[Main](Program.cs#NAMESPACE ""This is root"")]", @"<pre><code class=""lang-csharp"" name=""Main"" title=""This is root"">using System;
 
 using System.Collections.Generic;
 using System.IO;
 </code></pre>")]
-    [InlineData(@"[!code-csharp[Main](Program.cs#program ""This is root"")]", @"<pre><code class=""lang-csharp"" name=""Main"" title=""This is root"">class Program
+    [DataRow(@"[!code-csharp[Main](Program.cs#program ""This is root"")]", @"<pre><code class=""lang-csharp"" name=""Main"" title=""This is root"">class Program
 {
     static void Main(string[] args)
     {
@@ -370,7 +369,7 @@ static void Main(string[] args)
     }
 }
 </code></pre>")]
-    [InlineData(@"[!code-csharp[Main](Program.cs#snippetprogram ""This is root"")]", @"<pre><code class=""lang-csharp"" name=""Main"" title=""This is root"">class Program
+    [DataRow(@"[!code-csharp[Main](Program.cs#snippetprogram ""This is root"")]", @"<pre><code class=""lang-csharp"" name=""Main"" title=""This is root"">class Program
 {
     static void Main(string[] args)
     {
@@ -379,29 +378,29 @@ static void Main(string[] args)
     }
 }
 </code></pre>")]
-    [InlineData(@"[!code[Main](Program.cs?name=Foo ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">public static void Foo()
+    [DataRow(@"[!code[Main](Program.cs?name=Foo ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">public static void Foo()
 {
 }
 </code></pre>")]
-    [InlineData(@"[!code-csharp[Main](Program.cs?name=namespace ""This is root"")]", @"<pre><code class=""lang-csharp"" name=""Main"" title=""This is root"">using System;
+    [DataRow(@"[!code-csharp[Main](Program.cs?name=namespace ""This is root"")]", @"<pre><code class=""lang-csharp"" name=""Main"" title=""This is root"">using System;
 
 using System.Collections.Generic;
 using System.IO;
 </code></pre>")]
-    [InlineData(@"[!code[Main](Program.cs?start=5&end=9 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">using System.Collections.Generic;
+    [DataRow(@"[!code[Main](Program.cs?start=5&end=9 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">using System.Collections.Generic;
 using System.IO;
 // &lt;/namespace&gt;
 
 // &lt;snippetprogram&gt;
 </code></pre>")]
-    [InlineData(@"[!code[Main](Program.cs?name=Helper ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">internal static class Helper
+    [DataRow(@"[!code[Main](Program.cs?name=Helper ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">internal static class Helper
 {
     public static void Foo()
     {
     }
 }
 </code></pre>")]
-    [InlineData(@"[!code[Main](Program.cs?range=1-2,10,20-21,29- ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">namespace ConsoleApplication1
+    [DataRow(@"[!code[Main](Program.cs?range=1-2,10,20-21,29- ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">namespace ConsoleApplication1
 {
     class Program
     #region Helper
@@ -409,7 +408,7 @@ internal static class Helper
     #endregion
 }
 </code></pre>")]
-    [InlineData(@"[!code[Main](Program.cs?range=1,21,24-26,1,10,12-16 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">namespace ConsoleApplication1
+    [DataRow(@"[!code[Main](Program.cs?range=1,21,24-26,1,10,12-16 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">namespace ConsoleApplication1
     internal static class Helper
         public static void Foo()
         {
@@ -422,7 +421,7 @@ static void Main(string[] args)
             int i = 100;
         }
 </code></pre>")]
-    [InlineData("[!code-csharp[Main](Program.cs?highlight=1)]", @"<pre><code class=""lang-csharp"" name=""Main"" highlight-lines=""1"">namespace ConsoleApplication1
+    [DataRow("[!code-csharp[Main](Program.cs?highlight=1)]", @"<pre><code class=""lang-csharp"" name=""Main"" highlight-lines=""1"">namespace ConsoleApplication1
 {
     // &lt;namespace&gt;
     using System;
@@ -453,20 +452,20 @@ public static void Foo()
     #endregion
 }
 </code></pre>")]
-    [InlineData(@"[!code[Main](Program.cs?start=5&end=9&highlight=1 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"" highlight-lines=""1"">using System.Collections.Generic;
+    [DataRow(@"[!code[Main](Program.cs?start=5&end=9&highlight=1 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"" highlight-lines=""1"">using System.Collections.Generic;
 using System.IO;
 // &lt;/namespace&gt;
 
 // &lt;snippetprogram&gt;
 </code></pre>")]
-    [InlineData(@"[!code[Main](Program.cs?name=Helper&highlight=1 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"" highlight-lines=""1"">internal static class Helper
+    [DataRow(@"[!code[Main](Program.cs?name=Helper&highlight=1 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"" highlight-lines=""1"">internal static class Helper
 {
     public static void Foo()
     {
     }
 }
 </code></pre>")]
-    [InlineData(@"[!code[Main](Program.cs?range=1-2,10,20-21,29-&highlight=1-2,7- ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"" highlight-lines=""1-2,7-"">namespace ConsoleApplication1
+    [DataRow(@"[!code[Main](Program.cs?range=1-2,10,20-21,29-&highlight=1-2,7- ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"" highlight-lines=""1-2,7-"">namespace ConsoleApplication1
 {
     class Program
     #region Helper
@@ -474,7 +473,7 @@ internal static class Helper
     #endregion
 }
 </code></pre>")]
-    [InlineData(@"[!code[Main](Program.cs?range=1,21,24-26,1,10,12-16&highlight=8-12 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"" highlight-lines=""8-12"">namespace ConsoleApplication1
+    [DataRow(@"[!code[Main](Program.cs?range=1,21,24-26,1,10,12-16&highlight=8-12 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"" highlight-lines=""8-12"">namespace ConsoleApplication1
     internal static class Helper
         public static void Foo()
         {
@@ -487,7 +486,7 @@ static void Main(string[] args)
             int i = 100;
         }
 </code></pre>")]
-    [InlineData("[!code-csharp[Main](Program.cs?dedent=0)]", @"<pre><code class=""lang-csharp"" name=""Main"">namespace ConsoleApplication1
+    [DataRow("[!code-csharp[Main](Program.cs?dedent=0)]", @"<pre><code class=""lang-csharp"" name=""Main"">namespace ConsoleApplication1
 {
     // &lt;namespace&gt;
     using System;
@@ -518,20 +517,20 @@ public static void Foo()
     #endregion
 }
 </code></pre>")]
-    [InlineData(@"[!code[Main](Program.cs?start=5&end=9&dedent=0 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">    using System.Collections.Generic;
+    [DataRow(@"[!code[Main](Program.cs?start=5&end=9&dedent=0 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">    using System.Collections.Generic;
     using System.IO;
     // &lt;/namespace&gt;
 
     // &lt;snippetprogram&gt;
 </code></pre>")]
-    [InlineData(@"[!code[Main](Program.cs?name=Helper&dedent=8 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">internal static class Helper
+    [DataRow(@"[!code[Main](Program.cs?name=Helper&dedent=8 ""This is root"")]", @"<pre><code name=""Main"" title=""This is root"">internal static class Helper
 {
 public static void Foo()
 {
 }
 }
 </code></pre>")]
-    [InlineData(@"[!code[Main](Program.cs?range=1-2,10,20-21,29-&dedent=-4 ""Auto dedent if dedent < 0"")]", @"<pre><code name=""Main"" title=""Auto dedent if dedent &lt; 0"">namespace ConsoleApplication1
+    [DataRow(@"[!code[Main](Program.cs?range=1-2,10,20-21,29-&dedent=-4 ""Auto dedent if dedent < 0"")]", @"<pre><code name=""Main"" title=""Auto dedent if dedent &lt; 0"">namespace ConsoleApplication1
 {
     class Program
     #region Helper
@@ -580,8 +579,8 @@ public static void Foo()
         });
     }
 
-    [Fact]
-    [Trait("Related", "Markdown")]
+    [TestMethod]
+    [TestProperty("Related", "Markdown")]
     public void TestFencesBlockLevelWithWhitespaceLeading()
     {
         var root = @"
@@ -609,7 +608,7 @@ public void TestFencesBlockLevelWithWhitespaceLeading()
         });
     }
 
-    [Fact]
+    [TestMethod]
     public void Issue8777()
     {
         TestUtility.VerifyMarkup(
@@ -654,8 +653,8 @@ public Greet(string who)
             });
     }
 
-    [Fact]
-    [Trait("Related", "Markdown")]
+    [TestMethod]
+    [TestProperty("Related", "Markdown")]
     public void TestFencesBlockLevelWithWorkingFolder()
     {
         var root = "[!code-REST[REST](~/api.json)]";
@@ -686,8 +685,8 @@ public void TestFencesBlockLevelWithWorkingFolder()
         });
     }
 
-    [Fact]
-    [Trait("Related", "Markdown")]
+    [TestMethod]
+    [TestProperty("Related", "Markdown")]
     public void CodeSnippetShouldVerifyTagname()
     {
         //arrange
@@ -711,8 +710,9 @@ public void CodeSnippetShouldVerifyTagname()
         });
     }
 
-    [Fact(Skip = "won't support")]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [Ignore("won't support")]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfmFencesInlineLevel()
     {
         var root = @"
@@ -793,8 +793,9 @@ public void TestDfmFencesInlineLevel()
         });
     }
 
-    [Fact(Skip = "won't support")]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [Ignore("won't support")]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfmFencesInlineLevel_Legacy()
     {
         var root = @"
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/CodeTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/CodeTest.cs
index b306433a019..69d106f5318 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/CodeTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/CodeTest.cs
@@ -1,10 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class CodeTest
 {
     private static readonly string contentCSharp = @"using System;
@@ -1130,12 +1129,12 @@ def hello():
 /*</Snippet1>*/
 ";
 
-    [Theory]
-    [InlineData(@":::code source=""source.cs"" range=""9"" language=""csharp"":::", @"<pre>
+    [TestMethod]
+    [DataRow(@":::code source=""source.cs"" range=""9"" language=""csharp"":::", @"<pre>
 <code class=""lang-csharp"">namespace TableSnippets
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source.cs"" range=""11 - 33, 40-44"" highlight=""6-7"" language=""azurecli"" interactive=""try-dotnet"":::", @"<pre>
+    [DataRow(@":::code source=""source.cs"" range=""11 - 33, 40-44"" highlight=""6-7"" language=""azurecli"" interactive=""try-dotnet"":::", @"<pre>
 <code class=""lang-azurecli"" data-interactive=""azurecli"" data-interactive-mode=""try-dotnet"" highlight-lines=""6-7"">/// &lt;summary&gt;
 /// Interaction logic for Window1.xaml
 /// &lt;/summary&gt;
@@ -1166,17 +1165,17 @@ void TableColumnsProperty()
         // &lt;Snippet_Table_Columns_Insert&gt;
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source.cs"" range=""1-2"" language=""azurecli"" interactive=""try-dotnet"":::", @"<pre>
+    [DataRow(@":::code source=""source.cs"" range=""1-2"" language=""azurecli"" interactive=""try-dotnet"":::", @"<pre>
 <code class=""lang-azurecli"" data-interactive=""azurecli"" data-interactive-mode=""try-dotnet"">using System;
 using System.Windows;
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source.cs"" range=""1-2"" interactive=""try-dotnet"":::", @"<pre>
+    [DataRow(@":::code source=""source.cs"" range=""1-2"" interactive=""try-dotnet"":::", @"<pre>
 <code class=""lang-csharp"" data-interactive=""csharp"" data-interactive-mode=""try-dotnet"">using System;
 using System.Windows;
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source.cs"" range=""1-2,205-"" highlight=""6-7"" language=""azurecli"" interactive=""try-dotnet"":::", @"<pre>
+    [DataRow(@":::code source=""source.cs"" range=""1-2,205-"" highlight=""6-7"" language=""azurecli"" interactive=""try-dotnet"":::", @"<pre>
 <code class=""lang-azurecli"" data-interactive=""azurecli"" data-interactive-mode=""try-dotnet"" highlight-lines=""6-7"">using System;
 using System.Windows;
             TableCell cellx = new TableCell(para);
@@ -1186,14 +1185,14 @@ void TableColumnsProperty()
 }
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source.cs"" id=""Snippet_Table_RowGroups_Add"" language=""azurecli"" interactive=""try-dotnet"":::", @"<pre>
+    [DataRow(@":::code source=""source.cs"" id=""Snippet_Table_RowGroups_Add"" language=""azurecli"" interactive=""try-dotnet"":::", @"<pre>
 <code class=""lang-azurecli"" data-interactive=""azurecli"" data-interactive-mode=""try-dotnet"">Table tbl = new Table();
 int rowGroupsToAdd = 4;
 for (int x = 0; x &lt; rowGroupsToAdd; x++)
     tbl.RowGroups.Add(new TableRowGroup());
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source.vb"" id=""snippet2"" interactive=""try-dotnet"":::", @"<pre>
+    [DataRow(@":::code source=""source.vb"" id=""snippet2"" interactive=""try-dotnet"":::", @"<pre>
 <code class=""lang-vb"" data-interactive=""vb"" data-interactive-mode=""try-dotnet"">Imports System.Reflection
 
 Class AppDomain1
@@ -1207,7 +1206,7 @@ End Sub
 End Class
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source.vb"" id=""snippet1"" interactive=""try-dotnet"":::", @"<pre>
+    [DataRow(@":::code source=""source.vb"" id=""snippet1"" interactive=""try-dotnet"":::", @"<pre>
 <code class=""lang-vb"" data-interactive=""vb"" data-interactive-mode=""try-dotnet"">Class ADSetupInformation
 
     Shared Sub Main()
@@ -1237,7 +1236,7 @@ End Class
 &#39;        C:\Program Files\MyApp\MyAppSubfolder\
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source.cpp"" id=""snippet2"":::", @"<pre>
+    [DataRow(@":::code source=""source.cpp"" id=""snippet2"":::", @"<pre>
 <code class=""lang-cpp"">using namespace System;
 
 using namespace System::Reflection;
@@ -1270,7 +1269,7 @@ int main()
 }
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source.cpp"" id=""snippet2"":::
+    [DataRow(@":::code source=""source.cpp"" id=""snippet2"":::
 
 hi
 :::code source=""source.cpp"" id=""snippet1"":::
@@ -1336,7 +1335,7 @@ int main()
  */
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source2.cs"" id=""snippet_UseMvc"":::
+    [DataRow(@":::code source=""source2.cs"" id=""snippet_UseMvc"":::
 ", @"<pre>
 <code class=""lang-csharp"">app.UseMvc(routes =&gt;
 {
@@ -1350,13 +1349,13 @@ int main()
         template: &quot;{controller=Home}/{action=Index}/{id?}&quot;);
 });
 </code></pre>")]
-    [InlineData(@":::code source=""source2.cs"" id=""snippet_AllowAreas"":::
+    [DataRow(@":::code source=""source2.cs"" id=""snippet_AllowAreas"":::
 ", @"<pre>
 <code class=""lang-csharp"">services.AddMvc()
         .AddRazorPagesOptions(options =&gt; options.AllowAreas = true);
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source.vb"" id=""snippet3"":::
+    [DataRow(@":::code source=""source.vb"" id=""snippet3"":::
 ", @"<pre>
 <code class=""lang-vb"">Imports System.Reflection
 
@@ -1370,7 +1369,7 @@ End Sub
 End Class
 </code></pre>
 ")]
-    [InlineData(@":::code source=""asp.cshtml"" id=""snippet_BigSnippet"":::
+    [DataRow(@":::code source=""asp.cshtml"" id=""snippet_BigSnippet"":::
 ", @"<pre>
 <code class=""lang-cshtml"">&lt;tbody&gt;
     &lt;tr&gt;
@@ -1531,14 +1530,14 @@ End Class
 &lt;/tbody&gt;
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source.sql"" id=""teachers"":::
+    [DataRow(@":::code source=""source.sql"" id=""teachers"":::
 ", @"<pre>
 <code class=""lang-sql"">SELECT * FROM Teachers
 WHERE Grade = 12
 AND Class = &#39;Math&#39;
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source.sql"" id=""everything"":::
+    [DataRow(@":::code source=""source.sql"" id=""everything"":::
 ", @"<pre>
 <code class=""lang-sql"">SELECT * FROM Students
 WHERE Grade = 12
@@ -1549,7 +1548,7 @@ End Class
 AND Class = &#39;Math&#39;
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source.py"" id=""everything"":::
+    [DataRow(@":::code source=""source.py"" id=""everything"":::
 ", @"<pre>
 <code class=""lang-python"">from flask import Flask
 app = Flask(__name__)
@@ -1559,19 +1558,19 @@ def hello():
     return &quot;Hello World!&quot;
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source.bat"" id=""snippet"":::
+    [DataRow(@":::code source=""source.bat"" id=""snippet"":::
 ", @"<pre>
 <code class=""lang-batchfile"">:Label1
     :Label2
 :: Comment line 3
 </code></pre>")]
-    [InlineData(@":::code source=""source.erl"" id=""snippet"":::
+    [DataRow(@":::code source=""source.erl"" id=""snippet"":::
 ", @"<pre>
 <code class=""lang-erlang"">hello() -&gt;
     io:format(&quot;hello world~n&quot;).
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source.lsp"" id=""everything"":::
+    [DataRow(@":::code source=""source.lsp"" id=""everything"":::
 ", @"<pre>
 <code class=""lang-lisp"">USER(64): (member &#39;b &#39;(perhaps today is a good day to die)) ; test fails
 NIL
@@ -1579,7 +1578,7 @@ def hello():
 &#39;(a good day to die)
 </code></pre>
 ")]
-    [InlineData(@"An example of a delegate would be:
+    [DataRow(@"An example of a delegate would be:
 
 :::code language=""csharp"" source=""source3.cs"" id=""Delegate"":::", @"<p>An example of a delegate would be:</p>
 <pre>
@@ -1600,7 +1599,7 @@ def hello():
 }
 </code></pre>
 ")]
-    [InlineData(@":::code source=""source2.cpp"" id=""Snippet1"":::", @"<pre>
+    [DataRow(@":::code source=""source2.cpp"" id=""Snippet1"":::", @"<pre>
 <code class=""lang-cpp"">using namespace System;
 
 using namespace System::Collections::Generic;
@@ -1759,7 +1758,7 @@ int main()
  */
 </code></pre>
 ")]
-    [InlineData(@":::code source=""GemFile"" id=""GemFileSnippet"" language=""ruby"":::", @"<pre>
+    [DataRow(@":::code source=""GemFile"" id=""GemFileSnippet"" language=""ruby"":::", @"<pre>
 <code class=""lang-ruby""># OAuth
 gem &#39;omniauth-oauth2&#39;, &#39;~&gt; 1.6&#39;
 # OmniAuth CSRF protection
@@ -1770,7 +1769,7 @@ int main()
 gem &#39;activerecord-session_store&#39;, &#39;~&gt; 1.1&#39;
 </code></pre>
 ")]
-    [InlineData(@":::code source=""styles.css"" id=""Snippet1"" language=""css"":::", @"<pre>
+    [DataRow(@":::code source=""styles.css"" id=""Snippet1"" language=""css"":::", @"<pre>
 <code class=""lang-css"">div {
   padding-top: 70px;
 }
@@ -1862,11 +1861,11 @@ public void CodeTestBlockGeneral(string source, string expected)
 
     }
 
-    [Theory]
-    [InlineData(@":::code source=""source.cs"" badattribute=""ham"" range=""1-5"" language=""azurecli"" interactive=""try-dotnet"":::")]
-    [InlineData(@":::code range=""1-5"" language=""azurecli"" interactive=""try-dotnet"":::")]
-    [InlineData(@":::code source=""source.crazy"" range=""1-3"" interactive=""try-dotnet"":::")]
-    [InlineData(@":::code source=""source.missing"" range=""1-3"" interactive=""try-dotnet"" language=""azurecli"":::")]
+    [TestMethod]
+    [DataRow(@":::code source=""source.cs"" badattribute=""ham"" range=""1-5"" language=""azurecli"" interactive=""try-dotnet"":::")]
+    [DataRow(@":::code range=""1-5"" language=""azurecli"" interactive=""try-dotnet"":::")]
+    [DataRow(@":::code source=""source.crazy"" range=""1-3"" interactive=""try-dotnet"":::")]
+    [DataRow(@":::code source=""source.missing"" range=""1-3"" interactive=""try-dotnet"" language=""azurecli"":::")]
     public void CodeTestBlockGeneralCSharp_Error(string source)
     {
         // arrange
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/GeneralTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/GeneralTest.cs
index 6e36e91c233..b79fd62a8eb 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/GeneralTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/GeneralTest.cs
@@ -1,14 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class GeneralTest
 {
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void MarkdigWithDefaultFAL()
     {
         var source = "[!INCLUDE [title](~/token1573.md)]";
@@ -20,8 +19,8 @@ public void MarkdigWithDefaultFAL()
         });
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfm_TaskList_ExtensionDisabledByDefault()
     {
         // Confirm that the [ ] and { } in the middle of list should not be parsed by default.
@@ -33,8 +32,8 @@ public void TestDfm_TaskList_ExtensionDisabledByDefault()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfm_TaskList_ExtensionEnabled()
     {
         // Confirm that the [ ] and { } in the middle of list should be parsed if the Task List extension is enabled.
@@ -49,8 +48,8 @@ public void TestDfm_TaskList_ExtensionEnabled()
         ]);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfm_MultipleOptionalExtensionsEnabled()
     {
         // Confirm that multiple optional extensions can be enabled at once
@@ -75,8 +74,8 @@ Term 1
         ]);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfm_HeadingId()
     {
         var source = " ### 1. Deploying the network";
@@ -85,7 +84,7 @@ public void TestDfm_HeadingId()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestDfm_LinkDefinition()
     {
         var source = @"![scenario image][scenario]
@@ -98,8 +97,8 @@ public void TestDfm_LinkDefinition()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfm_EncodeInStrongEM()
     {
         var source = @"tag started with non-alphabet should be encoded <1-100>, <_hello>, <?world>, <1_2 href=""good"">, <1 att='bcd'>.
@@ -111,8 +110,8 @@ public void TestDfm_EncodeInStrongEM()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfmImageLink_WithSpecialCharactersInAltText()
     {
         var source = @"![This is image alt text with quotation ' and double quotation ""hello"" world](girl.png)";
@@ -122,37 +121,37 @@ public void TestDfmImageLink_WithSpecialCharactersInAltText()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Theory]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     #region Inline Data
-    [InlineData("", "")]
-    [InlineData("<address@example.com>", "<p><a href=\"mailto:address@example.com\">address@example.com</a></p>\n")]
-    [InlineData(" https://github.com/dotnet/docfx/releases ", "<p><a href=\"https://github.com/dotnet/docfx/releases\">https://github.com/dotnet/docfx/releases</a></p>\n")]
-    [InlineData("<http://example.com/>", "<p><a href=\"http://example.com/\">http://example.com/</a></p>\n")]
-    [InlineData("# Hello World", "<h1 id=\"hello-world\">Hello World</h1>\n")]
-    [InlineData("Hot keys: <kbd>Ctrl+[</kbd> and <kbd>Ctrl+]</kbd>", "<p>Hot keys: <kbd>Ctrl+[</kbd> and <kbd>Ctrl+]</kbd></p>\n")]
-    [InlineData("<div>Some text here</div>", "<div>Some text here</div>\n")]
-    [InlineData(@"# Hello @CrossLink1 @'CrossLink2'dummy 
+    [DataRow("", "")]
+    [DataRow("<address@example.com>", "<p><a href=\"mailto:address@example.com\">address@example.com</a></p>\n")]
+    [DataRow(" https://github.com/dotnet/docfx/releases ", "<p><a href=\"https://github.com/dotnet/docfx/releases\">https://github.com/dotnet/docfx/releases</a></p>\n")]
+    [DataRow("<http://example.com/>", "<p><a href=\"http://example.com/\">http://example.com/</a></p>\n")]
+    [DataRow("# Hello World", "<h1 id=\"hello-world\">Hello World</h1>\n")]
+    [DataRow("Hot keys: <kbd>Ctrl+[</kbd> and <kbd>Ctrl+]</kbd>", "<p>Hot keys: <kbd>Ctrl+[</kbd> and <kbd>Ctrl+]</kbd></p>\n")]
+    [DataRow("<div>Some text here</div>", "<div>Some text here</div>\n")]
+    [DataRow(@"# Hello @CrossLink1 @'CrossLink2'dummy 
 @World",
 "<h1 id=\"hello--dummy\">Hello <xref href=\"CrossLink1\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@CrossLink1\"></xref> <xref href=\"CrossLink2\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@'CrossLink2'\"></xref>dummy</h1>\n<p><xref href=\"World\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@World\"></xref></p>\n")]
-    [InlineData("a\n```\nc\n```",
+    [DataRow("a\n```\nc\n```",
 "<p>a</p>\n<pre><code>c\n</code></pre>\n")]
-    [InlineData(" *hello* abc @api__1",
+    [DataRow(" *hello* abc @api__1",
 "<p><em>hello</em> abc <xref href=\"api__1\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@api__1\"></xref></p>\n")]
-    [InlineData("@1abc", "<p>@1abc</p>\n")]
-    [InlineData(@"@api1 @api__1 @api!1 @api@a <abc@api.com> <a.b.c@api.com> @'a p ';@""a!pi"",@api...@api",
+    [DataRow("@1abc", "<p>@1abc</p>\n")]
+    [DataRow(@"@api1 @api__1 @api!1 @api@a <abc@api.com> <a.b.c@api.com> @'a p ';@""a!pi"",@api...@api",
 "<p><xref href=\"api1\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@api1\"></xref> <xref href=\"api__1\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@api__1\"></xref> <xref href=\"api!1\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@api!1\"></xref> <xref href=\"api@a\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@api@a\"></xref> <a href=\"mailto:abc@api.com\">abc@api.com</a> <a href=\"mailto:a.b.c@api.com\">a.b.c@api.com</a> <xref href=\"a p \" data-throw-if-not-resolved=\"False\" data-raw-source=\"@'a p '\"></xref>;<xref href=\"a!pi\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@&quot;a!pi&quot;\"></xref>,<xref href=\"api\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@api\"></xref>...<xref href=\"api\" data-throw-if-not-resolved=\"False\" data-raw-source=\"@api\"></xref></p>\n")]
-    [InlineData("[name](xref:uid \"title\")", "<p><a href=\"xref:uid\" title=\"title\">name</a></p>\n")]
-    [InlineData("<xref:uid>text", "<p><xref href=\"uid\" data-throw-if-not-resolved=\"True\" data-raw-source=\"&lt;xref:uid&gt;\"></xref>text</p>\n")]
-    [InlineData("<xref:'uid with space'>text", "<p><xref href=\"uid with space\" data-throw-if-not-resolved=\"True\" data-raw-source=\"&lt;xref:'uid with space'&gt;\"></xref>text</p>\n")]
-    [InlineData(
+    [DataRow("[name](xref:uid \"title\")", "<p><a href=\"xref:uid\" title=\"title\">name</a></p>\n")]
+    [DataRow("<xref:uid>text", "<p><xref href=\"uid\" data-throw-if-not-resolved=\"True\" data-raw-source=\"&lt;xref:uid&gt;\"></xref>text</p>\n")]
+    [DataRow("<xref:'uid with space'>text", "<p><xref href=\"uid with space\" data-throw-if-not-resolved=\"True\" data-raw-source=\"&lt;xref:'uid with space'&gt;\"></xref>text</p>\n")]
+    [DataRow(
 "[*a*](xref:uid)",
 "<p><a href=\"xref:uid\"><em>a</em></a></p>\n")]
-    [InlineData(
+    [DataRow(
 @"# <a id=""x""></a>Y",
 @"<h1 id=""x"">Y</h1>
 ")]
-    [InlineData(
+    [DataRow(
 @"# <a name=""x""></a>Y",
 @"<h1 id=""x"">Y</h1>
 ")]
@@ -162,8 +161,8 @@ public void TestDfmInGeneral(string source, string expected)
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfmLink_LinkWithSpecialCharactersInTitle()
     {
         var source = @"[text's string](https://www.google.com.sg/?gfe_rd=cr&ei=Xk ""Google's homepage"")";
@@ -172,8 +171,8 @@ public void TestDfmLink_LinkWithSpecialCharactersInTitle()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfmLink_WithSpecialCharactersInTitle()
     {
         var source = @"[This is link text with quotation ' and double quotation ""hello"" world](girl.png ""title is \""hello\"" world."")";
@@ -183,8 +182,8 @@ public void TestDfmLink_WithSpecialCharactersInTitle()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfmTagValidate()
     {
 
@@ -198,8 +197,8 @@ public void TestDfmTagValidate()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestPathUtility_AbsoluteLinkWithBracketAndBracket()
     {
         var source = @"[User-Defined Date/Time Formats (Format Function)](http://msdn2.microsoft.com/library/73ctwf33\(VS.90\).aspx)";
@@ -208,8 +207,8 @@ public void TestPathUtility_AbsoluteLinkWithBracketAndBracket()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestYaml_InvalidYamlInsideContent()
     {
         var source = @"# Title
@@ -225,8 +224,8 @@ Not yaml syntax
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestTabGroup()
     {
         string actual = @"# [title-a](#tab/a)
@@ -254,8 +253,8 @@ public void TestTabGroup()
         TestUtility.VerifyMarkup(actual, expected, lineNumber: true);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestTabGroup_2()
     {
         string actual = @"# [title-a](#tab/a)
@@ -306,8 +305,8 @@ public void TestTabGroup_2()
         TestUtility.VerifyMarkup(actual, expected, ["invalid-tab-group"], lineNumber: true);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestAllExtensions()
     {
         string source = @"---
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/ImageTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/ImageTest.cs
index 5130c66e302..cf3b50b5f0c 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/ImageTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/ImageTest.cs
@@ -1,13 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class ImageTest
 {
-    [Fact]
+    [TestMethod]
     public void ImageTestBlockGeneral()
     {
         var source = @":::image type=""content"" source=""example.jpg"" alt-text=""example"":::
@@ -84,7 +83,7 @@ public void ImageTestBlockGeneral()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void ComplexImageTestBlockGeneral()
     {
         var source = @"
@@ -138,7 +137,7 @@ public void ComplexImageTestBlockGeneral()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void ContentImageTestBlock_LinkAttribute()
     {
         var source = @"
@@ -164,7 +163,7 @@ public void ContentImageTestBlock_LinkAttribute()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void ImageTestBlock_InvalidImage_MissingSource()
     {
         var source = @"
@@ -177,7 +176,7 @@ public void ImageTestBlock_InvalidImage_MissingSource()
         TestUtility.VerifyMarkup(source, expected, errors: ["invalid-image", "invalid-image"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void ContentImageTestBlock_InvalidImage_MissingAlt()
     {
         var source = @"
@@ -190,7 +189,7 @@ public void ContentImageTestBlock_InvalidImage_MissingAlt()
         TestUtility.VerifyMarkup(source, expected, errors: ["invalid-image", "invalid-image"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void ImageWithIconTypeTestBlockGeneral()
     {
         var source = @":::image type=""icon"" source=""example.svg"":::
@@ -214,7 +213,7 @@ And this with inline text.</p>
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void ImageBlockTestBlockClosed()
     {
         var source = @":::image source=""example.jpg"" type=""complex"" alt-text=""example"":::
@@ -224,7 +223,7 @@ Lorem Ipsum
         TestUtility.VerifyMarkup(source, null);
     }
 
-    [Fact]
+    [TestMethod]
     public void ImageTestNotImageBlock()
     {
         var source = @":::row:::
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/InteractiveCodeTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/InteractiveCodeTest.cs
index 342bfe60d06..e88a4460ce6 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/InteractiveCodeTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/InteractiveCodeTest.cs
@@ -1,14 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class InteractiveCodeTest
 {
-    [Fact]
-    [Trait("Related", "InteractiveCode")]
+    [TestMethod]
+    [TestProperty("Related", "InteractiveCode")]
     public void TestInteractiveCode_CodeSnippetSimple()
     {
         TestUtility.VerifyMarkup(
@@ -21,8 +20,8 @@ public void TestInteractiveCode_CodeSnippetSimple()
             });
     }
 
-    [Fact]
-    [Trait("Related", "InteractiveCode")]
+    [TestMethod]
+    [TestProperty("Related", "InteractiveCode")]
     public void TestInteractiveCode_FencedCodeSimple()
     {
         TestUtility.VerifyMarkup(
@@ -34,8 +33,8 @@ public void TestInteractiveCode_FencedCodeSimple()
 ");
     }
 
-    [Fact]
-    [Trait("Related", "InteractiveCode")]
+    [TestMethod]
+    [TestProperty("Related", "InteractiveCode")]
     public void TestInteractiveCode_FencedCodeNonInteractiveSimple()
     {
         TestUtility.VerifyMarkup(
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/LineNumberTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/LineNumberTest.cs
index a13269f9664..b34706a0d99 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/LineNumberTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/LineNumberTest.cs
@@ -1,14 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class LineNumberTest
 {
-    [Fact]
-    [Trait("Related", "LineNumber")]
+    [TestMethod]
+    [TestProperty("Related", "LineNumber")]
     public void LineNumberTest_General()
     {
         // prepare
@@ -32,8 +31,8 @@ [Two Line Link](
         TestUtility.VerifyMarkup(content, expected, lineNumber: true, filePath: "Topic.md");
     }
 
-    [Fact]
-    [Trait("Related", "LineNumber")]
+    [TestMethod]
+    [TestProperty("Related", "LineNumber")]
     public void LineNumberTest_CodeSnippet()
     {
         var content = @"// <tag>
@@ -51,8 +50,8 @@ public void LineNumberTest_CodeSnippet()
         });
     }
 
-    [Fact]
-    [Trait("Related", "LineNumber")]
+    [TestMethod]
+    [TestProperty("Related", "LineNumber")]
     public void LineNumberTest_Inclusion()
     {
         var root = @"
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/AutoIdentifierTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/AutoIdentifierTest.cs
index 3ea1dc24ed2..32922d36261 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/AutoIdentifierTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/AutoIdentifierTest.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Markdig.Extensions.AutoIdentifiers;
-using Xunit;
 
 namespace Docfx.MarkdigEngine.Tests;
 
@@ -10,10 +9,11 @@ namespace Docfx.MarkdigEngine.Tests;
 /// Unit tests for markdig <see cref="AutoIdentifierExtension"/>.
 /// </summary>
 /// <seealso href="https://github.com/xoofx/markdig/blob/master/src/Markdig.Tests/Specs/AutoIdentifierSpecs.md"/>
-[Trait("Related", "MarkdigExtension")]
+[TestProperty("Related", "MarkdigExtension")]
+[TestClass]
 public class AutoIdentifierTest
 {
-    [Fact]
+    [TestMethod]
     public void AutoIdentifierTest_DocfxDefault()
     {
         // docfx use `AutoIdentifierOptions.GitHub` as default options.
@@ -26,7 +26,7 @@ public void AutoIdentifierTest_DocfxDefault()
         ]);
     }
 
-    [Fact]
+    [TestMethod]
     public void AutoIdentifierTest_MarkdigDefault()
     {
         var content = "# This - is a &@! heading _ with . and ! -";
@@ -44,7 +44,7 @@ public void AutoIdentifierTest_MarkdigDefault()
         ]);
     }
 
-    [Fact]
+    [TestMethod]
     public void AutoIdentifierTest_None()
     {
         var content = "# This - is a &@! heading _ with . and ! -";
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/AutoLinkTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/AutoLinkTest.cs
index 11978ad09cc..3fb2a3f1e97 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/AutoLinkTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/AutoLinkTest.cs
@@ -4,7 +4,6 @@
 using System.Text.Json;
 using Docfx.MarkdigEngine.Extensions;
 using Markdig.Extensions.AutoLinks;
-using Xunit;
 
 namespace Docfx.MarkdigEngine.Tests;
 
@@ -12,10 +11,11 @@ namespace Docfx.MarkdigEngine.Tests;
 /// Unit tests for markdig <see cref="AutoLinkExtension"/>.
 /// </summary>
 /// <seealso href="https://github.com/xoofx/markdig/blob/master/src/Markdig.Tests/Specs/AutoLinks.md"/>
-[Trait("Related", "MarkdigExtension")]
+[TestProperty("Related", "MarkdigExtension")]
+[TestClass]
 public class AutoLinkTest
 {
-    [Fact]
+    [TestMethod]
     public void AutoLinkTest_DocfxDefault()
     {
         // docfx use `AutoIdentifierOptions.GitHub` as default options.
@@ -26,7 +26,7 @@ public void AutoLinkTest_DocfxDefault()
         TestUtility.VerifyMarkup(content, expected, optionalExtensions: ["AutoLinks"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void AutoLinkTest_Custom()
     {
         var options = new AutoLinkOptions
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/EmojiTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/EmojiTest.cs
index 1154ab32225..ea9c6366dbf 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/EmojiTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/EmojiTest.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Markdig.Extensions.Emoji;
-using Xunit;
 
 namespace Docfx.MarkdigEngine.Tests;
 
@@ -10,10 +9,11 @@ namespace Docfx.MarkdigEngine.Tests;
 /// Unit tests for markdig <see cref="EmojiExtension"/>.
 /// </summary>
 /// <seealso href="https://github.com/xoofx/markdig/blob/master/src/Markdig.Tests/Specs/EmojiSpecs.md"/>
-[Trait("Related", "MarkdigExtension")]
+[TestProperty("Related", "MarkdigExtension")]
+[TestClass]
 public class EmojiTest
 {
-    [Fact]
+    [TestMethod]
     public void EmojiTest_DocfxDefault()
     {
         var content = "**content :** :smile:";
@@ -23,7 +23,7 @@ public void EmojiTest_DocfxDefault()
         TestUtility.VerifyMarkup(content, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void EmojiTest_MarkdigDefault()
     {
         var content = ":)";
@@ -33,7 +33,7 @@ public void EmojiTest_MarkdigDefault()
         TestUtility.VerifyMarkup(content, expected, optionalExtensions: ["Emojis"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void EmojiTest_Smileys_Enabled()
     {
         var content = ":)";
@@ -44,7 +44,7 @@ public void EmojiTest_Smileys_Enabled()
         ]);
     }
 
-    [Fact]
+    [TestMethod]
     public void EmojiTest_Smileys_Disabled()
     {
         var content = ":)";
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/EmphasisExtraTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/EmphasisExtraTest.cs
index 3bf1bfb5593..c6ed7e577c0 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/EmphasisExtraTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/EmphasisExtraTest.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Markdig.Extensions.EmphasisExtras;
-using Xunit;
 
 namespace Docfx.MarkdigEngine.Tests;
 
@@ -10,10 +9,11 @@ namespace Docfx.MarkdigEngine.Tests;
 /// Unit tests for markdig <see cref="EmphasisExtraExtension"/>.
 /// </summary>
 /// <seealso href="https://github.com/xoofx/markdig/blob/master/src/Markdig.Tests/Specs/EmphasisExtraSpecs.md"/>
-[Trait("Related", "MarkdigExtension")]
+[TestProperty("Related", "MarkdigExtension")]
+[TestClass]
 public class EmphasisExtraTest
 {
-    [Fact]
+    [TestMethod]
     public void EmphasisExtraTest_DocfxDefault()
     {
         var content = "The following text ~~is deleted~~";
@@ -23,7 +23,7 @@ public void EmphasisExtraTest_DocfxDefault()
         TestUtility.VerifyMarkup(content, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void EmphasisExtraTest_ResetToMarkdigDefault()
     {
         var content =
@@ -48,7 +48,7 @@ The following text <del>is deleted</del>
         TestUtility.VerifyMarkup(content, expected, optionalExtensions: ["EmphasisExtras"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void EmphasisExtraTest_SuperscriptAndSubscript()
     {
         var content = "H~2~O is a liquid. 2^10^ is 1024";
@@ -66,7 +66,7 @@ public void EmphasisExtraTest_SuperscriptAndSubscript()
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void EmphasisExtraTest_Inserted()
     {
         var content = "++Inserted text++";
@@ -84,7 +84,7 @@ public void EmphasisExtraTest_Inserted()
         }
     }
 
-    [Fact]
+    [TestMethod]
     public void EmphasisExtraTest_Marked()
     {
         var content = "==Marked text==";
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/MediaLinksTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/MediaLinksTest.cs
index e30d185a7d5..f604148c8cc 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/MediaLinksTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/MediaLinksTest.cs
@@ -4,7 +4,6 @@
 using System.Text.Json;
 using Docfx.MarkdigEngine.Extensions;
 using Markdig.Extensions.MediaLinks;
-using Xunit;
 
 namespace Docfx.MarkdigEngine.Tests;
 
@@ -12,10 +11,11 @@ namespace Docfx.MarkdigEngine.Tests;
 /// Unit tests for markdig <see cref="MediaLinkExtension"/>.
 /// </summary>
 /// <seealso href="https://github.com/xoofx/markdig/blob/master/src/Markdig.Tests/Specs/MediaSpecs.md"/>
-[Trait("Related", "MarkdigExtension")]
+[TestProperty("Related", "MarkdigExtension")]
+[TestClass]
 public class MediaLinksTest
 {
-    [Fact]
+    [TestMethod]
     public void MediaLinksTest_Default()
     {
         var content = "![static mp4](https://example.com/video.mp4)";
@@ -26,7 +26,7 @@ public void MediaLinksTest_Default()
         TestUtility.VerifyMarkup(content, expected, optionalExtensions: ["MediaLinks"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void MediaLinksTest_Custom()
     {
         // `ExtensionToMimeType` and `Hosts` property override is not supported.
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/PipeTableTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/PipeTableTest.cs
index e8a254da131..28793bb8e84 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/PipeTableTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/PipeTableTest.cs
@@ -4,7 +4,6 @@
 using System.Text.Json;
 using Docfx.MarkdigEngine.Extensions;
 using Markdig.Extensions.Tables;
-using Xunit;
 
 namespace Docfx.MarkdigEngine.Tests;
 
@@ -12,10 +11,11 @@ namespace Docfx.MarkdigEngine.Tests;
 /// Unit tests for markdig <see cref="PipeTableExtension"/>.
 /// </summary>
 /// <seealso href="https://github.com/xoofx/markdig/blob/master/src/Markdig.Tests/Specs/PipeTableSpecs.md"/>
-[Trait("Related", "MarkdigExtension")]
+[TestProperty("Related", "MarkdigExtension")]
+[TestClass]
 public class PipeTableTest
 {
-    [Fact]
+    [TestMethod]
     public void PipeTableTest_Default()
     {
         var content =
@@ -49,7 +49,7 @@ public void PipeTableTest_Default()
         TestUtility.VerifyMarkup(content, expected, optionalExtensions: ["PipeTables"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void PipeTableTest_Custom()
     {
         var options = new PipeTableOptions
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/SmartyPantsTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/SmartyPantsTest.cs
index b69ff223289..fa89e623b18 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/SmartyPantsTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/MarkdigBuiltinExtensionTests/SmartyPantsTest.cs
@@ -4,7 +4,6 @@
 using System.Text.Json;
 using Docfx.MarkdigEngine.Extensions;
 using Markdig.Extensions.SmartyPants;
-using Xunit;
 
 namespace Docfx.MarkdigEngine.Tests;
 
@@ -13,13 +12,14 @@ namespace Docfx.MarkdigEngine.Tests;
 /// Unit tests for markdig <see cref="SmartyPantsExtension"/>.
 /// </summary>
 /// <seealso href="https://github.com/xoofx/markdig/blob/master/src/Markdig.Tests/Specs/SmartyPantsSpecs.md"/>
-[Trait("Related", "MarkdigExtension")]
+[TestProperty("Related", "MarkdigExtension")]
+[TestClass]
 public class SmartyPantsTest
 {
     /// <summary>
     /// SmartyPants extension is not enabled by docfx default.
     /// </summary>
-    [Fact]
+    [TestMethod]
     public void SmartyPantsTest_DocfxDefault()
     {
         string content = "This is a \"text 'with\" a another text'";
@@ -28,7 +28,7 @@ public void SmartyPantsTest_DocfxDefault()
         TestUtility.VerifyMarkup(content, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void SmartyPantsTest_Default()
     {
         string content = "This is a \"text 'with\" a another text'";
@@ -39,7 +39,8 @@ public void SmartyPantsTest_Default()
 
     // Currently custom mapping is not works as expected.
     // Because SmartyPantOptions.Mapping is defined as setter-only property. It's not deserialized by default.
-    [Fact(Skip = "Currently custom mapping is not supported.")]
+    [TestMethod]
+    [Ignore("Currently custom mapping is not supported.")]
     public void SmartyPantsTest_Custom()
     {
         var options = new SmartyPantOptions();
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/MathematicsTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/MathematicsTest.cs
index c3c13ee76c7..69597ef3bd7 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/MathematicsTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/MathematicsTest.cs
@@ -1,13 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class MathematicsTest
 {
-    [Fact]
+    [TestMethod]
     public void Test_Mathematics_Support_0()
     {
         var source = "$ math inline $";
@@ -16,7 +15,7 @@ public void Test_Mathematics_Support_0()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void Test_Mathematics_Support_1()
     {
         var source = "$ math^0 **inline** $";
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/MonikerRangeTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/MonikerRangeTest.cs
index 5796c218fd0..ea0cfe7f914 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/MonikerRangeTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/MonikerRangeTest.cs
@@ -1,13 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class MonikerRangeTest
 {
-    [Fact]
+    [TestMethod]
     public void MonikerRangeTestGeneral()
     {
         //arrange
@@ -51,7 +50,7 @@ Shared content.
         TestUtility.VerifyMarkup(source, expected, lineNumber: true, filePath: "fake.md");
     }
 
-    [Fact]
+    [TestMethod]
     public void MonikerRangeTestInvalid()
     {
         //arrange
@@ -63,7 +62,7 @@ public void MonikerRangeTestInvalid()
         TestUtility.VerifyMarkup(source, expected, ["invalid-moniker-range"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void MonikerRangeTestNotClosed()
     {
         //arrange
@@ -79,7 +78,7 @@ public void MonikerRangeTestNotClosed()
         TestUtility.VerifyMarkup(source1, expected, ["invalid-moniker-range"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void MonikerRangeWithCodeIndent()
     {
         var source = @"::: moniker range=""start""
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/NolocTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/NolocTest.cs
index 40b239e1ab1..7fc6e79b155 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/NolocTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/NolocTest.cs
@@ -1,14 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class NolocTest
 {
-    [Fact]
-    [Trait("Related", "Noloc")]
+    [TestMethod]
+    [TestProperty("Related", "Noloc")]
     public void NolocTest_General()
     {
         // Normal syntax
@@ -25,8 +24,8 @@ public void NolocTest_General()
             "<p>*Hello*</p>");
     }
 
-    [Fact]
-    [Trait("Related", "Noloc")]
+    [TestMethod]
+    [TestProperty("Related", "Noloc")]
     public void NolocTest_Invalid()
     {
         // MultipleLines
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/PlantUmlTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/PlantUmlTest.cs
index ac9cf13347d..50f6041e4f6 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/PlantUmlTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/PlantUmlTest.cs
@@ -2,13 +2,14 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using FluentAssertions;
-using Xunit;
 
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class PlantUmlTest
 {
-    [Fact(Skip = "Flaky Tests")]
+    [TestMethod]
+    [Ignore("Flaky Tests")]
     public void TestRenderSvg_SequenceDiagram()
     {
         var source = """
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/QuoteSectionNoteTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/QuoteSectionNoteTest.cs
index 43a42ff810e..c286ed516e5 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/QuoteSectionNoteTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/QuoteSectionNoteTest.cs
@@ -1,14 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class QuoteSectionNoteTest
 {
-    [Fact]
-    [Trait("Related", "QuoteSectionNote")]
+    [TestMethod]
+    [TestProperty("Related", "QuoteSectionNote")]
     public void QuoteSectionNoteTest_CornerCases()
     {
         var source = @"> [!Video https://test]
@@ -31,8 +30,8 @@ public void QuoteSectionNoteTest_CornerCases()
         TestUtility.VerifyMarkup(source, expected, ["invalid-note-section"]);
     }
 
-    [Fact]
-    [Trait("Related", "QuoteSectionNote")]
+    [TestMethod]
+    [TestProperty("Related", "QuoteSectionNote")]
     public void QuoteSectionNoteTest_TabInSection()
     {
         var source = "> [!div\t\tclass=\"tab\"] \n> section";
@@ -43,8 +42,8 @@ public void QuoteSectionNoteTest_TabInSection()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfmNote_NoteWithLocalization()
     {
         var source = @"# Note not in one line
@@ -75,8 +74,8 @@ this is also warning</p>
         TestUtility.VerifyMarkup(source, expected, tokens: tokens);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfmNote_NoteCaseSensitive()
     {
         var source = @"> [!noTe]
@@ -93,8 +92,8 @@ public void TestDfmNote_NoteCaseSensitive()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfmNote_NoteWithMix()
     {
         var source = @"# Note not in one line
@@ -135,8 +134,8 @@ public void TestDfmNote_NoteWithMix()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfmNote_NoteWithTextFollow()
     {
         var source = @"# Note not in one line
@@ -161,8 +160,8 @@ this is also warning</p>
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfmVideo_ConsecutiveVideos()
     {
         // 1. Prepare data
@@ -178,8 +177,8 @@ public void TestDfmVideo_ConsecutiveVideos()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfmVideo_Video()
     {
         // 1. Prepare data
@@ -194,8 +193,8 @@ public void TestDfmVideo_Video()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfmVideo_MixWithNote()
     {
         // 1. Prepare data
@@ -217,10 +216,10 @@ public void TestDfmVideo_MixWithNote()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Theory]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     #region Inline Data
-    [InlineData(@"the following is note type
+    [DataRow(@"the following is note type
   > [!NOTE]
   > note text 1-1
   > note text 1-2  
@@ -240,7 +239,7 @@ This is also note with br</p>
 </div>
 <p>Skip the note</p>
 ")]
-    [InlineData(@"the following is not note type
+    [DataRow(@"the following is not note type
   > no-note text 1-1
   > [!NOTE]
   > no-note text 1-2  
@@ -255,7 +254,7 @@ This is also note with br</p>
 no-note text 2-1</p>
 </div>
 ")]
-    [InlineData(@"the following is not note type
+    [DataRow(@"the following is not note type
   > no-note text 1-1
   >
   > [!NOTE]
@@ -271,7 +270,7 @@ This is also note with br</p>
 no-note text 2-2</p>
 </div>
 ")]
-    [InlineData(@"the following is code
+    [DataRow(@"the following is code
 
     > code text 1-1
     > [!NOTE]
@@ -290,9 +289,9 @@ public void TestSectionNoteInBlockQuote(string source, string expected)
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Theory]
-    [Trait("Related", "DfmMarkdown")]
-    [InlineData(@"> this is blockquote
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
+    [DataRow(@"> this is blockquote
 >
 > this line is also in the before blockquote
 > [!NOTE]
@@ -313,9 +312,9 @@ public void TestSectionNoteMixture(string source)
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Theory]
-    [Trait("Related", "DfmMarkdown")]
-    [InlineData(@"> [!div class=""tabbedCodeSnippets"" data-resources=""OutlookServices.Calendar""]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
+    [DataRow(@"> [!div class=""tabbedCodeSnippets"" data-resources=""OutlookServices.Calendar""]
 >
 >```cs-i
 >    var outlookClient = await CreateOutlookClientAsync(""Calendar"");
@@ -360,9 +359,9 @@ public void TestSectionBlockLevel(string source)
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Theory]
-    [Trait("Related", "DfmMarkdown")]
-    [InlineData(@"> [!div class=""All"" id=""All""]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
+    [DataRow(@"> [!div class=""All"" id=""All""]
 > this is out all
 > > [!div class=""A"" id=""A""]
 > > this is A
@@ -383,19 +382,19 @@ public void TestSectionBlockLevelRecursive(string source)
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Theory]
-    [Trait("Related", "DfmMarkdown")]
-    [InlineData("> [!div]", "<div>\n</div>\n")]
-    [InlineData(@"> [!div `id=""error""]", "<div>\n</div>\n")]
-    [InlineData(@"> [!div `id=""right""`]", "<div id=\"right\">\n</div>\n")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
+    [DataRow("> [!div]", "<div>\n</div>\n")]
+    [DataRow(@"> [!div `id=""error""]", "<div>\n</div>\n")]
+    [DataRow(@"> [!div `id=""right""`]", "<div id=\"right\">\n</div>\n")]
     public void TestSectionCornerCase(string source, string expected)
     {
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Theory]
-    [Trait("Related", "DfmMarkdown")]
-    [InlineData(@"> [!div class=""All"" id=""All""] Followed text
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
+    [DataRow(@"> [!div class=""All"" id=""All""] Followed text
 > We should support that.")]
     public void TestSectionWithTextFollowed(string source)
     {
@@ -408,8 +407,8 @@ We should support that.</p>
         TestUtility.VerifyMarkup(source, expected, ["invalid-note-section"]);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestVideoBlock_Normal()
     {
         var source = @"# Article 2
@@ -421,8 +420,8 @@ public void TestVideoBlock_Normal()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestVideoBlock_Http()
     {
         var source = @"# Article 2
@@ -434,8 +433,8 @@ public void TestVideoBlock_Http()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestVideoBlock_Channel9()
     {
         var source = @"# Article 2
@@ -447,8 +446,8 @@ public void TestVideoBlock_Channel9()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestVideoBlock_Channel9WithQueryString()
     {
         var source = @"# Article 2
@@ -460,8 +459,8 @@ public void TestVideoBlock_Channel9WithQueryString()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestVideoBlock_YouTube()
     {
         var source = @"# Article 2
@@ -473,8 +472,8 @@ public void TestVideoBlock_YouTube()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void QuoteSectionNoteTest_ExtensionConfiguration()
     {
         var source = @"# Article 2
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/RenderZoneTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/RenderZoneTest.cs
index a91af0907a6..b795ba7d3e7 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/RenderZoneTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/RenderZoneTest.cs
@@ -1,13 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class RenderZoneTest
 {
-    [Fact]
+    [TestMethod]
     public void KitchenSink()
     {
         //arrange
@@ -72,7 +71,7 @@ a pivot with target
         TestUtility.VerifyMarkup(content, expected, lineNumber: true, filePath: "fake.md");
     }
 
-    [Fact]
+    [TestMethod]
     public void AttributeMissingClosingQuote()
     {
         //arrange
@@ -84,7 +83,7 @@ public void AttributeMissingClosingQuote()
         TestUtility.VerifyMarkup(source, expected, ["invalid-zone"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void MissingEndTag()
     {
         //arrange
@@ -101,7 +100,7 @@ public void MissingEndTag()
         TestUtility.VerifyMarkup(source1, expected, ["invalid-zone"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void NotNested()
     {
         //arrange
@@ -114,7 +113,7 @@ public void NotNested()
         TestUtility.VerifyMarkup(content, null, ["invalid-zone"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void PermitsNestedBlocks()
     {
         var source = @"::: zone target=""chromeless""
@@ -135,7 +134,7 @@ public void PermitsNestedBlocks()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void PdfPivotInvalid()
     {
         //arrange
@@ -147,7 +146,7 @@ public void PdfPivotInvalid()
         TestUtility.VerifyMarkup(source, expected, ["invalid-zone"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void PivotInvalid()
     {
         //arrange
@@ -160,7 +159,7 @@ public void PivotInvalid()
         TestUtility.VerifyMarkup(source, expected, ["invalid-zone"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void PivotInvalid2()
     {
         //arrange
@@ -173,7 +172,7 @@ public void PivotInvalid2()
         TestUtility.VerifyMarkup(source, expected, ["invalid-zone"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void PivotCommaDelimited()
     {
         //arrange
@@ -186,7 +185,7 @@ public void PivotCommaDelimited()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void UnexpectedAttribute()
     {
         //arrange
@@ -198,7 +197,7 @@ public void UnexpectedAttribute()
         TestUtility.VerifyMarkup(source, expected, ["invalid-zone"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void DuplicateAttribute()
     {
         //arrange
@@ -210,7 +209,7 @@ public void DuplicateAttribute()
         TestUtility.VerifyMarkup(source, expected, ["invalid-zone"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void InvalidAttribute()
     {
         //arrange
@@ -222,7 +221,7 @@ public void InvalidAttribute()
         TestUtility.VerifyMarkup(source, expected, ["invalid-zone"]);
     }
 
-    [Fact]
+    [TestMethod]
     public void TextAfterEndTag()
     {
         //arrange
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/RowsTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/RowsTest.cs
index 866200d4d26..009e07d575c 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/RowsTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/RowsTest.cs
@@ -1,14 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class RowTest
 {
-    [Fact]
-    [Trait("Related", "Row")]
+    [TestMethod]
+    [TestProperty("Related", "Row")]
     public void RowTest_SimpleRow()
     {
         var source = @":::row:::
@@ -26,8 +25,8 @@ This is where your content goes.
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "Row")]
+    [TestMethod]
+    [TestProperty("Related", "Row")]
     public void RowTest_WithColumns()
     {
         var source = @":::row:::
@@ -45,8 +44,8 @@ This is where your content goes.
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "Row")]
+    [TestMethod]
+    [TestProperty("Related", "Row")]
     public void RowTest_WithColumnsWithSpans()
     {
         var source = @":::row:::
@@ -70,8 +69,8 @@ This is where your content goes.
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "Row")]
+    [TestMethod]
+    [TestProperty("Related", "Row")]
     public void RowTest_WithThreeColumnsWithSpans()
     {
         var source = @":::row:::
@@ -101,8 +100,8 @@ This is where your content goes.
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "Row")]
+    [TestMethod]
+    [TestProperty("Related", "Row")]
     public void RowTest_WithColumnsWithThreeSpan()
     {
         var source = @":::row:::
@@ -126,8 +125,8 @@ This is where your content goes.
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "Row")]
+    [TestMethod]
+    [TestProperty("Related", "Row")]
     public void RowTest_WithColumnsOtherContent()
     {
         var source = @":::row:::
@@ -163,8 +162,8 @@ This is where your content goes.
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
-    [Trait("Related", "Row")]
+    [TestMethod]
+    [TestProperty("Related", "Row")]
     public void RowTest_FullWithWriteAttributes()
     {
         var source = @":::row:::
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/TabGroupTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/TabGroupTest.cs
index f02e426c32f..6895d48b1f3 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/TabGroupTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/TabGroupTest.cs
@@ -1,14 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class TabGroupTest
 {
-    [Fact]
-    [Trait("Related", "TabGroup")]
+    [TestMethod]
+    [TestProperty("Related", "TabGroup")]
     public void Test_General()
     {
         TestMarkupInGeneral(
@@ -41,8 +40,8 @@ public void Test_General()
         );
     }
 
-    [Fact]
-    [Trait("Related", "TabGroup")]
+    [TestMethod]
+    [TestProperty("Related", "TabGroup")]
     public void Test_TabGroup_Combining()
     {
         TestMarkupInGeneral(
@@ -94,7 +93,7 @@ public void Test_TabGroup_Combining()
         );
     }
 
-    [Fact]
+    [TestMethod]
     public void TestTableInTabGroup()
     {
         TestMarkupInGeneral(@"# [title](#tab/id)
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/TestUtility.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/TestUtility.cs
index 96c98606e4b..b72221cebd2 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/TestUtility.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/TestUtility.cs
@@ -4,7 +4,6 @@
 using Docfx.MarkdigEngine.Extensions;
 using Markdig;
 using Markdig.Syntax;
-using Xunit;
 
 namespace Docfx.MarkdigEngine.Tests;
 
@@ -57,16 +56,16 @@ public static string VerifyMarkup(
 
             if (html != null)
             {
-                Assert.Equal(
+                Assert.AreEqual(
                     html.Replace("\r", "").Replace("\n", ""),
                     actualHtml.Replace("\r", "").Replace("\n", ""));
             }
 
-            Assert.Equal(errors.OrderBy(_ => _), actualErrors.OrderBy(_ => _));
+            CollectionAssert.AreEqual(errors.OrderBy(_ => _).ToArray(), actualErrors.OrderBy(_ => _).ToArray());
 
             if (dependencies != null)
             {
-                Assert.Equal(dependencies.OrderBy(_ => _), actualDependencies.OrderBy(_ => _));
+                Assert.AreEqual(dependencies.OrderBy(_ => _), actualDependencies.OrderBy(_ => _));
             }
             return actualHtml;
         }
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/TripleColonTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/TripleColonTest.cs
index f92946d08dd..596f2a59a7a 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/TripleColonTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/TripleColonTest.cs
@@ -2,13 +2,13 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Text;
-using Xunit;
 
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class TripleColonTest
 {
-    [Fact]
+    [TestMethod]
     public void TripleColonTestGeneral()
     {
         var source = @"::: zone pivot=""windows""
@@ -23,7 +23,7 @@ public void TripleColonTestGeneral()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void TripleColonTestSelfClosing()
     {
         var source = @"::: zone target=""chromeless""
@@ -41,7 +41,7 @@ public void TripleColonTestSelfClosing()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void TripleColonTestBlockClosed()
     {
         var source = @"::: zone target=""chromeless""
@@ -59,7 +59,7 @@ public void TripleColonTestBlockClosed()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void TripleColonWithInMonikerTestBlockClosed()
     {
         var source = new StringBuilder()
@@ -79,7 +79,7 @@ public void TripleColonWithInMonikerTestBlockClosed()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void TripleColonWithInMonikerTestBlockUnClosed()
     {
         var source = new StringBuilder()
@@ -99,7 +99,7 @@ public void TripleColonWithInMonikerTestBlockUnClosed()
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Fact]
+    [TestMethod]
     public void Issue8999()
     {
         TestUtility.VerifyMarkup(
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/VideoTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/VideoTest.cs
index f09d0034673..02a0798b954 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/VideoTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/VideoTest.cs
@@ -1,26 +1,25 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class VideoTest
 {
-    [Theory]
-    [InlineData(@":::video source=""https://channel9.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/player?nocookie=true"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" max-width=""400"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::", @"<p><div class=""embeddedvideo"">
+    [TestMethod]
+    [DataRow(@":::video source=""https://channel9.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/player?nocookie=true"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" max-width=""400"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::", @"<p><div class=""embeddedvideo"">
 <iframe src=""https://channel9.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/player?nocookie=true&amp;nocookie=true"" allowFullScreen=""true"" frameBorder=""0"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" style=""max-width:400px;"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020""></iframe>
 </div></p>
 ")]
-    [InlineData(@":::video source=""https://www.youtube.com/embed/wV11_nbT2XE"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::", @"<p><div class=""embeddedvideo"">
+    [DataRow(@":::video source=""https://www.youtube.com/embed/wV11_nbT2XE"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::", @"<p><div class=""embeddedvideo"">
 <iframe src=""https://www.youtube-nocookie.com/embed/wV11_nbT2XE?rel=0"" allowFullScreen=""true"" frameBorder=""0"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020""></iframe>
 </div></p>
 ")]
-    [InlineData(@":::video source=""https://www.youtube.com/embed/wV11_nbT2XE?rel=1"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::", @"<p><div class=""embeddedvideo"">
+    [DataRow(@":::video source=""https://www.youtube.com/embed/wV11_nbT2XE?rel=1"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::", @"<p><div class=""embeddedvideo"">
 <iframe src=""https://www.youtube-nocookie.com/embed/wV11_nbT2XE?rel=1"" allowFullScreen=""true"" frameBorder=""0"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020""></iframe>
 </div></p>
 ")]
-    [InlineData(
+    [DataRow(
         @":::video source=""https://www.youtube.com/embed/wV11_nbT2XE"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::
 :::video source=""https://channel9.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/player?nocookie=true"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" max-width=""400"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::
 ", @"<p><div class=""embeddedvideo"">
@@ -29,10 +28,10 @@ public class VideoTest
 <div class=""embeddedvideo"">
 <iframe src=""https://channel9.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/player?nocookie=true&amp;nocookie=true"" allowFullScreen=""true"" frameBorder=""0"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" style=""max-width:400px;"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"">
 </iframe></div></p>")]
-    [InlineData(@":::video source=""https://www.microsoft.com/en-us/videoplayer/embed/wV11_nbT2XE"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::", @"<p><div class=""embeddedvideo"">
+    [DataRow(@":::video source=""https://www.microsoft.com/en-us/videoplayer/embed/wV11_nbT2XE"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::", @"<p><div class=""embeddedvideo"">
 <iframe src=""https://www.microsoft.com/en-us/videoplayer/embed/wV11_nbT2XE"" allowFullScreen=""true"" frameBorder=""0"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020""></iframe>
 </div></p>")]
-    [InlineData(@":::video source=""https://www.microsoft.com/en-us/videoplayer/embed/RE1XVQS"" title=""Introduction to Custom Vision Service"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::", @"<p><div class=""embeddedvideo"">
+    [DataRow(@":::video source=""https://www.microsoft.com/en-us/videoplayer/embed/RE1XVQS"" title=""Introduction to Custom Vision Service"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::", @"<p><div class=""embeddedvideo"">
 <iframe src=""https://www.microsoft.com/en-us/videoplayer/embed/RE1XVQS"" allowFullScreen=""true"" frameBorder=""0"" title=""Introduction to Custom Vision Service"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020""></iframe>
 </div></p>")]
     public void VideoTestBlockGeneral(string source, string expected)
@@ -40,20 +39,20 @@ public void VideoTestBlockGeneral(string source, string expected)
         TestUtility.VerifyMarkup(source, expected);
     }
 
-    [Theory]
-    [InlineData(@":::video source="""" title=""My title"":::", @"<p>:::video source=&quot;&quot; title=&quot;My title&quot;:::</p>
+    [TestMethod]
+    [DataRow(@":::video source="""" title=""My title"":::", @"<p>:::video source=&quot;&quot; title=&quot;My title&quot;:::</p>
 ")]
-    [InlineData(@":::video title=""My title"":::", @"<p>:::video title=&quot;My title&quot;:::</p>
+    [DataRow(@":::video title=""My title"":::", @"<p>:::video title=&quot;My title&quot;:::</p>
 ")]
-    [InlineData(@":::video source=""https://videoland.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/player?nocookie=true"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" max-width=""400"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::", @"<p><div class=""embeddedvideo"">
+    [DataRow(@":::video source=""https://videoland.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/player?nocookie=true"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" max-width=""400"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::", @"<p><div class=""embeddedvideo"">
 <iframe src=""https://videoland.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/player?nocookie=true"" allowFullScreen=""true"" frameBorder=""0"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" style=""max-width:400px;"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"">
 </iframe></div></p>
 ")]
-    [InlineData(@":::video source=""https://channel9.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/player?nocookie=true"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" max-width=""what"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::", @"<p>:::video source=&quot;https://channel9.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/player?nocookie=true&quot; title=&quot;Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin&quot; max-width=&quot;what&quot; thumbnail=&quot;media/3-eclipse-install-button.png&quot; upload-date=&quot;07/27/2020&quot;:::</p>
+    [DataRow(@":::video source=""https://channel9.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/player?nocookie=true"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" max-width=""what"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::", @"<p>:::video source=&quot;https://channel9.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/player?nocookie=true&quot; title=&quot;Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin&quot; max-width=&quot;what&quot; thumbnail=&quot;media/3-eclipse-install-button.png&quot; upload-date=&quot;07/27/2020&quot;:::</p>
 ")]
-    [InlineData(@":::video blab=""blib"" source=""https://channel9.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/player?nocookie=true"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"":::", @"<p>:::video blab=&quot;blib&quot; source=&quot;https://channel9.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/player?nocookie=true&quot; title=&quot;Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin&quot;:::</p>
+    [DataRow(@":::video blab=""blib"" source=""https://channel9.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/player?nocookie=true"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"":::", @"<p>:::video blab=&quot;blib&quot; source=&quot;https://channel9.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/player?nocookie=true&quot; title=&quot;Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin&quot;:::</p>
 ")]
-    [InlineData(@":::video source=""https://channel9.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::", @"<p><div class=""embeddedvideo"">
+    [DataRow(@":::video source=""https://channel9.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"":::", @"<p><div class=""embeddedvideo"">
 <iframe src=""https://channel9.msdn.com/Shows/XamarinShow/Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin/?nocookie=true"" allowFullScreen=""true"" frameBorder=""0"" title=""Video: Build-Your-First-Android-App-with-Visual-Studio-2019-and-Xamarin"" thumbnail=""media/3-eclipse-install-button.png"" upload-date=""07/27/2020"">
 </iframe></div></p>
 ")]
diff --git a/test/Docfx.MarkdigEngine.Extensions.Tests/XrefTest.cs b/test/Docfx.MarkdigEngine.Extensions.Tests/XrefTest.cs
index 38c32abfd99..23df0273eec 100644
--- a/test/Docfx.MarkdigEngine.Extensions.Tests/XrefTest.cs
+++ b/test/Docfx.MarkdigEngine.Extensions.Tests/XrefTest.cs
@@ -1,13 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Xunit;
-
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class XrefTest
 {
-    [Fact]
+    [TestMethod]
     public void XrefTestGeneral()
     {
         //arrange
diff --git a/test/Docfx.MarkdigEngine.Tests/InclusionTest.cs b/test/Docfx.MarkdigEngine.Tests/InclusionTest.cs
index 2c27735c078..72ea4146a63 100644
--- a/test/Docfx.MarkdigEngine.Tests/InclusionTest.cs
+++ b/test/Docfx.MarkdigEngine.Tests/InclusionTest.cs
@@ -1,20 +1,19 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Collections.Immutable;
 using Docfx.Common;
 using Docfx.MarkdigEngine.Extensions;
 using Docfx.Plugins;
 using Markdig;
-using Xunit;
 
 namespace Docfx.MarkdigEngine.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class InclusionTest
 {
-    [Fact]
-    [Trait("Related", "Inclusion")]
+    [TestMethod]
+    [TestProperty("Related", "Inclusion")]
     public void TestBlockLevelInclusion_General()
     {
         var root = """
@@ -66,15 +65,15 @@ Test Include File
                        <p>[!include<a href="a.md">refa</a> ]</p>
 
                        """;
-        Assert.Equal(expected.Replace("\r\n", "\n"), result.Html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), result.Html);
 
         var dependency = result.Dependency;
         var expectedDependency = new List<string> { "a.md", "b.md" };
-        Assert.Equal(expectedDependency.ToImmutableList(), dependency);
+        CollectionAssert.AreEqual(expectedDependency.ToArray(), dependency.ToArray());
     }
 
-    [Fact]
-    [Trait("Related", "IncludeFile")]
+    [TestMethod]
+    [TestProperty("Related", "IncludeFile")]
     public void TestBlockLevelInclusion_Escape()
     {
         var root = """
@@ -107,15 +106,15 @@ This is a file A included by another file.
                        <p>This is a file A included by another file.</p>
 
                        """;
-        Assert.Equal(expected.Replace("\r\n", "\n"), result.Html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), result.Html);
 
         var dependency = result.Dependency;
         var expectedDependency = new List<string> { "a(x).md" };
-        Assert.Equal(expectedDependency.ToImmutableList(), dependency);
+        CollectionAssert.AreEqual(expectedDependency.ToArray(), dependency.ToArray());
     }
 
-    [Fact]
-    [Trait("Related", "Inclusion")]
+    [TestMethod]
+    [TestProperty("Related", "Inclusion")]
     public void TestBlockLevelInclusion_RelativePath()
     {
         var root = """
@@ -148,15 +147,15 @@ This is a file A included by another file.
                        <p>This is a file A included by another file.</p>
 
                        """;
-        Assert.Equal(expected.Replace("\r\n", "\n"), result.Html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), result.Html);
 
         var dependency = result.Dependency;
         var expectedDependency = new List<string> { "a.md" };
-        Assert.Equal(expectedDependency.ToImmutableList(), dependency);
+        CollectionAssert.AreEqual(expectedDependency.ToArray(), dependency.ToArray());
     }
 
-    [Fact]
-    [Trait("Related", "Inclusion")]
+    [TestMethod]
+    [TestProperty("Related", "Inclusion")]
     public void TestBlockLevelInclusion_CycleInclude()
     {
         var root = """
@@ -204,15 +203,16 @@ This is a file A included by another file.
                        [!include[refa](a.md)]
                        """;
 
-        Assert.Equal(expected.Replace("\r\n", "\n"), result.Html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), result.Html);
         Logger.UnregisterListener(listener);
-        Assert.Collection(listener.Items, log => Assert.Equal(
+        var log = Assert.ContainsSingle(listener.Items);
+        Assert.AreEqual(
             "Build has identified file(s) referencing each other: 'r/root.md' --> '~/r/a.md' --> '~/r/b.md' --> '~/r/a.md'",
-            log.Message));
+            log.Message);
     }
 
-    [Fact]
-    [Trait("Related", "Inclusion")]
+    [TestMethod]
+    [TestProperty("Related", "Inclusion")]
     public void TestInlineLevelInclusion_General()
     {
         var root = """
@@ -237,15 +237,15 @@ public void TestInlineLevelInclusion_General()
                        <p>Test Escaped Inline Included File: [!include<a href="%7E/r/a.md">refa</a>].</p>
 
                        """;
-        Assert.Equal(expected.Replace("\r\n", "\n"), result.Html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), result.Html);
 
         var dependency = result.Dependency;
         var expectedDependency = new List<string> { "a.md" };
-        Assert.Equal(expectedDependency.ToImmutableList(), dependency);
+        CollectionAssert.AreEqual(expectedDependency.ToArray(), dependency.ToArray());
     }
 
-    [Fact]
-    [Trait("Related", "Inclusion")]
+    [TestMethod]
+    [TestProperty("Related", "Inclusion")]
     public void TestInlineLevelInclusion_CycleInclude()
     {
         var root = """
@@ -269,11 +269,11 @@ public void TestInlineLevelInclusion_CycleInclude()
 
                        """;
 
-        Assert.Equal(expected.Replace("\r\n", "\n"), result.Html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), result.Html);
     }
 
-    [Fact]
-    [Trait("Related", "Inclusion")]
+    [TestMethod]
+    [TestProperty("Related", "Inclusion")]
     public void TestInlineLevelInclusion_Block()
     {
         var root = """
@@ -300,15 +300,15 @@ block content in Inline Inclusion.
                        <p>Test Inline Included File: ## This is a included tokenblock content in Inline Inclusion..</p>
 
                        """;
-        Assert.Equal(expected.Replace("\r\n", "\n"), result.Html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), result.Html);
 
         var dependency = result.Dependency;
         var expectedDependency = new List<string> { "a.md" };
-        Assert.Equal(expectedDependency.ToImmutableList(), dependency);
+        CollectionAssert.AreEqual(expectedDependency.ToArray(), dependency.ToArray());
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestBlockLevelInclusion()
     {
         // -r
@@ -367,8 +367,8 @@ public void TestBlockLevelInclusion()
                        [!include[external](http://microsoft.com/a.md)]
                        """.Replace("\r\n", "\n");
 
-        Assert.Equal(expected, marked.Html);
-        Assert.Equal(
+        Assert.AreEqual(expected, marked.Html);
+        CollectionAssert.AreEqual(
             new[]
             {
                 "a/refc.md",
@@ -381,8 +381,8 @@ public void TestBlockLevelInclusion()
             dependency.OrderBy(x => x).ToArray());
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestBlockLevelInclusionWithSameFile()
     {
         // -r
@@ -432,29 +432,29 @@ public void TestBlockLevelInclusionWithSameFile()
                        <a href="%7E/r/c/d/d.md#anchor">d</a></p>
                        """.Replace("\r\n", "\n") + "\n";
         var dependency = marked.Dependency;
-        Assert.Equal(expected, marked.Html);
-        Assert.Equal(
+        Assert.AreEqual(expected, marked.Html);
+        CollectionAssert.AreEqual(
             new[] { "../b/token.md" },
             dependency.OrderBy(x => x).ToArray());
 
         marked = TestUtility.MarkupWithoutSourceInfo(d, "r/c/d/d.md");
         dependency = marked.Dependency;
-        Assert.Equal(expected, marked.Html);
-        Assert.Equal(
+        Assert.AreEqual(expected, marked.Html);
+        CollectionAssert.AreEqual(
             new[] { "../../b/token.md" },
             dependency.OrderBy(x => x).ToArray());
 
         dependency.Clear();
         marked = TestUtility.MarkupWithoutSourceInfo(r, "r/r.md");
         dependency = marked.Dependency;
-        Assert.Equal($"{expected}{expected}", marked.Html);
-        Assert.Equal(
+        Assert.AreEqual($"{expected}{expected}", marked.Html);
+        CollectionAssert.AreEqual(
             new[] { "a/a.md", "b/token.md", "c/d/d.md" },
             dependency.OrderBy(x => x).ToArray());
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestBlockLevelInclusionWithWorkingFolder()
     {
         // -r
@@ -467,13 +467,14 @@ public void TestBlockLevelInclusionWithWorkingFolder()
         TestUtility.WriteToFile("r/b/linkAndRefRoot.md", linkAndRefRoot);
         var marked = TestUtility.MarkupWithoutSourceInfo(root, "r/root.md");
         var expected = "<p>Paragraph1</p>" + "\n";
-        Assert.Equal(expected, marked.Html);
+        Assert.AreEqual(expected, marked.Html);
     }
 
     #region Fallback folders testing
 
-    [Fact(Skip = "won't support")]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [Ignore("won't support")]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestFallback_Inclusion_random_name()
     {
         // -root_folder (this is also docset folder)
@@ -530,7 +531,7 @@ markdown token1.md content end.
         var marked = service.Markup("place", "holder");
         var dependency = marked.Dependency;
 
-        Assert.Equal("""
+        Assert.AreEqual("""
                      <p>1markdown root.md main content start.</p>
                      <p>1markdown a.md main content start.</p>
                      <p>1markdown token1.md content start.</p>
@@ -541,13 +542,14 @@ markdown token1.md content end.
                      <p>markdown root.md main content end.</p>
 
                      """.Replace("\r\n", "\n"), marked.Html);
-        Assert.Equal(
+        Assert.AreEqual(
             new[] { $"../fallback_folder_{uniqueFolderName}/token_folder_{uniqueFolderName}/token2_{uniqueFolderName}.md", $"a_folder_{uniqueFolderName}/a_{uniqueFolderName}.md", $"token_folder_{uniqueFolderName}/token1_{uniqueFolderName}.md", $"token_folder_{uniqueFolderName}/token2_{uniqueFolderName}.md" },
             dependency.OrderBy(x => x).ToArray());
     }
 
-    [Fact(Skip = "won't support")]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [Ignore("won't support")]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestFallback_InclusionWithCodeFences()
     {
         // -root_folder (this is also docset folder)
@@ -623,7 +625,7 @@ markdown a.md a.md content end.
         //var rootMarked = service.Markup(Path.Combine(Directory.GetCurrentDirectory(), $"{uniqueFolderName}/root_folder"), root, fallbackFolders, "root.md");
         var rootMarked = service.Markup("place", "holder");
         var rootDependency = rootMarked.Dependency;
-        Assert.Equal("""
+        Assert.AreEqual("""
                      <p>markdown root.md main content start.</p>
                      <p>markdown a content in root.md content start</p>
                      <p>markdown a.md main content start.</p>
@@ -641,7 +643,7 @@ markdown a.md a.md content end.
                      <p>markdown root.md main content end.</p>
 
                      """.Replace("\r\n", "\n"), rootMarked.Html);
-        Assert.Equal(
+        Assert.AreEqual(
             new[] { "../fallback_folder/a_folder/code_in_a.cs", "../fallback_folder/code_folder/sample2.cs", "a_folder/a.md", "a_folder/code_in_a.cs", "code_folder/sample1.cs", "code_folder/sample2.cs" },
             rootDependency.OrderBy(x => x).ToArray());
 
@@ -649,7 +651,7 @@ markdown a.md a.md content end.
         //var aMarked = service.Markup(Path.Combine(Directory.GetCurrentDirectory(), $"{uniqueFolderName}/root_folder"), a, fallbackFolders, "a_folder/a.md");
         var aMarked = service.Markup("place", "holder");
         var aDependency = aMarked.Dependency;
-        Assert.Equal("""
+        Assert.AreEqual("""
                      <p>markdown a.md main content start.</p>
                      <p>code_in_a code in a.md content start</p>
                      <pre><code class="lang-cs" name="this is code_in_a code">namespace code_in_a{}
@@ -657,15 +659,15 @@ markdown a.md a.md content end.
                      <p>markdown a.md a.md content end.</p>
 
                      """.Replace("\r\n", "\n"), aMarked.Html);
-        Assert.Equal(
+        Assert.AreEqual(
             new[] { "../../fallback_folder/a_folder/code_in_a.cs", "code_in_a.cs" },
             aDependency.OrderBy(x => x).ToArray());
     }
 
     #endregion
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestInclusion_InlineLevel()
     {
         // 1. Prepare data
@@ -688,14 +690,14 @@ public void TestInclusion_InlineLevel()
         var dependency = marked.Dependency;
         var expected = "<p>Inline ## Inline inclusion do not parse header [!include[root](root.md)]\nInline <strong>Hello</strong></p>\n";
 
-        Assert.Equal(expected, marked.Html);
-        Assert.Equal(
+        Assert.AreEqual(expected, marked.Html);
+        CollectionAssert.AreEqual(
             new[] { "ref1.md", "ref2.md", "ref3.md", "root.md" },
             dependency.OrderBy(x => x).ToArray());
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestBlockInclude_ShouldExcludeBracketInRegex()
     {
         // 1. Prepare data
@@ -725,14 +727,14 @@ public void TestBlockInclude_ShouldExcludeBracketInRegex()
 
         var marked = TestUtility.MarkupWithoutSourceInfo(root, "root.md");
         var dependency = marked.Dependency;
-        Assert.Equal(expected.Replace("\r\n", "\n"), marked.Html);
-        Assert.Equal(
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), marked.Html);
+        CollectionAssert.AreEqual(
           new[] { "inc1.md", "inc2.md", "inc3.md" },
           dependency.OrderBy(x => x).ToArray());
     }
 
-    [Fact]
-    [Trait("Related", "Inclusion")]
+    [TestMethod]
+    [TestProperty("Related", "Inclusion")]
     public void TestBlockInclude_ImageRelativePath()
     {
         var root = """
@@ -766,15 +768,15 @@ Test Include File
                        <p><img src="%7E/r/include/media/refb.png" alt="img" /></p>
 
                        """;
-        Assert.Equal(expected.Replace("\r\n", "\n"), result.Html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), result.Html);
 
         var dependency = result.Dependency;
         var expectedDependency = new List<string> { "../../include/a.md" };
-        Assert.Equal(expectedDependency.ToImmutableList(), dependency);
+        CollectionAssert.AreEqual(expectedDependency.ToArray(), dependency.ToArray());
     }
 
-    [Fact]
-    [Trait("Related", "Inclusion")]
+    [TestMethod]
+    [TestProperty("Related", "Inclusion")]
     public void TestBlockInclude_WithYamlHeader()
     {
         var root = """
@@ -806,15 +808,16 @@ Test Include File
                        <p>body</p>
 
                        """;
-        Assert.Equal(expected.Replace("\r\n", "\n"), result.Html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), result.Html);
 
         var dependency = result.Dependency;
         var expectedDependency = new List<string> { "../../include/a.md" };
-        Assert.Equal(expectedDependency.ToImmutableList(), dependency);
+        CollectionAssert.AreEqual(expectedDependency.ToArray(), dependency.ToArray());
     }
 
-    [Fact(Skip = "failed frequently")]
-    [Trait("Related", "Inclusion")]
+    [TestMethod]
+    [Ignore("failed frequently")]
+    [TestProperty("Related", "Inclusion")]
     public void TestInclusionContext_CurrentFile_RootFile()
     {
         var root = "[!include[](embed)]";
@@ -822,36 +825,36 @@ public void TestInclusionContext_CurrentFile_RootFile()
         var context = new MarkdownContext(
             readFile: (path, _) =>
             {
-                Assert.Equal("embed", path);
+                Assert.AreEqual("embed", path);
 
-                Assert.Equal("root", InclusionContext.RootFile);
-                Assert.Equal("root", InclusionContext.File);
+                Assert.AreEqual("root", InclusionContext.RootFile);
+                Assert.AreEqual("root", InclusionContext.File);
 
                 return ("embed [content](c.md)", "embed");
             });
 
         var pipeline = new MarkdownPipelineBuilder().UseDocfxExtensions(context).Build();
 
-        Assert.Null(InclusionContext.RootFile);
-        Assert.Null(InclusionContext.File);
+        Assert.IsNull(InclusionContext.RootFile);
+        Assert.IsNull(InclusionContext.File);
 
         using (InclusionContext.PushFile("root"))
         {
-            Assert.Equal("root", InclusionContext.RootFile);
-            Assert.Equal("root", InclusionContext.File);
+            Assert.AreEqual("root", InclusionContext.RootFile);
+            Assert.AreEqual("root", InclusionContext.File);
 
             var result = Markdown.ToHtml(root, pipeline);
 
-            Assert.Equal("<p>embed <a href=\"c.md\">content</a></p>", result.Trim());
-            Assert.Equal("root", InclusionContext.RootFile);
-            Assert.Equal("root", InclusionContext.File);
+            Assert.AreEqual("<p>embed <a href=\"c.md\">content</a></p>", result.Trim());
+            Assert.AreEqual("root", InclusionContext.RootFile);
+            Assert.AreEqual("root", InclusionContext.File);
         }
-        Assert.Null(InclusionContext.RootFile);
-        Assert.Null(InclusionContext.File);
+        Assert.IsNull(InclusionContext.RootFile);
+        Assert.IsNull(InclusionContext.File);
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestComplexImageBlockSrcResolveInToken()
     {
         // -r
@@ -883,10 +886,10 @@ public void TestComplexImageBlockSrcResolveInToken()
                        </p>
 
                        """;
-        Assert.Equal(expected.Replace("\r\n", "\n"), marked.Html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), marked.Html);
     }
 
-    [Fact]
+    [TestMethod]
     public void ImageTestBlockGeneralWithInclude()
     {
         var source = "[!include[](includes/source.md)]";
@@ -932,11 +935,11 @@ public void ImageTestBlockGeneralWithInclude()
 
                        """;
 
-        Assert.Equal(expected.Replace("\r\n", "\n").Replace("\n", ""), marked.Html.Replace("\r\n", "\n").Replace("\n", ""));
+        Assert.AreEqual(expected.Replace("\r\n", "\n").Replace("\n", ""), marked.Html.Replace("\r\n", "\n").Replace("\n", ""));
     }
 
-    [Fact]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestImageWithIconTypeBlockSrcResolveInToken()
     {
         // -r
@@ -962,6 +965,6 @@ public void TestImageWithIconTypeBlockSrcResolveInToken()
                        </p>
 
                        """;
-        Assert.Equal(expected.Replace("\r\n", "\n"), marked.Html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), marked.Html);
     }
 }
diff --git a/test/Docfx.MarkdigEngine.Tests/MarkdigServiceTest.cs b/test/Docfx.MarkdigEngine.Tests/MarkdigServiceTest.cs
index fa724a9d9bd..4ea9066e74f 100644
--- a/test/Docfx.MarkdigEngine.Tests/MarkdigServiceTest.cs
+++ b/test/Docfx.MarkdigEngine.Tests/MarkdigServiceTest.cs
@@ -1,18 +1,17 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Collections.Immutable;
 using Docfx.MarkdigEngine.Extensions;
 using Markdig.Syntax;
-using Xunit;
 
 namespace Docfx.MarkdigEngine.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class MarkdigServiceTest
 {
-    [Fact]
-    [Trait("Related", "MarkdigService")]
+    [TestMethod]
+    [TestProperty("Related", "MarkdigService")]
     public void MarkdigServiceTest_ParseAndRender_Simple()
     {
         var markdown = @"# title
@@ -23,20 +22,20 @@ public void MarkdigServiceTest_ParseAndRender_Simple()
         var service = TestUtility.CreateMarkdownService();
         var document = service.Parse(markdown, "topic.md");
 
-        Assert.Equal(2, document.Count);
-        Assert.IsType<HeadingBlock>(document[0]);
-        Assert.IsType<FencedCodeBlock>(document[1]);
+        Assert.AreEqual(2, document.Count);
+        Assert.IsInstanceOfType<HeadingBlock>(document[0]);
+        Assert.IsInstanceOfType<FencedCodeBlock>(document[1]);
 
         var mr = service.Render(document);
         var expected = @"<h1 id=""title"">title</h1>
 <pre><code class=""lang-yaml"">key: value
 </code></pre>
 ";
-        Assert.Equal(expected.Replace("\r\n", "\n"), mr.Html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), mr.Html);
     }
 
-    [Fact]
-    [Trait("Related", "MarkdigService")]
+    [TestMethod]
+    [TestProperty("Related", "MarkdigService")]
     public void MarkdigServiceTest_ParseAndRender_Inclusion()
     {
         // -x
@@ -51,19 +50,19 @@ public void MarkdigServiceTest_ParseAndRender_Inclusion()
         var service = TestUtility.CreateMarkdownService();
         var document = service.Parse(root, "x/root.md");
 
-        Assert.Single(document);
-        Assert.IsType<InclusionBlock>(document[0]);
+        Assert.ContainsSingle(document);
+        Assert.IsInstanceOfType<InclusionBlock>(document[0]);
 
         var mr = service.Render(document);
         var expected = "<p>Paragraph1</p>" + "\n";
-        Assert.Equal(expected, mr.Html);
+        Assert.AreEqual(expected, mr.Html);
 
         var expectedDependency = new List<string> { "b/linkAndRefRoot.md" };
-        Assert.Equal(expectedDependency.ToImmutableList(), mr.Dependency);
+        CollectionAssert.AreEqual(expectedDependency.ToArray(), mr.Dependency.ToArray());
     }
 
-    [Fact]
-    [Trait("Related", "MarkdigService")]
+    [TestMethod]
+    [TestProperty("Related", "MarkdigService")]
     public void MarkdigServiceTest_ParseInline()
     {
         var content = "# I am a heading";
@@ -71,8 +70,8 @@ public void MarkdigServiceTest_ParseInline()
         var document = service.Parse(content, "topic.md", true);
         var result = service.Render(document, true).Html;
 
-        Assert.Single(document);
-        Assert.IsType<ParagraphBlock>(document[0]);
-        Assert.Equal(content, result);
+        Assert.ContainsSingle(document);
+        Assert.IsInstanceOfType<ParagraphBlock>(document[0]);
+        Assert.AreEqual(content, result);
     }
 }
diff --git a/test/Docfx.MarkdigEngine.Tests/TestUtility/TestUtility.cs b/test/Docfx.MarkdigEngine.Tests/TestUtility/TestUtility.cs
index 3d217a6b369..43102d6e92e 100644
--- a/test/Docfx.MarkdigEngine.Tests/TestUtility/TestUtility.cs
+++ b/test/Docfx.MarkdigEngine.Tests/TestUtility/TestUtility.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Docfx.Plugins;
-using Xunit;
 
 namespace Docfx.MarkdigEngine.Tests;
 
@@ -11,13 +10,13 @@ public static class TestUtility
     public static void AssertEqual(string expected, string actual, Func<string, MarkupResult> markup)
     {
         var result = markup(actual);
-        Assert.Equal(expected.Replace("\r\n", "\n"), result.Html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), result.Html);
     }
 
     public static void AssertEqual(string expected, string actual, Func<string, string, MarkupResult> markup)
     {
         var result = markup(actual, null);
-        Assert.Equal(expected.Replace("\r\n", "\n"), result.Html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), result.Html);
     }
 
     public static MarkupResult Markup(string content, string filePath = null)
diff --git a/test/Docfx.MarkdigEngine.Tests/YamlHeaderTest.cs b/test/Docfx.MarkdigEngine.Tests/YamlHeaderTest.cs
index 4077b5fdccb..d86df52db30 100644
--- a/test/Docfx.MarkdigEngine.Tests/YamlHeaderTest.cs
+++ b/test/Docfx.MarkdigEngine.Tests/YamlHeaderTest.cs
@@ -2,10 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Docfx.Plugins;
-using Xunit;
 
 namespace Docfx.MarkdigEngine.Tests;
 
+[TestClass]
 public class YamlHeaderTest
 {
     private static MarkupResult SimpleMarkup(string source)
@@ -18,8 +18,9 @@ private static MarkupResult SimpleMarkup(string source)
         return service.Markup(source, "Topic.md");
     }
 
-    [Fact(Skip = "Invalid YamlHeader")]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [Ignore("Invalid YamlHeader")]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfm_InvalidYamlHeader_YamlUtilityThrowException()
     {
         var source = @"---
@@ -35,11 +36,12 @@ public void TestDfm_InvalidYamlHeader_YamlUtilityThrowException()
 <hr />
 ";
         var marked = SimpleMarkup(source);
-        Assert.Equal(expected.Replace("\r\n", "\n"), marked.Html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), marked.Html);
     }
 
-    [Fact(Skip = "Invalid YamlHeader")]
-    [Trait("Related", "DfmMarkdown")]
+    [TestMethod]
+    [Ignore("Invalid YamlHeader")]
+    [TestProperty("Related", "DfmMarkdown")]
     public void TestDfmYamlHeader_YamlUtilityReturnNull()
     {
         var source = @"---
@@ -52,10 +54,10 @@ public void TestDfmYamlHeader_YamlUtilityReturnNull()
 <hr />
 ";
         var marked = SimpleMarkup(source);
-        Assert.Equal(expected.Replace("\r\n", "\n"), marked.Html);
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), marked.Html);
     }
 
-    [Fact]
+    [TestMethod]
     public void TestDfmYamlHeader_General()
     {
         //arrange
@@ -113,6 +115,6 @@ public void TestDfmYamlHeader_General()
 translationtype: Human Translation
 ms.sourcegitcommit: 5c6fbfc8699d7d66c40b0458972d8b6ef0dcc705
 ms.openlocfilehash: 2ea129ac94cb1ddc7486ba69280dc0390896e088</yamlheader>";
-        Assert.Equal(expected.Replace("\r\n", "\n"), marked.Html.Replace("\r\n", "\n"));
+        Assert.AreEqual(expected.Replace("\r\n", "\n"), marked.Html.Replace("\r\n", "\n"));
     }
 }
diff --git a/test/Docfx.Tests.Common/TestBase.cs b/test/Docfx.Tests.Common/TestBase.cs
index 750958e7297..bafd6e2adcd 100644
--- a/test/Docfx.Tests.Common/TestBase.cs
+++ b/test/Docfx.Tests.Common/TestBase.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Text.Json;
-using Xunit;
 
 namespace Docfx.Tests.Common;
 
@@ -95,7 +94,7 @@ public static void AssertJsonEquivalent(string expected, string actual)
 
     public static void AssertJsonEquivalent(JsonElement expected, JsonElement actual)
     {
-        Assert.Equal(expected.ValueKind, actual.ValueKind);
+        Assert.AreEqual(expected.ValueKind, actual.ValueKind);
 
         switch (expected.ValueKind)
         {
@@ -110,7 +109,7 @@ public static void AssertJsonEquivalent(JsonElement expected, JsonElement actual
                 break;
 
             default:
-                Assert.Equal(expected.GetRawText(), actual.GetRawText());
+                Assert.AreEqual(expected.GetRawText(), actual.GetRawText());
                 break;
         }
     }
diff --git a/test/docfx.Snapshot.Tests/PercyTest.cs b/test/docfx.Snapshot.Tests/PercyTest.cs
index 9528ebe1ed6..41863e41f28 100644
--- a/test/docfx.Snapshot.Tests/PercyTest.cs
+++ b/test/docfx.Snapshot.Tests/PercyTest.cs
@@ -10,15 +10,23 @@
 
 namespace Docfx.Tests;
 
-[Trait("Stage", "Percy")]
+[TestProperty("Stage", "Percy")]
+[TestClass]
 public class PercyTest
 {
-    private class PercyFactAttribute : FactAttribute
+    private class PercyConditionAttribute : ConditionBaseAttribute
     {
-        public PercyFactAttribute()
+        public PercyConditionAttribute()
+            : base(ConditionMode.Include)
         {
-            Skip = IsActiveLocalTcpPort(5338) ? null : "Run percy tests with `percy exec`";
+            IgnoreMessage = IsActiveLocalTcpPort(5338) ? null : "Run percy tests with `percy exec`";
         }
+
+        public override string IgnoreMessage { get; }
+
+        public override string GroupName => nameof(PercyConditionAttribute);
+
+        public override bool ShouldRun => IgnoreMessage is null;
     }
 
     private static readonly string s_samplesDir = Path.GetFullPath("../../../../../samples");
@@ -42,7 +50,8 @@ static PercyTest()
         Microsoft.Playwright.Program.Main(["install", "chromium", "--only-shell"]);
     }
 
-    [PercyFact]
+    [PercyCondition]
+    [TestMethod]
     public async Task SeedHtml()
     {
         var samplePath = $"{s_samplesDir}/seed";
@@ -52,8 +61,8 @@ public async Task SeedHtml()
         await process.WaitForExitAsync();
 
         var docfxPath = Path.GetFullPath(OperatingSystem.IsWindows() ? "docfx.exe" : "docfx");
-        Assert.Equal(0, Exec(docfxPath, $"metadata {samplePath}/docfx.json"));
-        Assert.Equal(0, Exec(docfxPath, $"build {samplePath}/docfx.json"));
+        Assert.AreEqual(0, Exec(docfxPath, $"metadata {samplePath}/docfx.json"));
+        Assert.AreEqual(0, Exec(docfxPath, $"build {samplePath}/docfx.json"));
 
         const int port = 8089;
         var _ = Task.Run(() => Program.Main(["serve", "--port", $"{port}", $"{samplePath}/_site"]))
diff --git a/test/docfx.Snapshot.Tests/SamplesTest.Seed/articles/csharp_coding_standards.html.view.verified.json b/test/docfx.Snapshot.Tests/SamplesTest.Seed/articles/csharp_coding_standards.html.view.verified.json
index 5180aef7c93..8d2de60f121 100644
--- a/test/docfx.Snapshot.Tests/SamplesTest.Seed/articles/csharp_coding_standards.html.view.verified.json
+++ b/test/docfx.Snapshot.Tests/SamplesTest.Seed/articles/csharp_coding_standards.html.view.verified.json
@@ -1,5 +1,5 @@
 {
-  "conceptual": "\n<h2 id=\"introduction\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"5\">Introduction</h2>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"6\">The coding standard will be used in conjunction with customized version of <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"6\">StyleCop</em> and <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"6\">FxCop</em> [<strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"6\">TODO</strong>] during both development and build process. This will help ensure that the standard is followed by all developers on the team in a consistent manner.</p>\n<blockquote sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"8\">\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"8\">&quot;Any fool can write code that a computer can understand. Good programmers write code that humans understand&quot;.</p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"10\">Martin Fowler. <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"10\">Refactoring: Improving the design of existing code.</em></p>\n</blockquote>\n<h3 id=\"purpose\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"12\">Purpose</h3>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"14\">The aim of this section is to define a set of C# coding standards to be used by CAPS build team to guarantee maximum legibility, reliability, re-usability and homogeneity of our code. Each section is marked <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"14\">Mandatory</em> or <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"14\">Recommended</em>. <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"14\">Mandatory</em> sections, will be enforced during code reviews as well as tools like <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"14\">StyleCop</em> and <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"14\">FxCop</em>, and code will not be considered complete until it is compliant.</p>\n<h3 id=\"scope\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"16\">Scope</h3>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"18\">This section contains general C# coding standards which can be applied to any type of application developed in C#, based on <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"18\"><a href=\"http://msdn.microsoft.com/en-us/library/ms229042.aspx\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"18\">Framework Design Guidelines</a></em>.</p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"20\">It does not pretend to be a tutorial on C#. It only includes a set of limitations and recommendations focused on clarifying the development.</p>\n<h2 id=\"tools\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"23\">Tools</h2>\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"25\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"25\"><a href=\"http://www.jetbrains.com/resharper/\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"25\">Resharper</a> is a great 3rd party code cleanup and style tool.</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"26\"><a href=\"http://stylecop.codeplex.com/\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"26\">StyleCop</a> analyzes C# srouce code to enforce a set of style and consistency rules and has been integrated into many 3rd party development tools such as Resharper.</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"27\"><a href=\"http://codebox/SDLFxCop\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"27\">FxCop</a> is an application that analyzes managed code assemblies (code that targets the .NET Framework common language runtime) and reports information about the assemblies, such as possible design, localization, performance, and security improvements.</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"28\"><a href=\"http://toolbox/22561\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"28\">C# Stylizer</a> does many of the style rules automatically</li>\n</ul>\n<h2 id=\"highlights-of-coding-standards\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"31\">Highlights of Coding Standards</h2>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"33\">This section is not intended to give a summary of all the coding standards that enabled by our customized StyleCop, but to give a highlight of some rules one will possibly meet in daily coding life. It also provides some recommended however not mandatory(which means not enabled in StyleCop) coding standards.</p>\n<h3 id=\"file-layout-recommended\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"35\">File Layout (Recommended)</h3>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"36\">Only one public class is allowed per file.</p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"38\">The file name is derived from the class name.</p>\n<pre><code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"40\">\tClass   : Observer\n\tFilename: Observer.cs\n</code></pre>\n<h3 id=\"class-definition-order-mandatory\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"43\">Class Definition Order (Mandatory)</h3>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"45\">The class definition contains class members in the following order, from <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"45\">less</em> restricted scope (public) to <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"45\">more</em> restrictive (private):</p>\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"47\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"47\">Nested types, e.g. classes, enum, struct, etc.</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"48\">Field members, e.g. member variables, const, etc.</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"49\">Member functions\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"50\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"50\">Constructors</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"51\">Finalizer (Do not use unless absolutely necessary)</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"52\">Methods (Properties, Events, Operations, Overridables, Static)</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"53\">Private nested types</li>\n</ul>\n</li>\n</ul>\n<h3 id=\"naming-mandatory\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"55\">Naming (Mandatory)</h3>\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"56\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"56\"><p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"56\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"56\">DO</strong> use PascalCasing for all public member, type, and namespace names consisting of multiple words.</p>\n<pre><code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"58\">  PropertyDescriptor\n  HtmlTag\n  IOStream\n</code></pre>\n</li>\n</ul>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"61\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"61\">NOTE</strong>: A special case is made for two-letter acronyms in which both letters are capitalized, e.g. <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"61\">IOStream</em></p>\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"62\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"62\"><p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"62\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"62\">DO</strong> use camelCasing for parameter names.</p>\n<pre><code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"64\">  propertyDescriptor\n  htmlTag\n  ioStream\n</code></pre>\n</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"68\"><p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"68\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"68\">DO</strong> start with underscore for private fields</p>\n<pre><code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"70\">  private readonly Guid _userId = Guid.NewGuid();\n</code></pre>\n</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"72\"><p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"72\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"72\">DO</strong> start static readonly fields, constants with capitalized case</p>\n<pre><code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"74\">  private static readonly IEntityAccessor EntityAccessor = null;\n  private const string MetadataName = &quot;MetadataName&quot;;\n</code></pre>\n</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"77\"><p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"77\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"77\">DO NOT</strong> capitalize each word in so-called <a href=\"http://msdn.microsoft.com/en-us/library/ms229043.aspx\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"77\">closed-form compound words</a>.</p>\n</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"79\"><p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"79\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"79\">DO</strong> have <strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"79\">&quot;Async&quot;</strong> explicitly in the Async method name to notice people how to use it properly</p>\n</li>\n</ul>\n<h3 id=\"formatting-mandatory\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"81\">Formatting (Mandatory)</h3>\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"82\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"82\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"82\">DO</strong> use spaces over tabs, and always show all spaces/tabs in IDE</li>\n</ul>\n<blockquote sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"84\">\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"84\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"84\">Tips</strong></p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"86\">Visual Studio &gt; TOOLS &gt; Options &gt; Text Editor &gt; C# &gt; Tabs &gt; Insert spaces (Tab size: 4)</p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"88\">Visual Studio &gt; Edit &gt; Advanced &gt; View White Space</p>\n</blockquote>\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"90\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"90\"><p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"90\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"90\">DO</strong> add <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"90\">using</em> inside <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"90\">namespace</em> declaration</p>\n<pre><code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"92\">  namespace Microsoft.Content.Build.BuildWorker.UnitTest\n  {\n  \tusing System;\n  }\n</code></pre>\n</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"97\"><p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"97\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"97\">DO</strong> add a space when:</p>\n<ol sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"98\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"98\"><code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"98\">for (var i = 0; i &lt; 1; i++)</code></li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"99\"><code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"99\">if (a == b)</code></li>\n</ol>\n</li>\n</ul>\n<h3 id=\"cross-platform-coding\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"101\">Cross-platform coding</h3>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"102\">Our code should supports multiple operating systems. Don't assume we only run (and develop) on Windows. Code should be sensitvie to the differences between OS's. Here are some specifics to consider.</p>\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"104\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"104\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"104\">DO</strong> use <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"104\">Enviroment.NewLine</code> instead of hard-coding the line break instead of <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"104\">\\r\\n</code>, as Windows uses <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"104\">\\r\\n</code> and OSX/Linux uses <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"104\">\\n</code>.</li>\n</ul>\n<blockquote sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"106\">\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"106\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"106\">Note</strong></p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"108\">Be aware that thes line-endings may cause problems in code when using <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"108\">@&quot;&quot;</code> text blocks with line breaks.</p>\n</blockquote>\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"110\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"110\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"110\">DO</strong> Use <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"110\">Path.Combine()</code> or <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"110\">Path.DirectorySeparatorChar</code> to separate directories. If this is not possible (such as in scripting), use a forward slash <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"110\">/</code>. Windows is more forgiving than Linux in this regard.</li>\n</ul>\n<h3 id=\"unit-tests-and-functional-tests\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"112\">Unit tests and functional tests</h3>\n<h4 id=\"assembly-naming\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"113\">Assembly naming</h4>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"114\">The unit tests for the <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"114\">Microsoft.Foo</code> assembly live in the <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"114\">Microsoft.Foo.Tests</code> assembly.</p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"116\">The functional tests for the <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"116\">Microsoft.Foo</code> assmebly live in the <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"116\">Microsoft.Foo.FunctionalTests</code> assmebly.</p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"118\">In general there should be exactly one unit test assebmly for each product runtime assembly. In general there should be one functional test assembly per repo. Exceptions can be made for both.</p>\n<h4 id=\"unit-test-class-naming\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"120\">Unit test class naming</h4>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"121\">Test class names end with <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"121\">Test</code> and live in the same namespace as the class being tested. For example, the unit tests for the <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"121\">Microsoft.Foo.Boo</code> class would be in a <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"121\">Microsoft.Foo.Boo</code> class in the test assembly.</p>\n<h4 id=\"unit-test-method-naming\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"123\">Unit test method naming</h4>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"124\">Unit test method names must be descriptive about <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"124\">what is being tested, under what conditions, and what the expectations are</em>. Pascal casing and underscores can be used to improve readability. The following test names are correct:</p>\n<pre><code class=\"lang-cs\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"126\">PublicApiArgumentsShouldHaveNotNullAnnotation\nPublic_api_arguments_should_have_not_null_annotation\n</code></pre>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"131\">The following test names are incorrect:</p>\n<pre><code class=\"lang-cs\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"133\">Test1\nConstructor\nFormatString\nGetData\n</code></pre>\n<h4 id=\"unit-test-structure\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"140\">Unit test structure</h4>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"141\">The contents of every unit test should be split into three distinct stages, optionally separated by these comments:</p>\n<pre><code class=\"lang-cs\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"143\">// Arrange\n// Act\n// Assert\n</code></pre>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"149\">The crucial thing here is the <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"149\">Act</code> stage is exactly one statement. That one statement is nothing more than a call to the one method that you are trying to test. keeping that one statement as simple as possible is also very important. For example, this is not ideal:</p>\n<pre><code class=\"lang-cs\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"151\">int result = myObj.CallSomeMethod(GetComplexParam1(), GetComplexParam2(), GetComplexParam3());\n</code></pre>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"155\">This style is not recomended because way too many things can go wrong in this one statement. All the <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"155\">GetComplexParamN()</code> calls can throw for a variety of reasons unrelated to the test itself. It is thus unclear to someone running into a problem why the failure occured.</p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"157\">The ideal pattern is to move the complex parameter building into the `Arrange section:</p>\n<pre><code class=\"lang-cs\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"159\">// Arrange\nP1 p1 = GetComplexParam1();\nP2 p2 = GetComplexParam2();\nP3 p3 = GetComplexParam3();\n\n// Act\nint result = myObj.CallSomeMethod(p1, p2, p3);\n\n// Assert\nAssert.AreEqual(1234, result);\n</code></pre>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"172\">Now the only reason the line with <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"172\">CallSomeMethod()</code> can fail is if the method itself blew up.</p>\n<h4 id=\"testing-exception-messages\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"174\">Testing exception messages</h4>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"176\">In general testing the specific exception message in a unit test is important. This ensures that the exact desired exception is what is being tested rather than a different exception of the same type. In order to verify the exact exception it is important to verify the message.</p>\n<pre><code class=\"lang-cs\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"178\">var ex = Assert.Throws&lt;InvalidOperationException&gt;(\n    () =&gt; fruitBasket.GetBananaById(1234));\nAssert.Equal(\n    &quot;1234&quot;,\n    ex.Message);\n</code></pre>\n<h4 id=\"use-xunitnets-plethora-of-built-in-assertions\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"186\">Use xUnit.net's plethora of built-in assertions</h4>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"187\">xUnit.net includes many kinds of assertions – please use the most appropriate one for your test. This will make the tests a lot more readable and also allow the test runner report the best possible errors (whether it's local or the CI machine). For example, these are bad:</p>\n<pre><code class=\"lang-cs\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"189\">Assert.Equal(true, someBool);\n\nAssert.True(&quot;abc123&quot; == someString);\n\nAssert.True(list1.Length == list2.Length);\n\nfor (int i = 0; i &lt; list1.Length; i++) {\n    Assert.True(\n        String.Equals\n            list1[i],\n            list2[i],\n            StringComparison.OrdinalIgnoreCase));\n}\n</code></pre>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"205\">These are good:</p>\n<pre><code class=\"lang-cs\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"207\">Assert.True(someBool);\n\nAssert.Equal(&quot;abc123&quot;, someString);\n\n// built-in collection assertions!\nAssert.Equal(list1, list2, StringComparer.OrdinalIgnoreCase);\n</code></pre>\n<h4 id=\"parallel-tests\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"216\">Parallel tests</h4>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"217\">By default all unit test assemblies should run in parallel mode, which is the default. Unit tests shouldn't depend on any shared state, and so should generally be runnable in parallel. If the tests fail in parallel, the first thing to do is to figure out why; do not just disable parallel tests!</p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"219\">For functional tests it is reasonable to disable parallel tests.</p>\n",
+  "conceptual": "\n<h2 id=\"introduction\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"5\">Introduction</h2>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"6\">The coding standard will be used in conjunction with customized version of <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"6\">StyleCop</em> and <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"6\">FxCop</em> [<strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"6\">TODO</strong>] during both development and build process. This will help ensure that the standard is followed by all developers on the team in a consistent manner.</p>\n<blockquote sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"8\">\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"8\">&quot;Any fool can write code that a computer can understand. Good programmers write code that humans understand&quot;.</p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"10\">Martin Fowler. <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"10\">Refactoring: Improving the design of existing code.</em></p>\n</blockquote>\n<h3 id=\"purpose\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"12\">Purpose</h3>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"14\">The aim of this section is to define a set of C# coding standards to be used by CAPS build team to guarantee maximum legibility, reliability, re-usability and homogeneity of our code. Each section is marked <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"14\">Mandatory</em> or <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"14\">Recommended</em>. <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"14\">Mandatory</em> sections, will be enforced during code reviews as well as tools like <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"14\">StyleCop</em> and <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"14\">FxCop</em>, and code will not be considered complete until it is compliant.</p>\n<h3 id=\"scope\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"16\">Scope</h3>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"18\">This section contains general C# coding standards which can be applied to any type of application developed in C#, based on <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"18\"><a href=\"http://msdn.microsoft.com/en-us/library/ms229042.aspx\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"18\">Framework Design Guidelines</a></em>.</p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"20\">It does not pretend to be a tutorial on C#. It only includes a set of limitations and recommendations focused on clarifying the development.</p>\n<h2 id=\"tools\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"23\">Tools</h2>\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"25\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"25\"><a href=\"http://www.jetbrains.com/resharper/\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"25\">Resharper</a> is a great 3rd party code cleanup and style tool.</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"26\"><a href=\"http://stylecop.codeplex.com/\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"26\">StyleCop</a> analyzes C# srouce code to enforce a set of style and consistency rules and has been integrated into many 3rd party development tools such as Resharper.</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"27\"><a href=\"http://codebox/SDLFxCop\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"27\">FxCop</a> is an application that analyzes managed code assemblies (code that targets the .NET Framework common language runtime) and reports information about the assemblies, such as possible design, localization, performance, and security improvements.</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"28\"><a href=\"http://toolbox/22561\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"28\">C# Stylizer</a> does many of the style rules automatically</li>\n</ul>\n<h2 id=\"highlights-of-coding-standards\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"31\">Highlights of Coding Standards</h2>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"33\">This section is not intended to give a summary of all the coding standards that enabled by our customized StyleCop, but to give a highlight of some rules one will possibly meet in daily coding life. It also provides some recommended however not mandatory(which means not enabled in StyleCop) coding standards.</p>\n<h3 id=\"file-layout-recommended\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"35\">File Layout (Recommended)</h3>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"36\">Only one public class is allowed per file.</p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"38\">The file name is derived from the class name.</p>\n<pre><code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"40\">\tClass   : Observer\n\tFilename: Observer.cs\n</code></pre>\n<h3 id=\"class-definition-order-mandatory\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"43\">Class Definition Order (Mandatory)</h3>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"45\">The class definition contains class members in the following order, from <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"45\">less</em> restricted scope (public) to <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"45\">more</em> restrictive (private):</p>\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"47\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"47\">Nested types, e.g. classes, enum, struct, etc.</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"48\">Field members, e.g. member variables, const, etc.</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"49\">Member functions\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"50\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"50\">Constructors</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"51\">Finalizer (Do not use unless absolutely necessary)</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"52\">Methods (Properties, Events, Operations, Overridables, Static)</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"53\">Private nested types</li>\n</ul>\n</li>\n</ul>\n<h3 id=\"naming-mandatory\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"55\">Naming (Mandatory)</h3>\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"56\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"56\"><p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"56\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"56\">DO</strong> use PascalCasing for all public member, type, and namespace names consisting of multiple words.</p>\n<pre><code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"58\">  PropertyDescriptor\n  HtmlTag\n  IOStream\n</code></pre>\n</li>\n</ul>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"61\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"61\">NOTE</strong>: A special case is made for two-letter acronyms in which both letters are capitalized, e.g. <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"61\">IOStream</em></p>\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"62\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"62\"><p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"62\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"62\">DO</strong> use camelCasing for parameter names.</p>\n<pre><code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"64\">  propertyDescriptor\n  htmlTag\n  ioStream\n</code></pre>\n</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"68\"><p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"68\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"68\">DO</strong> start with underscore for private fields</p>\n<pre><code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"70\">  private readonly Guid _userId = Guid.NewGuid();\n</code></pre>\n</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"72\"><p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"72\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"72\">DO</strong> start static readonly fields, constants with capitalized case</p>\n<pre><code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"74\">  private static readonly IEntityAccessor EntityAccessor = null;\n  private const string MetadataName = &quot;MetadataName&quot;;\n</code></pre>\n</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"77\"><p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"77\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"77\">DO NOT</strong> capitalize each word in so-called <a href=\"http://msdn.microsoft.com/en-us/library/ms229043.aspx\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"77\">closed-form compound words</a>.</p>\n</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"79\"><p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"79\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"79\">DO</strong> have <strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"79\">&quot;Async&quot;</strong> explicitly in the Async method name to notice people how to use it properly</p>\n</li>\n</ul>\n<h3 id=\"formatting-mandatory\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"81\">Formatting (Mandatory)</h3>\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"82\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"82\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"82\">DO</strong> use spaces over tabs, and always show all spaces/tabs in IDE</li>\n</ul>\n<blockquote sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"84\">\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"84\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"84\">Tips</strong></p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"86\">Visual Studio &gt; TOOLS &gt; Options &gt; Text Editor &gt; C# &gt; Tabs &gt; Insert spaces (Tab size: 4)</p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"88\">Visual Studio &gt; Edit &gt; Advanced &gt; View White Space</p>\n</blockquote>\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"90\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"90\"><p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"90\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"90\">DO</strong> add <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"90\">using</em> inside <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"90\">namespace</em> declaration</p>\n<pre><code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"92\">  namespace Microsoft.Content.Build.BuildWorker.UnitTest\n  {\n  \tusing System;\n  }\n</code></pre>\n</li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"97\"><p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"97\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"97\">DO</strong> add a space when:</p>\n<ol sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"98\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"98\"><code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"98\">for (var i = 0; i &lt; 1; i++)</code></li>\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"99\"><code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"99\">if (a == b)</code></li>\n</ol>\n</li>\n</ul>\n<h3 id=\"cross-platform-coding\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"101\">Cross-platform coding</h3>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"102\">Our code should supports multiple operating systems. Don't assume we only run (and develop) on Windows. Code should be sensitvie to the differences between OS's. Here are some specifics to consider.</p>\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"104\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"104\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"104\">DO</strong> use <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"104\">Enviroment.NewLine</code> instead of hard-coding the line break instead of <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"104\">\\r\\n</code>, as Windows uses <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"104\">\\r\\n</code> and OSX/Linux uses <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"104\">\\n</code>.</li>\n</ul>\n<blockquote sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"106\">\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"106\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"106\">Note</strong></p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"108\">Be aware that thes line-endings may cause problems in code when using <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"108\">@&quot;&quot;</code> text blocks with line breaks.</p>\n</blockquote>\n<ul sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"110\">\n<li sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"110\"><strong sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"110\">DO</strong> Use <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"110\">Path.Combine()</code> or <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"110\">Path.DirectorySeparatorChar</code> to separate directories. If this is not possible (such as in scripting), use a forward slash <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"110\">/</code>. Windows is more forgiving than Linux in this regard.</li>\n</ul>\n<h3 id=\"unit-tests-and-functional-tests\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"112\">Unit tests and functional tests</h3>\n<h4 id=\"assembly-naming\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"113\">Assembly naming</h4>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"114\">The unit tests for the <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"114\">Microsoft.Foo</code> assembly live in the <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"114\">Microsoft.Foo.Tests</code> assembly.</p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"116\">The functional tests for the <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"116\">Microsoft.Foo</code> assmebly live in the <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"116\">Microsoft.Foo.FunctionalTests</code> assmebly.</p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"118\">In general there should be exactly one unit test assebmly for each product runtime assembly. In general there should be one functional test assembly per repo. Exceptions can be made for both.</p>\n<h4 id=\"unit-test-class-naming\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"120\">Unit test class naming</h4>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"121\">Test class names end with <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"121\">Test</code> and live in the same namespace as the class being tested. For example, the unit tests for the <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"121\">Microsoft.Foo.Boo</code> class would be in a <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"121\">Microsoft.Foo.Boo</code> class in the test assembly.</p>\n<h4 id=\"unit-test-method-naming\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"123\">Unit test method naming</h4>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"124\">Unit test method names must be descriptive about <em sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"124\">what is being tested, under what conditions, and what the expectations are</em>. Pascal casing and underscores can be used to improve readability. The following test names are correct:</p>\n<pre><code class=\"lang-cs\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"126\">PublicApiArgumentsShouldHaveNotNullAnnotation\nPublic_api_arguments_should_have_not_null_annotation\n</code></pre>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"131\">The following test names are incorrect:</p>\n<pre><code class=\"lang-cs\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"133\">Test1\nConstructor\nFormatString\nGetData\n</code></pre>\n<h4 id=\"unit-test-structure\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"140\">Unit test structure</h4>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"141\">The contents of every unit test should be split into three distinct stages, optionally separated by these comments:</p>\n<pre><code class=\"lang-cs\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"143\">// Arrange\n// Act\n// Assert\n</code></pre>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"149\">The crucial thing here is the <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"149\">Act</code> stage is exactly one statement. That one statement is nothing more than a call to the one method that you are trying to test. keeping that one statement as simple as possible is also very important. For example, this is not ideal:</p>\n<pre><code class=\"lang-cs\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"151\">int result = myObj.CallSomeMethod(GetComplexParam1(), GetComplexParam2(), GetComplexParam3());\n</code></pre>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"155\">This style is not recomended because way too many things can go wrong in this one statement. All the <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"155\">GetComplexParamN()</code> calls can throw for a variety of reasons unrelated to the test itself. It is thus unclear to someone running into a problem why the failure occured.</p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"157\">The ideal pattern is to move the complex parameter building into the `Arrange section:</p>\n<pre><code class=\"lang-cs\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"159\">// Arrange\nP1 p1 = GetComplexParam1();\nP2 p2 = GetComplexParam2();\nP3 p3 = GetComplexParam3();\n\n// Act\nint result = myObj.CallSomeMethod(p1, p2, p3);\n\n// Assert\nAssert.AreEqual(1234, result);\n</code></pre>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"172\">Now the only reason the line with <code sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"172\">CallSomeMethod()</code> can fail is if the method itself blew up.</p>\n<h4 id=\"testing-exception-messages\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"174\">Testing exception messages</h4>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"176\">In general testing the specific exception message in a unit test is important. This ensures that the exact desired exception is what is being tested rather than a different exception of the same type. In order to verify the exact exception it is important to verify the message.</p>\n<pre><code class=\"lang-cs\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"178\">var ex = Assert.Throws&lt;InvalidOperationException&gt;(\n    () =&gt; fruitBasket.GetBananaById(1234));\nAssert.AreEqual(\n    &quot;1234&quot;,\n    ex.Message);\n</code></pre>\n<h4 id=\"use-xunitnets-plethora-of-built-in-assertions\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"186\">Use xUnit.net's plethora of built-in assertions</h4>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"187\">xUnit.net includes many kinds of assertions – please use the most appropriate one for your test. This will make the tests a lot more readable and also allow the test runner report the best possible errors (whether it's local or the CI machine). For example, these are bad:</p>\n<pre><code class=\"lang-cs\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"189\">Assert.AreEqual(true, someBool);\n\nAssert.IsTrue(&quot;abc123&quot; == someString);\n\nAssert.IsTrue(list1.Length == list2.Length);\n\nfor (int i = 0; i &lt; list1.Length; i++) {\n    Assert.IsTrue(\n        String.Equals\n            list1[i],\n            list2[i],\n            StringComparison.OrdinalIgnoreCase));\n}\n</code></pre>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"205\">These are good:</p>\n<pre><code class=\"lang-cs\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"207\">Assert.IsTrue(someBool);\n\nAssert.AreEqual(&quot;abc123&quot;, someString);\n\n// built-in collection assertions!\nAssert.AreEqual(list1, list2, StringComparer.OrdinalIgnoreCase);\n</code></pre>\n<h4 id=\"parallel-tests\" sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"216\">Parallel tests</h4>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"217\">By default all unit test assemblies should run in parallel mode, which is the default. Unit tests shouldn't depend on any shared state, and so should generally be runnable in parallel. If the tests fail in parallel, the first thing to do is to figure out why; do not just disable parallel tests!</p>\n<p sourcefile=\"articles/csharp_coding_standards.md\" sourcestartlinenumber=\"219\">For functional tests it is reasonable to disable parallel tests.</p>\n",
   "type": "Conceptual",
   "source": {
     "remote": {
diff --git a/test/docfx.Snapshot.Tests/SamplesTest.Seed/articles/seed.pdf.verified.json b/test/docfx.Snapshot.Tests/SamplesTest.Seed/articles/seed.pdf.verified.json
index 6eeb7b4254d..1810f9b9e2f 100644
--- a/test/docfx.Snapshot.Tests/SamplesTest.Seed/articles/seed.pdf.verified.json
+++ b/test/docfx.Snapshot.Tests/SamplesTest.Seed/articles/seed.pdf.verified.json
@@ -177,7 +177,7 @@
     },
     {
       "Number": 13,
-      "Text": "13 / 19\nthe same type. In order to verify the exact exception it is important to verify the message.\nUse xUnit.net's plethora of built-in assertions\nxUnit.net includes many kinds of assertions – please use the most appropriate one for your\ntest. This will make the tests a lot more readable and also allow the test runner report the\nbest possible errors (whether it's local or the CI machine). For example, these are bad:\nThese are good:\nParallel tests\nBy default all unit test assemblies should run in parallel mode, which is the default. Unit\ntests shouldn't depend on any shared state, and so should generally be runnable in\nparallel. If the tests fail in parallel, the first thing to do is to figure out why; do not just\ndisable parallel tests!\nvar ex = Assert.Throws<InvalidOperationException>(\n() => fruitBasket.GetBananaById(1234));\nAssert.Equal(\n\"1234\",\nex.Message);\nAssert.Equal(true, someBool);\nAssert.True(\"abc123\" == someString);\nAssert.True(list1.Length == list2.Length);\nfor (int i = 0; i < list1.Length; i++) {\nAssert.True(\nString.Equals\nlist1[i],\nlist2[i],\nStringComparison.OrdinalIgnoreCase));\n}\nAssert.True(someBool);\nAssert.Equal(\"abc123\", someString);\n// built-in collection assertions!\nAssert.Equal(list1, list2, StringComparer.OrdinalIgnoreCase);",
+      "Text": "13 / 19\nthe same type. In order to verify the exact exception it is important to verify the message.\nUse xUnit.net's plethora of built-in assertions\nxUnit.net includes many kinds of assertions – please use the most appropriate one for your\ntest. This will make the tests a lot more readable and also allow the test runner report the\nbest possible errors (whether it's local or the CI machine). For example, these are bad:\nThese are good:\nParallel tests\nBy default all unit test assemblies should run in parallel mode, which is the default. Unit\ntests shouldn't depend on any shared state, and so should generally be runnable in\nparallel. If the tests fail in parallel, the first thing to do is to figure out why; do not just\ndisable parallel tests!\nvar ex = Assert.Throws<InvalidOperationException>(\n() => fruitBasket.GetBananaById(1234));\nAssert.AreEqual(\n\"1234\",\nex.Message);\nAssert.AreEqual(true, someBool);\nAssert.IsTrue(\"abc123\" == someString);\nAssert.IsTrue(list1.Length == list2.Length);\nfor (int i = 0; i < list1.Length; i++) {\nAssert.IsTrue(\nString.Equals\nlist1[i],\nlist2[i],\nStringComparison.OrdinalIgnoreCase));\n}\nAssert.IsTrue(someBool);\nAssert.AreEqual(\"abc123\", someString);\n// built-in collection assertions!\nAssert.AreEqual(list1, list2, StringComparer.OrdinalIgnoreCase);",
       "Links": []
     },
     {
diff --git a/test/docfx.Snapshot.Tests/SamplesTest.Seed/index.verified.json b/test/docfx.Snapshot.Tests/SamplesTest.Seed/index.verified.json
index 019606d0795..ed8b829f1eb 100644
--- a/test/docfx.Snapshot.Tests/SamplesTest.Seed/index.verified.json
+++ b/test/docfx.Snapshot.Tests/SamplesTest.Seed/index.verified.json
@@ -582,7 +582,7 @@
   "articles/csharp_coding_standards.html": {
     "href": "articles/csharp_coding_standards.html",
     "title": "C# Coding Standards | docfx seed website",
-    "summary": "C# Coding Standards Introduction The coding standard will be used in conjunction with customized version of StyleCop and FxCop [TODO] during both development and build process. This will help ensure that the standard is followed by all developers on the team in a consistent manner. \"Any fool can write code that a computer can understand. Good programmers write code that humans understand\". Martin Fowler. Refactoring: Improving the design of existing code. Purpose The aim of this section is to define a set of C# coding standards to be used by CAPS build team to guarantee maximum legibility, reliability, re-usability and homogeneity of our code. Each section is marked Mandatory or Recommended. Mandatory sections, will be enforced during code reviews as well as tools like StyleCop and FxCop, and code will not be considered complete until it is compliant. Scope This section contains general C# coding standards which can be applied to any type of application developed in C#, based on Framework Design Guidelines. It does not pretend to be a tutorial on C#. It only includes a set of limitations and recommendations focused on clarifying the development. Tools Resharper is a great 3rd party code cleanup and style tool. StyleCop analyzes C# srouce code to enforce a set of style and consistency rules and has been integrated into many 3rd party development tools such as Resharper. FxCop is an application that analyzes managed code assemblies (code that targets the .NET Framework common language runtime) and reports information about the assemblies, such as possible design, localization, performance, and security improvements. C# Stylizer does many of the style rules automatically Highlights of Coding Standards This section is not intended to give a summary of all the coding standards that enabled by our customized StyleCop, but to give a highlight of some rules one will possibly meet in daily coding life. It also provides some recommended however not mandatory(which means not enabled in StyleCop) coding standards. File Layout (Recommended) Only one public class is allowed per file. The file name is derived from the class name. Class : Observer Filename: Observer.cs Class Definition Order (Mandatory) The class definition contains class members in the following order, from less restricted scope (public) to more restrictive (private): Nested types, e.g. classes, enum, struct, etc. Field members, e.g. member variables, const, etc. Member functions Constructors Finalizer (Do not use unless absolutely necessary) Methods (Properties, Events, Operations, Overridables, Static) Private nested types Naming (Mandatory) DO use PascalCasing for all public member, type, and namespace names consisting of multiple words. PropertyDescriptor HtmlTag IOStream NOTE: A special case is made for two-letter acronyms in which both letters are capitalized, e.g. IOStream DO use camelCasing for parameter names. propertyDescriptor htmlTag ioStream DO start with underscore for private fields private readonly Guid _userId = Guid.NewGuid(); DO start static readonly fields, constants with capitalized case private static readonly IEntityAccessor EntityAccessor = null; private const string MetadataName = \"MetadataName\"; DO NOT capitalize each word in so-called closed-form compound words. DO have \"Async\" explicitly in the Async method name to notice people how to use it properly Formatting (Mandatory) DO use spaces over tabs, and always show all spaces/tabs in IDE Tips Visual Studio > TOOLS > Options > Text Editor > C# > Tabs > Insert spaces (Tab size: 4) Visual Studio > Edit > Advanced > View White Space DO add using inside namespace declaration namespace Microsoft.Content.Build.BuildWorker.UnitTest { using System; } DO add a space when: for (var i = 0; i < 1; i++) if (a == b) Cross-platform coding Our code should supports multiple operating systems. Don't assume we only run (and develop) on Windows. Code should be sensitvie to the differences between OS's. Here are some specifics to consider. DO use Enviroment.NewLine instead of hard-coding the line break instead of \\r\\n, as Windows uses \\r\\n and OSX/Linux uses \\n. Note Be aware that thes line-endings may cause problems in code when using @\"\" text blocks with line breaks. DO Use Path.Combine() or Path.DirectorySeparatorChar to separate directories. If this is not possible (such as in scripting), use a forward slash /. Windows is more forgiving than Linux in this regard. Unit tests and functional tests Assembly naming The unit tests for the Microsoft.Foo assembly live in the Microsoft.Foo.Tests assembly. The functional tests for the Microsoft.Foo assmebly live in the Microsoft.Foo.FunctionalTests assmebly. In general there should be exactly one unit test assebmly for each product runtime assembly. In general there should be one functional test assembly per repo. Exceptions can be made for both. Unit test class naming Test class names end with Test and live in the same namespace as the class being tested. For example, the unit tests for the Microsoft.Foo.Boo class would be in a Microsoft.Foo.Boo class in the test assembly. Unit test method naming Unit test method names must be descriptive about what is being tested, under what conditions, and what the expectations are. Pascal casing and underscores can be used to improve readability. The following test names are correct: PublicApiArgumentsShouldHaveNotNullAnnotation Public_api_arguments_should_have_not_null_annotation The following test names are incorrect: Test1 Constructor FormatString GetData Unit test structure The contents of every unit test should be split into three distinct stages, optionally separated by these comments: // Arrange // Act // Assert The crucial thing here is the Act stage is exactly one statement. That one statement is nothing more than a call to the one method that you are trying to test. keeping that one statement as simple as possible is also very important. For example, this is not ideal: int result = myObj.CallSomeMethod(GetComplexParam1(), GetComplexParam2(), GetComplexParam3()); This style is not recomended because way too many things can go wrong in this one statement. All the GetComplexParamN() calls can throw for a variety of reasons unrelated to the test itself. It is thus unclear to someone running into a problem why the failure occured. The ideal pattern is to move the complex parameter building into the `Arrange section: // Arrange P1 p1 = GetComplexParam1(); P2 p2 = GetComplexParam2(); P3 p3 = GetComplexParam3(); // Act int result = myObj.CallSomeMethod(p1, p2, p3); // Assert Assert.AreEqual(1234, result); Now the only reason the line with CallSomeMethod() can fail is if the method itself blew up. Testing exception messages In general testing the specific exception message in a unit test is important. This ensures that the exact desired exception is what is being tested rather than a different exception of the same type. In order to verify the exact exception it is important to verify the message. var ex = Assert.Throws<InvalidOperationException>( () => fruitBasket.GetBananaById(1234)); Assert.Equal( \"1234\", ex.Message); Use xUnit.net's plethora of built-in assertions xUnit.net includes many kinds of assertions – please use the most appropriate one for your test. This will make the tests a lot more readable and also allow the test runner report the best possible errors (whether it's local or the CI machine). For example, these are bad: Assert.Equal(true, someBool); Assert.True(\"abc123\" == someString); Assert.True(list1.Length == list2.Length); for (int i = 0; i < list1.Length; i++) { Assert.True( String.Equals list1[i], list2[i], StringComparison.OrdinalIgnoreCase)); } These are good: Assert.True(someBool); Assert.Equal(\"abc123\", someString); // built-in collection assertions! Assert.Equal(list1, list2, StringComparer.OrdinalIgnoreCase); Parallel tests By default all unit test assemblies should run in parallel mode, which is the default. Unit tests shouldn't depend on any shared state, and so should generally be runnable in parallel. If the tests fail in parallel, the first thing to do is to figure out why; do not just disable parallel tests! For functional tests it is reasonable to disable parallel tests."
+    "summary": "C# Coding Standards Introduction The coding standard will be used in conjunction with customized version of StyleCop and FxCop [TODO] during both development and build process. This will help ensure that the standard is followed by all developers on the team in a consistent manner. \"Any fool can write code that a computer can understand. Good programmers write code that humans understand\". Martin Fowler. Refactoring: Improving the design of existing code. Purpose The aim of this section is to define a set of C# coding standards to be used by CAPS build team to guarantee maximum legibility, reliability, re-usability and homogeneity of our code. Each section is marked Mandatory or Recommended. Mandatory sections, will be enforced during code reviews as well as tools like StyleCop and FxCop, and code will not be considered complete until it is compliant. Scope This section contains general C# coding standards which can be applied to any type of application developed in C#, based on Framework Design Guidelines. It does not pretend to be a tutorial on C#. It only includes a set of limitations and recommendations focused on clarifying the development. Tools Resharper is a great 3rd party code cleanup and style tool. StyleCop analyzes C# srouce code to enforce a set of style and consistency rules and has been integrated into many 3rd party development tools such as Resharper. FxCop is an application that analyzes managed code assemblies (code that targets the .NET Framework common language runtime) and reports information about the assemblies, such as possible design, localization, performance, and security improvements. C# Stylizer does many of the style rules automatically Highlights of Coding Standards This section is not intended to give a summary of all the coding standards that enabled by our customized StyleCop, but to give a highlight of some rules one will possibly meet in daily coding life. It also provides some recommended however not mandatory(which means not enabled in StyleCop) coding standards. File Layout (Recommended) Only one public class is allowed per file. The file name is derived from the class name. Class : Observer Filename: Observer.cs Class Definition Order (Mandatory) The class definition contains class members in the following order, from less restricted scope (public) to more restrictive (private): Nested types, e.g. classes, enum, struct, etc. Field members, e.g. member variables, const, etc. Member functions Constructors Finalizer (Do not use unless absolutely necessary) Methods (Properties, Events, Operations, Overridables, Static) Private nested types Naming (Mandatory) DO use PascalCasing for all public member, type, and namespace names consisting of multiple words. PropertyDescriptor HtmlTag IOStream NOTE: A special case is made for two-letter acronyms in which both letters are capitalized, e.g. IOStream DO use camelCasing for parameter names. propertyDescriptor htmlTag ioStream DO start with underscore for private fields private readonly Guid _userId = Guid.NewGuid(); DO start static readonly fields, constants with capitalized case private static readonly IEntityAccessor EntityAccessor = null; private const string MetadataName = \"MetadataName\"; DO NOT capitalize each word in so-called closed-form compound words. DO have \"Async\" explicitly in the Async method name to notice people how to use it properly Formatting (Mandatory) DO use spaces over tabs, and always show all spaces/tabs in IDE Tips Visual Studio > TOOLS > Options > Text Editor > C# > Tabs > Insert spaces (Tab size: 4) Visual Studio > Edit > Advanced > View White Space DO add using inside namespace declaration namespace Microsoft.Content.Build.BuildWorker.UnitTest { using System; } DO add a space when: for (var i = 0; i < 1; i++) if (a == b) Cross-platform coding Our code should supports multiple operating systems. Don't assume we only run (and develop) on Windows. Code should be sensitvie to the differences between OS's. Here are some specifics to consider. DO use Enviroment.NewLine instead of hard-coding the line break instead of \\r\\n, as Windows uses \\r\\n and OSX/Linux uses \\n. Note Be aware that thes line-endings may cause problems in code when using @\"\" text blocks with line breaks. DO Use Path.Combine() or Path.DirectorySeparatorChar to separate directories. If this is not possible (such as in scripting), use a forward slash /. Windows is more forgiving than Linux in this regard. Unit tests and functional tests Assembly naming The unit tests for the Microsoft.Foo assembly live in the Microsoft.Foo.Tests assembly. The functional tests for the Microsoft.Foo assmebly live in the Microsoft.Foo.FunctionalTests assmebly. In general there should be exactly one unit test assebmly for each product runtime assembly. In general there should be one functional test assembly per repo. Exceptions can be made for both. Unit test class naming Test class names end with Test and live in the same namespace as the class being tested. For example, the unit tests for the Microsoft.Foo.Boo class would be in a Microsoft.Foo.Boo class in the test assembly. Unit test method naming Unit test method names must be descriptive about what is being tested, under what conditions, and what the expectations are. Pascal casing and underscores can be used to improve readability. The following test names are correct: PublicApiArgumentsShouldHaveNotNullAnnotation Public_api_arguments_should_have_not_null_annotation The following test names are incorrect: Test1 Constructor FormatString GetData Unit test structure The contents of every unit test should be split into three distinct stages, optionally separated by these comments: // Arrange // Act // Assert The crucial thing here is the Act stage is exactly one statement. That one statement is nothing more than a call to the one method that you are trying to test. keeping that one statement as simple as possible is also very important. For example, this is not ideal: int result = myObj.CallSomeMethod(GetComplexParam1(), GetComplexParam2(), GetComplexParam3()); This style is not recomended because way too many things can go wrong in this one statement. All the GetComplexParamN() calls can throw for a variety of reasons unrelated to the test itself. It is thus unclear to someone running into a problem why the failure occured. The ideal pattern is to move the complex parameter building into the `Arrange section: // Arrange P1 p1 = GetComplexParam1(); P2 p2 = GetComplexParam2(); P3 p3 = GetComplexParam3(); // Act int result = myObj.CallSomeMethod(p1, p2, p3); // Assert Assert.AreEqual(1234, result); Now the only reason the line with CallSomeMethod() can fail is if the method itself blew up. Testing exception messages In general testing the specific exception message in a unit test is important. This ensures that the exact desired exception is what is being tested rather than a different exception of the same type. In order to verify the exact exception it is important to verify the message. var ex = Assert.Throws<InvalidOperationException>( () => fruitBasket.GetBananaById(1234)); Assert.AreEqual( \"1234\", ex.Message); Use xUnit.net's plethora of built-in assertions xUnit.net includes many kinds of assertions – please use the most appropriate one for your test. This will make the tests a lot more readable and also allow the test runner report the best possible errors (whether it's local or the CI machine). For example, these are bad: Assert.AreEqual(true, someBool); Assert.IsTrue(\"abc123\" == someString); Assert.IsTrue(list1.Length == list2.Length); for (int i = 0; i < list1.Length; i++) { Assert.IsTrue( String.Equals list1[i], list2[i], StringComparison.OrdinalIgnoreCase)); } These are good: Assert.IsTrue(someBool); Assert.AreEqual(\"abc123\", someString); // built-in collection assertions! Assert.AreEqual(list1, list2, StringComparer.OrdinalIgnoreCase); Parallel tests By default all unit test assemblies should run in parallel mode, which is the default. Unit tests shouldn't depend on any shared state, and so should generally be runnable in parallel. If the tests fail in parallel, the first thing to do is to figure out why; do not just disable parallel tests! For functional tests it is reasonable to disable parallel tests."
   },
   "articles/docfx_getting_started.html": {
     "href": "articles/docfx_getting_started.html",
diff --git a/test/docfx.Snapshot.Tests/SamplesTest.Seed/pdf/toc.pdf.verified.json b/test/docfx.Snapshot.Tests/SamplesTest.Seed/pdf/toc.pdf.verified.json
index 1d810f16bd5..bc4a25e5240 100644
--- a/test/docfx.Snapshot.Tests/SamplesTest.Seed/pdf/toc.pdf.verified.json
+++ b/test/docfx.Snapshot.Tests/SamplesTest.Seed/pdf/toc.pdf.verified.json
@@ -709,7 +709,7 @@
     },
     {
       "Number": 13,
-      "Text": "13 / 131\nthe same type. In order to verify the exact exception it is important to verify the message.\nUse xUnit.net's plethora of built-in assertions\nxUnit.net includes many kinds of assertions – please use the most appropriate one for your\ntest. This will make the tests a lot more readable and also allow the test runner report the\nbest possible errors (whether it's local or the CI machine). For example, these are bad:\nThese are good:\nParallel tests\nBy default all unit test assemblies should run in parallel mode, which is the default. Unit\ntests shouldn't depend on any shared state, and so should generally be runnable in\nparallel. If the tests fail in parallel, the first thing to do is to figure out why; do not just\ndisable parallel tests!\nvar ex = Assert.Throws<InvalidOperationException>(\n() => fruitBasket.GetBananaById(1234));\nAssert.Equal(\n\"1234\",\nex.Message);\nAssert.Equal(true, someBool);\nAssert.True(\"abc123\" == someString);\nAssert.True(list1.Length == list2.Length);\nfor (int i = 0; i < list1.Length; i++) {\nAssert.True(\nString.Equals\nlist1[i],\nlist2[i],\nStringComparison.OrdinalIgnoreCase));\n}\nAssert.True(someBool);\nAssert.Equal(\"abc123\", someString);\n// built-in collection assertions!\nAssert.Equal(list1, list2, StringComparer.OrdinalIgnoreCase);",
+      "Text": "13 / 131\nthe same type. In order to verify the exact exception it is important to verify the message.\nUse xUnit.net's plethora of built-in assertions\nxUnit.net includes many kinds of assertions – please use the most appropriate one for your\ntest. This will make the tests a lot more readable and also allow the test runner report the\nbest possible errors (whether it's local or the CI machine). For example, these are bad:\nThese are good:\nParallel tests\nBy default all unit test assemblies should run in parallel mode, which is the default. Unit\ntests shouldn't depend on any shared state, and so should generally be runnable in\nparallel. If the tests fail in parallel, the first thing to do is to figure out why; do not just\ndisable parallel tests!\nvar ex = Assert.Throws<InvalidOperationException>(\n() => fruitBasket.GetBananaById(1234));\nAssert.AreEqual(\n\"1234\",\nex.Message);\nAssert.AreEqual(true, someBool);\nAssert.IsTrue(\"abc123\" == someString);\nAssert.IsTrue(list1.Length == list2.Length);\nfor (int i = 0; i < list1.Length; i++) {\nAssert.IsTrue(\nString.Equals\nlist1[i],\nlist2[i],\nStringComparison.OrdinalIgnoreCase));\n}\nAssert.IsTrue(someBool);\nAssert.AreEqual(\"abc123\", someString);\n// built-in collection assertions!\nAssert.AreEqual(list1, list2, StringComparer.OrdinalIgnoreCase);",
       "Links": []
     },
     {
diff --git a/test/docfx.Snapshot.Tests/SamplesTest.cs b/test/docfx.Snapshot.Tests/SamplesTest.cs
index d5f8ae8212c..e0bb9ffc144 100644
--- a/test/docfx.Snapshot.Tests/SamplesTest.cs
+++ b/test/docfx.Snapshot.Tests/SamplesTest.cs
@@ -18,9 +18,11 @@
 
 namespace Docfx.Tests;
 
-[Collection("docfx STA")]
-[Trait("Stage", "Snapshot")]
-public class SamplesTest : IDisposable
+[UsesVerify]
+[DoNotParallelize]
+[TestProperty("Stage", "Snapshot")]
+[TestClass]
+public partial class SamplesTest : IDisposable
 {
     private static readonly string s_samplesDir = Path.GetFullPath("../../../../../samples");
 
@@ -36,19 +38,27 @@ public void Dispose()
         Environment.SetEnvironmentVariable(DOCFX_SOURCE_REPOSITORY_URL, null);
     }
 
-    private class SamplesFactAttribute : FactAttribute
+    private class SamplesConditionAttribute : ConditionBaseAttribute
     {
-        public SamplesFactAttribute()
+        public SamplesConditionAttribute()
+            : base(ConditionMode.Include)
         {
             // When target framework is changed.
             // It need to modify TargetFrameworks property of `docfx.Snapshot.Tests.csproj`
 #if !NET8_0
-            Skip = "Skip by target framework";
+            IgnoreMessage = "Skip by target framework";
 #endif
         }
+
+        public override string IgnoreMessage { get; }
+
+        public override string GroupName => nameof(SamplesConditionAttribute);
+
+        public override bool ShouldRun => IgnoreMessage is null;
     }
 
-    [SamplesFact]
+    [TestMethod]
+    [SamplesCondition]
     public async Task Seed()
     {
         var samplePath = $"{s_samplesDir}/seed";
@@ -61,12 +71,12 @@ public async Task Seed()
         if (Debugger.IsAttached || IsWslRemoteTest())
         {
             Environment.SetEnvironmentVariable("DOCFX_SOURCE_BRANCH_NAME", "main");
-            Assert.Equal(0, Program.Main([$"{samplePath}/docfx.json"]));
+            Assert.AreEqual(0, Program.Main([$"{samplePath}/docfx.json"]));
         }
         else
         {
             var docfxPath = Path.GetFullPath(OperatingSystem.IsWindows() ? "docfx.exe" : "docfx");
-            Assert.Equal(0, Exec(docfxPath, $"{samplePath}/docfx.json"));
+            Assert.AreEqual(0, Exec(docfxPath, $"{samplePath}/docfx.json"));
         }
 
         Parallel.ForEach(Directory.EnumerateFiles($"{samplePath}/_site", "*.pdf", SearchOption.AllDirectories), PdfToJson);
@@ -115,7 +125,8 @@ object ToBookmarks(IEnumerable<BookmarkNode> nodes)
         }
     }
 
-    [SamplesFact]
+    [TestMethod]
+    [SamplesCondition]
     public async Task SeedMarkdown()
     {
         var samplePath = $"{s_samplesDir}/seed";
@@ -123,12 +134,13 @@ public async Task SeedMarkdown()
         Clean(samplePath);
 
         var exitCode = Program.Main(["metadata", $"{samplePath}/docfx.json", "--outputFormat", "markdown", "--output", outputPath]);
-        Assert.Equal(0, exitCode);
+        Assert.AreEqual(0, exitCode);
 
         await VerifyDirectory(outputPath).AutoVerify(includeBuildServer: false);
     }
 
-    [SamplesFact]
+    [TestMethod]
+    [SamplesCondition]
     public async Task CSharp()
     {
         var samplePath = $"{s_samplesDir}/csharp";
@@ -149,7 +161,8 @@ public async Task CSharp()
         await VerifyDirectory($"{samplePath}/_site", IncludeFile).AutoVerify(includeBuildServer: false);
     }
 
-    [SamplesFact]
+    [TestMethod]
+    [SamplesCondition]
     public Task Extensions()
     {
         var samplePath = $"{s_samplesDir}/extensions";
@@ -159,12 +172,12 @@ public Task Extensions()
         using var process = Process.Start("dotnet", $"build \"{samplePath}/build\"");
         process.WaitForExit();
         VerifyExitCode(process);
-        Assert.Equal(0, Exec("dotnet", "run --no-build --project build", workingDirectory: samplePath));
+        Assert.AreEqual(0, Exec("dotnet", "run --no-build --project build", workingDirectory: samplePath));
 #else
         using var process = Process.Start("dotnet", $"build -c Release \"{samplePath}/build\"");
         process.WaitForExit();
         VerifyExitCode(process);
-        Assert.Equal(0, Exec("dotnet", "run --no-build -c Release --project build", workingDirectory: samplePath));
+        Assert.AreEqual(0, Exec("dotnet", "run --no-build -c Release --project build", workingDirectory: samplePath));
 #endif
 
         return VerifyDirectory($"{samplePath}/_site", IncludeFile).AutoVerify(includeBuildServer: false);
@@ -256,6 +269,6 @@ private static void VerifyExitCode(Process process)
         process.Close();
 
         // Assert exit code
-        Assert.Equal(0, exitCode);
+        Assert.AreEqual(0, exitCode);
     }
 }
diff --git a/test/docfx.Snapshot.Tests/docfx.Snapshot.Tests.csproj b/test/docfx.Snapshot.Tests/docfx.Snapshot.Tests.csproj
index 56c718ed26b..eaa00f8939c 100644
--- a/test/docfx.Snapshot.Tests/docfx.Snapshot.Tests.csproj
+++ b/test/docfx.Snapshot.Tests/docfx.Snapshot.Tests.csproj
@@ -6,7 +6,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.Playwright" />
     <PackageReference Include="Verify.DiffPlex" />
-    <PackageReference Include="Verify.Xunit" />
+    <PackageReference Include="Verify.MSTest" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/docfx.Tests/Attributes/WindowsOnlyFactAttribute.cs b/test/docfx.Tests/Attributes/WindowsOnlyFactAttribute.cs
deleted file mode 100644
index 0f2bad2b44b..00000000000
--- a/test/docfx.Tests/Attributes/WindowsOnlyFactAttribute.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-
-namespace docfx.Tests.Attributes;
-
-/// <summary>
-/// XUnit Fact attribute that skips the test if the OS is not Windows.
-/// </summary>
-/// <remarks>
-/// Taken from https://github.com/dotnet/sdk/blob/a30e465a2e2ea4e2550f319a2dc088daaafe5649/src/Tests/Microsoft.NET.TestFramework/Attributes/WindowsOnlyFactAttribute.cs
-/// </remarks>
-public class WindowsOnlyFactAttribute : FactAttribute
-{
-    public WindowsOnlyFactAttribute()
-    {
-        if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-        {
-            Skip = "This test requires Windows to run";
-        }
-    }
-}
diff --git a/test/docfx.Tests/CommandLineTest.cs b/test/docfx.Tests/CommandLineTest.cs
index ad509286aff..18288b6c6a6 100644
--- a/test/docfx.Tests/CommandLineTest.cs
+++ b/test/docfx.Tests/CommandLineTest.cs
@@ -3,41 +3,42 @@
 
 namespace Docfx.Tests;
 
-[Collection("docfx STA")]
-public static class CommandLineTest
+[DoNotParallelize]
+[TestClass]
+public class CommandLineTest
 {
-    [Fact]
-    public static void PrintsVersion()
+    [TestMethod]
+    public void PrintsVersion()
     {
-        Assert.Equal(0, Program.Main(["-v"]));
-        Assert.Equal(0, Program.Main(["--version"]));
+        Assert.AreEqual(0, Program.Main(["-v"]));
+        Assert.AreEqual(0, Program.Main(["--version"]));
     }
 
-    [Fact]
-    public static void PrintsHelp()
+    [TestMethod]
+    public void PrintsHelp()
     {
-        Assert.Equal(0, Program.Main(["-h"]));
-        Assert.Equal(0, Program.Main(["--help"]));
-        Assert.Equal(0, Program.Main(["build", "--help"]));
-        Assert.Equal(0, Program.Main(["serve", "--help"]));
-        Assert.Equal(0, Program.Main(["metadata", "--help"]));
-        Assert.Equal(0, Program.Main(["pdf", "--help"]));
-        Assert.Equal(0, Program.Main(["init", "--help"]));
-        Assert.Equal(0, Program.Main(["download", "--help"]));
-        Assert.Equal(0, Program.Main(["merge", "--help"]));
-        Assert.Equal(0, Program.Main(["template", "--help"]));
+        Assert.AreEqual(0, Program.Main(["-h"]));
+        Assert.AreEqual(0, Program.Main(["--help"]));
+        Assert.AreEqual(0, Program.Main(["build", "--help"]));
+        Assert.AreEqual(0, Program.Main(["serve", "--help"]));
+        Assert.AreEqual(0, Program.Main(["metadata", "--help"]));
+        Assert.AreEqual(0, Program.Main(["pdf", "--help"]));
+        Assert.AreEqual(0, Program.Main(["init", "--help"]));
+        Assert.AreEqual(0, Program.Main(["download", "--help"]));
+        Assert.AreEqual(0, Program.Main(["merge", "--help"]));
+        Assert.AreEqual(0, Program.Main(["template", "--help"]));
     }
 
-    [Fact]
-    public static void FailForUnknownArgs()
+    [TestMethod]
+    public void FailForUnknownArgs()
     {
-        Assert.Equal(-1, Program.Main(["--unknown"]));
+        Assert.AreEqual(-1, Program.Main(["--unknown"]));
     }
 
-    [Fact]
-    public static void InitBuild()
+    [TestMethod]
+    public void InitBuild()
     {
-        Assert.Equal(0, Program.Main(["init", "-o", "init", "-y"]));
-        Assert.Equal(0, Program.Main(["init/docfx.json"]));
+        Assert.AreEqual(0, Program.Main(["init", "-o", "init", "-y"]));
+        Assert.AreEqual(0, Program.Main(["init/docfx.json"]));
     }
 }
diff --git a/test/docfx.Tests/CompositeCommandTest.cs b/test/docfx.Tests/CompositeCommandTest.cs
index 215fdc56ded..15501bb38f8 100644
--- a/test/docfx.Tests/CompositeCommandTest.cs
+++ b/test/docfx.Tests/CompositeCommandTest.cs
@@ -8,7 +8,8 @@
 
 namespace Docfx.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class CompositeCommandTest : TestBase
 {
     /// <summary>
@@ -23,8 +24,8 @@ public CompositeCommandTest()
         _projectFolder = Path.GetFullPath(GetRandomFolder());
     }
 
-    [Fact]
-    [Trait("Related", "docfx#428")]
+    [TestMethod]
+    [TestProperty("Related", "docfx#428")]
     public void TestCommandFromCSCodeToHtml()
     {
         // Create source file
@@ -87,40 +88,40 @@ public class HelloWorld {}}
 
         var docfxJsonFile = Path.Combine(_projectFolder, "docfx.json");
         File.WriteAllText(docfxJsonFile, docfxJson);
-        Assert.Equal(0, Program.Main([docfxJsonFile]));
+        Assert.AreEqual(0, Program.Main([docfxJsonFile]));
         var filePath = Path.Combine(_outputFolder, "site", "api", "Hello.HelloWorld.html");
-        Assert.True(File.Exists(filePath));
+        Assert.IsTrue(File.Exists(filePath));
         var html = new HtmlDocument();
         html.Load(filePath);
         var summary = html.DocumentNode.SelectSingleNode("//div[contains(@class, 'summary')]/p").InnerHtml;
-        Assert.Equal("The class &lt; &gt; &gt; description goes here...", summary.Trim());
+        Assert.AreEqual("The class &lt; &gt; &gt; description goes here...", summary.Trim());
         var note = html.DocumentNode.SelectSingleNode("//div[@class='NOTE']").InnerHtml;
-        Assert.Equal("<h5>Note</h5>\n<p>This is <em>note</em></p>", note.Trim());
+        Assert.AreEqual("<h5>Note</h5>\n<p>This is <em>note</em></p>", note.Trim());
         var code = html.DocumentNode.SelectNodes("//pre/code")[1].InnerHtml;
-        Assert.Equal("""
+        Assert.AreEqual("""
             var handler = DateTimeHandler();
             for (var i = 0; i &lt; 10; i++){
                 date = date.AddMonths(1);
             }
             """.Replace("\r\n", "\n"), code);
         var sitemap = Path.Combine(_outputFolder, "site", "sitemap.xml");
-        Assert.True(File.Exists(sitemap));
+        Assert.IsTrue(File.Exists(sitemap));
 
         XDocument xDoc = XDocument.Load(sitemap);
 
         var documentElement = xDoc.Elements().FirstOrDefault();
-        Assert.NotNull(documentElement);
+        Assert.IsNotNull(documentElement);
         var ns = "http://www.sitemaps.org/schemas/sitemap/0.9";
-        Assert.Equal(ns, documentElement.GetDefaultNamespace());
+        Assert.AreEqual(ns, documentElement.GetDefaultNamespace());
         var elements = documentElement.Elements().ToList();
-        Assert.Equal(2, elements.Count);
-        Assert.Equal("0.3", elements[0].Element(XName.Get("priority", ns)).Value);
-        Assert.Equal("monthly", elements[0].Element(XName.Get("changefreq", ns)).Value);
-        Assert.Equal("https://dotnet.github.io/docfx/api/Hello.HelloWorld.html", elements[0].Element(XName.Get("loc", ns)).Value);
-        Assert.Equal(new DateTime(1999, 01, 01).ToString("yyyy-MM-ddThh:mm:ssK"), elements[0].Element(XName.Get("lastmod", ns)).Value);
+        Assert.AreEqual(2, elements.Count);
+        Assert.AreEqual("0.3", elements[0].Element(XName.Get("priority", ns)).Value);
+        Assert.AreEqual("monthly", elements[0].Element(XName.Get("changefreq", ns)).Value);
+        Assert.AreEqual("https://dotnet.github.io/docfx/api/Hello.HelloWorld.html", elements[0].Element(XName.Get("loc", ns)).Value);
+        Assert.AreEqual(new DateTime(1999, 01, 01).ToString("yyyy-MM-ddThh:mm:ssK"), elements[0].Element(XName.Get("lastmod", ns)).Value);
 
-        Assert.Equal("0.8", elements[1].Element(XName.Get("priority", ns)).Value);
-        Assert.Equal("daily", elements[1].Element(XName.Get("changefreq", ns)).Value);
-        Assert.Equal("https://dotnet.github.io/docfx/1/api/Hello.html", elements[1].Element(XName.Get("loc", ns)).Value);
+        Assert.AreEqual("0.8", elements[1].Element(XName.Get("priority", ns)).Value);
+        Assert.AreEqual("daily", elements[1].Element(XName.Get("changefreq", ns)).Value);
+        Assert.AreEqual("https://dotnet.github.io/docfx/1/api/Hello.html", elements[1].Element(XName.Get("loc", ns)).Value);
     }
 }
diff --git a/test/docfx.Tests/DocsetBuildTest.cs b/test/docfx.Tests/DocsetBuildTest.cs
index b07ec876457..0649f5c1398 100644
--- a/test/docfx.Tests/DocsetBuildTest.cs
+++ b/test/docfx.Tests/DocsetBuildTest.cs
@@ -8,7 +8,8 @@
 
 namespace Docfx.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class DocsetBuildTest : TestBase
 {
     private static async Task<Dictionary<string, Func<string>>> Build(Dictionary<string, string> files, [CallerMemberName] string testName = null)
@@ -49,8 +50,8 @@ await File.WriteAllTextAsync($"{testDirectory}/docfx.json",
                             f => new Func<string>(() => File.ReadAllText(f)));
     }
 
-    [Fact]
-    public static async Task CustomLogo_Override_LogoFromTemplate()
+    [TestMethod]
+    public async Task CustomLogo_Override_LogoFromTemplate()
     {
         var outputs = await Build(new()
         {
@@ -67,11 +68,11 @@ public static async Task CustomLogo_Override_LogoFromTemplate()
             ["logo.svg"] = "<svg>my svg</svg>"
         });
 
-        Assert.Equal("<svg>my svg</svg>", outputs["logo.svg"]());
+        Assert.AreEqual("<svg>my svg</svg>", outputs["logo.svg"]());
     }
 
-    [Fact]
-    public static async Task Load_Custom_Plugin_From_Template()
+    [TestMethod]
+    public async Task Load_Custom_Plugin_From_Template()
     {
         var outputs = await Build(new()
         {
@@ -89,11 +90,11 @@ public static async Task Load_Custom_Plugin_From_Template()
             ["index.md"] = ""
         });
 
-        Assert.Equal("customPostProcessor", outputs["customPostProcessor.txt"]());
+        Assert.AreEqual("customPostProcessor", outputs["customPostProcessor.txt"]());
     }
 
-    [Fact]
-    public static async Task Build_With_Global_Metadata_Files()
+    [TestMethod]
+    public async Task Build_With_Global_Metadata_Files()
     {
         var outputs = await Build(new()
         {
@@ -129,13 +130,13 @@ public static async Task Build_With_Global_Metadata_Files()
         });
 
         var metadata = JsonDocument.Parse(outputs["index.raw.json"]()).RootElement;
-        Assert.Equal("projectMetadata1.json", metadata.GetProperty("meta1").GetString());
-        Assert.Equal("projectMetadata2.json", metadata.GetProperty("meta2").GetString());
-        Assert.Equal("docfx.json", metadata.GetProperty("meta3").GetString());
+        Assert.AreEqual("projectMetadata1.json", metadata.GetProperty("meta1").GetString());
+        Assert.AreEqual("projectMetadata2.json", metadata.GetProperty("meta2").GetString());
+        Assert.AreEqual("docfx.json", metadata.GetProperty("meta3").GetString());
     }
 
-    [Fact]
-    public static async Task Build_With_File_Metadata_Files()
+    [TestMethod]
+    public async Task Build_With_File_Metadata_Files()
     {
         var outputs = await Build(new()
         {
@@ -178,12 +179,12 @@ public static async Task Build_With_File_Metadata_Files()
 
         var a = JsonDocument.Parse(outputs["a.raw.json"]()).RootElement;
         var b = JsonDocument.Parse(outputs["b.raw.json"]()).RootElement;
-        Assert.Equal("fileMetadata1.json", a.GetProperty("meta1").GetString());
-        Assert.Equal("fileMetadata2.json", b.GetProperty("meta1").GetString());
+        Assert.AreEqual("fileMetadata1.json", a.GetProperty("meta1").GetString());
+        Assert.AreEqual("fileMetadata2.json", b.GetProperty("meta1").GetString());
     }
 
-    [Fact]
-    public static async Task Build_With_RedirectUri_Files()
+    [TestMethod]
+    public async Task Build_With_RedirectUri_Files()
     {
         // Act
         var outputs = await Build(new()
@@ -215,7 +216,7 @@ public static async Task Build_With_RedirectUri_Files()
 
         // Assert
         var result = outputs["index.html"]();
-        Assert.Equal(
+        Assert.AreEqual(
             """
             <!DOCTYPE html>
             <html>
@@ -229,11 +230,11 @@ public static async Task Build_With_RedirectUri_Files()
         // Test redirect page.is excluded from sitemap.
         var sitemapXml = outputs["sitemap.xml"]();
         var urls = XDocument.Parse(sitemapXml).Root.Elements();
-        Assert.False(urls.Any());
+        Assert.IsFalse(urls.Any());
     }
 
-    [Fact]
-    public static async Task Build_Toc_Gen_Name()
+    [TestMethod]
+    public async Task Build_Toc_Gen_Name()
     {
         var outputs = await Build(new()
         {
@@ -268,14 +269,14 @@ public static async Task Build_Toc_Gen_Name()
             """, outputs["toc.json"]());
     }
 
-    [Fact]
-    public static async Task Issue5174()
+    [TestMethod]
+    public async Task Issue5174()
     {
         var outputs = await Build(new()
         {
             ["index.md"] = "[link](On%25252Dcall-duties.md)",
             ["On%252Dcall-duties.md"] = "a",
         });
-        Assert.NotEmpty(outputs["On%252Dcall-duties.html"]());
+        Assert.IsNotEmpty(outputs["On%252Dcall-duties.html"]());
     }
 }
diff --git a/test/docfx.Tests/JsonConverterTest.cs b/test/docfx.Tests/JsonConverterTest.cs
index 795fa6b4c30..6de749edb26 100644
--- a/test/docfx.Tests/JsonConverterTest.cs
+++ b/test/docfx.Tests/JsonConverterTest.cs
@@ -10,10 +10,11 @@
 
 namespace Docfx.Tests;
 
+[TestClass]
 public class JsonConverterTest
 {
-    [Fact]
-    [Trait("Related", "docfx")]
+    [TestMethod]
+    [TestProperty("Related", "docfx")]
     public void TestJObjectDictionaryToObjectDictionaryConverterSerializeAndDeserialize()
     {
         string jsonString = "{" +
@@ -37,7 +38,7 @@ public void TestJObjectDictionaryToObjectDictionaryConverterSerializeAndDeserial
 
         BuildJsonConfig buildOptions = JsonConvert.DeserializeObject<BuildJsonConfig>(jsonString);
 
-        Assert.Equal(7, buildOptions.GlobalMetadata.Count);
+        Assert.AreEqual(7, buildOptions.GlobalMetadata.Count);
 
         JsonSerializerSettings settings = new()
         {
@@ -46,11 +47,11 @@ public void TestJObjectDictionaryToObjectDictionaryConverterSerializeAndDeserial
             ContractResolver = new SkipEmptyOrNullContractResolver()
         };
 
-        Assert.Equal(jsonString, JsonConvert.SerializeObject(buildOptions, settings), ignoreLineEndingDifferences: true);
+        Assert.AreEqual(jsonString.ReplaceLineEndings(), JsonConvert.SerializeObject(buildOptions, settings).ReplaceLineEndings());
     }
 
-    [Fact]
-    [Trait("Related", "docfx")]
+    [TestMethod]
+    [TestProperty("Related", "docfx")]
     public void TestFileMetadataPairsConverterCouldSerializeAndDeserialize()
     {
         FileMetadataPairs item = new(
@@ -65,27 +66,27 @@ public void TestFileMetadataPairsConverterCouldSerializeAndDeserialize()
             });
 
         var result = JsonUtility.Serialize(item);
-        Assert.Equal("{\"*.md\":1,\"*.m\":true,\"abc\":\"string\",\"/[]\\\\*.cs\":{\"key\":\"2\"},\"*/*.cs\":[\"1\",\"2\"],\"**\":{\"key\":[\"1\",\"2\"]}}", result);
+        Assert.AreEqual("{\"*.md\":1,\"*.m\":true,\"abc\":\"string\",\"/[]\\\\*.cs\":{\"key\":\"2\"},\"*/*.cs\":[\"1\",\"2\"],\"**\":{\"key\":[\"1\",\"2\"]}}", result);
         using var reader = new StringReader(result);
         var pairs = JsonUtility.Deserialize<FileMetadataPairs>(reader);
-        Assert.Equal(item.Count, pairs.Count);
+        Assert.AreEqual(item.Count, pairs.Count);
 
         // Assert
         pairs.Should().BeEquivalentTo(item);
     }
 
-    [Fact]
-    [Trait("Related", "docfx")]
+    [TestMethod]
+    [TestProperty("Related", "docfx")]
     public void TestFileMappingItemSrcInputShouldWork()
     {
         var input = "{\"files\":[\"file1\"],\"src\":\"folder1\"}";
         using var sr = new StringReader(input);
         var result = JsonUtility.Deserialize<FileMappingItem>(sr);
-        Assert.Equal("folder1", result.Src);
+        Assert.AreEqual("folder1", result.Src);
     }
 
-    [Fact]
-    [Trait("Related", "docfx")]
+    [TestMethod]
+    [TestProperty("Related", "docfx")]
     public void TestFileMappingItemOutputShouldContainSrcOnly()
     {
         var fileMappingItem = new FileMappingItem
@@ -95,7 +96,7 @@ public void TestFileMappingItemOutputShouldContainSrcOnly()
         };
 
         var result = JsonUtility.Serialize(fileMappingItem);
-        Assert.Equal("{\"files\":[\"file1\"],\"src\":\"folder1\"}", result);
+        Assert.AreEqual("{\"files\":[\"file1\"],\"src\":\"folder1\"}", result);
     }
 }
 
diff --git a/test/docfx.Tests/JsonSchemaTest.cs b/test/docfx.Tests/JsonSchemaTest.cs
index 43bec4c851f..e8d9c60ff63 100644
--- a/test/docfx.Tests/JsonSchemaTest.cs
+++ b/test/docfx.Tests/JsonSchemaTest.cs
@@ -10,19 +10,20 @@
 
 namespace Docfx.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class JsonSchemaTest : TestBase
 {
-    [Theory]
-    [InlineData("docs/docfx.json")]
-    [InlineData("samples/csharp/docfx.json")]
-    [InlineData("samples/extensions/docfx.json")]
-    [InlineData("samples/seed/docfx.json")]
-    [InlineData("test/docfx.Tests/Assets/docfx.json_build/docfx.json")]
-    [InlineData("test/docfx.Tests/Assets/docfx.json_empty/docfx.json")]
-    [InlineData("test/docfx.Tests/Assets/docfx.json_metadata/docfx.json")]
-    [InlineData("test/docfx.Tests/Assets/docfx.json_metadata/docfxWithFilter.json")]
-    [InlineData("test/docfx.Tests/Assets/docfx.json_metadata_build/docfx.json")]
+    [TestMethod]
+    [DataRow("docs/docfx.json")]
+    [DataRow("samples/csharp/docfx.json")]
+    [DataRow("samples/extensions/docfx.json")]
+    [DataRow("samples/seed/docfx.json")]
+    [DataRow("test/docfx.Tests/Assets/docfx.json_build/docfx.json")]
+    [DataRow("test/docfx.Tests/Assets/docfx.json_empty/docfx.json")]
+    [DataRow("test/docfx.Tests/Assets/docfx.json_metadata/docfx.json")]
+    [DataRow("test/docfx.Tests/Assets/docfx.json_metadata/docfxWithFilter.json")]
+    [DataRow("test/docfx.Tests/Assets/docfx.json_metadata_build/docfx.json")]
     public void JsonSchemaTest_Docfx_Json(string path)
     {
         // Arrange
@@ -35,9 +36,9 @@ public void JsonSchemaTest_Docfx_Json(string path)
         result.IsValid.Should().BeTrue();
     }
 
-    [Theory]
-    [InlineData("test/docfx.Tests/Assets/docfx.json_invalid_format/docfx.json")]
-    [InlineData("test/docfx.Tests/Assets/docfx.json_invalid_key/docfx.json")]
+    [TestMethod]
+    [DataRow("test/docfx.Tests/Assets/docfx.json_invalid_format/docfx.json")]
+    [DataRow("test/docfx.Tests/Assets/docfx.json_invalid_key/docfx.json")]
     public void JsonSchemaTest_Docfx_Json_Invalid(string path)
     {
         // Arrange
@@ -50,11 +51,11 @@ public void JsonSchemaTest_Docfx_Json_Invalid(string path)
         result.IsValid.Should().BeFalse();
     }
 
-    [Theory]
-    [InlineData("src/Docfx.Dotnet/Resources/defaultfilterconfig.yml")]
-    [InlineData("test/Docfx.Dotnet.Tests/TestData/filterconfig.yml")]
-    [InlineData("test/Docfx.Dotnet.Tests/TestData/filterconfig_attribute.yml")]
-    [InlineData("test/Docfx.Dotnet.Tests/TestData/filterconfig_docs_sample.yml")]
+    [TestMethod]
+    [DataRow("src/Docfx.Dotnet/Resources/defaultfilterconfig.yml")]
+    [DataRow("test/Docfx.Dotnet.Tests/TestData/filterconfig.yml")]
+    [DataRow("test/Docfx.Dotnet.Tests/TestData/filterconfig_attribute.yml")]
+    [DataRow("test/Docfx.Dotnet.Tests/TestData/filterconfig_docs_sample.yml")]
     public void JsonSchemaTest_FilterConfig(string path)
     {
         // Arrange
@@ -67,17 +68,17 @@ public void JsonSchemaTest_FilterConfig(string path)
         result.IsValid.Should().BeTrue();
     }
 
-    [Theory]
-    [InlineData("test/docfx.Snapshot.Tests/SamplesTest.CSharp/api/toc.json.view.verified.json")]
-    [InlineData("test/docfx.Snapshot.Tests/SamplesTest.Extensions/api/toc.json.view.verified.json")]
-    [InlineData("test/docfx.Snapshot.Tests/SamplesTest.Extensions/toc.json.view.verified.json")]
-    [InlineData("test/docfx.Snapshot.Tests/SamplesTest.Seed/api/toc.json.view.verified.json")]
-    [InlineData("test/docfx.Snapshot.Tests/SamplesTest.Seed/apipage/toc.json.view.verified.json")]
-    [InlineData("test/docfx.Snapshot.Tests/SamplesTest.Seed/articles/toc.json.view.verified.json")]
-    [InlineData("test/docfx.Snapshot.Tests/SamplesTest.Seed/md/toc.json.view.verified.json")]
-    [InlineData("test/docfx.Snapshot.Tests/SamplesTest.Seed/pdf/toc.json.view.verified.json")]
-    [InlineData("test/docfx.Snapshot.Tests/SamplesTest.Seed/restapi/toc.json.view.verified.json")]
-    [InlineData("test/docfx.Snapshot.Tests/SamplesTest.Seed/toc.json.view.verified.json")]
+    [TestMethod]
+    [DataRow("test/docfx.Snapshot.Tests/SamplesTest.CSharp/api/toc.json.view.verified.json")]
+    [DataRow("test/docfx.Snapshot.Tests/SamplesTest.Extensions/api/toc.json.view.verified.json")]
+    [DataRow("test/docfx.Snapshot.Tests/SamplesTest.Extensions/toc.json.view.verified.json")]
+    [DataRow("test/docfx.Snapshot.Tests/SamplesTest.Seed/api/toc.json.view.verified.json")]
+    [DataRow("test/docfx.Snapshot.Tests/SamplesTest.Seed/apipage/toc.json.view.verified.json")]
+    [DataRow("test/docfx.Snapshot.Tests/SamplesTest.Seed/articles/toc.json.view.verified.json")]
+    [DataRow("test/docfx.Snapshot.Tests/SamplesTest.Seed/md/toc.json.view.verified.json")]
+    [DataRow("test/docfx.Snapshot.Tests/SamplesTest.Seed/pdf/toc.json.view.verified.json")]
+    [DataRow("test/docfx.Snapshot.Tests/SamplesTest.Seed/restapi/toc.json.view.verified.json")]
+    [DataRow("test/docfx.Snapshot.Tests/SamplesTest.Seed/toc.json.view.verified.json")]
     public void JsonSchemaTest_Toc_Json(string path)
     {
         // Arrange
@@ -90,9 +91,9 @@ public void JsonSchemaTest_Toc_Json(string path)
         result.IsValid.Should().BeTrue();
     }
 
-    [Theory]
-    [InlineData("test/Docfx.Build.RestApi.WithPlugins.Tests/TestData/swagger/toc.yml")]
-    [InlineData("test/docfx.Snapshot.Tests/SamplesTest.SeedMarkdown/toc.verified.yml")]
+    [TestMethod]
+    [DataRow("test/Docfx.Build.RestApi.WithPlugins.Tests/TestData/swagger/toc.yml")]
+    [DataRow("test/docfx.Snapshot.Tests/SamplesTest.SeedMarkdown/toc.verified.yml")]
     public void JsonSchemaTest_Toc_Yaml(string path)
     {
         // Arrange
@@ -105,8 +106,8 @@ public void JsonSchemaTest_Toc_Yaml(string path)
         result.IsValid.Should().BeTrue();
     }
 
-    [Theory]
-    [InlineData("test/Docfx.Build.Tests/TestData/xrefmap.json")]
+    [TestMethod]
+    [DataRow("test/Docfx.Build.Tests/TestData/xrefmap.json")]
     public void JsonSchemaTest_XrefMap_Json(string path)
     {
         // Arrange
@@ -119,11 +120,11 @@ public void JsonSchemaTest_XrefMap_Json(string path)
         result.IsValid.Should().BeTrue();
     }
 
-    [Theory]
-    [InlineData("test/Docfx.Build.Tests/TestData/xrefmap.yml")]
-    [InlineData("test/docfx.Snapshot.Tests/SamplesTest.CSharp/xrefmap.verified.yml")]
-    [InlineData("test/docfx.Snapshot.Tests/SamplesTest.Extensions/xrefmap.verified.yml")]
-    [InlineData("test/docfx.Snapshot.Tests/SamplesTest.Seed/xrefmap.verified.yml")]
+    [TestMethod]
+    [DataRow("test/Docfx.Build.Tests/TestData/xrefmap.yml")]
+    [DataRow("test/docfx.Snapshot.Tests/SamplesTest.CSharp/xrefmap.verified.yml")]
+    [DataRow("test/docfx.Snapshot.Tests/SamplesTest.Extensions/xrefmap.verified.yml")]
+    [DataRow("test/docfx.Snapshot.Tests/SamplesTest.Seed/xrefmap.verified.yml")]
     public void JsonSchemaTest_XrefMap_Yaml(string path)
     {
         // Arrange
diff --git a/test/docfx.Tests/MetadataCommandTest.cs b/test/docfx.Tests/MetadataCommandTest.cs
index e01761fb414..1058b57e33a 100644
--- a/test/docfx.Tests/MetadataCommandTest.cs
+++ b/test/docfx.Tests/MetadataCommandTest.cs
@@ -9,7 +9,8 @@
 
 namespace Docfx.Tests;
 
-[Collection("docfx STA")]
+[DoNotParallelize]
+[TestClass]
 public class MetadataCommandTest : TestBase
 {
     /// <summary>
@@ -24,8 +25,8 @@ public MetadataCommandTest()
         _projectFolder = GetRandomFolder();
     }
 
-    [Fact]
-    [Trait("Related", "docfx")]
+    [TestMethod]
+    [TestProperty("Related", "docfx")]
     public async Task TestMetadataCommandFromCSProject()
     {
         var projectFile = Path.Combine(_projectFolder, "test.csproj");
@@ -40,8 +41,8 @@ await DotnetApiCatalog.Exec(
         CheckResult();
     }
 
-    [Fact]
-    [Trait("Related", "docfx")]
+    [TestMethod]
+    [TestProperty("Related", "docfx")]
     public async Task TestMetadataCommandFromDll()
     {
         var dllFile = Path.Combine(_projectFolder, "test.dll");
@@ -54,8 +55,8 @@ await DotnetApiCatalog.Exec(
         CheckResult();
     }
 
-    [Fact]
-    [Trait("Related", "docfx")]
+    [TestMethod]
+    [TestProperty("Related", "docfx")]
     public async Task TestMetadataCommandFromMultipleFrameworksCSProject()
     {
         // Create default project
@@ -76,8 +77,8 @@ await DotnetApiCatalog.Exec(
         CheckResult();
     }
 
-    [Fact]
-    [Trait("Related", "docfx")]
+    [TestMethod]
+    [TestProperty("Related", "docfx")]
     public async Task TestMetadataCommandFromVBProject()
     {
         if (!OperatingSystem.IsWindows())
@@ -93,54 +94,54 @@ await DotnetApiCatalog.Exec(
             new(new MetadataJsonItemConfig { Dest = _outputFolder, Src = new(new FileMappingItem(projectFile)) { Expanded = true } }),
             new(), Directory.GetCurrentDirectory());
 
-        Assert.True(File.Exists(Path.Combine(_outputFolder, ".manifest")));
+        Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, ".manifest")));
 
         var file = Path.Combine(_outputFolder, "toc.yml");
-        Assert.True(File.Exists(file));
+        Assert.IsTrue(File.Exists(file));
         var tocViewModel = YamlUtility.Deserialize<TocItemViewModel>(file).Items;
-        Assert.Equal("testVBproj1.Foo", tocViewModel[0].Uid);
-        Assert.Equal("testVBproj1.Foo", tocViewModel[0].Name);
-        Assert.Equal("testVBproj1.Foo.Bar", tocViewModel[0].Items[0].Uid);
-        Assert.Equal("Bar", tocViewModel[0].Items[0].Name);
+        Assert.AreEqual("testVBproj1.Foo", tocViewModel[0].Uid);
+        Assert.AreEqual("testVBproj1.Foo", tocViewModel[0].Name);
+        Assert.AreEqual("testVBproj1.Foo.Bar", tocViewModel[0].Items[0].Uid);
+        Assert.AreEqual("Bar", tocViewModel[0].Items[0].Name);
 
         file = Path.Combine(_outputFolder, "testVBproj1.Foo.yml");
-        Assert.True(File.Exists(file));
+        Assert.IsTrue(File.Exists(file));
         var memberViewModel = YamlUtility.Deserialize<PageViewModel>(file);
-        Assert.Equal("testVBproj1.Foo", memberViewModel.Items[0].Uid);
-        Assert.Equal("testVBproj1.Foo", memberViewModel.Items[0].Id);
-        Assert.Equal("testVBproj1.Foo", memberViewModel.Items[0].Name);
-        Assert.Equal("testVBproj1.Foo", memberViewModel.Items[0].FullName);
+        Assert.AreEqual("testVBproj1.Foo", memberViewModel.Items[0].Uid);
+        Assert.AreEqual("testVBproj1.Foo", memberViewModel.Items[0].Id);
+        Assert.AreEqual("testVBproj1.Foo", memberViewModel.Items[0].Name);
+        Assert.AreEqual("testVBproj1.Foo", memberViewModel.Items[0].FullName);
 
         file = Path.Combine(_outputFolder, "testVBproj1.Foo.Bar.yml");
-        Assert.True(File.Exists(file));
+        Assert.IsTrue(File.Exists(file));
         memberViewModel = YamlUtility.Deserialize<PageViewModel>(file);
-        Assert.Equal("testVBproj1.Foo.Bar", memberViewModel.Items[0].Uid);
-        Assert.Equal("Bar", memberViewModel.Items[0].Id);
-        Assert.Equal("Bar", memberViewModel.Items[0].Name);
-        Assert.Equal("testVBproj1.Foo.Bar", memberViewModel.Items[0].FullName);
-        Assert.Equal("testVBproj1.Foo.Bar.FooBar``1(System.Int32[],System.Byte,``0,System.Collections.Generic.List{``0[]})", memberViewModel.Items[1].Uid);
-        Assert.Equal("FooBar``1(System.Int32[],System.Byte,``0,System.Collections.Generic.List{``0[]})", memberViewModel.Items[1].Id);
-        Assert.Equal("FooBar<TArg>(int[], byte, TArg, List<TArg[]>)", memberViewModel.Items[1].Name);
-        Assert.Equal("testVBproj1.Foo.Bar.FooBar<TArg>(int[], byte, TArg, System.Collections.Generic.List<TArg[]>)", memberViewModel.Items[1].FullName);
-        Assert.NotNull(memberViewModel.References.Find(
+        Assert.AreEqual("testVBproj1.Foo.Bar", memberViewModel.Items[0].Uid);
+        Assert.AreEqual("Bar", memberViewModel.Items[0].Id);
+        Assert.AreEqual("Bar", memberViewModel.Items[0].Name);
+        Assert.AreEqual("testVBproj1.Foo.Bar", memberViewModel.Items[0].FullName);
+        Assert.AreEqual("testVBproj1.Foo.Bar.FooBar``1(System.Int32[],System.Byte,``0,System.Collections.Generic.List{``0[]})", memberViewModel.Items[1].Uid);
+        Assert.AreEqual("FooBar``1(System.Int32[],System.Byte,``0,System.Collections.Generic.List{``0[]})", memberViewModel.Items[1].Id);
+        Assert.AreEqual("FooBar<TArg>(int[], byte, TArg, List<TArg[]>)", memberViewModel.Items[1].Name);
+        Assert.AreEqual("testVBproj1.Foo.Bar.FooBar<TArg>(int[], byte, TArg, System.Collections.Generic.List<TArg[]>)", memberViewModel.Items[1].FullName);
+        Assert.IsNotNull(memberViewModel.References.Find(
             s => s.Uid.Equals("System.Collections.Generic.List{System.String}")
             ));
-        Assert.NotNull(memberViewModel.References.Find(
+        Assert.IsNotNull(memberViewModel.References.Find(
             s => s.Uid.Equals("System.Int32[]")
             ));
-        Assert.NotNull(memberViewModel.References.Find(
+        Assert.IsNotNull(memberViewModel.References.Find(
             s => s.Uid.Equals("System.Byte")
             ));
-        Assert.NotNull(memberViewModel.References.Find(
+        Assert.IsNotNull(memberViewModel.References.Find(
             s => s.Uid.Equals("{TArg}")
             ));
-        Assert.NotNull(memberViewModel.References.Find(
+        Assert.IsNotNull(memberViewModel.References.Find(
             s => s.Uid.Equals("System.Collections.Generic.List{{TArg}[]}")
             ));
     }
 
-    [Fact]
-    [Trait("Related", "docfx")]
+    [TestMethod]
+    [TestProperty("Related", "docfx")]
     public async Task TestMetadataCommandFromCSProjectWithFilterInOption()
     {
         // Create default project
@@ -160,37 +161,37 @@ await DotnetApiCatalog.Exec(
             }),
             new(), Directory.GetCurrentDirectory());
 
-        Assert.True(File.Exists(Path.Combine(_outputFolder, ".manifest")));
+        Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, ".manifest")));
 
         var file = Path.Combine(_outputFolder, "toc.yml");
-        Assert.True(File.Exists(file));
+        Assert.IsTrue(File.Exists(file));
         var tocViewModel = YamlUtility.Deserialize<TocItemViewModel>(file).Items;
-        Assert.Equal("Foo", tocViewModel[0].Uid);
-        Assert.Equal("Foo", tocViewModel[0].Name);
-        Assert.Equal("Foo.Bar", tocViewModel[0].Items[0].Uid);
-        Assert.Equal("Bar", tocViewModel[0].Items[0].Name);
+        Assert.AreEqual("Foo", tocViewModel[0].Uid);
+        Assert.AreEqual("Foo", tocViewModel[0].Name);
+        Assert.AreEqual("Foo.Bar", tocViewModel[0].Items[0].Uid);
+        Assert.AreEqual("Bar", tocViewModel[0].Items[0].Name);
 
         file = Path.Combine(_outputFolder, "Foo.yml");
-        Assert.True(File.Exists(file));
+        Assert.IsTrue(File.Exists(file));
         var memberViewModel = YamlUtility.Deserialize<PageViewModel>(file);
-        Assert.Equal("Foo", memberViewModel.Items[0].Uid);
-        Assert.Equal("Foo", memberViewModel.Items[0].Id);
-        Assert.Equal("Foo", memberViewModel.Items[0].Name);
-        Assert.Equal("Foo", memberViewModel.Items[0].FullName);
+        Assert.AreEqual("Foo", memberViewModel.Items[0].Uid);
+        Assert.AreEqual("Foo", memberViewModel.Items[0].Id);
+        Assert.AreEqual("Foo", memberViewModel.Items[0].Name);
+        Assert.AreEqual("Foo", memberViewModel.Items[0].FullName);
 
         file = Path.Combine(_outputFolder, "Foo.Bar.yml");
-        Assert.True(File.Exists(file));
+        Assert.IsTrue(File.Exists(file));
         memberViewModel = YamlUtility.Deserialize<PageViewModel>(file);
-        Assert.Equal("Foo.Bar", memberViewModel.Items[0].Uid);
-        Assert.Equal("Bar", memberViewModel.Items[0].Id);
-        Assert.Equal("Bar", memberViewModel.Items[0].Name);
-        Assert.Equal("Foo.Bar", memberViewModel.Items[0].FullName);
-        Assert.Single(memberViewModel.Items);
-        Assert.NotNull(memberViewModel.References.Find(s => s.Uid.Equals("Foo")));
+        Assert.AreEqual("Foo.Bar", memberViewModel.Items[0].Uid);
+        Assert.AreEqual("Bar", memberViewModel.Items[0].Id);
+        Assert.AreEqual("Bar", memberViewModel.Items[0].Name);
+        Assert.AreEqual("Foo.Bar", memberViewModel.Items[0].FullName);
+        Assert.ContainsSingle(memberViewModel.Items);
+        Assert.IsNotNull(memberViewModel.References.Find(s => s.Uid.Equals("Foo")));
     }
 
-    [Fact]
-    [Trait("Related", "docfx")]
+    [TestMethod]
+    [TestProperty("Related", "docfx")]
     public async Task TestMetadataCommandFromCSProjectWithDuplicateProjectReference()
     {
         // Create default project
@@ -208,8 +209,8 @@ await DotnetApiCatalog.Exec(
         CheckResult();
     }
 
-    [Fact]
-    [Trait("Related", "docfx")]
+    [TestMethod]
+    [TestProperty("Related", "docfx")]
     public async Task TestMetadataCommandFromCSProjectWithMultipleNamespaces()
     {
         var projectFile = Path.Combine(_projectFolder, "test.csproj");
@@ -227,28 +228,28 @@ await DotnetApiCatalog.Exec(
             new(), Directory.GetCurrentDirectory());
 
         var file = Path.Combine(_outputFolder, "toc.yml");
-        Assert.True(File.Exists(file));
+        Assert.IsTrue(File.Exists(file));
         var tocViewModel = YamlUtility.Deserialize<TocItemViewModel>(file).Items;
-        Assert.Equal("OtherNamespace", tocViewModel[0].Uid);
-        Assert.Equal("OtherNamespace", tocViewModel[0].Name);
+        Assert.AreEqual("OtherNamespace", tocViewModel[0].Uid);
+        Assert.AreEqual("OtherNamespace", tocViewModel[0].Name);
 
-        Assert.Equal("OtherNamespace.OtherBar", tocViewModel[0].Items[0].Uid);
-        Assert.Equal("OtherBar", tocViewModel[0].Items[0].Name);
+        Assert.AreEqual("OtherNamespace.OtherBar", tocViewModel[0].Items[0].Uid);
+        Assert.AreEqual("OtherBar", tocViewModel[0].Items[0].Name);
 
-        Assert.Equal("Samples.Foo", tocViewModel[1].Uid);
-        Assert.Equal("Samples.Foo", tocViewModel[1].Name);
+        Assert.AreEqual("Samples.Foo", tocViewModel[1].Uid);
+        Assert.AreEqual("Samples.Foo", tocViewModel[1].Name);
 
-        Assert.Equal("Samples.Foo.Sub", tocViewModel[1].Items[0].Uid);
-        Assert.Equal("Sub", tocViewModel[1].Items[0].Name);
-        Assert.Equal("Samples.Foo.Sub.SubBar", tocViewModel[1].Items[0].Items[0].Uid);
-        Assert.Equal("SubBar", tocViewModel[1].Items[0].Items[0].Name);
+        Assert.AreEqual("Samples.Foo.Sub", tocViewModel[1].Items[0].Uid);
+        Assert.AreEqual("Sub", tocViewModel[1].Items[0].Name);
+        Assert.AreEqual("Samples.Foo.Sub.SubBar", tocViewModel[1].Items[0].Items[0].Uid);
+        Assert.AreEqual("SubBar", tocViewModel[1].Items[0].Items[0].Name);
 
-        Assert.Equal("Samples.Foo.Bar", tocViewModel[1].Items[1].Uid);
-        Assert.Equal("Bar", tocViewModel[1].Items[1].Name);
+        Assert.AreEqual("Samples.Foo.Bar", tocViewModel[1].Items[1].Uid);
+        Assert.AreEqual("Bar", tocViewModel[1].Items[1].Name);
     }
 
-    [Fact]
-    [Trait("Related", "docfx")]
+    [TestMethod]
+    [TestProperty("Related", "docfx")]
     public async Task TestMetadataCommandFromCSProjectWithMultipleNamespacesWithFlatToc()
     {
         var projectFile = Path.Combine(_projectFolder, "test.csproj");
@@ -266,28 +267,28 @@ await DotnetApiCatalog.Exec(
             new(), Directory.GetCurrentDirectory());
 
         var file = Path.Combine(_outputFolder, "toc.yml");
-        Assert.True(File.Exists(file));
+        Assert.IsTrue(File.Exists(file));
         var tocViewModel = YamlUtility.Deserialize<TocItemViewModel>(file).Items;
-        Assert.Equal("OtherNamespace", tocViewModel[0].Uid);
-        Assert.Equal("OtherNamespace", tocViewModel[0].Name);
+        Assert.AreEqual("OtherNamespace", tocViewModel[0].Uid);
+        Assert.AreEqual("OtherNamespace", tocViewModel[0].Name);
 
-        Assert.Equal("OtherNamespace.OtherBar", tocViewModel[0].Items[0].Uid);
-        Assert.Equal("OtherBar", tocViewModel[0].Items[0].Name);
+        Assert.AreEqual("OtherNamespace.OtherBar", tocViewModel[0].Items[0].Uid);
+        Assert.AreEqual("OtherBar", tocViewModel[0].Items[0].Name);
 
-        Assert.Equal("Samples.Foo", tocViewModel[1].Uid);
-        Assert.Equal("Samples.Foo", tocViewModel[1].Name);
-        Assert.Equal("Samples.Foo.Bar", tocViewModel[1].Items[0].Uid);
-        Assert.Equal("Bar", tocViewModel[1].Items[0].Name);
+        Assert.AreEqual("Samples.Foo", tocViewModel[1].Uid);
+        Assert.AreEqual("Samples.Foo", tocViewModel[1].Name);
+        Assert.AreEqual("Samples.Foo.Bar", tocViewModel[1].Items[0].Uid);
+        Assert.AreEqual("Bar", tocViewModel[1].Items[0].Name);
 
-        Assert.Equal("Samples.Foo.Sub", tocViewModel[2].Uid);
-        Assert.Equal("Samples.Foo.Sub", tocViewModel[2].Name);
+        Assert.AreEqual("Samples.Foo.Sub", tocViewModel[2].Uid);
+        Assert.AreEqual("Samples.Foo.Sub", tocViewModel[2].Name);
 
-        Assert.Equal("Samples.Foo.Sub.SubBar", tocViewModel[2].Items[0].Uid);
-        Assert.Equal("SubBar", tocViewModel[2].Items[0].Name);
+        Assert.AreEqual("Samples.Foo.Sub.SubBar", tocViewModel[2].Items[0].Uid);
+        Assert.AreEqual("SubBar", tocViewModel[2].Items[0].Name);
     }
 
-    [Fact]
-    [Trait("Related", "docfx")]
+    [TestMethod]
+    [TestProperty("Related", "docfx")]
     public async Task TestMetadataCommandFromCSProjectWithMultipleNamespacesWithGapsWithNestedToc()
     {
         var projectFile = Path.Combine(_projectFolder, "test.csproj");
@@ -305,77 +306,77 @@ await DotnetApiCatalog.Exec(
             new(), Directory.GetCurrentDirectory());
 
         var file = Path.Combine(_outputFolder, "toc.yml");
-        Assert.True(File.Exists(file));
+        Assert.IsTrue(File.Exists(file));
         var tocViewModel = YamlUtility.Deserialize<TocItemViewModel>(file).Items;
-        Assert.Equal("OtherNamespace", tocViewModel[0].Uid);
-        Assert.Equal("OtherNamespace", tocViewModel[0].Name);
+        Assert.AreEqual("OtherNamespace", tocViewModel[0].Uid);
+        Assert.AreEqual("OtherNamespace", tocViewModel[0].Name);
 
-        Assert.Equal("OtherNamespace.OtherBar", tocViewModel[0].Items[0].Uid);
-        Assert.Equal("OtherBar", tocViewModel[0].Items[0].Name);
+        Assert.AreEqual("OtherNamespace.OtherBar", tocViewModel[0].Items[0].Uid);
+        Assert.AreEqual("OtherBar", tocViewModel[0].Items[0].Name);
 
-        Assert.Equal("Samples.Foo", tocViewModel[1].Uid);
-        Assert.Equal("Samples.Foo", tocViewModel[1].Name);
+        Assert.AreEqual("Samples.Foo", tocViewModel[1].Uid);
+        Assert.AreEqual("Samples.Foo", tocViewModel[1].Name);
 
-        Assert.Equal("Samples.Foo.Sub", tocViewModel[1].Items[0].Uid);
-        Assert.Equal("Sub", tocViewModel[1].Items[0].Name);
-        Assert.Equal("Samples.Foo.Sub.Subber1", tocViewModel[1].Items[0].Items[0].Uid);
-        Assert.Equal("Subber1", tocViewModel[1].Items[0].Items[0].Name);
-        Assert.Equal("Samples.Foo.Sub.Subber1.SubberBar", tocViewModel[1].Items[0].Items[0].Items[0].Uid);
-        Assert.Equal("SubberBar", tocViewModel[1].Items[0].Items[0].Items[0].Name);
+        Assert.AreEqual("Samples.Foo.Sub", tocViewModel[1].Items[0].Uid);
+        Assert.AreEqual("Sub", tocViewModel[1].Items[0].Name);
+        Assert.AreEqual("Samples.Foo.Sub.Subber1", tocViewModel[1].Items[0].Items[0].Uid);
+        Assert.AreEqual("Subber1", tocViewModel[1].Items[0].Items[0].Name);
+        Assert.AreEqual("Samples.Foo.Sub.Subber1.SubberBar", tocViewModel[1].Items[0].Items[0].Items[0].Uid);
+        Assert.AreEqual("SubberBar", tocViewModel[1].Items[0].Items[0].Items[0].Name);
 
-        Assert.Equal("Samples.Foo.Sub.Subber2", tocViewModel[1].Items[0].Items[1].Uid);
-        Assert.Equal("Subber2", tocViewModel[1].Items[0].Items[1].Name);
-        Assert.Equal("Samples.Foo.Sub.Subber2.Subber2Bar", tocViewModel[1].Items[0].Items[1].Items[0].Uid);
-        Assert.Equal("Subber2Bar", tocViewModel[1].Items[0].Items[1].Items[0].Name);
+        Assert.AreEqual("Samples.Foo.Sub.Subber2", tocViewModel[1].Items[0].Items[1].Uid);
+        Assert.AreEqual("Subber2", tocViewModel[1].Items[0].Items[1].Name);
+        Assert.AreEqual("Samples.Foo.Sub.Subber2.Subber2Bar", tocViewModel[1].Items[0].Items[1].Items[0].Uid);
+        Assert.AreEqual("Subber2Bar", tocViewModel[1].Items[0].Items[1].Items[0].Name);
 
-        Assert.Equal("Samples.Foo.Bar", tocViewModel[1].Items[1].Uid);
-        Assert.Equal("Bar", tocViewModel[1].Items[1].Name);
+        Assert.AreEqual("Samples.Foo.Bar", tocViewModel[1].Items[1].Uid);
+        Assert.AreEqual("Bar", tocViewModel[1].Items[1].Name);
     }
 
     private void CheckResult()
     {
-        Assert.True(File.Exists(Path.Combine(_outputFolder, ".manifest")));
+        Assert.IsTrue(File.Exists(Path.Combine(_outputFolder, ".manifest")));
 
         var file = Path.Combine(_outputFolder, "toc.yml");
-        Assert.True(File.Exists(file));
+        Assert.IsTrue(File.Exists(file));
         var tocViewModel = YamlUtility.Deserialize<TocItemViewModel>(file).Items;
-        Assert.Equal("Foo", tocViewModel[0].Uid);
-        Assert.Equal("Foo", tocViewModel[0].Name);
-        Assert.Equal("Foo.Bar", tocViewModel[0].Items[0].Uid);
-        Assert.Equal("Bar", tocViewModel[0].Items[0].Name);
+        Assert.AreEqual("Foo", tocViewModel[0].Uid);
+        Assert.AreEqual("Foo", tocViewModel[0].Name);
+        Assert.AreEqual("Foo.Bar", tocViewModel[0].Items[0].Uid);
+        Assert.AreEqual("Bar", tocViewModel[0].Items[0].Name);
 
         file = Path.Combine(_outputFolder, "Foo.yml");
-        Assert.True(File.Exists(file));
+        Assert.IsTrue(File.Exists(file));
         var memberViewModel = YamlUtility.Deserialize<PageViewModel>(file);
-        Assert.Equal("Foo", memberViewModel.Items[0].Uid);
-        Assert.Equal("Foo", memberViewModel.Items[0].Id);
-        Assert.Equal("Foo", memberViewModel.Items[0].Name);
-        Assert.Equal("Foo", memberViewModel.Items[0].FullName);
+        Assert.AreEqual("Foo", memberViewModel.Items[0].Uid);
+        Assert.AreEqual("Foo", memberViewModel.Items[0].Id);
+        Assert.AreEqual("Foo", memberViewModel.Items[0].Name);
+        Assert.AreEqual("Foo", memberViewModel.Items[0].FullName);
 
         file = Path.Combine(_outputFolder, "Foo.Bar.yml");
-        Assert.True(File.Exists(file));
+        Assert.IsTrue(File.Exists(file));
         memberViewModel = YamlUtility.Deserialize<PageViewModel>(file);
-        Assert.Equal("Foo.Bar", memberViewModel.Items[0].Uid);
-        Assert.Equal("Bar", memberViewModel.Items[0].Id);
-        Assert.Equal("Bar", memberViewModel.Items[0].Name);
-        Assert.Equal("Foo.Bar", memberViewModel.Items[0].FullName);
-        Assert.Equal("Foo.Bar.FooBar``1(System.Int32[],System.Byte*,``0,System.Collections.Generic.List{``0[]})", memberViewModel.Items[1].Uid);
-        Assert.Equal("FooBar``1(System.Int32[],System.Byte*,``0,System.Collections.Generic.List{``0[]})", memberViewModel.Items[1].Id);
-        Assert.Equal("FooBar<TArg>(int[], byte*, TArg, List<TArg[]>)", memberViewModel.Items[1].Name);
-        Assert.Equal("Foo.Bar.FooBar<TArg>(int[], byte*, TArg, System.Collections.Generic.List<TArg[]>)", memberViewModel.Items[1].FullName);
-        Assert.NotNull(memberViewModel.References.Find(
+        Assert.AreEqual("Foo.Bar", memberViewModel.Items[0].Uid);
+        Assert.AreEqual("Bar", memberViewModel.Items[0].Id);
+        Assert.AreEqual("Bar", memberViewModel.Items[0].Name);
+        Assert.AreEqual("Foo.Bar", memberViewModel.Items[0].FullName);
+        Assert.AreEqual("Foo.Bar.FooBar``1(System.Int32[],System.Byte*,``0,System.Collections.Generic.List{``0[]})", memberViewModel.Items[1].Uid);
+        Assert.AreEqual("FooBar``1(System.Int32[],System.Byte*,``0,System.Collections.Generic.List{``0[]})", memberViewModel.Items[1].Id);
+        Assert.AreEqual("FooBar<TArg>(int[], byte*, TArg, List<TArg[]>)", memberViewModel.Items[1].Name);
+        Assert.AreEqual("Foo.Bar.FooBar<TArg>(int[], byte*, TArg, System.Collections.Generic.List<TArg[]>)", memberViewModel.Items[1].FullName);
+        Assert.IsNotNull(memberViewModel.References.Find(
             s => s.Uid.Equals("System.Collections.Generic.List{System.String}")
             ));
-        Assert.NotNull(memberViewModel.References.Find(
+        Assert.IsNotNull(memberViewModel.References.Find(
             s => s.Uid.Equals("System.Int32[]")
             ));
-        Assert.NotNull(memberViewModel.References.Find(
+        Assert.IsNotNull(memberViewModel.References.Find(
             s => s.Uid.Equals("System.Byte*")
             ));
-        Assert.NotNull(memberViewModel.References.Find(
+        Assert.IsNotNull(memberViewModel.References.Find(
             s => s.Uid.Equals("{TArg}")
             ));
-        Assert.NotNull(memberViewModel.References.Find(
+        Assert.IsNotNull(memberViewModel.References.Find(
             s => s.Uid.Equals("System.Collections.Generic.List{{TArg}[]}")
             ));
     }
diff --git a/test/docfx.Tests/SerializationTests/JsonSerializationEncoderTest.cs b/test/docfx.Tests/SerializationTests/JsonSerializationEncoderTest.cs
index f01b44e125d..c3e9d343a4d 100644
--- a/test/docfx.Tests/SerializationTests/JsonSerializationEncoderTest.cs
+++ b/test/docfx.Tests/SerializationTests/JsonSerializationEncoderTest.cs
@@ -6,17 +6,18 @@
 
 namespace docfx.Tests;
 
+[TestClass]
 public partial class JsonSerializationEncoderTest
 {
-    [Theory]
-    [InlineData("abcdefghighlmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")]
-    [InlineData("0123456789")]
-    [InlineData("\0\a\b\t\n\v\f\r\e")]
-    [InlineData("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~")]
-    [InlineData("①②③")] // NonAscii chars (Enclosed Alphanumerics)
-    [InlineData("１２３")] // NonAscii chars (Full-width digits)
-    [InlineData("äöü")]   // Umlaut
-    [InlineData("漢字")]   // Kanji
+    [TestMethod]
+    [DataRow("abcdefghighlmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")]
+    [DataRow("0123456789")]
+    [DataRow("\0\a\b\t\n\v\f\r\e")]
+    [DataRow("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~")]
+    [DataRow("①②③")] // NonAscii chars (Enclosed Alphanumerics)
+    [DataRow("１２３")] // NonAscii chars (Full-width digits)
+    [DataRow("äöü")]   // Umlaut
+    [DataRow("漢字")]   // Kanji
     public void JsonEncoderTest(string data)
     {
         // Arrange
@@ -33,11 +34,11 @@ public void JsonEncoderTest(string data)
         ((object)systemTextJsonResult).Should().Be(newtonsoftJsonResult, StringComparer.OrdinalIgnoreCase); // Currently StringAssertions don't expose overload that accepts StringComparer. (See: https://github.com/fluentassertions/fluentassertions/issues/2720)
     }
 
-    [Theory]
-    [InlineData("　", @"\u3000")]                                 // Full-Width space (Excaped by global block list (https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/character-encoding#global-block-list))
-    [InlineData("𠮟", @"\uD842\uDF9F")]                           // Kanji (that use Surrogate Pair)
-    [InlineData("📄", @"\uD83D\uDCC4")]                          // Emoji
-    [InlineData("👁‍🗨", @"\uD83D\uDC41‍\uD83D\uDDE8")] // Emoji (with ZWJ (ZERO WIDTH JOINER))
+    [TestMethod]
+    [DataRow("　", @"\u3000")]                                 // Full-Width space (Excaped by global block list (https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/character-encoding#global-block-list))
+    [DataRow("𠮟", @"\uD842\uDF9F")]                           // Kanji (that use Surrogate Pair)
+    [DataRow("📄", @"\uD83D\uDCC4")]                          // Emoji
+    [DataRow("👁‍🗨", @"\uD83D\uDC41‍\uD83D\uDDE8")] // Emoji (with ZWJ (ZERO WIDTH JOINER))
     public void JsonEncoderTest_NoCompatibility(string data, string expected)
     {
         // Arrange
diff --git a/test/docfx.Tests/SerializationTests/JsonSerializationTest.BuildJsonConfig.cs b/test/docfx.Tests/SerializationTests/JsonSerializationTest.BuildJsonConfig.cs
index f479f417ecc..69d5954f6c2 100644
--- a/test/docfx.Tests/SerializationTests/JsonSerializationTest.BuildJsonConfig.cs
+++ b/test/docfx.Tests/SerializationTests/JsonSerializationTest.BuildJsonConfig.cs
@@ -7,7 +7,7 @@ namespace docfx.Tests;
 
 public partial class JsonSerializationTest
 {
-    [Theory]
+    [TestMethod]
     [TestData<BuildJsonConfig>]
     public void JsonSerializationTest_BuildJsonConfig(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/JsonSerializationTest.DocfxConfig.cs b/test/docfx.Tests/SerializationTests/JsonSerializationTest.DocfxConfig.cs
index 4cdc1bcd705..e8b270ef25c 100644
--- a/test/docfx.Tests/SerializationTests/JsonSerializationTest.DocfxConfig.cs
+++ b/test/docfx.Tests/SerializationTests/JsonSerializationTest.DocfxConfig.cs
@@ -7,7 +7,7 @@ namespace docfx.Tests;
 
 public partial class JsonSerializationTest
 {
-    [Theory]
+    [TestMethod]
     [TestData<DocfxConfig>]
     public void JsonSerializationTest_DocfxConfig(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/JsonSerializationTest.FileMapping.cs b/test/docfx.Tests/SerializationTests/JsonSerializationTest.FileMapping.cs
index 7b68bee9566..3f255e3912b 100644
--- a/test/docfx.Tests/SerializationTests/JsonSerializationTest.FileMapping.cs
+++ b/test/docfx.Tests/SerializationTests/JsonSerializationTest.FileMapping.cs
@@ -7,7 +7,7 @@ namespace docfx.Tests;
 
 public partial class JsonSerializationTest
 {
-    [Theory]
+    [TestMethod]
     [TestData<FileMapping>]
     public void JsonSerializationTest_FileMapping(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/JsonSerializationTest.FileMetadataPairs.cs b/test/docfx.Tests/SerializationTests/JsonSerializationTest.FileMetadataPairs.cs
index 496b86868af..6a3082fddce 100644
--- a/test/docfx.Tests/SerializationTests/JsonSerializationTest.FileMetadataPairs.cs
+++ b/test/docfx.Tests/SerializationTests/JsonSerializationTest.FileMetadataPairs.cs
@@ -7,7 +7,7 @@ namespace docfx.Tests;
 
 public partial class JsonSerializationTest
 {
-    [Theory]
+    [TestMethod]
     [TestData<FileMetadataPairs>]
     public void JsonSerializationTest_FileMetadataPairs(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/JsonSerializationTest.ListWithStringFallback.cs b/test/docfx.Tests/SerializationTests/JsonSerializationTest.ListWithStringFallback.cs
index 05bf661d959..bfbeea98c23 100644
--- a/test/docfx.Tests/SerializationTests/JsonSerializationTest.ListWithStringFallback.cs
+++ b/test/docfx.Tests/SerializationTests/JsonSerializationTest.ListWithStringFallback.cs
@@ -7,7 +7,7 @@ namespace docfx.Tests;
 
 public partial class JsonSerializationTest
 {
-    [Theory]
+    [TestMethod]
     [TestData<ListWithStringFallback>]
     public void JsonSerializationTest_ListWithStringFallback(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/JsonSerializationTest.Manifest.cs b/test/docfx.Tests/SerializationTests/JsonSerializationTest.Manifest.cs
index 8c425f89b9a..5fa50ace482 100644
--- a/test/docfx.Tests/SerializationTests/JsonSerializationTest.Manifest.cs
+++ b/test/docfx.Tests/SerializationTests/JsonSerializationTest.Manifest.cs
@@ -7,7 +7,7 @@ namespace docfx.Tests;
 
 public partial class JsonSerializationTest
 {
-    [Theory]
+    [TestMethod]
     [TestData<Manifest>]
     public void JsonSerializationTest_Manifest(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/JsonSerializationTest.MarkdownServiceProperties.cs b/test/docfx.Tests/SerializationTests/JsonSerializationTest.MarkdownServiceProperties.cs
index 8e4c693a560..9e8d92f9a92 100644
--- a/test/docfx.Tests/SerializationTests/JsonSerializationTest.MarkdownServiceProperties.cs
+++ b/test/docfx.Tests/SerializationTests/JsonSerializationTest.MarkdownServiceProperties.cs
@@ -9,7 +9,7 @@ namespace docfx.Tests;
 
 public partial class JsonSerializationTest
 {
-    [Theory]
+    [TestMethod]
     [TestData<MarkdownServiceProperties>]
     public void JsonSerializationTest_MarkdownServiceProperties(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/JsonSerializationTest.MergeJsonConfig.cs b/test/docfx.Tests/SerializationTests/JsonSerializationTest.MergeJsonConfig.cs
index 0abb22f8dee..a20b119ae2f 100644
--- a/test/docfx.Tests/SerializationTests/JsonSerializationTest.MergeJsonConfig.cs
+++ b/test/docfx.Tests/SerializationTests/JsonSerializationTest.MergeJsonConfig.cs
@@ -7,7 +7,7 @@ namespace docfx.Tests;
 
 public partial class JsonSerializationTest
 {
-    [Theory]
+    [TestMethod]
     [TestData<MergeJsonConfig>]
     public void JsonSerializationTest_MergeJsonConfig(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/JsonSerializationTest.MetadataJsonConfig.cs b/test/docfx.Tests/SerializationTests/JsonSerializationTest.MetadataJsonConfig.cs
index e1eff91f639..90f1595c7f8 100644
--- a/test/docfx.Tests/SerializationTests/JsonSerializationTest.MetadataJsonConfig.cs
+++ b/test/docfx.Tests/SerializationTests/JsonSerializationTest.MetadataJsonConfig.cs
@@ -7,7 +7,7 @@ namespace docfx.Tests;
 
 public partial class JsonSerializationTest
 {
-    [Theory]
+    [TestMethod]
     [TestData<MetadataJsonConfig>]
     public void JsonSerializationTest_MetadataJsonConfig(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/JsonSerializationTest.TocItemViewModel.cs b/test/docfx.Tests/SerializationTests/JsonSerializationTest.TocItemViewModel.cs
index 3d248bfab97..753cf092bf0 100644
--- a/test/docfx.Tests/SerializationTests/JsonSerializationTest.TocItemViewModel.cs
+++ b/test/docfx.Tests/SerializationTests/JsonSerializationTest.TocItemViewModel.cs
@@ -7,7 +7,7 @@ namespace docfx.Tests;
 
 public partial class JsonSerializationTest
 {
-    [Theory]
+    [TestMethod]
     [TestData<TocItemViewModel>]
     public void JsonSerializationTest_TocItemViewModel(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/JsonSerializationTest.XRefMap.cs b/test/docfx.Tests/SerializationTests/JsonSerializationTest.XRefMap.cs
index ccf7f032eaa..e293573b011 100644
--- a/test/docfx.Tests/SerializationTests/JsonSerializationTest.XRefMap.cs
+++ b/test/docfx.Tests/SerializationTests/JsonSerializationTest.XRefMap.cs
@@ -7,7 +7,7 @@ namespace docfx.Tests;
 
 public partial class JsonSerializationTest
 {
-    [Theory]
+    [TestMethod]
     [TestData<XRefMap>]
     public void JsonSerializationTest_XRefMap(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/JsonSerializationTest.cs b/test/docfx.Tests/SerializationTests/JsonSerializationTest.cs
index 8acd8b9e54d..d7d8d1562e3 100644
--- a/test/docfx.Tests/SerializationTests/JsonSerializationTest.cs
+++ b/test/docfx.Tests/SerializationTests/JsonSerializationTest.cs
@@ -8,6 +8,7 @@
 
 namespace docfx.Tests;
 
+[TestClass]
 public partial class JsonSerializationTest
 {
     /// <summary>
diff --git a/test/docfx.Tests/SerializationTests/TestData/TestDataAttribute.cs b/test/docfx.Tests/SerializationTests/TestData/TestDataAttribute.cs
index 1e53e2bc5ec..5f093bac3e4 100644
--- a/test/docfx.Tests/SerializationTests/TestData/TestDataAttribute.cs
+++ b/test/docfx.Tests/SerializationTests/TestData/TestDataAttribute.cs
@@ -2,13 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Reflection;
-using Xunit.Sdk;
 
 namespace docfx.Tests;
 
-public class TestDataAttribute<T> : DataAttribute
+public class TestDataAttribute<T> : Attribute, ITestDataSource
 {
-    public override IEnumerable<object[]> GetData(MethodInfo testMethod)
+    public IEnumerable<object[]> GetData(MethodInfo testMethod)
     {
         var key = GetTestDataKey();
         var paths = TestData.GetTestDataFilePaths(key);
@@ -28,7 +27,10 @@ public override IEnumerable<object[]> GetData(MethodInfo testMethod)
                 throw new NotSupportedException($"{className} is not supported.");
         }
 
-        return new TheoryData<string>(paths);
+        foreach (var path in paths)
+        {
+            yield return new object[] { path };
+        }
     }
 
     private static string GetTestDataKey()
@@ -46,4 +48,6 @@ private static string GetTestDataKey()
                 return type.Name;
         }
     }
+
+    public string GetDisplayName(MethodInfo methodInfo, object[] data) => null;
 }
diff --git a/test/docfx.Tests/SerializationTests/YamlSerializationTest.ApiPage.cs b/test/docfx.Tests/SerializationTests/YamlSerializationTest.ApiPage.cs
index 2230c9d82b2..29d1d5df287 100644
--- a/test/docfx.Tests/SerializationTests/YamlSerializationTest.ApiPage.cs
+++ b/test/docfx.Tests/SerializationTests/YamlSerializationTest.ApiPage.cs
@@ -14,7 +14,7 @@ public partial class YamlSerializationTest
 {
     private static IDeserializer deserializer = new DeserializerBuilder().WithAttemptingUnquotedStringTypeDeserialization().Build();
 
-    [Theory]
+    [TestMethod]
     [TestData<ApiPage>]
     public void YamlSerializationTest_ApiPage(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/YamlSerializationTest.FilterConfig.cs b/test/docfx.Tests/SerializationTests/YamlSerializationTest.FilterConfig.cs
index 5385f8d5092..9d7eef60a1b 100644
--- a/test/docfx.Tests/SerializationTests/YamlSerializationTest.FilterConfig.cs
+++ b/test/docfx.Tests/SerializationTests/YamlSerializationTest.FilterConfig.cs
@@ -7,7 +7,7 @@ namespace docfx.Tests;
 
 public partial class YamlSerializationTest
 {
-    [Theory]
+    [TestMethod]
     [TestData<ConfigFilterRule>]
     public void YamlSerializationTest_FilterConfig(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/YamlSerializationTest.ManagedReference.cs b/test/docfx.Tests/SerializationTests/YamlSerializationTest.ManagedReference.cs
index 505598ef3fe..37bea7fd43b 100644
--- a/test/docfx.Tests/SerializationTests/YamlSerializationTest.ManagedReference.cs
+++ b/test/docfx.Tests/SerializationTests/YamlSerializationTest.ManagedReference.cs
@@ -7,7 +7,7 @@ namespace docfx.Tests;
 
 public partial class YamlSerializationTest
 {
-    [Theory]
+    [TestMethod]
     [TestData<PageViewModel>]
     public void YamlSerializationTest_ManagedReference(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/YamlSerializationTest.TocItemViewModel.cs b/test/docfx.Tests/SerializationTests/YamlSerializationTest.TocItemViewModel.cs
index b4486079209..a2352a8dd81 100644
--- a/test/docfx.Tests/SerializationTests/YamlSerializationTest.TocItemViewModel.cs
+++ b/test/docfx.Tests/SerializationTests/YamlSerializationTest.TocItemViewModel.cs
@@ -7,7 +7,7 @@ namespace docfx.Tests;
 
 public partial class YamlSerializationTest
 {
-    [Theory]
+    [TestMethod]
     [TestData<TocItemViewModel>]
     public void YamlSerializationTest_TocItemViewModel(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/YamlSerializationTest.UniversalReference.cs b/test/docfx.Tests/SerializationTests/YamlSerializationTest.UniversalReference.cs
index 15eaf1a2d99..105499330b8 100644
--- a/test/docfx.Tests/SerializationTests/YamlSerializationTest.UniversalReference.cs
+++ b/test/docfx.Tests/SerializationTests/YamlSerializationTest.UniversalReference.cs
@@ -7,7 +7,7 @@ namespace docfx.Tests;
 
 public partial class YamlSerializationTest
 {
-    [Theory]
+    [TestMethod]
     [TestData<PageViewModel>]
     public void YamlSerializationTest_Universal(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/YamlSerializationTest.XRefMap.cs b/test/docfx.Tests/SerializationTests/YamlSerializationTest.XRefMap.cs
index 9d512152db9..ee4617bc775 100644
--- a/test/docfx.Tests/SerializationTests/YamlSerializationTest.XRefMap.cs
+++ b/test/docfx.Tests/SerializationTests/YamlSerializationTest.XRefMap.cs
@@ -7,7 +7,7 @@ namespace docfx.Tests;
 
 public partial class YamlSerializationTest
 {
-    [Theory]
+    [TestMethod]
     [TestData<XRefMap>]
     public void YamlSerializationTest_XRefMap(string path)
     {
diff --git a/test/docfx.Tests/SerializationTests/YamlSerializationTest.cs b/test/docfx.Tests/SerializationTests/YamlSerializationTest.cs
index 8ca63495949..47b36fa5bda 100644
--- a/test/docfx.Tests/SerializationTests/YamlSerializationTest.cs
+++ b/test/docfx.Tests/SerializationTests/YamlSerializationTest.cs
@@ -8,6 +8,7 @@
 using FluentAssertions.Equivalency;
 namespace docfx.Tests;
 
+[TestClass]
 public partial class YamlSerializationTest
 {
     private static readonly ThreadLocal<YamlSerializer> YamlJsonSerializer = new(() => new YamlSerializer(SerializationOptions.JsonCompatible | SerializationOptions.DisableAliases));
diff --git a/test/docfx.Tests/docfx.Tests.csproj b/test/docfx.Tests/docfx.Tests.csproj
index 13bd2fdfaf3..d3c8444b924 100644
--- a/test/docfx.Tests/docfx.Tests.csproj
+++ b/test/docfx.Tests/docfx.Tests.csproj
@@ -5,7 +5,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Verify.Xunit" />
+    <PackageReference Include="Verify.MSTest" />
   </ItemGroup>
 
   <ItemGroup>