Migrate to NUnit 4 based on https://docs.nunit.org/articles/nunit/release-notes/Nunit4.0-MigrationGuide.html. Needed fix for https://github.com/nunit/nunit/issues/4564

Directory.Packages.props

@@ -29,7 +29,7 @@
 	<PackageVersion Include="Mono.Cecil" Version="0.11.5" />
 	<PackageVersion Include="NSubstitute" Version="5.0.0" />
 	<PackageVersion Include="NSubstitute.Analyzers.CSharp" Version="1.0.16" />
-	<PackageVersion Include="NUnit" Version="3.14.0" />
+	<PackageVersion Include="NUnit" Version="4.0.0" />
 	<PackageVersion Include="NUnit3TestAdapter" Version="4.5.0" />
 	<PackageVersion Include="NuGet.Protocol" Version="6.8.0" />
 	<PackageVersion Include="PowerShellStandard.Library" Version="5.1.1" />

ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs

@@ -46,7 +46,7 @@ namespace ICSharpCode.Decompiler.Tests
 				if (file.Extension == ".txt" || file.Extension == ".exe" || file.Extension == ".config")
 					continue;
 				var testName = Path.GetFileNameWithoutExtension(file.Name);
-				Assert.Contains(testName, testNames);
+				Assert.That(testNames, Has.Member(testName));
 			}
 		}
 
@@ -486,7 +486,7 @@ namespace ICSharpCode.Decompiler.Tests
 			bool optionsForce32Bit = options.HasFlag(CompilerOptions.Force32Bit);
 			bool asmOptionsForce32Bit = asmOptions.HasFlag(AssemblerOptions.Force32Bit);
 
-			Assert.AreEqual(optionsForce32Bit, asmOptionsForce32Bit, "Inconsistent architecture.");
+			Assert.That(asmOptionsForce32Bit, Is.EqualTo(optionsForce32Bit), "Inconsistent architecture.");
 
 			try
 			{

ICSharpCode.Decompiler.Tests/DataFlowTest.cs

@@ -45,11 +45,11 @@ namespace ICSharpCode.Decompiler.Tests
 
 			protected internal override void VisitTryFinally(TryFinally inst)
 			{
-				Assert.IsTrue(IsPotentiallyUninitialized(state, v));
+				Assert.That(IsPotentiallyUninitialized(state, v));
 				base.VisitTryFinally(inst);
-				Assert.IsTrue(state.IsReachable);
-				Assert.AreEqual(1, GetStores(state, v).Count());
-				Assert.IsFalse(IsPotentiallyUninitialized(state, v));
+				Assert.That(state.IsReachable);
+				Assert.That(GetStores(state, v).Count(), Is.EqualTo(1));
+				Assert.That(!IsPotentiallyUninitialized(state, v));
 			}
 		}
 

ICSharpCode.Decompiler.Tests/DisassemblerPrettyTestRunner.cs

@@ -47,7 +47,7 @@ namespace ICSharpCode.Decompiler.Tests
 				if (file.Extension.Equals(".il", StringComparison.OrdinalIgnoreCase))
 				{
 					var testName = file.Name.Split('.')[0];
-					Assert.Contains(testName, testNames);
+					Assert.That(testNames, Has.Member(testName));
 				}
 			}
 		}

ICSharpCode.Decompiler.Tests/Helpers/Tester.VB.cs

@@ -133,7 +133,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
 				{
 					Console.WriteLine("errors:" + Environment.NewLine + result.StandardError);
 				}
-				Assert.AreEqual(0, result.ExitCode, "vbc failed");
+				Assert.That(result.ExitCode, Is.EqualTo(0), "vbc failed");
 
 				return results;
 			}

ICSharpCode.Decompiler.Tests/Helpers/Tester.cs

@@ -198,7 +198,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
 			{
 				Console.WriteLine("errors:" + Environment.NewLine + result.StandardError);
 			}
-			Assert.AreEqual(0, result.ExitCode, "ilasm failed");
+			Assert.That(result.ExitCode, Is.EqualTo(0), "ilasm failed");
 
 			return outputFile;
 		}
@@ -251,7 +251,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
 			{
 				Console.WriteLine("errors:" + Environment.NewLine + result.StandardError);
 			}
-			Assert.AreEqual(0, result.ExitCode, "ildasm failed");
+			Assert.That(result.ExitCode, Is.EqualTo(0), "ildasm failed");
 
 			// Unlike the .imagebase directive (which is a fixed value when compiling with /deterministic),
 			// the image base comment still varies... ildasm putting a random number here?
@@ -520,7 +520,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
 					Console.WriteLine("errors:" + Environment.NewLine + result.StandardError);
 				}
 
-				Assert.AreEqual(0, result.ExitCode, "csc failed");
+				Assert.That(result.ExitCode, Is.EqualTo(0), "csc failed");
 
 				return results;
 			}
@@ -582,7 +582,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
 				{
 					Console.WriteLine("errors:" + Environment.NewLine + result.StandardError);
 				}
-				Assert.AreEqual(0, result.ExitCode, "mcs failed");
+				Assert.That(result.ExitCode, Is.EqualTo(0), "mcs failed");
 
 				return results;
 			}
@@ -764,8 +764,8 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
 				(result2, output2, error2) = await Run(decompiledOutputFile).ConfigureAwait(false);
 			}
 
-			Assert.AreEqual(0, result1, "Exit code != 0; did the test case crash?" + Environment.NewLine + error1);
-			Assert.AreEqual(0, result2, "Exit code != 0; did the decompiled code crash?" + Environment.NewLine + error2);
+			Assert.That(result1, Is.EqualTo(0), "Exit code != 0; did the test case crash?" + Environment.NewLine + error1);
+			Assert.That(result2, Is.EqualTo(0), "Exit code != 0; did the decompiled code crash?" + Environment.NewLine + error2);
 
 			if (output1 != output2 || error1 != error2)
 			{
@@ -851,7 +851,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
 				.WithValidation(CommandResultValidation.None);
 
 			var result = await command.ExecuteBufferedAsync().ConfigureAwait(false);
-			Assert.AreEqual(0, result.ExitCode, "sn failed");
+			Assert.That(result.ExitCode, Is.EqualTo(0), "sn failed");
 
 			if (!string.IsNullOrWhiteSpace(result.StandardOutput))
 			{

ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj

@@ -109,6 +109,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <Compile Include="..\ILSpy.Tests\Workaround4564.cs" Link="Workaround4564.cs" />
     <Compile Include="DisassemblerPrettyTestRunner.cs" />
     <Compile Include="Helpers\RoslynToolset.cs" />
     <Compile Include="Output\InsertParenthesesVisitorTests.cs" />

ICSharpCode.Decompiler.Tests/ILPrettyTestRunner.cs

@@ -45,8 +45,8 @@ namespace ICSharpCode.Decompiler.Tests
 				if (file.Extension.Equals(".il", StringComparison.OrdinalIgnoreCase))
 				{
 					var testName = file.Name.Split('.')[0];
-					Assert.Contains(testName, testNames);
-					Assert.IsTrue(File.Exists(Path.Combine(TestCasePath, testName + ".cs")));
+					Assert.That(testNames, Has.Member(testName));
+					Assert.That(File.Exists(Path.Combine(TestCasePath, testName + ".cs")));
 				}
 			}
 		}

ICSharpCode.Decompiler.Tests/Output/CSharpAmbienceTests.cs

@@ -55,7 +55,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 			}
 
 			var foundType = compilation.FindType(type).GetDefinition();
-			Assert.IsNotNull(foundType);
+			Assert.That(foundType, Is.Not.Null);
 			return foundType;
 		}
 
@@ -76,7 +76,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 		{
 			var typeDef = GetDefinition(typeof(Dictionary<,>));
 			ambience.ConversionFlags = flags;
-			Assert.AreEqual(expectedOutput, ambience.ConvertSymbol(typeDef));
+			Assert.That(ambience.ConvertSymbol(typeDef), Is.EqualTo(expectedOutput));
 		}
 
 		[TestCase(None, "Object")]
@@ -92,7 +92,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 		{
 			var typeDef = GetDefinition(typeof(object));
 			ambience.ConversionFlags = flags;
-			Assert.AreEqual(expectedOutput, ambience.ConvertSymbol(typeDef));
+			Assert.That(ambience.ConvertSymbol(typeDef), Is.EqualTo(expectedOutput));
 		}
 
 		[TestCase(None, "IEnumerable")]
@@ -104,7 +104,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 		{
 			var typeDef = GetDefinition(typeof(IEnumerable<>));
 			ambience.ConversionFlags = flags;
-			Assert.AreEqual(expectedOutput, ambience.ConvertSymbol(typeDef));
+			Assert.That(ambience.ConvertSymbol(typeDef), Is.EqualTo(expectedOutput));
 		}
 
 		[TestCase(None, "Enumerator")]
@@ -121,7 +121,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 		{
 			var typeDef = GetDefinition(typeof(List<>.Enumerator));
 			ambience.ConversionFlags = flags;
-			Assert.AreEqual(expectedOutput, ambience.ConvertSymbol(typeDef));
+			Assert.That(ambience.ConvertSymbol(typeDef), Is.EqualTo(expectedOutput));
 		}
 
 		[TestCase(None, "StaticClass")]
@@ -137,7 +137,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 		{
 			var typeDef = GetDefinition(typeof(StaticClass));
 			ambience.ConversionFlags = flags;
-			Assert.AreEqual(expectedOutput, ambience.ConvertSymbol(typeDef));
+			Assert.That(ambience.ConvertSymbol(typeDef), Is.EqualTo(expectedOutput));
 		}
 
 		[TestCase(None, "SealedClass")]
@@ -153,7 +153,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 		{
 			var typeDef = GetDefinition(typeof(SealedClass));
 			ambience.ConversionFlags = flags;
-			Assert.AreEqual(expectedOutput, ambience.ConvertSymbol(typeDef));
+			Assert.That(ambience.ConvertSymbol(typeDef), Is.EqualTo(expectedOutput));
 		}
 
 		[TestCase(None, "RefStruct")]
@@ -169,7 +169,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 		{
 			var typeDef = GetDefinition(typeof(RefStruct));
 			ambience.ConversionFlags = flags;
-			Assert.AreEqual(expectedOutput, ambience.ConvertSymbol(typeDef));
+			Assert.That(ambience.ConvertSymbol(typeDef), Is.EqualTo(expectedOutput));
 		}
 
 		[TestCase(None, "ReadonlyStruct")]
@@ -185,7 +185,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 		{
 			var typeDef = GetDefinition(typeof(ReadonlyStruct));
 			ambience.ConversionFlags = flags;
-			Assert.AreEqual(expectedOutput, ambience.ConvertSymbol(typeDef));
+			Assert.That(ambience.ConvertSymbol(typeDef), Is.EqualTo(expectedOutput));
 		}
 
 		[TestCase(None, "ReadonlyRefStruct")]
@@ -201,7 +201,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 		{
 			var typeDef = GetDefinition(typeof(ReadonlyRefStruct));
 			ambience.ConversionFlags = flags;
-			Assert.AreEqual(expectedOutput, ambience.ConvertSymbol(typeDef));
+			Assert.That(ambience.ConvertSymbol(typeDef), Is.EqualTo(expectedOutput));
 		}
 		#endregion
 
@@ -219,7 +219,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 		{
 			var func = GetDefinition(typeof(Func<,>));
 			ambience.ConversionFlags = flags;
-			Assert.AreEqual(expectedOutput, ambience.ConvertSymbol(func));
+			Assert.That(ambience.ConvertSymbol(func), Is.EqualTo(expectedOutput));
 		}
 		#endregion
 
@@ -232,7 +232,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 			var field = GetDefinition(typeof(CSharpAmbienceTests.Program)).GetFields(f => f.Name == "test").Single();
 			ambience.ConversionFlags = flags;
 
-			Assert.AreEqual(expectedOutput, ambience.ConvertSymbol(field));
+			Assert.That(ambience.ConvertSymbol(field), Is.EqualTo(expectedOutput));
 		}
 
 		[TestCase(All & ~PlaceReturnTypeAfterParameterList, "private const int ICSharpCode.Decompiler.Tests.Output.CSharpAmbienceTests.Program.TEST2;")]
@@ -242,7 +242,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 			var field = compilation.FindType(typeof(CSharpAmbienceTests.Program)).GetFields(f => f.Name == "TEST2").Single();
 			ambience.ConversionFlags = flags;
 
-			Assert.AreEqual(expectedOutput, ambience.ConvertSymbol(field));
+			Assert.That(ambience.ConvertSymbol(field), Is.EqualTo(expectedOutput));
 		}
 		#endregion
 
@@ -254,7 +254,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 			ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.ShowDeclaringType;
 			string result = ambience.ConvertSymbol(ev);
 
-			Assert.AreEqual("public event EventHandler Program.ProgramChanged;", result);
+			Assert.That(result, Is.EqualTo("public event EventHandler Program.ProgramChanged;"));
 		}
 
 		[Test]
@@ -264,7 +264,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 			ambience.ConversionFlags = ConversionFlags.StandardConversionFlags;
 			string result = ambience.ConvertSymbol(ev);
 
-			Assert.AreEqual("public event EventHandler SomeEvent;", result);
+			Assert.That(result, Is.EqualTo("public event EventHandler SomeEvent;"));
 		}
 		#endregion
 
@@ -276,7 +276,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 			var prop = compilation.FindType(typeof(CSharpAmbienceTests.Program)).GetProperties(p => p.Name == "Test").Single();
 			ambience.ConversionFlags = flags;
 
-			Assert.AreEqual(expectedOutput, ambience.ConvertSymbol(prop));
+			Assert.That(ambience.ConvertSymbol(prop), Is.EqualTo(expectedOutput));
 		}
 
 		[TestCase(StandardConversionFlags, "public int this[int index] { get; }")]
@@ -286,7 +286,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 			var prop = compilation.FindType(typeof(CSharpAmbienceTests.Program)).GetProperties(p => p.IsIndexer).Single();
 			ambience.ConversionFlags = flags;
 
-			Assert.AreEqual(expectedOutput, ambience.ConvertSymbol(prop));
+			Assert.That(ambience.ConvertSymbol(prop), Is.EqualTo(expectedOutput));
 		}
 		#endregion
 
@@ -298,7 +298,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 			var prop = compilation.FindType(typeof(CSharpAmbienceTests.Program)).GetConstructors().Single();
 			ambience.ConversionFlags = flags;
 
-			Assert.AreEqual(expectedOutput, ambience.ConvertSymbol(prop));
+			Assert.That(ambience.ConvertSymbol(prop), Is.EqualTo(expectedOutput));
 		}
 
 		[TestCase(StandardConversionFlags, "~Program();")]
@@ -309,7 +309,7 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				.GetMembers(m => m.SymbolKind == SymbolKind.Destructor, GetMemberOptions.IgnoreInheritedMembers).Single();
 			ambience.ConversionFlags = flags;
 
-			Assert.AreEqual(expectedOutput, ambience.ConvertSymbol(dtor));
+			Assert.That(ambience.ConvertSymbol(dtor), Is.EqualTo(expectedOutput));
 		}
 		#endregion
 

ICSharpCode.Decompiler.Tests/Output/InsertParenthesesVisitorTests.cs

@@ -68,8 +68,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				)
 			);
 
-			Assert.AreEqual("cond = a == b", InsertRequired(expr));
-			Assert.AreEqual("cond = a == b", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("cond = a == b"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("cond = a == b"));
 		}
 
 		[Test]
@@ -86,8 +86,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				}
 			);
 
-			Assert.AreEqual("p = () => a + b", InsertRequired(expr));
-			Assert.AreEqual("p = () => a + b", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("p = () => a + b"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("p = () => a + b"));
 		}
 
 		[Test]
@@ -105,8 +105,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				}
 			};
 
-			Assert.AreEqual("p + () => a + b", InsertRequired(expr));
-			Assert.AreEqual("p + (() => a + b)", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("p + () => a + b"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("p + (() => a + b)"));
 		}
 
 		[Test]
@@ -124,8 +124,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				Right = new IdentifierExpression("p"),
 			};
 
-			Assert.AreEqual("(() => a + b) + p", InsertRequired(expr));
-			Assert.AreEqual("(() => a + b) + p", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("(() => a + b) + p"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("(() => a + b) + p"));
 		}
 
 		[Test]
@@ -138,8 +138,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				)
 			};
 
-			Assert.AreEqual("(int)-a", InsertRequired(expr));
-			Assert.AreEqual("(int)(-a)", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("(int)-a"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("(int)(-a)"));
 		}
 
 		[Test]
@@ -152,8 +152,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				)
 			};
 
-			Assert.AreEqual("(MyType)(-a)", InsertRequired(expr));
-			Assert.AreEqual("(MyType)(-a)", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("(MyType)(-a)"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("(MyType)(-a)"));
 		}
 
 		[Test]
@@ -166,8 +166,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				)
 			};
 
-			Assert.AreEqual("(MyType)!a", InsertRequired(expr));
-			Assert.AreEqual("(MyType)(!a)", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("(MyType)!a"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("(MyType)(!a)"));
 		}
 
 		[Test]
@@ -178,8 +178,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				Expression = new PrimitiveExpression(int.MinValue),
 			};
 
-			Assert.AreEqual("(MyType)(-2147483648)", InsertRequired(expr));
-			Assert.AreEqual("(MyType)(-2147483648)", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("(MyType)(-2147483648)"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("(MyType)(-2147483648)"));
 		}
 
 		[Test]
@@ -190,8 +190,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				Expression = new PrimitiveExpression(-1.0),
 			};
 
-			Assert.AreEqual("(MyType)(-1.0)", InsertRequired(expr));
-			Assert.AreEqual("(MyType)(-1.0)", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("(MyType)(-1.0)"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("(MyType)(-1.0)"));
 		}
 
 		[Test]
@@ -202,8 +202,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				Expression = new PrimitiveExpression(int.MinValue),
 			};
 
-			Assert.AreEqual("(double)-2147483648", InsertRequired(expr));
-			Assert.AreEqual("(double)(-2147483648)", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("(double)-2147483648"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("(double)(-2147483648)"));
 		}
 
 		[Test]
@@ -217,8 +217,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				MemberName = "Length"
 			};
 
-			Assert.AreEqual("((string)a).Length", InsertRequired(expr));
-			Assert.AreEqual("((string)a).Length", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("((string)a).Length"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("((string)a).Length"));
 		}
 
 		[Test]
@@ -229,8 +229,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				new UnaryOperatorExpression(UnaryOperatorType.Minus, new IdentifierExpression("a"))
 			);
 
-			Assert.AreEqual("- -a", InsertRequired(expr));
-			Assert.AreEqual("-(-a)", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("- -a"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("-(-a)"));
 		}
 
 		[Test]
@@ -250,8 +250,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				}
 			};
 
-			Assert.AreEqual("a + (b == null ? c : d)", InsertRequired(expr));
-			Assert.AreEqual("a + ((b == null) ? c : d)", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("a + (b == null ? c : d)"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("a + ((b == null) ? c : d)"));
 		}
 
 		[Test]
@@ -269,16 +269,16 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				FalseExpression = new IdentifierExpression("c")
 			};
 
-			Assert.AreEqual("a is int? ? b : c", InsertRequired(expr));
-			Assert.AreEqual("(a is int?) ? b : c", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("a is int? ? b : c"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("(a is int?) ? b : c"));
 
 			policy.SpaceBeforeConditionalOperatorCondition = false;
 			policy.SpaceAfterConditionalOperatorCondition = false;
 			policy.SpaceBeforeConditionalOperatorSeparator = false;
 			policy.SpaceAfterConditionalOperatorSeparator = false;
 
-			Assert.AreEqual("a is int? ?b:c", InsertRequired(expr));
-			Assert.AreEqual("(a is int?)?b:c", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("a is int? ?b:c"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("(a is int?)?b:c"));
 		}
 
 		[Test]
@@ -302,8 +302,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				MemberName = "ToArray"
 			});
 
-			Assert.AreEqual("(from a in b select a.c ()).ToArray ()", InsertRequired(expr));
-			Assert.AreEqual("(from a in b select a.c ()).ToArray ()", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("(from a in b select a.c ()).ToArray ()"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("(from a in b select a.c ()).ToArray ()"));
 		}
 
 		[Test]
@@ -326,10 +326,10 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				query.Clone()
 			);
 
-			Assert.AreEqual("(from a in b select a) + " +
-							"from a in b select a", InsertRequired(expr));
-			Assert.AreEqual("(from a in b select a) + " +
-							"(from a in b select a)", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("(from a in b select a) + " +
+							"from a in b select a"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("(from a in b select a) + " +
+							"(from a in b select a)"));
 		}
 
 		[Test]
@@ -350,8 +350,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				Type = new PrimitiveType("int")
 			};
 
-			Assert.AreEqual("(from a in b select a) is int", InsertRequired(expr));
-			Assert.AreEqual("(from a in b select a) is int", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("(from a in b select a) is int"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("(from a in b select a) is int"));
 		}
 
 		[Test]
@@ -365,8 +365,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				)
 			);
 
-			Assert.AreEqual("++a++", InsertRequired(expr));
-			Assert.AreEqual("++(a++)", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("++a++"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("++(a++)"));
 		}
 
 		[Test]
@@ -380,8 +380,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				)
 			);
 
-			Assert.AreEqual("(++a)++", InsertRequired(expr));
-			Assert.AreEqual("(++a)++", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("(++a)++"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("(++a)++"));
 		}
 
 		[Test]
@@ -397,8 +397,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				new IdentifierExpression("c")
 			);
 
-			Assert.AreEqual("a && b && c", InsertRequired(expr));
-			Assert.AreEqual("a && b && c", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("a && b && c"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("a && b && c"));
 		}
 
 		[Test]
@@ -414,8 +414,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				)
 			);
 
-			Assert.AreEqual("a && (b && c)", InsertRequired(expr));
-			Assert.AreEqual("a && (b && c)", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("a && (b && c)"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("a && (b && c)"));
 		}
 
 		[Test]
@@ -431,8 +431,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				)
 			);
 
-			Assert.AreEqual("a || b && c", InsertRequired(expr));
-			Assert.AreEqual("a || (b && c)", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("a || b && c"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("a || (b && c)"));
 		}
 
 		[Test]
@@ -448,8 +448,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				)
 			);
 
-			Assert.AreEqual("a && (b || c)", InsertRequired(expr));
-			Assert.AreEqual("a && (b || c)", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("a && (b || c)"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("a && (b || c)"));
 		}
 
 		[Test]
@@ -463,8 +463,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				Arguments = { new PrimitiveExpression(0) }
 			};
 
-			Assert.AreEqual("(new int[1]) [0]", InsertRequired(expr));
-			Assert.AreEqual("(new int[1]) [0]", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("(new int[1]) [0]"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("(new int[1]) [0]"));
 		}
 
 		[Test]
@@ -481,8 +481,8 @@ namespace ICSharpCode.Decompiler.Tests.Output
 				Arguments = { new PrimitiveExpression(0) }
 			};
 
-			Assert.AreEqual("new int[1] { 42 } [0]", InsertRequired(expr));
-			Assert.AreEqual("(new int[1] { 42 }) [0]", InsertReadable(expr));
+			Assert.That(InsertRequired(expr), Is.EqualTo("new int[1] { 42 } [0]"));
+			Assert.That(InsertReadable(expr), Is.EqualTo("(new int[1] { 42 }) [0]"));
 		}
 	}
 }

ICSharpCode.Decompiler.Tests/PdbGenerationTestRunner.cs

@@ -70,8 +70,8 @@ namespace ICSharpCode.Decompiler.Tests
 				var metadataReader = MetadataReaderProvider.FromPortablePdbStream(pdbStream).GetMetadataReader();
 				var generatedPdbId = new BlobContentId(metadataReader.DebugMetadataHeader.Id);
 
-				Assert.AreEqual(expectedPdbId.Guid, generatedPdbId.Guid);
-				Assert.AreEqual(expectedPdbId.Stamp, generatedPdbId.Stamp);
+				Assert.That(generatedPdbId.Guid, Is.EqualTo(expectedPdbId.Guid));
+				Assert.That(generatedPdbId.Stamp, Is.EqualTo(expectedPdbId.Stamp));
 			}
 		}
 
@@ -95,8 +95,8 @@ namespace ICSharpCode.Decompiler.Tests
 					totalFiles = progress.TotalUnits;
 				}
 
-				Assert.AreEqual(progress.TotalUnits, totalFiles);
-				Assert.AreEqual(progress.UnitsCompleted, lastFilesWritten + 1);
+				Assert.That(totalFiles, Is.EqualTo(progress.TotalUnits));
+				Assert.That(lastFilesWritten + 1, Is.EqualTo(progress.UnitsCompleted));
 
 				lastFilesWritten = progress.UnitsCompleted;
 			};
@@ -111,7 +111,7 @@ namespace ICSharpCode.Decompiler.Tests
 				var generatedPdbId = new BlobContentId(metadataReader.DebugMetadataHeader.Id);
 			}
 
-			Assert.AreEqual(totalFiles, lastFilesWritten);
+			Assert.That(lastFilesWritten, Is.EqualTo(totalFiles));
 		}
 
 		private class TestProgressReporter : IProgress<DecompilationProgress>

ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs

@@ -46,7 +46,7 @@ namespace ICSharpCode.Decompiler.Tests
 					|| file.Extension.Equals(".cs", StringComparison.OrdinalIgnoreCase))
 				{
 					var testName = file.Name.Split('.')[0];
-					Assert.Contains(testName, testNames);
+					Assert.That(testNames, Has.Member(testName));
 				}
 			}
 		}

ICSharpCode.Decompiler.Tests/ProjectDecompiler/TargetFrameworkTests.cs

@@ -57,8 +57,8 @@ namespace ICSharpCode.Decompiler.Tests
 			var targetFramework = new TargetFramework(identifier: null, version, profile: null);
 
 			// Assert
-			Assert.AreEqual(version, targetFramework.VersionNumber);
-			Assert.AreEqual(expectedVersion, targetFramework.VersionString);
+			Assert.That(targetFramework.VersionNumber, Is.EqualTo(version));
+			Assert.That(targetFramework.VersionString, Is.EqualTo(expectedVersion));
 		}
 
 		[Test]
@@ -71,8 +71,8 @@ namespace ICSharpCode.Decompiler.Tests
 			var targetFramework = new TargetFramework(identifier, 100, profile: null);
 
 			// Assert
-			Assert.IsTrue(targetFramework.IsPortableClassLibrary);
-			Assert.AreEqual(identifier, targetFramework.Identifier);
+			Assert.That(targetFramework.IsPortableClassLibrary);
+			Assert.That(targetFramework.Identifier, Is.EqualTo(identifier));
 		}
 
 		[Test]
@@ -87,8 +87,8 @@ namespace ICSharpCode.Decompiler.Tests
 			var targetFramework = new TargetFramework(identifier, 100, profile);
 
 			// Assert
-			Assert.AreEqual(identifier, targetFramework.Identifier);
-			Assert.AreEqual(profile, targetFramework.Profile);
+			Assert.That(targetFramework.Identifier, Is.EqualTo(identifier));
+			Assert.That(targetFramework.Profile, Is.EqualTo(profile));
 		}
 
 		[TestCase(null, 350, "net35")]
@@ -117,7 +117,7 @@ namespace ICSharpCode.Decompiler.Tests
 			var targetFramework = new TargetFramework(identifier, version, profile: null);
 
 			// Assert
-			Assert.AreEqual(expectedMoniker, targetFramework.Moniker);
+			Assert.That(targetFramework.Moniker, Is.EqualTo(expectedMoniker));
 		}
 	}
 }

ICSharpCode.Decompiler.Tests/RoundtripAssembly.cs

@@ -212,7 +212,7 @@ namespace ICSharpCode.Decompiler.Tests
 					File.Copy(file, Path.Combine(outputDir, relFile));
 				}
 			}
-			Assert.IsNotNull(projectFile, $"Could not find {fileToRoundtrip}");
+			Assert.That(projectFile, Is.Not.Null, $"Could not find {fileToRoundtrip}");
 
 			await Compile(projectFile, outputDir);
 			testAction(outputDir);

ICSharpCode.Decompiler.Tests/Semantics/ExplicitConversionTest.cs

@@ -58,11 +58,11 @@ namespace ICSharpCode.Decompiler.Tests.Semantics
 		[Test]
 		public void PointerConversion()
 		{
-			Assert.AreEqual(C.ExplicitPointerConversion, ExplicitConversion(typeof(int*), typeof(short)));
-			Assert.AreEqual(C.ExplicitPointerConversion, ExplicitConversion(typeof(short), typeof(void*)));
+			Assert.That(ExplicitConversion(typeof(int*), typeof(short)), Is.EqualTo(C.ExplicitPointerConversion));
+			Assert.That(ExplicitConversion(typeof(short), typeof(void*)), Is.EqualTo(C.ExplicitPointerConversion));
 
-			Assert.AreEqual(C.ExplicitPointerConversion, ExplicitConversion(typeof(void*), typeof(int*)));
-			Assert.AreEqual(C.ExplicitPointerConversion, ExplicitConversion(typeof(long*), typeof(byte*)));
+			Assert.That(ExplicitConversion(typeof(void*), typeof(int*)), Is.EqualTo(C.ExplicitPointerConversion));
+			Assert.That(ExplicitConversion(typeof(long*), typeof(byte*)), Is.EqualTo(C.ExplicitPointerConversion));
 		}
 
 		[Test]
@@ -70,60 +70,60 @@ namespace ICSharpCode.Decompiler.Tests.Semantics
 		{
 			// Explicit dynamic conversion is for resolve results only;
 			// otherwise it's an explicit reference / unboxing conversion
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(dynamic), typeof(string)));
-			Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(dynamic), typeof(int)));
+			Assert.That(ExplicitConversion(typeof(dynamic), typeof(string)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(dynamic), typeof(int)), Is.EqualTo(C.UnboxingConversion));
 
 			var dynamicRR = new ResolveResult(SpecialType.Dynamic);
-			Assert.AreEqual(C.ExplicitDynamicConversion, conversions.ExplicitConversion(dynamicRR, compilation.FindType(typeof(string))));
-			Assert.AreEqual(C.ExplicitDynamicConversion, conversions.ExplicitConversion(dynamicRR, compilation.FindType(typeof(int))));
+			Assert.That(conversions.ExplicitConversion(dynamicRR, compilation.FindType(typeof(string))), Is.EqualTo(C.ExplicitDynamicConversion));
+			Assert.That(conversions.ExplicitConversion(dynamicRR, compilation.FindType(typeof(int))), Is.EqualTo(C.ExplicitDynamicConversion));
 		}
 
 		[Test]
 		public void NumericConversions()
 		{
-			Assert.AreEqual(C.ExplicitNumericConversion, ExplicitConversion(typeof(sbyte), typeof(uint)));
-			Assert.AreEqual(C.ExplicitNumericConversion, ExplicitConversion(typeof(sbyte), typeof(char)));
-			Assert.AreEqual(C.ExplicitNumericConversion, ExplicitConversion(typeof(byte), typeof(char)));
-			Assert.AreEqual(C.ExplicitNumericConversion, ExplicitConversion(typeof(byte), typeof(sbyte)));
+			Assert.That(ExplicitConversion(typeof(sbyte), typeof(uint)), Is.EqualTo(C.ExplicitNumericConversion));
+			Assert.That(ExplicitConversion(typeof(sbyte), typeof(char)), Is.EqualTo(C.ExplicitNumericConversion));
+			Assert.That(ExplicitConversion(typeof(byte), typeof(char)), Is.EqualTo(C.ExplicitNumericConversion));
+			Assert.That(ExplicitConversion(typeof(byte), typeof(sbyte)), Is.EqualTo(C.ExplicitNumericConversion));
 			// if an implicit conversion exists, ExplicitConversion() should return that
-			Assert.AreEqual(C.ImplicitNumericConversion, ExplicitConversion(typeof(byte), typeof(int)));
-			Assert.AreEqual(C.ExplicitNumericConversion, ExplicitConversion(typeof(double), typeof(float)));
-			Assert.AreEqual(C.ExplicitNumericConversion, ExplicitConversion(typeof(double), typeof(decimal)));
-			Assert.AreEqual(C.ExplicitNumericConversion, ExplicitConversion(typeof(decimal), typeof(double)));
-			Assert.AreEqual(C.ImplicitNumericConversion, ExplicitConversion(typeof(int), typeof(decimal)));
+			Assert.That(ExplicitConversion(typeof(byte), typeof(int)), Is.EqualTo(C.ImplicitNumericConversion));
+			Assert.That(ExplicitConversion(typeof(double), typeof(float)), Is.EqualTo(C.ExplicitNumericConversion));
+			Assert.That(ExplicitConversion(typeof(double), typeof(decimal)), Is.EqualTo(C.ExplicitNumericConversion));
+			Assert.That(ExplicitConversion(typeof(decimal), typeof(double)), Is.EqualTo(C.ExplicitNumericConversion));
+			Assert.That(ExplicitConversion(typeof(int), typeof(decimal)), Is.EqualTo(C.ImplicitNumericConversion));
 
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(bool), typeof(int)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(int), typeof(bool)));
+			Assert.That(ExplicitConversion(typeof(bool), typeof(int)), Is.EqualTo(C.None));
+			Assert.That(ExplicitConversion(typeof(int), typeof(bool)), Is.EqualTo(C.None));
 		}
 
 		[Test]
 		public void EnumerationConversions()
 		{
 			var explicitEnumerationConversion = C.EnumerationConversion(false, false);
-			Assert.AreEqual(explicitEnumerationConversion, ExplicitConversion(typeof(sbyte), typeof(StringComparison)));
-			Assert.AreEqual(explicitEnumerationConversion, ExplicitConversion(typeof(char), typeof(StringComparison)));
-			Assert.AreEqual(explicitEnumerationConversion, ExplicitConversion(typeof(int), typeof(StringComparison)));
-			Assert.AreEqual(explicitEnumerationConversion, ExplicitConversion(typeof(decimal), typeof(StringComparison)));
-			Assert.AreEqual(explicitEnumerationConversion, ExplicitConversion(typeof(StringComparison), typeof(char)));
-			Assert.AreEqual(explicitEnumerationConversion, ExplicitConversion(typeof(StringComparison), typeof(int)));
-			Assert.AreEqual(explicitEnumerationConversion, ExplicitConversion(typeof(StringComparison), typeof(decimal)));
-			Assert.AreEqual(explicitEnumerationConversion, ExplicitConversion(typeof(StringComparison), typeof(StringSplitOptions)));
+			Assert.That(ExplicitConversion(typeof(sbyte), typeof(StringComparison)), Is.EqualTo(explicitEnumerationConversion));
+			Assert.That(ExplicitConversion(typeof(char), typeof(StringComparison)), Is.EqualTo(explicitEnumerationConversion));
+			Assert.That(ExplicitConversion(typeof(int), typeof(StringComparison)), Is.EqualTo(explicitEnumerationConversion));
+			Assert.That(ExplicitConversion(typeof(decimal), typeof(StringComparison)), Is.EqualTo(explicitEnumerationConversion));
+			Assert.That(ExplicitConversion(typeof(StringComparison), typeof(char)), Is.EqualTo(explicitEnumerationConversion));
+			Assert.That(ExplicitConversion(typeof(StringComparison), typeof(int)), Is.EqualTo(explicitEnumerationConversion));
+			Assert.That(ExplicitConversion(typeof(StringComparison), typeof(decimal)), Is.EqualTo(explicitEnumerationConversion));
+			Assert.That(ExplicitConversion(typeof(StringComparison), typeof(StringSplitOptions)), Is.EqualTo(explicitEnumerationConversion));
 		}
 
 		[Test]
 		public void NullableConversion_BasedOnIdentityConversion()
 		{
-			Assert.AreEqual(C.IdentityConversion, ExplicitConversion(typeof(ArraySegment<dynamic>?), typeof(ArraySegment<object>?)));
-			Assert.AreEqual(C.ImplicitNullableConversion, ExplicitConversion(typeof(ArraySegment<dynamic>), typeof(ArraySegment<object>?)));
-			Assert.AreEqual(C.ExplicitNullableConversion, ExplicitConversion(typeof(ArraySegment<dynamic>?), typeof(ArraySegment<object>)));
+			Assert.That(ExplicitConversion(typeof(ArraySegment<dynamic>?), typeof(ArraySegment<object>?)), Is.EqualTo(C.IdentityConversion));
+			Assert.That(ExplicitConversion(typeof(ArraySegment<dynamic>), typeof(ArraySegment<object>?)), Is.EqualTo(C.ImplicitNullableConversion));
+			Assert.That(ExplicitConversion(typeof(ArraySegment<dynamic>?), typeof(ArraySegment<object>)), Is.EqualTo(C.ExplicitNullableConversion));
 		}
 
 		[Test]
 		public void NullableConversion_BasedOnImplicitNumericConversion()
 		{
-			Assert.AreEqual(C.ImplicitLiftedNumericConversion, ExplicitConversion(typeof(int?), typeof(long?)));
-			Assert.AreEqual(C.ImplicitLiftedNumericConversion, ExplicitConversion(typeof(int), typeof(long?)));
-			Assert.AreEqual(C.ExplicitLiftedNumericConversion, ExplicitConversion(typeof(int?), typeof(long)));
+			Assert.That(ExplicitConversion(typeof(int?), typeof(long?)), Is.EqualTo(C.ImplicitLiftedNumericConversion));
+			Assert.That(ExplicitConversion(typeof(int), typeof(long?)), Is.EqualTo(C.ImplicitLiftedNumericConversion));
+			Assert.That(ExplicitConversion(typeof(int?), typeof(long)), Is.EqualTo(C.ExplicitLiftedNumericConversion));
 		}
 
 		[Test]
@@ -131,160 +131,160 @@ namespace ICSharpCode.Decompiler.Tests.Semantics
 		{
 			ResolveResult zero = new ConstantResolveResult(compilation.FindType(KnownTypeCode.Int32), 0);
 			ResolveResult one = new ConstantResolveResult(compilation.FindType(KnownTypeCode.Int32), 1);
-			Assert.AreEqual(C.EnumerationConversion(true, true), conversions.ExplicitConversion(zero, compilation.FindType(typeof(StringComparison?))));
-			Assert.AreEqual(C.EnumerationConversion(false, true), conversions.ExplicitConversion(one, compilation.FindType(typeof(StringComparison?))));
+			Assert.That(conversions.ExplicitConversion(zero, compilation.FindType(typeof(StringComparison?))), Is.EqualTo(C.EnumerationConversion(true, true)));
+			Assert.That(conversions.ExplicitConversion(one, compilation.FindType(typeof(StringComparison?))), Is.EqualTo(C.EnumerationConversion(false, true)));
 		}
 
 		[Test]
 		public void NullableConversion_BasedOnExplicitNumericConversion()
 		{
-			Assert.AreEqual(C.ExplicitLiftedNumericConversion, ExplicitConversion(typeof(int?), typeof(short?)));
-			Assert.AreEqual(C.ExplicitLiftedNumericConversion, ExplicitConversion(typeof(int), typeof(short?)));
-			Assert.AreEqual(C.ExplicitLiftedNumericConversion, ExplicitConversion(typeof(int?), typeof(short)));
+			Assert.That(ExplicitConversion(typeof(int?), typeof(short?)), Is.EqualTo(C.ExplicitLiftedNumericConversion));
+			Assert.That(ExplicitConversion(typeof(int), typeof(short?)), Is.EqualTo(C.ExplicitLiftedNumericConversion));
+			Assert.That(ExplicitConversion(typeof(int?), typeof(short)), Is.EqualTo(C.ExplicitLiftedNumericConversion));
 		}
 
 		[Test]
 		public void NullableConversion_BasedOnExplicitEnumerationConversion()
 		{
 			C c = C.EnumerationConversion(false, true); // c = explicit lifted enumeration conversion
-			Assert.AreEqual(c, ExplicitConversion(typeof(int?), typeof(StringComparison?)));
-			Assert.AreEqual(c, ExplicitConversion(typeof(int), typeof(StringComparison?)));
-			Assert.AreEqual(c, ExplicitConversion(typeof(int?), typeof(StringComparison)));
+			Assert.That(ExplicitConversion(typeof(int?), typeof(StringComparison?)), Is.EqualTo(c));
+			Assert.That(ExplicitConversion(typeof(int), typeof(StringComparison?)), Is.EqualTo(c));
+			Assert.That(ExplicitConversion(typeof(int?), typeof(StringComparison)), Is.EqualTo(c));
 
-			Assert.AreEqual(c, ExplicitConversion(typeof(StringComparison?), typeof(int?)));
-			Assert.AreEqual(c, ExplicitConversion(typeof(StringComparison), typeof(int?)));
-			Assert.AreEqual(c, ExplicitConversion(typeof(StringComparison?), typeof(int)));
+			Assert.That(ExplicitConversion(typeof(StringComparison?), typeof(int?)), Is.EqualTo(c));
+			Assert.That(ExplicitConversion(typeof(StringComparison), typeof(int?)), Is.EqualTo(c));
+			Assert.That(ExplicitConversion(typeof(StringComparison?), typeof(int)), Is.EqualTo(c));
 
-			Assert.AreEqual(c, ExplicitConversion(typeof(StringComparison?), typeof(StringSplitOptions?)));
-			Assert.AreEqual(c, ExplicitConversion(typeof(StringComparison), typeof(StringSplitOptions?)));
-			Assert.AreEqual(c, ExplicitConversion(typeof(StringComparison?), typeof(StringSplitOptions)));
+			Assert.That(ExplicitConversion(typeof(StringComparison?), typeof(StringSplitOptions?)), Is.EqualTo(c));
+			Assert.That(ExplicitConversion(typeof(StringComparison), typeof(StringSplitOptions?)), Is.EqualTo(c));
+			Assert.That(ExplicitConversion(typeof(StringComparison?), typeof(StringSplitOptions)), Is.EqualTo(c));
 		}
 
 		[Test]
 		public void ExplicitReferenceConversion_SealedClass()
 		{
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(object), typeof(string)));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable<char>), typeof(string)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(IEnumerable<int>), typeof(string)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(IEnumerable<object>), typeof(string)));
-			Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(string), typeof(IEnumerable<char>)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(string), typeof(IEnumerable<int>)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(string), typeof(IEnumerable<object>)));
+			Assert.That(ExplicitConversion(typeof(object), typeof(string)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<char>), typeof(string)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<int>), typeof(string)), Is.EqualTo(C.None));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<object>), typeof(string)), Is.EqualTo(C.None));
+			Assert.That(ExplicitConversion(typeof(string), typeof(IEnumerable<char>)), Is.EqualTo(C.ImplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(string), typeof(IEnumerable<int>)), Is.EqualTo(C.None));
+			Assert.That(ExplicitConversion(typeof(string), typeof(IEnumerable<object>)), Is.EqualTo(C.None));
 		}
 
 		[Test]
 		public void ExplicitReferenceConversion_NonSealedClass()
 		{
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(object), typeof(List<string>)));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable<object>), typeof(List<string>)));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable<string>), typeof(List<string>)));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable<int>), typeof(List<string>)));
+			Assert.That(ExplicitConversion(typeof(object), typeof(List<string>)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<object>), typeof(List<string>)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<string>), typeof(List<string>)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<int>), typeof(List<string>)), Is.EqualTo(C.ExplicitReferenceConversion));
 
-			Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(List<string>), typeof(IEnumerable<object>)));
-			Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(List<string>), typeof(IEnumerable<string>)));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(List<string>), typeof(IEnumerable<int>)));
+			Assert.That(ExplicitConversion(typeof(List<string>), typeof(IEnumerable<object>)), Is.EqualTo(C.ImplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(List<string>), typeof(IEnumerable<string>)), Is.EqualTo(C.ImplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(List<string>), typeof(IEnumerable<int>)), Is.EqualTo(C.ExplicitReferenceConversion));
 
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(List<string>), typeof(List<object>)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(List<string>), typeof(List<int>)));
+			Assert.That(ExplicitConversion(typeof(List<string>), typeof(List<object>)), Is.EqualTo(C.None));
+			Assert.That(ExplicitConversion(typeof(List<string>), typeof(List<int>)), Is.EqualTo(C.None));
 		}
 
 		[Test]
 		public void ExplicitReferenceConversion_Interfaces()
 		{
-			Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable<string>), typeof(IEnumerable<object>)));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable<int>), typeof(IEnumerable<object>)));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable<object>), typeof(IEnumerable<string>)));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable<object>), typeof(IEnumerable<int>)));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable<object>), typeof(IConvertible)));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<string>), typeof(IEnumerable<object>)), Is.EqualTo(C.ImplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<int>), typeof(IEnumerable<object>)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<object>), typeof(IEnumerable<string>)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<object>), typeof(IEnumerable<int>)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<object>), typeof(IConvertible)), Is.EqualTo(C.ExplicitReferenceConversion));
 		}
 
 		[Test]
 		public void ExplicitReferenceConversion_Arrays()
 		{
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(object[]), typeof(string[])));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(dynamic[]), typeof(string[])));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(object[]), typeof(object[,])));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(object[]), typeof(int[])));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(short[]), typeof(int[])));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(Array), typeof(int[])));
+			Assert.That(ExplicitConversion(typeof(object[]), typeof(string[])), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(dynamic[]), typeof(string[])), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(object[]), typeof(object[,])), Is.EqualTo(C.None));
+			Assert.That(ExplicitConversion(typeof(object[]), typeof(int[])), Is.EqualTo(C.None));
+			Assert.That(ExplicitConversion(typeof(short[]), typeof(int[])), Is.EqualTo(C.None));
+			Assert.That(ExplicitConversion(typeof(Array), typeof(int[])), Is.EqualTo(C.ExplicitReferenceConversion));
 		}
 
 		[Test]
 		public void ExplicitReferenceConversion_InterfaceToArray()
 		{
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(ICloneable), typeof(int[])));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable<string>), typeof(string[])));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable<object>), typeof(string[])));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable<string>), typeof(object[])));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable<string>), typeof(dynamic[])));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable<int>), typeof(int[])));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(IEnumerable<string>), typeof(object[,])));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(IEnumerable<short>), typeof(object[])));
+			Assert.That(ExplicitConversion(typeof(ICloneable), typeof(int[])), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<string>), typeof(string[])), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<object>), typeof(string[])), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<string>), typeof(object[])), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<string>), typeof(dynamic[])), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<int>), typeof(int[])), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<string>), typeof(object[,])), Is.EqualTo(C.None));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<short>), typeof(object[])), Is.EqualTo(C.None));
 		}
 
 		[Test]
 		public void ExplicitReferenceConversion_ArrayToInterface()
 		{
-			Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(int[]), typeof(ICloneable)));
-			Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(string[]), typeof(IEnumerable<string>)));
-			Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(string[]), typeof(IEnumerable<object>)));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(object[]), typeof(IEnumerable<string>)));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(dynamic[]), typeof(IEnumerable<string>)));
-			Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(int[]), typeof(IEnumerable<int>)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(object[,]), typeof(IEnumerable<string>)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(object[]), typeof(IEnumerable<short>)));
+			Assert.That(ExplicitConversion(typeof(int[]), typeof(ICloneable)), Is.EqualTo(C.ImplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(string[]), typeof(IEnumerable<string>)), Is.EqualTo(C.ImplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(string[]), typeof(IEnumerable<object>)), Is.EqualTo(C.ImplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(object[]), typeof(IEnumerable<string>)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(dynamic[]), typeof(IEnumerable<string>)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(int[]), typeof(IEnumerable<int>)), Is.EqualTo(C.ImplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(object[,]), typeof(IEnumerable<string>)), Is.EqualTo(C.None));
+			Assert.That(ExplicitConversion(typeof(object[]), typeof(IEnumerable<short>)), Is.EqualTo(C.None));
 		}
 
 		[Test]
 		public void ExplicitReferenceConversion_Delegates()
 		{
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(MulticastDelegate), typeof(Action)));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(Delegate), typeof(Action)));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(ICloneable), typeof(Action)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(System.Threading.ThreadStart), typeof(Action)));
+			Assert.That(ExplicitConversion(typeof(MulticastDelegate), typeof(Action)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(Delegate), typeof(Action)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(ICloneable), typeof(Action)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(System.Threading.ThreadStart), typeof(Action)), Is.EqualTo(C.None));
 		}
 
 		[Test]
 		public void ExplicitReferenceConversion_GenericDelegates()
 		{
-			Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(Action<object>), typeof(Action<string>)));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(Action<string>), typeof(Action<object>)));
+			Assert.That(ExplicitConversion(typeof(Action<object>), typeof(Action<string>)), Is.EqualTo(C.ImplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(Action<string>), typeof(Action<object>)), Is.EqualTo(C.ExplicitReferenceConversion));
 
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(Func<object>), typeof(Func<string>)));
-			Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(Func<string>), typeof(Func<object>)));
+			Assert.That(ExplicitConversion(typeof(Func<object>), typeof(Func<string>)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(Func<string>), typeof(Func<object>)), Is.EqualTo(C.ImplicitReferenceConversion));
 
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(Action<IFormattable>), typeof(Action<IConvertible>)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(Action<IFormattable>), typeof(Action<int>)));
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(Action<string>), typeof(Action<IEnumerable<int>>)));
+			Assert.That(ExplicitConversion(typeof(Action<IFormattable>), typeof(Action<IConvertible>)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(Action<IFormattable>), typeof(Action<int>)), Is.EqualTo(C.None));
+			Assert.That(ExplicitConversion(typeof(Action<string>), typeof(Action<IEnumerable<int>>)), Is.EqualTo(C.ExplicitReferenceConversion));
 
-			Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(Func<IFormattable>), typeof(Func<IConvertible>)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(Func<IFormattable>), typeof(Func<int>)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(Func<string>), typeof(Func<IEnumerable<int>>)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(Func<string>), typeof(Func<IEnumerable<int>>)));
+			Assert.That(ExplicitConversion(typeof(Func<IFormattable>), typeof(Func<IConvertible>)), Is.EqualTo(C.ExplicitReferenceConversion));
+			Assert.That(ExplicitConversion(typeof(Func<IFormattable>), typeof(Func<int>)), Is.EqualTo(C.None));
+			Assert.That(ExplicitConversion(typeof(Func<string>), typeof(Func<IEnumerable<int>>)), Is.EqualTo(C.None));
+			Assert.That(ExplicitConversion(typeof(Func<string>), typeof(Func<IEnumerable<int>>)), Is.EqualTo(C.None));
 		}
 
 		[Test]
 		public void UnboxingConversion()
 		{
-			Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(object), typeof(int)));
-			Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(object), typeof(decimal)));
-			Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(ValueType), typeof(int)));
-			Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(IFormattable), typeof(int)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(IEnumerable<object>), typeof(int)));
-			Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(Enum), typeof(StringComparison)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(Enum), typeof(int)));
+			Assert.That(ExplicitConversion(typeof(object), typeof(int)), Is.EqualTo(C.UnboxingConversion));
+			Assert.That(ExplicitConversion(typeof(object), typeof(decimal)), Is.EqualTo(C.UnboxingConversion));
+			Assert.That(ExplicitConversion(typeof(ValueType), typeof(int)), Is.EqualTo(C.UnboxingConversion));
+			Assert.That(ExplicitConversion(typeof(IFormattable), typeof(int)), Is.EqualTo(C.UnboxingConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<object>), typeof(int)), Is.EqualTo(C.None));
+			Assert.That(ExplicitConversion(typeof(Enum), typeof(StringComparison)), Is.EqualTo(C.UnboxingConversion));
+			Assert.That(ExplicitConversion(typeof(Enum), typeof(int)), Is.EqualTo(C.None));
 		}
 
 		[Test]
 		public void LiftedUnboxingConversion()
 		{
-			Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(object), typeof(int?)));
-			Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(object), typeof(decimal?)));
-			Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(ValueType), typeof(int?)));
-			Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(IFormattable), typeof(int?)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(IEnumerable<object>), typeof(int?)));
-			Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(Enum), typeof(StringComparison?)));
-			Assert.AreEqual(C.None, ExplicitConversion(typeof(Enum), typeof(int?)));
+			Assert.That(ExplicitConversion(typeof(object), typeof(int?)), Is.EqualTo(C.UnboxingConversion));
+			Assert.That(ExplicitConversion(typeof(object), typeof(decimal?)), Is.EqualTo(C.UnboxingConversion));
+			Assert.That(ExplicitConversion(typeof(ValueType), typeof(int?)), Is.EqualTo(C.UnboxingConversion));
+			Assert.That(ExplicitConversion(typeof(IFormattable), typeof(int?)), Is.EqualTo(C.UnboxingConversion));
+			Assert.That(ExplicitConversion(typeof(IEnumerable<object>), typeof(int?)), Is.EqualTo(C.None));
+			Assert.That(ExplicitConversion(typeof(Enum), typeof(StringComparison?)), Is.EqualTo(C.UnboxingConversion));
+			Assert.That(ExplicitConversion(typeof(Enum), typeof(int?)), Is.EqualTo(C.None));
 		}
 
 		/* TODO: we should probably revive these tests somehow
@@ -477,8 +477,8 @@ class C {
 		C1 c1 = $(C1)c2$;
 	}
 }");
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
 			Assert.AreEqual("op_Explicit", rr.Conversion.Method.Name);
 		}
 
@@ -496,8 +496,8 @@ class C {
 				T t = $(T)b$;
 			}
 		}");
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
 			Assert.AreEqual("B", rr.Input.Type.Name);
 		}
 
@@ -513,10 +513,10 @@ class C {
 				int x = $(int)t$;
 			}
 		}");
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
 			// even though the user-defined conversion is implicit, the combined conversion is explicit
-			Assert.IsTrue(rr.Conversion.IsExplicit);
+			Assert.That(rr.Conversion.IsExplicit);
 		}
 
 		[Test]
@@ -534,8 +534,8 @@ class C {
 				T t = $(T)b$;
 			}
 		}");
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
 			Assert.AreEqual("b", rr.Conversion.Method.Parameters.Single().Name);
 		}
 
@@ -553,8 +553,8 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
 			Assert.AreEqual("i", rr.Conversion.Method.Parameters[0].Name);
 		}
 
@@ -572,8 +572,8 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
 			Assert.AreEqual("ui", rr.Conversion.Method.Parameters[0].Name);
 		}
 
@@ -591,8 +591,8 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
 			Assert.AreEqual("i", rr.Conversion.Method.Parameters[0].Name);
 		}
 
@@ -610,7 +610,7 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsFalse(rr.Conversion.IsValid);
+			Assert.That(!rr.Conversion.IsValid);
 		}
 
 		[Test]
@@ -627,8 +627,8 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
 			Assert.AreEqual("i", rr.Conversion.Method.Parameters[0].Name);
 		}
 
@@ -646,8 +646,8 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
 			Assert.AreEqual("us", rr.Conversion.Method.Parameters[0].Name);
 		}
 
@@ -665,8 +665,8 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
 			Assert.AreEqual("ui", rr.Conversion.Method.Parameters[0].Name);
 		}
 
@@ -684,7 +684,7 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsFalse(rr.Conversion.IsValid);
+			Assert.That(!rr.Conversion.IsValid);
 		}
 
 		[Test]
@@ -703,7 +703,7 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsFalse(rr.Conversion.IsValid);
+			Assert.That(!rr.Conversion.IsValid);
 		}
 
 		[Test]
@@ -719,9 +719,9 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
-			Assert.IsTrue(rr.Conversion.IsLifted);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsLifted);
 		}
 
 		[Test]
@@ -737,9 +737,9 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
-			Assert.IsFalse(rr.Conversion.IsLifted);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
+			Assert.That(!rr.Conversion.IsLifted);
 		}
 
 		[Test]
@@ -756,9 +756,9 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
-			Assert.IsFalse(rr.Conversion.IsLifted);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
+			Assert.That(!rr.Conversion.IsLifted);
 			Assert.AreEqual("i", rr.Conversion.Method.Parameters[0].Name);
 		}
 
@@ -776,9 +776,9 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
-			Assert.IsFalse(rr.Conversion.IsLifted);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
+			Assert.That(!rr.Conversion.IsLifted);
 			Assert.AreEqual("ni", rr.Conversion.Method.Parameters[0].Name);
 		}
 
@@ -796,8 +796,8 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
 			Assert.AreEqual("ui", rr.Conversion.Method.Parameters[0].Name);
 		}
 
@@ -815,8 +815,8 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
 			Assert.AreEqual("ui", rr.Conversion.Method.Parameters[0].Name);
 		}
 
@@ -833,10 +833,10 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
-			Assert.IsTrue(rr.Conversion.IsLifted);
-			Assert.IsTrue(rr.Input is LocalResolveResult);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsLifted);
+			Assert.That(rr.Input is LocalResolveResult);
 		}
 
 		[Test]
@@ -854,8 +854,8 @@ class Program {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
 			Assert.AreEqual("System.Int16", rr.Conversion.Method.ReturnType.FullName);
 		}
 
@@ -874,8 +874,8 @@ class Program {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
 			Assert.AreEqual("s", rr.Conversion.Method.Parameters[0].Name);
 		}
 
@@ -893,8 +893,8 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.IsUserDefined);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.IsUserDefined);
 			Assert.AreEqual("ci", rr.Conversion.Method.Parameters[0].Name);
 		}
 
@@ -912,11 +912,11 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.ConversionBeforeUserDefinedOperator.IsValid);
-			Assert.IsTrue(rr.Conversion.ConversionBeforeUserDefinedOperator.IsExplicit);
-			Assert.IsTrue(rr.Conversion.ConversionBeforeUserDefinedOperator.IsNumericConversion);
-			Assert.IsTrue(rr.Conversion.ConversionAfterUserDefinedOperator.IsIdentityConversion);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.ConversionBeforeUserDefinedOperator.IsValid);
+			Assert.That(rr.Conversion.ConversionBeforeUserDefinedOperator.IsExplicit);
+			Assert.That(rr.Conversion.ConversionBeforeUserDefinedOperator.IsNumericConversion);
+			Assert.That(rr.Conversion.ConversionAfterUserDefinedOperator.IsIdentityConversion);
 		}
 
 		[Test]
@@ -932,11 +932,11 @@ class Test {
 	}
 }";
 			var rr = Resolve<ConversionResolveResult>(program);
-			Assert.IsTrue(rr.Conversion.IsValid);
-			Assert.IsTrue(rr.Conversion.ConversionBeforeUserDefinedOperator.IsIdentityConversion);
-			Assert.IsTrue(rr.Conversion.ConversionAfterUserDefinedOperator.IsValid);
-			Assert.IsTrue(rr.Conversion.ConversionAfterUserDefinedOperator.IsExplicit);
-			Assert.IsTrue(rr.Conversion.ConversionAfterUserDefinedOperator.IsNumericConversion);
+			Assert.That(rr.Conversion.IsValid);
+			Assert.That(rr.Conversion.ConversionBeforeUserDefinedOperator.IsIdentityConversion);
+			Assert.That(rr.Conversion.ConversionAfterUserDefinedOperator.IsValid);
+			Assert.That(rr.Conversion.ConversionAfterUserDefinedOperator.IsExplicit);
+			Assert.That(rr.Conversion.ConversionAfterUserDefinedOperator.IsNumericConversion);
 		}*/
 	}
 }

ICSharpCode.Decompiler.Tests/Semantics/OverloadResolutionTests.cs

@@ -86,10 +86,10 @@ namespace ICSharpCode.Decompiler.Tests.Semantics
 		{
 			OverloadResolution r = new OverloadResolution(compilation, MakeArgumentList(typeof(ushort)));
 			var c1 = MakeMethod(typeof(int));
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(c1));
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeMethod(typeof(uint))));
-			Assert.IsFalse(r.IsAmbiguous);
-			Assert.AreSame(c1, r.BestCandidate);
+			Assert.That(r.AddCandidate(c1), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(r.AddCandidate(MakeMethod(typeof(uint))), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(!r.IsAmbiguous);
+			Assert.That(r.BestCandidate, Is.SameAs(c1));
 		}
 
 		[Test]
@@ -98,66 +98,66 @@ namespace ICSharpCode.Decompiler.Tests.Semantics
 			ResolveResult[] args = { new ConstantResolveResult(compilation.FindType(KnownTypeCode.Int32), 1) };
 			OverloadResolution r = new OverloadResolution(compilation, args);
 			var c1 = MakeMethod(typeof(uint));
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(c1));
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeMethod(typeof(long))));
-			Assert.IsFalse(r.IsAmbiguous);
-			Assert.AreSame(c1, r.BestCandidate);
+			Assert.That(r.AddCandidate(c1), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(r.AddCandidate(MakeMethod(typeof(long))), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(!r.IsAmbiguous);
+			Assert.That(r.BestCandidate, Is.SameAs(c1));
 		}
 
 		[Test]
 		public void NullableIntAndNullableUIntIsAmbiguous()
 		{
 			OverloadResolution r = new OverloadResolution(compilation, MakeArgumentList(typeof(ushort?)));
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeMethod(typeof(int?))));
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeMethod(typeof(uint?))));
-			Assert.AreEqual(OverloadResolutionErrors.AmbiguousMatch, r.BestCandidateErrors);
+			Assert.That(r.AddCandidate(MakeMethod(typeof(int?))), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(r.AddCandidate(MakeMethod(typeof(uint?))), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(r.BestCandidateErrors, Is.EqualTo(OverloadResolutionErrors.AmbiguousMatch));
 
 			// then adding a matching overload solves the ambiguity:
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeMethod(typeof(ushort?))));
-			Assert.AreEqual(OverloadResolutionErrors.None, r.BestCandidateErrors);
-			Assert.IsNull(r.BestCandidateAmbiguousWith);
+			Assert.That(r.AddCandidate(MakeMethod(typeof(ushort?))), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(r.BestCandidateErrors, Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(r.BestCandidateAmbiguousWith, Is.Null);
 		}
 
 		[Test]
 		public void ParamsMethodMatchesEmptyArgumentList()
 		{
 			OverloadResolution r = new OverloadResolution(compilation, MakeArgumentList());
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeParamsMethod(typeof(int[]))));
-			Assert.IsTrue(r.BestCandidateIsExpandedForm);
+			Assert.That(r.AddCandidate(MakeParamsMethod(typeof(int[]))), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(r.BestCandidateIsExpandedForm);
 		}
 
 		[Test]
 		public void ParamsMethodMatchesOneArgumentInExpandedForm()
 		{
 			OverloadResolution r = new OverloadResolution(compilation, MakeArgumentList(typeof(int)));
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeParamsMethod(typeof(int[]))));
-			Assert.IsTrue(r.BestCandidateIsExpandedForm);
+			Assert.That(r.AddCandidate(MakeParamsMethod(typeof(int[]))), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(r.BestCandidateIsExpandedForm);
 		}
 
 		[Test]
 		public void ParamsMethodMatchesInUnexpandedForm()
 		{
 			OverloadResolution r = new OverloadResolution(compilation, MakeArgumentList(typeof(int[])));
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeParamsMethod(typeof(int[]))));
-			Assert.IsFalse(r.BestCandidateIsExpandedForm);
+			Assert.That(r.AddCandidate(MakeParamsMethod(typeof(int[]))), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(!r.BestCandidateIsExpandedForm);
 		}
 
 		[Test]
 		public void LessArgumentsPassedToParamsIsBetter()
 		{
 			OverloadResolution r = new OverloadResolution(compilation, MakeArgumentList(typeof(int), typeof(int), typeof(int)));
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeParamsMethod(typeof(int[]))));
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(MakeParamsMethod(typeof(int), typeof(int[]))));
-			Assert.IsFalse(r.IsAmbiguous);
-			Assert.AreEqual(2, r.BestCandidate.Parameters.Count);
+			Assert.That(r.AddCandidate(MakeParamsMethod(typeof(int[]))), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(r.AddCandidate(MakeParamsMethod(typeof(int), typeof(int[]))), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(!r.IsAmbiguous);
+			Assert.That(r.BestCandidate.Parameters.Count, Is.EqualTo(2));
 		}
 
 		[Test]
 		public void CallInvalidParamsDeclaration()
 		{
 			OverloadResolution r = new OverloadResolution(compilation, MakeArgumentList(typeof(int[,])));
-			Assert.AreEqual(OverloadResolutionErrors.ArgumentTypeMismatch, r.AddCandidate(MakeParamsMethod(typeof(int))));
-			Assert.IsFalse(r.BestCandidateIsExpandedForm);
+			Assert.That(r.AddCandidate(MakeParamsMethod(typeof(int))), Is.EqualTo(OverloadResolutionErrors.ArgumentTypeMismatch));
+			Assert.That(!r.BestCandidateIsExpandedForm);
 		}
 
 		[Test]
@@ -167,10 +167,10 @@ namespace ICSharpCode.Decompiler.Tests.Semantics
 			var m2 = MakeMethod(1);
 
 			OverloadResolution r = new OverloadResolution(compilation, MakeArgumentList());
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(m1));
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(m2));
-			Assert.IsFalse(r.IsAmbiguous);
-			Assert.AreSame(m1, r.BestCandidate);
+			Assert.That(r.AddCandidate(m1), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(r.AddCandidate(m2), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(!r.IsAmbiguous);
+			Assert.That(r.BestCandidate, Is.SameAs(m1));
 		}
 
 		[Test]
@@ -186,22 +186,22 @@ namespace ICSharpCode.Decompiler.Tests.Semantics
 			// Call: Foo<int>();
 			OverloadResolution o;
 			o = new OverloadResolution(compilation, new ResolveResult[0], typeArguments: new[] { compilation.FindType(typeof(int)) });
-			Assert.AreEqual(OverloadResolutionErrors.None, o.AddCandidate(resolvedM1));
-			Assert.AreEqual(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint, o.AddCandidate(resolvedM2));
-			Assert.AreSame(resolvedM1, o.BestCandidate);
+			Assert.That(o.AddCandidate(resolvedM1), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(o.AddCandidate(resolvedM2), Is.EqualTo(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint));
+			Assert.That(o.BestCandidate, Is.SameAs(resolvedM1));
 
 			// Call: Foo<string>();
 			o = new OverloadResolution(compilation, new ResolveResult[0], typeArguments: new[] { compilation.FindType(typeof(string)) });
-			Assert.AreEqual(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint, o.AddCandidate(resolvedM1));
-			Assert.AreEqual(OverloadResolutionErrors.None, o.AddCandidate(resolvedM2));
-			Assert.AreSame(resolvedM2, o.BestCandidate);
+			Assert.That(o.AddCandidate(resolvedM1), Is.EqualTo(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint));
+			Assert.That(o.AddCandidate(resolvedM2), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(o.BestCandidate, Is.SameAs(resolvedM2));
 
 			// Call: Foo<int?>();
 			o = new OverloadResolution(compilation, new ResolveResult[0], typeArguments: new[] { compilation.FindType(typeof(int?)) });
-			Assert.AreEqual(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint, o.AddCandidate(resolvedM1));
-			Assert.AreEqual(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint, o.AddCandidate(resolvedM2));
-			Assert.AreEqual(OverloadResolutionErrors.None, o.AddCandidate(resolvedM3));
-			Assert.AreSame(resolvedM3, o.BestCandidate);
+			Assert.That(o.AddCandidate(resolvedM1), Is.EqualTo(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint));
+			Assert.That(o.AddCandidate(resolvedM2), Is.EqualTo(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint));
+			Assert.That(o.AddCandidate(resolvedM3), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(o.BestCandidate, Is.SameAs(resolvedM3));
 		}
 
 		class SkeetEvilOverloadResolutionTestCase
@@ -276,10 +276,10 @@ namespace ICSharpCode.Decompiler.Tests.Semantics
 			};
 
 			OverloadResolution r = new OverloadResolution(compilation, args);
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(m1));
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(m2));
-			Assert.AreSame(m2, r.BestCandidate);
-			Assert.AreEqual(OverloadResolutionErrors.None, r.BestCandidateErrors);
+			Assert.That(r.AddCandidate(m1), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(r.AddCandidate(m2), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(r.BestCandidate, Is.SameAs(m2));
+			Assert.That(r.BestCandidateErrors, Is.EqualTo(OverloadResolutionErrors.None));
 		}
 
 		[Test]
@@ -294,10 +294,10 @@ namespace ICSharpCode.Decompiler.Tests.Semantics
 			};
 
 			OverloadResolution r = new OverloadResolution(compilation, args);
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(m1));
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(m2));
-			Assert.AreSame(m2, r.BestCandidate);
-			Assert.AreEqual(OverloadResolutionErrors.None, r.BestCandidateErrors);
+			Assert.That(r.AddCandidate(m1), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(r.AddCandidate(m2), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(r.BestCandidate, Is.SameAs(m2));
+			Assert.That(r.BestCandidateErrors, Is.EqualTo(OverloadResolutionErrors.None));
 		}
 
 		[Test]
@@ -312,9 +312,9 @@ namespace ICSharpCode.Decompiler.Tests.Semantics
 			};
 
 			OverloadResolution r = new OverloadResolution(compilation, args);
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(m1));
-			Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(m2));
-			Assert.AreEqual(OverloadResolutionErrors.AmbiguousMatch, r.BestCandidateErrors);
+			Assert.That(r.AddCandidate(m1), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(r.AddCandidate(m2), Is.EqualTo(OverloadResolutionErrors.None));
+			Assert.That(r.BestCandidateErrors, Is.EqualTo(OverloadResolutionErrors.AmbiguousMatch));
 		}
 
 		[Test, Ignore("Overload Resolution bug")]
@@ -329,10 +329,10 @@ namespace ICSharpCode.Decompiler.Tests.Semantics
 			OverloadResolution r = new OverloadResolution(compilation, args);
 			foreach (var method in container.GetMethods(m => m.Name == "Method"))
 			{
-				Assert.AreEqual(OverloadResolutionErrors.None, r.AddCandidate(method));
+				Assert.That(r.AddCandidate(method), Is.EqualTo(OverloadResolutionErrors.None));
 			}
 
-			Assert.AreEqual(container.GetMethods(m => m.Name == "Method").Last(), r.BestCandidate);
+			Assert.That(r.BestCandidate, Is.EqualTo(container.GetMethods(m => m.Name == "Method").Last()));
 		}
 
 		class BetterFunctionMemberIsNotTransitiveTestCase

ICSharpCode.Decompiler.Tests/TypeSystem/ReflectionHelperTests.cs

@@ -36,8 +36,8 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 		void TestFindType(Type type)
 		{
 			IType t = compilation.FindType(type);
-			Assert.IsNotNull(t, type.FullName);
-			Assert.AreEqual(type.FullName, t.ReflectionName);
+			Assert.That(t, Is.Not.Null, type.FullName);
+			Assert.That(t.ReflectionName, Is.EqualTo(type.FullName));
 		}
 
 		[Test]
@@ -73,83 +73,70 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 		[Test]
 		public void TestToTypeReferenceInnerClass()
 		{
-			Assert.AreEqual("System.Environment+SpecialFolder",
-							compilation.FindType(typeof(Environment.SpecialFolder)).ReflectionName);
+			Assert.That(compilation.FindType(typeof(Environment.SpecialFolder)).ReflectionName, Is.EqualTo("System.Environment+SpecialFolder"));
 		}
 
 		[Test]
 		public void TestToTypeReferenceUnboundGenericClass()
 		{
-			Assert.AreEqual("System.Action`1",
-							compilation.FindType(typeof(Action<>)).ReflectionName);
-			Assert.AreEqual("System.Action`2",
-							compilation.FindType(typeof(Action<,>)).ReflectionName);
+			Assert.That(compilation.FindType(typeof(Action<>)).ReflectionName, Is.EqualTo("System.Action`1"));
+			Assert.That(compilation.FindType(typeof(Action<,>)).ReflectionName, Is.EqualTo("System.Action`2"));
 		}
 
 		[Test]
 		public void TestToTypeReferenceBoundGenericClass()
 		{
-			Assert.AreEqual("System.Action`1[[System.String]]",
-							compilation.FindType(typeof(Action<string>)).ReflectionName);
-			Assert.AreEqual("System.Action`2[[System.Int32],[System.Int16]]",
-							compilation.FindType(typeof(Action<int, short>)).ReflectionName);
+			Assert.That(compilation.FindType(typeof(Action<string>)).ReflectionName, Is.EqualTo("System.Action`1[[System.String]]"));
+			Assert.That(compilation.FindType(typeof(Action<int, short>)).ReflectionName, Is.EqualTo("System.Action`2[[System.Int32],[System.Int16]]"));
 		}
 
 
 		[Test]
 		public void TestToTypeReferenceNullableType()
 		{
-			Assert.AreEqual("System.Nullable`1[[System.Int32]]",
-							compilation.FindType(typeof(int?)).ReflectionName);
+			Assert.That(compilation.FindType(typeof(int?)).ReflectionName, Is.EqualTo("System.Nullable`1[[System.Int32]]"));
 		}
 
 		[Test]
 		public void TestToTypeReferenceInnerClassInUnboundGenericType()
 		{
-			Assert.AreEqual("System.Collections.Generic.Dictionary`2+ValueCollection",
-							compilation.FindType(typeof(Dictionary<,>.ValueCollection)).ReflectionName);
+			Assert.That(compilation.FindType(typeof(Dictionary<,>.ValueCollection)).ReflectionName, Is.EqualTo("System.Collections.Generic.Dictionary`2+ValueCollection"));
 		}
 
 		[Test]
 		public void TestToTypeReferenceInnerClassInBoundGenericType()
 		{
-			Assert.AreEqual("System.Collections.Generic.Dictionary`2+KeyCollection[[System.String],[System.Int32]]",
-							compilation.FindType(typeof(Dictionary<string, int>.KeyCollection)).ReflectionName);
+			Assert.That(compilation.FindType(typeof(Dictionary<string, int>.KeyCollection)).ReflectionName, Is.EqualTo("System.Collections.Generic.Dictionary`2+KeyCollection[[System.String],[System.Int32]]"));
 		}
 
 		[Test]
 		public void TestToTypeReferenceArrayType()
 		{
-			Assert.AreEqual(typeof(int[]).FullName,
-							compilation.FindType(typeof(int[])).ReflectionName);
+			Assert.That(compilation.FindType(typeof(int[])).ReflectionName, Is.EqualTo(typeof(int[]).FullName));
 		}
 
 		[Test]
 		public void TestToTypeReferenceMultidimensionalArrayType()
 		{
-			Assert.AreEqual(typeof(int[,]).FullName,
-							compilation.FindType(typeof(int[,])).ReflectionName);
+			Assert.That(compilation.FindType(typeof(int[,])).ReflectionName, Is.EqualTo(typeof(int[,]).FullName));
 		}
 
 		[Test]
 		public void TestToTypeReferenceJaggedMultidimensionalArrayType()
 		{
-			Assert.AreEqual(typeof(int[,][,,]).FullName,
-							compilation.FindType(typeof(int[,][,,])).ReflectionName);
+			Assert.That(compilation.FindType(typeof(int[,][,,])).ReflectionName, Is.EqualTo(typeof(int[,][,,]).FullName));
 		}
 
 		[Test]
 		public void TestToTypeReferencePointerType()
 		{
-			Assert.AreEqual(typeof(int*).FullName,
-							compilation.FindType(typeof(int*)).ReflectionName);
+			Assert.That(compilation.FindType(typeof(int*)).ReflectionName, Is.EqualTo(typeof(int*).FullName));
 		}
 
 		[Test]
 		public void TestToTypeReferenceByReferenceType()
 		{
-			Assert.AreEqual(typeof(int).MakeByRefType().FullName,
-							compilation.FindType(typeof(int).MakeByRefType()).ReflectionName);
+			Assert.That(compilation.FindType(typeof(int).MakeByRefType()).ReflectionName, Is.EqualTo(typeof(int).MakeByRefType().FullName));
 		}
 
 		[Test]
@@ -159,43 +146,43 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 			ITypeReference parameterType = convertAllInfo.GetParameters()[0].ParameterType.ToTypeReference(); // Converter[[`0],[``0]]
 																											  // cannot resolve generic types without knowing the parent entity:
 			IType resolvedWithoutEntity = parameterType.Resolve(new SimpleTypeResolveContext(compilation));
-			Assert.AreEqual("System.Converter`2[[`0],[``0]]", resolvedWithoutEntity.ReflectionName);
-			Assert.IsNull(((ITypeParameter)((ParameterizedType)resolvedWithoutEntity).GetTypeArgument(0)).Owner);
+			Assert.That(resolvedWithoutEntity.ReflectionName, Is.EqualTo("System.Converter`2[[`0],[``0]]"));
+			Assert.That(((ITypeParameter)((ParameterizedType)resolvedWithoutEntity).GetTypeArgument(0)).Owner, Is.Null);
 			// now try with parent entity:
 			IMethod convertAll = compilation.FindType(typeof(List<>)).GetMethods(m => m.Name == "ConvertAll").Single();
 			IType resolvedWithEntity = parameterType.Resolve(new SimpleTypeResolveContext(convertAll));
-			Assert.AreEqual("System.Converter`2[[`0],[``0]]", resolvedWithEntity.ReflectionName);
-			Assert.AreSame(convertAll.DeclaringTypeDefinition, ((ITypeParameter)((ParameterizedType)resolvedWithEntity).GetTypeArgument(0)).Owner);
+			Assert.That(resolvedWithEntity.ReflectionName, Is.EqualTo("System.Converter`2[[`0],[``0]]"));
+			Assert.That(((ITypeParameter)((ParameterizedType)resolvedWithEntity).GetTypeArgument(0)).Owner, Is.SameAs(convertAll.DeclaringTypeDefinition));
 		}
 
 		[Test]
 		public void ParseReflectionName()
 		{
 			var context = new SimpleTypeResolveContext(compilation.MainModule);
-			Assert.AreEqual("System.Int32", ReflectionHelper.ParseReflectionName("System.Int32").Resolve(context).ReflectionName);
-			Assert.AreEqual("System.Int32&", ReflectionHelper.ParseReflectionName("System.Int32&").Resolve(context).ReflectionName);
-			Assert.AreEqual("System.Int32*&", ReflectionHelper.ParseReflectionName("System.Int32*&").Resolve(context).ReflectionName);
-			Assert.AreEqual("System.Int32", ReflectionHelper.ParseReflectionName(typeof(int).AssemblyQualifiedName).Resolve(context).ReflectionName);
-			Assert.AreEqual("System.Action`1[[System.String]]", ReflectionHelper.ParseReflectionName("System.Action`1[[System.String]]").Resolve(context).ReflectionName);
-			Assert.AreEqual("System.Action`1[[System.String]]", ReflectionHelper.ParseReflectionName("System.Action`1[[System.String, mscorlib]]").Resolve(context).ReflectionName);
-			Assert.AreEqual("System.Int32[,,][,]", ReflectionHelper.ParseReflectionName(typeof(int[,][,,]).AssemblyQualifiedName).Resolve(context).ReflectionName);
-			Assert.AreEqual("System.Environment+SpecialFolder", ReflectionHelper.ParseReflectionName("System.Environment+SpecialFolder").Resolve(context).ReflectionName);
+			Assert.That(ReflectionHelper.ParseReflectionName("System.Int32").Resolve(context).ReflectionName, Is.EqualTo("System.Int32"));
+			Assert.That(ReflectionHelper.ParseReflectionName("System.Int32&").Resolve(context).ReflectionName, Is.EqualTo("System.Int32&"));
+			Assert.That(ReflectionHelper.ParseReflectionName("System.Int32*&").Resolve(context).ReflectionName, Is.EqualTo("System.Int32*&"));
+			Assert.That(ReflectionHelper.ParseReflectionName(typeof(int).AssemblyQualifiedName).Resolve(context).ReflectionName, Is.EqualTo("System.Int32"));
+			Assert.That(ReflectionHelper.ParseReflectionName("System.Action`1[[System.String]]").Resolve(context).ReflectionName, Is.EqualTo("System.Action`1[[System.String]]"));
+			Assert.That(ReflectionHelper.ParseReflectionName("System.Action`1[[System.String, mscorlib]]").Resolve(context).ReflectionName, Is.EqualTo("System.Action`1[[System.String]]"));
+			Assert.That(ReflectionHelper.ParseReflectionName(typeof(int[,][,,]).AssemblyQualifiedName).Resolve(context).ReflectionName, Is.EqualTo("System.Int32[,,][,]"));
+			Assert.That(ReflectionHelper.ParseReflectionName("System.Environment+SpecialFolder").Resolve(context).ReflectionName, Is.EqualTo("System.Environment+SpecialFolder"));
 		}
 
 		[Test]
 		public void ParseOpenGenericReflectionName()
 		{
 			ITypeReference typeRef = ReflectionHelper.ParseReflectionName("System.Converter`2[[`0],[``0]]");
-			Assert.AreEqual("System.Converter`2[[`0],[``0]]", typeRef.Resolve(new SimpleTypeResolveContext(compilation.MainModule)).ReflectionName);
+			Assert.That(typeRef.Resolve(new SimpleTypeResolveContext(compilation.MainModule)).ReflectionName, Is.EqualTo("System.Converter`2[[`0],[``0]]"));
 			IMethod convertAll = compilation.FindType(typeof(List<>)).GetMethods(m => m.Name == "ConvertAll").Single();
-			Assert.AreEqual("System.Converter`2[[`0],[``0]]", typeRef.Resolve(new SimpleTypeResolveContext(convertAll)).ReflectionName);
+			Assert.That(typeRef.Resolve(new SimpleTypeResolveContext(convertAll)).ReflectionName, Is.EqualTo("System.Converter`2[[`0],[``0]]"));
 		}
 
 		[Test]
 		public void ArrayOfTypeParameter()
 		{
 			var context = new SimpleTypeResolveContext(compilation.MainModule);
-			Assert.AreEqual("`0[,]", ReflectionHelper.ParseReflectionName("`0[,]").Resolve(context).ReflectionName);
+			Assert.That(ReflectionHelper.ParseReflectionName("`0[,]").Resolve(context).ReflectionName, Is.EqualTo("`0[,]"));
 		}
 
 		[Test]

ICSharpCode.Decompiler.Tests/UglyTestRunner.cs

@@ -47,7 +47,7 @@ namespace ICSharpCode.Decompiler.Tests
 					|| file.Extension.Equals(".cs", StringComparison.OrdinalIgnoreCase))
 				{
 					var testName = file.Name.Split('.')[0];
-					Assert.Contains(testName, testNames);
+					Assert.That(testNames, Has.Member(testName));
 				}
 			}
 		}

ICSharpCode.Decompiler.Tests/Util/BitSetTests.cs

@@ -30,13 +30,13 @@ namespace ICSharpCode.Decompiler.Tests.Util
 		{
 			var bitset = new BitSet(302);
 			bitset.Set(2, 300);
-			Assert.IsFalse(bitset[0]);
-			Assert.IsFalse(bitset[1]);
+			Assert.That(!bitset[0]);
+			Assert.That(!bitset[1]);
 			for (int i = 2; i < 300; ++i)
 			{
-				Assert.IsTrue(bitset[i]);
+				Assert.That(bitset[i]);
 			}
-			Assert.IsFalse(bitset[301]);
+			Assert.That(!bitset[301]);
 		}
 
 		[Test]
@@ -45,12 +45,12 @@ namespace ICSharpCode.Decompiler.Tests.Util
 			var bitset = new BitSet(300);
 			bitset.Set(0, 300);
 			bitset.Clear(1, 299);
-			Assert.IsTrue(bitset[0]);
+			Assert.That(bitset[0]);
 			for (int i = 1; i < 299; ++i)
 			{
-				Assert.IsFalse(bitset[i]);
+				Assert.That(!bitset[i]);
 			}
-			Assert.IsTrue(bitset[299]);
+			Assert.That(bitset[299]);
 		}
 
 		[Test]
@@ -58,14 +58,14 @@ namespace ICSharpCode.Decompiler.Tests.Util
 		{
 			var bitset = new BitSet(300);
 			bitset.Set(1, 299);
-			Assert.IsTrue(bitset.All(1, 299));
-			Assert.IsTrue(bitset.All(10, 290));
-			Assert.IsTrue(bitset.All(100, 200));
-			Assert.IsFalse(bitset.All(0, 200));
-			Assert.IsFalse(bitset.All(0, 1));
-			Assert.IsFalse(bitset.All(1, 300));
+			Assert.That(bitset.All(1, 299));
+			Assert.That(bitset.All(10, 290));
+			Assert.That(bitset.All(100, 200));
+			Assert.That(!bitset.All(0, 200));
+			Assert.That(!bitset.All(0, 1));
+			Assert.That(!bitset.All(1, 300));
 			bitset[200] = false;
-			Assert.IsFalse(bitset.All(1, 299));
+			Assert.That(!bitset.All(1, 299));
 		}
 
 		[Test]

ICSharpCode.Decompiler.Tests/Util/FileUtilityTests.cs

@@ -29,157 +29,157 @@ namespace ICSharpCode.Decompiler.Tests.Util
 		[Test]
 		public void NormalizePath()
 		{
-			Assert.AreEqual(@"c:\temp\test.txt", FileUtility.NormalizePath(@"c:\temp\project\..\test.txt"));
-			Assert.AreEqual(@"c:\temp\test.txt", FileUtility.NormalizePath(@"c:\temp\project\.\..\test.txt"));
-			Assert.AreEqual(@"c:\temp\test.txt", FileUtility.NormalizePath(@"c:\temp\\test.txt")); // normalize double backslash
-			Assert.AreEqual(@"c:\temp", FileUtility.NormalizePath(@"c:\temp\."));
-			Assert.AreEqual(@"c:\temp", FileUtility.NormalizePath(@"c:\temp\subdir\.."));
+			Assert.That(FileUtility.NormalizePath(@"c:\temp\project\..\test.txt"), Is.EqualTo(@"c:\temp\test.txt"));
+			Assert.That(FileUtility.NormalizePath(@"c:\temp\project\.\..\test.txt"), Is.EqualTo(@"c:\temp\test.txt"));
+			Assert.That(FileUtility.NormalizePath(@"c:\temp\\test.txt"), Is.EqualTo(@"c:\temp\test.txt")); // normalize double backslash
+			Assert.That(FileUtility.NormalizePath(@"c:\temp\."), Is.EqualTo(@"c:\temp"));
+			Assert.That(FileUtility.NormalizePath(@"c:\temp\subdir\.."), Is.EqualTo(@"c:\temp"));
 		}
 
 		[Test]
 		public void NormalizePath_DriveRoot()
 		{
-			Assert.AreEqual(@"C:\", FileUtility.NormalizePath(@"C:\"));
-			Assert.AreEqual(@"C:\", FileUtility.NormalizePath(@"C:/"));
-			Assert.AreEqual(@"C:\", FileUtility.NormalizePath(@"C:"));
-			Assert.AreEqual(@"C:\", FileUtility.NormalizePath(@"C:/."));
-			Assert.AreEqual(@"C:\", FileUtility.NormalizePath(@"C:/.."));
-			Assert.AreEqual(@"C:\", FileUtility.NormalizePath(@"C:/./"));
-			Assert.AreEqual(@"C:\", FileUtility.NormalizePath(@"C:/..\"));
+			Assert.That(FileUtility.NormalizePath(@"C:\"), Is.EqualTo(@"C:\"));
+			Assert.That(FileUtility.NormalizePath(@"C:/"), Is.EqualTo(@"C:\"));
+			Assert.That(FileUtility.NormalizePath(@"C:"), Is.EqualTo(@"C:\"));
+			Assert.That(FileUtility.NormalizePath(@"C:/."), Is.EqualTo(@"C:\"));
+			Assert.That(FileUtility.NormalizePath(@"C:/.."), Is.EqualTo(@"C:\"));
+			Assert.That(FileUtility.NormalizePath(@"C:/./"), Is.EqualTo(@"C:\"));
+			Assert.That(FileUtility.NormalizePath(@"C:/..\"), Is.EqualTo(@"C:\"));
 		}
 
 		[Test]
 		public void NormalizePath_UNC()
 		{
-			Assert.AreEqual(@"\\server\share", FileUtility.NormalizePath(@"\\server\share"));
-			Assert.AreEqual(@"\\server\share", FileUtility.NormalizePath(@"\\server\share\"));
-			Assert.AreEqual(@"\\server\share", FileUtility.NormalizePath(@"//server/share/"));
-			Assert.AreEqual(@"\\server\share\otherdir", FileUtility.NormalizePath(@"//server/share/dir/..\otherdir"));
+			Assert.That(FileUtility.NormalizePath(@"\\server\share"), Is.EqualTo(@"\\server\share"));
+			Assert.That(FileUtility.NormalizePath(@"\\server\share\"), Is.EqualTo(@"\\server\share"));
+			Assert.That(FileUtility.NormalizePath(@"//server/share/"), Is.EqualTo(@"\\server\share"));
+			Assert.That(FileUtility.NormalizePath(@"//server/share/dir/..\otherdir"), Is.EqualTo(@"\\server\share\otherdir"));
 		}
 
 		[Test]
 		public void NormalizePath_Web()
 		{
-			Assert.AreEqual(@"http://danielgrunwald.de/path/", FileUtility.NormalizePath(@"http://danielgrunwald.de/path/"));
-			Assert.AreEqual(@"browser://http://danielgrunwald.de/path/", FileUtility.NormalizePath(@"browser://http://danielgrunwald.de/wrongpath/../path/"));
+			Assert.That(FileUtility.NormalizePath(@"http://danielgrunwald.de/path/"), Is.EqualTo(@"http://danielgrunwald.de/path/"));
+			Assert.That(FileUtility.NormalizePath(@"browser://http://danielgrunwald.de/wrongpath/../path/"), Is.EqualTo(@"browser://http://danielgrunwald.de/path/"));
 		}
 
 		[Test]
 		public void NormalizePath_Relative()
 		{
-			Assert.AreEqual(@"../b", FileUtility.NormalizePath(@"..\a\..\b"));
-			Assert.AreEqual(@".", FileUtility.NormalizePath(@"."));
-			Assert.AreEqual(@".", FileUtility.NormalizePath(@"a\.."));
+			Assert.That(FileUtility.NormalizePath(@"..\a\..\b"), Is.EqualTo(@"../b"));
+			Assert.That(FileUtility.NormalizePath(@"."), Is.EqualTo(@"."));
+			Assert.That(FileUtility.NormalizePath(@"a\.."), Is.EqualTo(@"."));
 		}
 
 		[Test]
 		public void NormalizePath_UnixStyle()
 		{
-			Assert.AreEqual("/", FileUtility.NormalizePath("/"));
-			Assert.AreEqual("/a/b", FileUtility.NormalizePath("/a/b"));
-			Assert.AreEqual("/a/b", FileUtility.NormalizePath("/c/../a/./b"));
-			Assert.AreEqual("/a/b", FileUtility.NormalizePath("/c/../../a/./b"));
+			Assert.That(FileUtility.NormalizePath("/"), Is.EqualTo("/"));
+			Assert.That(FileUtility.NormalizePath("/a/b"), Is.EqualTo("/a/b"));
+			Assert.That(FileUtility.NormalizePath("/c/../a/./b"), Is.EqualTo("/a/b"));
+			Assert.That(FileUtility.NormalizePath("/c/../../a/./b"), Is.EqualTo("/a/b"));
 		}
 		#endregion
 
 		[Test]
 		public void TestIsBaseDirectory()
 		{
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"C:\a", @"C:\A\b\hello"));
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"C:\a", @"C:\a"));
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"C:\a\", @"C:\a\"));
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"C:\a\", @"C:\a"));
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"C:\a", @"C:\a\"));
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"C:\A", @"C:\a"));
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"C:\a", @"C:\A"));
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"C:\a\x\fWufhweoe", @"C:\a\x\fwuFHweoe\a\b\hello"));
-
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"C:\b\..\A", @"C:\a"));
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"C:\HELLO\..\B\..\a", @"C:\b\..\a"));
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"C:\.\B\..\.\.\a", @"C:\.\.\.\.\.\.\.\a"));
-
-			Assert.IsFalse(FileUtility.IsBaseDirectory(@"C:\b", @"C:\a\b\hello"));
-			Assert.IsFalse(FileUtility.IsBaseDirectory(@"C:\a\b\hello", @"C:\b"));
-			Assert.IsFalse(FileUtility.IsBaseDirectory(@"C:\a\x\fwufhweoe", @"C:\a\x\fwuFHweoex\a\b\hello"));
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"C:\", @"C:\"));
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"C:\", @"C:\a\b\hello"));
-			Assert.IsFalse(FileUtility.IsBaseDirectory(@"C:\", @"D:\a\b\hello"));
+			Assert.That(FileUtility.IsBaseDirectory(@"C:\a", @"C:\A\b\hello"));
+			Assert.That(FileUtility.IsBaseDirectory(@"C:\a", @"C:\a"));
+			Assert.That(FileUtility.IsBaseDirectory(@"C:\a\", @"C:\a\"));
+			Assert.That(FileUtility.IsBaseDirectory(@"C:\a\", @"C:\a"));
+			Assert.That(FileUtility.IsBaseDirectory(@"C:\a", @"C:\a\"));
+			Assert.That(FileUtility.IsBaseDirectory(@"C:\A", @"C:\a"));
+			Assert.That(FileUtility.IsBaseDirectory(@"C:\a", @"C:\A"));
+			Assert.That(FileUtility.IsBaseDirectory(@"C:\a\x\fWufhweoe", @"C:\a\x\fwuFHweoe\a\b\hello"));
+
+			Assert.That(FileUtility.IsBaseDirectory(@"C:\b\..\A", @"C:\a"));
+			Assert.That(FileUtility.IsBaseDirectory(@"C:\HELLO\..\B\..\a", @"C:\b\..\a"));
+			Assert.That(FileUtility.IsBaseDirectory(@"C:\.\B\..\.\.\a", @"C:\.\.\.\.\.\.\.\a"));
+
+			Assert.That(!FileUtility.IsBaseDirectory(@"C:\b", @"C:\a\b\hello"));
+			Assert.That(!FileUtility.IsBaseDirectory(@"C:\a\b\hello", @"C:\b"));
+			Assert.That(!FileUtility.IsBaseDirectory(@"C:\a\x\fwufhweoe", @"C:\a\x\fwuFHweoex\a\b\hello"));
+			Assert.That(FileUtility.IsBaseDirectory(@"C:\", @"C:\"));
+			Assert.That(FileUtility.IsBaseDirectory(@"C:\", @"C:\a\b\hello"));
+			Assert.That(!FileUtility.IsBaseDirectory(@"C:\", @"D:\a\b\hello"));
 		}
 
 
 		[Test]
 		public void TestIsBaseDirectoryRelative()
 		{
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@".", @"a\b"));
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@".", @"a"));
-			Assert.IsFalse(FileUtility.IsBaseDirectory(@".", @"c:\"));
-			Assert.IsFalse(FileUtility.IsBaseDirectory(@".", @"/"));
+			Assert.That(FileUtility.IsBaseDirectory(@".", @"a\b"));
+			Assert.That(FileUtility.IsBaseDirectory(@".", @"a"));
+			Assert.That(!FileUtility.IsBaseDirectory(@".", @"c:\"));
+			Assert.That(!FileUtility.IsBaseDirectory(@".", @"/"));
 		}
 
 		[Test]
 		public void TestIsBaseDirectoryUnixStyle()
 		{
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"/", @"/"));
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"/", @"/a"));
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"/", @"/a/subdir"));
+			Assert.That(FileUtility.IsBaseDirectory(@"/", @"/"));
+			Assert.That(FileUtility.IsBaseDirectory(@"/", @"/a"));
+			Assert.That(FileUtility.IsBaseDirectory(@"/", @"/a/subdir"));
 		}
 
 		[Test]
 		public void TestIsBaseDirectoryUNC()
 		{
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"\\server\share", @"\\server\share\dir\subdir"));
-			Assert.IsTrue(FileUtility.IsBaseDirectory(@"\\server\share", @"\\server\share\dir\subdir"));
-			Assert.IsFalse(FileUtility.IsBaseDirectory(@"\\server2\share", @"\\server\share\dir\subdir"));
+			Assert.That(FileUtility.IsBaseDirectory(@"\\server\share", @"\\server\share\dir\subdir"));
+			Assert.That(FileUtility.IsBaseDirectory(@"\\server\share", @"\\server\share\dir\subdir"));
+			Assert.That(!FileUtility.IsBaseDirectory(@"\\server2\share", @"\\server\share\dir\subdir"));
 		}
 
 		[Test]
 		public void TestGetRelativePath()
 		{
-			Assert.AreEqual(@"blub", FileUtility.GetRelativePath(@"C:\hello\.\..\a", @"C:\.\a\blub"));
-			Assert.AreEqual(@"..\a\blub", FileUtility.GetRelativePath(@"C:\.\.\.\.\hello", @"C:\.\blub\.\..\.\a\.\blub"));
-			Assert.AreEqual(@"..\a\blub", FileUtility.GetRelativePath(@"C:\.\.\.\.\hello\", @"C:\.\blub\.\..\.\a\.\blub"));
-			Assert.AreEqual(@".", FileUtility.GetRelativePath(@"C:\hello", @"C:\.\hello"));
-			Assert.AreEqual(@".", FileUtility.GetRelativePath(@"C:\", @"C:\"));
-			Assert.AreEqual(@"blub", FileUtility.GetRelativePath(@"C:\", @"C:\blub"));
-			Assert.AreEqual(@"D:\", FileUtility.GetRelativePath(@"C:\", @"D:\"));
-			Assert.AreEqual(@"D:\def", FileUtility.GetRelativePath(@"C:\abc", @"D:\def"));
+			Assert.That(FileUtility.GetRelativePath(@"C:\hello\.\..\a", @"C:\.\a\blub"), Is.EqualTo(@"blub"));
+			Assert.That(FileUtility.GetRelativePath(@"C:\.\.\.\.\hello", @"C:\.\blub\.\..\.\a\.\blub"), Is.EqualTo(@"..\a\blub"));
+			Assert.That(FileUtility.GetRelativePath(@"C:\.\.\.\.\hello\", @"C:\.\blub\.\..\.\a\.\blub"), Is.EqualTo(@"..\a\blub"));
+			Assert.That(FileUtility.GetRelativePath(@"C:\hello", @"C:\.\hello"), Is.EqualTo(@"."));
+			Assert.That(FileUtility.GetRelativePath(@"C:\", @"C:\"), Is.EqualTo(@"."));
+			Assert.That(FileUtility.GetRelativePath(@"C:\", @"C:\blub"), Is.EqualTo(@"blub"));
+			Assert.That(FileUtility.GetRelativePath(@"C:\", @"D:\"), Is.EqualTo(@"D:\"));
+			Assert.That(FileUtility.GetRelativePath(@"C:\abc", @"D:\def"), Is.EqualTo(@"D:\def"));
 
 			// casing troubles
-			Assert.AreEqual(@"blub", FileUtility.GetRelativePath(@"C:\hello\.\..\A", @"C:\.\a\blub"));
-			Assert.AreEqual(@"..\a\blub", FileUtility.GetRelativePath(@"C:\.\.\.\.\HELlo", @"C:\.\blub\.\..\.\a\.\blub"));
-			Assert.AreEqual(@"..\a\blub", FileUtility.GetRelativePath(@"C:\.\.\.\.\heLLo\A\..", @"C:\.\blub\.\..\.\a\.\blub"));
+			Assert.That(FileUtility.GetRelativePath(@"C:\hello\.\..\A", @"C:\.\a\blub"), Is.EqualTo(@"blub"));
+			Assert.That(FileUtility.GetRelativePath(@"C:\.\.\.\.\HELlo", @"C:\.\blub\.\..\.\a\.\blub"), Is.EqualTo(@"..\a\blub"));
+			Assert.That(FileUtility.GetRelativePath(@"C:\.\.\.\.\heLLo\A\..", @"C:\.\blub\.\..\.\a\.\blub"), Is.EqualTo(@"..\a\blub"));
 		}
 
 		[Test]
 		public void RelativeGetRelativePath()
 		{
 			// Relative path
-			Assert.AreEqual(@"a", FileUtility.GetRelativePath(@".", @"a"));
-			Assert.AreEqual(@"..", FileUtility.GetRelativePath(@"a", @"."));
-			Assert.AreEqual(@"..\b", FileUtility.GetRelativePath(@"a", @"b"));
-			Assert.AreEqual(@"..\..", FileUtility.GetRelativePath(@"a", @".."));
+			Assert.That(FileUtility.GetRelativePath(@".", @"a"), Is.EqualTo(@"a"));
+			Assert.That(FileUtility.GetRelativePath(@"a", @"."), Is.EqualTo(@".."));
+			Assert.That(FileUtility.GetRelativePath(@"a", @"b"), Is.EqualTo(@"..\b"));
+			Assert.That(FileUtility.GetRelativePath(@"a", @".."), Is.EqualTo(@"..\.."));
 
 			// Getting a path from an absolute path to a relative path isn't really possible;
 			// so we just keep the existing relative path (don't introduce incorrect '..\').
-			Assert.AreEqual(@"def", FileUtility.GetRelativePath(@"C:\abc", @"def"));
+			Assert.That(FileUtility.GetRelativePath(@"C:\abc", @"def"), Is.EqualTo(@"def"));
 		}
 
 		[Test]
 		public void GetRelativePath_Unix()
 		{
-			Assert.AreEqual(@"a", FileUtility.GetRelativePath("/", "/a"));
-			Assert.AreEqual(@"a\b", FileUtility.GetRelativePath("/", "/a/b"));
-			Assert.AreEqual(@"b", FileUtility.GetRelativePath("/a", "/a/b"));
+			Assert.That(FileUtility.GetRelativePath("/", "/a"), Is.EqualTo(@"a"));
+			Assert.That(FileUtility.GetRelativePath("/", "/a/b"), Is.EqualTo(@"a\b"));
+			Assert.That(FileUtility.GetRelativePath("/a", "/a/b"), Is.EqualTo(@"b"));
 		}
 
 		[Test]
 		public void TestIsEqualFile()
 		{
-			Assert.IsTrue(FileUtility.IsEqualFileName(@"C:\.\Hello World.Exe", @"C:\HELLO WOrld.exe"));
-			Assert.IsTrue(FileUtility.IsEqualFileName(@"C:\bla\..\a\my.file.is.this", @"C:\gg\..\.\.\.\.\a\..\a\MY.FILE.IS.THIS"));
+			Assert.That(FileUtility.IsEqualFileName(@"C:\.\Hello World.Exe", @"C:\HELLO WOrld.exe"));
+			Assert.That(FileUtility.IsEqualFileName(@"C:\bla\..\a\my.file.is.this", @"C:\gg\..\.\.\.\.\a\..\a\MY.FILE.IS.THIS"));
 
-			Assert.IsFalse(FileUtility.IsEqualFileName(@"C:\.\Hello World.Exe", @"C:\HELLO_WOrld.exe"));
-			Assert.IsFalse(FileUtility.IsEqualFileName(@"C:\a\my.file.is.this", @"C:\gg\..\.\.\.\.\a\..\b\MY.FILE.IS.THIS"));
+			Assert.That(!FileUtility.IsEqualFileName(@"C:\.\Hello World.Exe", @"C:\HELLO_WOrld.exe"));
+			Assert.That(!FileUtility.IsEqualFileName(@"C:\a\my.file.is.this", @"C:\gg\..\.\.\.\.\a\..\b\MY.FILE.IS.THIS"));
 		}
 	}
 }

ICSharpCode.Decompiler.Tests/Util/IntervalTests.cs

@@ -27,54 +27,54 @@ namespace ICSharpCode.Decompiler.Tests.Util
 		[Test]
 		public void DefaultIsEmpty()
 		{
-			Assert.IsTrue(default(Interval).IsEmpty);
-			Assert.IsFalse(default(Interval).Contains(-1));
-			Assert.IsFalse(default(Interval).Contains(0));
-			Assert.IsFalse(default(Interval).Contains(1));
+			Assert.That(default(Interval).IsEmpty);
+			Assert.That(!default(Interval).Contains(-1));
+			Assert.That(!default(Interval).Contains(0));
+			Assert.That(!default(Interval).Contains(1));
 		}
 		[Test]
 		public void EmptyAt1()
 		{
 			Interval i = new Interval(1, 1);
-			Assert.IsTrue(default(Interval).IsEmpty);
-			Assert.IsFalse(default(Interval).Contains(-1));
-			Assert.IsFalse(default(Interval).Contains(0));
-			Assert.IsFalse(default(Interval).Contains(1));
-			Assert.IsFalse(default(Interval).Contains(2));
+			Assert.That(default(Interval).IsEmpty);
+			Assert.That(!default(Interval).Contains(-1));
+			Assert.That(!default(Interval).Contains(0));
+			Assert.That(!default(Interval).Contains(1));
+			Assert.That(!default(Interval).Contains(2));
 		}
 
 		[Test]
 		public void OneToThree()
 		{
 			Interval i = new Interval(1, 3);
-			Assert.IsFalse(i.IsEmpty);
-			Assert.IsFalse(i.Contains(0));
-			Assert.IsTrue(i.Contains(1));
-			Assert.IsTrue(i.Contains(2));
-			Assert.IsFalse(i.Contains(3));
+			Assert.That(!i.IsEmpty);
+			Assert.That(!i.Contains(0));
+			Assert.That(i.Contains(1));
+			Assert.That(i.Contains(2));
+			Assert.That(!i.Contains(3));
 		}
 
 		[Test]
 		public void FullInterval()
 		{
 			Interval full = new Interval(int.MinValue, int.MinValue);
-			Assert.IsFalse(full.IsEmpty);
-			Assert.IsTrue(full.Contains(int.MinValue));
-			Assert.IsTrue(full.Contains(0));
-			Assert.IsTrue(full.Contains(int.MaxValue));
+			Assert.That(!full.IsEmpty);
+			Assert.That(full.Contains(int.MinValue));
+			Assert.That(full.Contains(0));
+			Assert.That(full.Contains(int.MaxValue));
 		}
 
 		[Test]
 		public void NonNegativeIntegers()
 		{
 			Interval i = new Interval(0, int.MinValue);
-			Assert.IsFalse(i.IsEmpty);
-			Assert.IsTrue(i.Contains(0));
-			Assert.IsTrue(i.Contains(1000));
-			Assert.IsTrue(i.Contains(int.MaxValue));
-			Assert.IsFalse(i.Contains(-1));
-			Assert.IsFalse(i.Contains(-1000));
-			Assert.IsFalse(i.Contains(int.MinValue));
+			Assert.That(!i.IsEmpty);
+			Assert.That(i.Contains(0));
+			Assert.That(i.Contains(1000));
+			Assert.That(i.Contains(int.MaxValue));
+			Assert.That(!i.Contains(-1));
+			Assert.That(!i.Contains(-1000));
+			Assert.That(!i.Contains(int.MinValue));
 		}
 
 		[Test]
@@ -87,12 +87,12 @@ namespace ICSharpCode.Decompiler.Tests.Util
 			Interval nonneg = new Interval(0, int.MinValue);
 			Interval nonpos = new Interval(int.MinValue, 1);
 			Interval maxval = new Interval(int.MaxValue, int.MinValue);
-			Assert.AreEqual(nonneg, full.Intersect(nonneg));
-			Assert.AreEqual(nonneg, nonneg.Intersect(full));
-			Assert.AreEqual(zero, nonneg.Intersect(zero));
-			Assert.AreEqual(zero, nonneg.Intersect(nonpos));
-			Assert.AreEqual(maxval, nonneg.Intersect(maxval));
-			Assert.AreEqual(empty, nonpos.Intersect(maxval));
+			Assert.That(full.Intersect(nonneg), Is.EqualTo(nonneg));
+			Assert.That(nonneg.Intersect(full), Is.EqualTo(nonneg));
+			Assert.That(nonneg.Intersect(zero), Is.EqualTo(zero));
+			Assert.That(nonneg.Intersect(nonpos), Is.EqualTo(zero));
+			Assert.That(nonneg.Intersect(maxval), Is.EqualTo(maxval));
+			Assert.That(nonpos.Intersect(maxval), Is.EqualTo(empty));
 		}
 	}
 }

ICSharpCode.Decompiler.Tests/Util/LongSetTests.cs

@@ -32,94 +32,92 @@ namespace ICSharpCode.Decompiler.Tests.Util
 		public void UpperBound()
 		{
 			var longSet = new LongSet(new[] { new LongInterval(1, 5), new LongInterval(6, 7) }.ToImmutableArray());
-			Assert.AreEqual(0, longSet.upper_bound(0));
+			Assert.That(longSet.upper_bound(0), Is.EqualTo(0));
 			for (int i = 1; i <= 5; i++)
-				Assert.AreEqual(1, longSet.upper_bound(i));
+				Assert.That(longSet.upper_bound(i), Is.EqualTo(1));
 			for (int i = 6; i <= 10; i++)
-				Assert.AreEqual(2, longSet.upper_bound(i));
+				Assert.That(longSet.upper_bound(i), Is.EqualTo(2));
 		}
 
 		[Test]
 		public void UniverseContainsAll()
 		{
-			Assert.IsTrue(LongSet.Universe.Contains(long.MinValue));
-			Assert.IsTrue(LongSet.Universe.Contains(1));
-			Assert.IsTrue(LongSet.Universe.Contains(long.MaxValue));
-			Assert.IsFalse(LongSet.Universe.IsEmpty);
+			Assert.That(LongSet.Universe.Contains(long.MinValue));
+			Assert.That(LongSet.Universe.Contains(1));
+			Assert.That(LongSet.Universe.Contains(long.MaxValue));
+			Assert.That(!LongSet.Universe.IsEmpty);
 		}
 
 		[Test]
 		public void IntersectUniverse()
 		{
-			Assert.AreEqual(LongSet.Universe, LongSet.Universe.IntersectWith(LongSet.Universe));
-			Assert.AreEqual(LongSet.Empty, LongSet.Universe.IntersectWith(LongSet.Empty));
-			Assert.AreEqual(new LongSet(long.MaxValue), LongSet.Universe.IntersectWith(new LongSet(long.MaxValue)));
+			Assert.That(LongSet.Universe.IntersectWith(LongSet.Universe), Is.EqualTo(LongSet.Universe));
+			Assert.That(LongSet.Universe.IntersectWith(LongSet.Empty), Is.EqualTo(LongSet.Empty));
+			Assert.That(LongSet.Universe.IntersectWith(new LongSet(long.MaxValue)), Is.EqualTo(new LongSet(long.MaxValue)));
 			var longSet = new LongSet(new[] { new LongInterval(1, 5), new LongInterval(6, 7) }.ToImmutableArray());
-			Assert.AreEqual(longSet, longSet.IntersectWith(LongSet.Universe));
+			Assert.That(longSet.IntersectWith(LongSet.Universe), Is.EqualTo(longSet));
 		}
 
 		[Test]
 		public void UnionUniverse()
 		{
-			Assert.AreEqual(LongSet.Universe, LongSet.Universe.UnionWith(LongSet.Universe));
-			Assert.AreEqual(LongSet.Universe, LongSet.Universe.UnionWith(LongSet.Empty));
-			Assert.AreEqual(LongSet.Universe, LongSet.Universe.UnionWith(new LongSet(long.MaxValue)));
+			Assert.That(LongSet.Universe.UnionWith(LongSet.Universe), Is.EqualTo(LongSet.Universe));
+			Assert.That(LongSet.Universe.UnionWith(LongSet.Empty), Is.EqualTo(LongSet.Universe));
+			Assert.That(LongSet.Universe.UnionWith(new LongSet(long.MaxValue)), Is.EqualTo(LongSet.Universe));
 			var longSet = new LongSet(new[] { new LongInterval(1, 5), new LongInterval(6, 7) }.ToImmutableArray());
-			Assert.AreEqual(LongSet.Universe, longSet.UnionWith(LongSet.Universe));
+			Assert.That(longSet.UnionWith(LongSet.Universe), Is.EqualTo(LongSet.Universe));
 		}
 
 		[Test]
 		public void ExceptWithUniverse()
 		{
-			Assert.AreEqual(LongSet.Universe, LongSet.Universe.ExceptWith(LongSet.Empty));
-			Assert.AreEqual(LongSet.Empty, LongSet.Universe.ExceptWith(LongSet.Universe));
-			Assert.AreEqual(LongSet.Empty, LongSet.Empty.ExceptWith(LongSet.Universe));
-			Assert.AreEqual(LongSet.Empty, LongSet.Empty.ExceptWith(LongSet.Empty));
+			Assert.That(LongSet.Universe.ExceptWith(LongSet.Empty), Is.EqualTo(LongSet.Universe));
+			Assert.That(LongSet.Universe.ExceptWith(LongSet.Universe), Is.EqualTo(LongSet.Empty));
+			Assert.That(LongSet.Empty.ExceptWith(LongSet.Universe), Is.EqualTo(LongSet.Empty));
+			Assert.That(LongSet.Empty.ExceptWith(LongSet.Empty), Is.EqualTo(LongSet.Empty));
 		}
 
 		[Test]
 		public void UnionWith()
 		{
-			Assert.AreEqual(new LongSet(new LongInterval(0, 2)),
-				new LongSet(0).UnionWith(new LongSet(1)));
+			Assert.That(new LongSet(0).UnionWith(new LongSet(1)), Is.EqualTo(new LongSet(new LongInterval(0, 2))));
 
-			Assert.AreEqual(LongSet.Universe, new LongSet(0).Invert().UnionWith(new LongSet(0)));
+			Assert.That(new LongSet(0).Invert().UnionWith(new LongSet(0)), Is.EqualTo(LongSet.Universe));
 		}
 
 		[Test]
 		public void AddTo()
 		{
-			Assert.AreEqual(new LongSet(1), new LongSet(0).AddOffset(1));
-			Assert.AreEqual(new LongSet(long.MinValue), new LongSet(long.MaxValue).AddOffset(1));
+			Assert.That(new LongSet(0).AddOffset(1), Is.EqualTo(new LongSet(1)));
+			Assert.That(new LongSet(long.MaxValue).AddOffset(1), Is.EqualTo(new LongSet(long.MinValue)));
 
 			TestAddTo(new LongSet(new LongInterval(-10, 10)), 5);
 			TestAddTo(new LongSet(new LongInterval(-10, 10)), long.MaxValue);
-			Assert.AreEqual(new LongSet(10).Invert(), new LongSet(0).Invert().AddOffset(10));
-			Assert.AreEqual(new LongSet(20).Invert(), new LongSet(30).Invert().AddOffset(-10));
+			Assert.That(new LongSet(0).Invert().AddOffset(10), Is.EqualTo(new LongSet(10).Invert()));
+			Assert.That(new LongSet(30).Invert().AddOffset(-10), Is.EqualTo(new LongSet(20).Invert()));
 		}
 
 		void TestAddTo(LongSet input, long constant)
 		{
-			Assert.AreEqual(
-				input.Values.Select(e => unchecked(e + constant)).OrderBy(e => e).ToList(),
-				input.AddOffset(constant).Values.ToList());
+			Assert.That(
+				input.AddOffset(constant).Values.ToList(), Is.EqualTo(input.Values.Select(e => unchecked(e + constant)).OrderBy(e => e).ToList()));
 		}
 
 		[Test]
 		public void Values()
 		{
-			Assert.IsFalse(LongSet.Empty.Values.Any());
-			Assert.IsTrue(LongSet.Universe.Values.Any());
-			Assert.AreEqual(new[] { 1, 2, 3 }, new LongSet(LongInterval.Inclusive(1, 3)).Values.ToArray());
+			Assert.That(!LongSet.Empty.Values.Any());
+			Assert.That(LongSet.Universe.Values.Any());
+			Assert.That(new LongSet(LongInterval.Inclusive(1, 3)).Values.ToArray(), Is.EqualTo(new[] { 1, 2, 3 }));
 		}
 
 		[Test]
 		public void ValueCount()
 		{
-			Assert.AreEqual(0, LongSet.Empty.Count());
-			Assert.AreEqual(ulong.MaxValue, new LongSet(3).Invert().Count());
-			Assert.AreEqual(ulong.MaxValue, LongSet.Universe.Count());
-			Assert.AreEqual(long.MaxValue + 2ul, new LongSet(LongInterval.Inclusive(-1, long.MaxValue)).Count());
+			Assert.That(LongSet.Empty.Count(), Is.EqualTo(0));
+			Assert.That(new LongSet(3).Invert().Count(), Is.EqualTo(ulong.MaxValue));
+			Assert.That(LongSet.Universe.Count(), Is.EqualTo(ulong.MaxValue));
+			Assert.That(new LongSet(LongInterval.Inclusive(-1, long.MaxValue)).Count(), Is.EqualTo(long.MaxValue + 2ul));
 		}
 	}
 }

ICSharpCode.Decompiler.Tests/Util/ResourceReaderWriterTests.cs

@@ -100,9 +100,9 @@ namespace ICSharpCode.Decompiler.Tests.Util
 			using var testFile = ProduceResourcesTestFile(name, value);
 			using var reader = new ResourcesFile(testFile);
 			var items = reader.ToArray();
-			Assert.AreEqual(1, items.Length);
-			Assert.AreEqual(name, items[0].Key);
-			Assert.AreEqual(value, items[0].Value);
+			Assert.That(items.Length, Is.EqualTo(1));
+			Assert.That(items[0].Key, Is.EqualTo(name));
+			Assert.That(items[0].Value, Is.EqualTo(value));
 		}
 
 		[TestCase("Null", null, null, "System.Resources.ResXNullRef" + WinFormsAssemblyName)]
@@ -124,14 +124,14 @@ namespace ICSharpCode.Decompiler.Tests.Util
 		public void Write(string name, object value, string serializedValue, string typeName)
 		{
 			var element = ProduceResXTest(name, value);
-			Assert.AreEqual(name, element.Attribute("name")?.Value);
+			Assert.That(element.Attribute("name")?.Value, Is.EqualTo(name));
 			if (typeName != null)
 			{
-				Assert.AreEqual(typeName, element.Attribute("type")?.Value);
+				Assert.That(element.Attribute("type")?.Value, Is.EqualTo(typeName));
 			}
 			var v = element.Element("value");
-			Assert.IsNotNull(v);
-			Assert.IsTrue(v.IsEmpty ? serializedValue == null : v.Value == serializedValue);
+			Assert.That(v, Is.Not.Null);
+			Assert.That(v.IsEmpty ? serializedValue == null : v.Value == serializedValue);
 		}
 
 		[Test]
@@ -149,10 +149,10 @@ namespace ICSharpCode.Decompiler.Tests.Util
 				.GetManifestResourceStream(typeof(ResourceReaderWriterTests).Namespace + ".Test.resources");
 			using var reader = new ResourcesFile(stream);
 			var items = reader.ToArray();
-			Assert.AreEqual(3, items.Length);
+			Assert.That(items.Length, Is.EqualTo(3));
 			var item = items.FirstOrDefault(i => i.Key == "Bitmap");
-			Assert.IsNotNull(item.Key);
-			Assert.IsInstanceOf<ResourceSerializedObject>(item.Value);
+			Assert.That(item.Key, Is.Not.Null);
+			Assert.That(item.Value, Is.InstanceOf<ResourceSerializedObject>());
 		}
 
 		[Test]
@@ -162,15 +162,15 @@ namespace ICSharpCode.Decompiler.Tests.Util
 				.GetManifestResourceStream(typeof(ResourceReaderWriterTests).Namespace + ".Test.resources");
 			using var reader = new ResourcesFile(stream);
 			var items = reader.ToArray();
-			Assert.AreEqual(3, items.Length);
+			Assert.That(items.Length, Is.EqualTo(3));
 			var item = items.FirstOrDefault(i => i.Key == "Byte[]");
-			Assert.IsNotNull(item.Key);
-			Assert.IsInstanceOf<byte[]>(item.Value);
+			Assert.That(item.Key, Is.Not.Null);
+			Assert.That(item.Value, Is.InstanceOf<byte[]>());
 			byte[] array = (byte[])item.Value;
-			Assert.AreEqual(3, array.Length);
-			Assert.AreEqual(42, array[0]);
-			Assert.AreEqual(43, array[1]);
-			Assert.AreEqual(44, array[2]);
+			Assert.That(array.Length, Is.EqualTo(3));
+			Assert.That(array[0], Is.EqualTo(42));
+			Assert.That(array[1], Is.EqualTo(43));
+			Assert.That(array[2], Is.EqualTo(44));
 		}
 
 		[Test]
@@ -180,10 +180,10 @@ namespace ICSharpCode.Decompiler.Tests.Util
 				.GetManifestResourceStream(typeof(ResourceReaderWriterTests).Namespace + ".Test.resources");
 			using var reader = new ResourcesFile(stream);
 			var items = reader.ToArray();
-			Assert.AreEqual(3, items.Length);
+			Assert.That(items.Length, Is.EqualTo(3));
 			var item = items.FirstOrDefault(i => i.Key == "MemoryStream");
-			Assert.IsNotNull(item.Key);
-			Assert.IsInstanceOf<MemoryStream>(item.Value);
+			Assert.That(item.Key, Is.Not.Null);
+			Assert.That(item.Value, Is.InstanceOf<MemoryStream>());
 		}
 	}
 }

ICSharpCode.Decompiler.Tests/VBPrettyTestRunner.cs

@@ -45,8 +45,8 @@ namespace ICSharpCode.Decompiler.Tests
 				if (file.Extension.Equals(".vb", StringComparison.OrdinalIgnoreCase))
 				{
 					var testName = file.Name.Split('.')[0];
-					Assert.Contains(testName, testNames);
-					Assert.IsTrue(File.Exists(Path.Combine(TestCasePath, testName + ".cs")));
+					Assert.That(testNames, Has.Member(testName));
+					Assert.That(File.Exists(Path.Combine(TestCasePath, testName + ".cs")));
 				}
 			}
 		}

ILSpy.BamlDecompiler.Tests/BamlTestRunner.cs

@@ -179,7 +179,7 @@ namespace ILSpy.BamlDecompiler.Tests
 				resolver.AddSearchDirectory(Path.GetDirectoryName(asmPath));
 				var res = module.Resources.First();
 				Stream bamlStream = LoadBaml(res, name + ".baml");
-				Assert.IsNotNull(bamlStream);
+				Assert.That(bamlStream, Is.Not.Null);
 
 				BamlDecompilerTypeSystem typeSystem = new BamlDecompilerTypeSystem(module, resolver);
 				var decompiler = new XamlDecompiler(typeSystem, new BamlDecompilerSettings());

ILSpy.BamlDecompiler.Tests/ILSpy.BamlDecompiler.Tests.csproj

@@ -45,6 +45,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <Compile Include="..\ILSpy.Tests\Workaround4564.cs" Link="Workaround4564.cs" />
     <Compile Include="BamlTestRunner.cs" />
     <Compile Include="Cases\AttachedEvent.xaml.cs">
       <DependentUpon>AttachedEvent.xaml</DependentUpon>

ILSpy.Tests/Analyzers/MemberImplementsInterfaceAnalyzerTests.cs

@@ -69,7 +69,7 @@ namespace ICSharpCode.ILSpy.Tests.Analyzers
 			var shouldShow = analyzer.Show(symbol: null);
 
 			// Assert
-			Assert.IsFalse(shouldShow, $"The analyzer will be unexpectedly shown for no symbol");
+			Assert.That(!shouldShow, $"The analyzer will be unexpectedly shown for no symbol");
 		}
 
 		[Test]
@@ -85,7 +85,7 @@ namespace ICSharpCode.ILSpy.Tests.Analyzers
 			var shouldShow = analyzer.Show(symbolMock);
 
 			// Assert
-			Assert.IsFalse(shouldShow, $"The analyzer will be unexpectedly shown for symbol '{symbolKind}'");
+			Assert.That(!shouldShow, $"The analyzer will be unexpectedly shown for symbol '{symbolKind}'");
 		}
 
 		[Test]
@@ -100,7 +100,7 @@ namespace ICSharpCode.ILSpy.Tests.Analyzers
 			var shouldShow = analyzer.Show(memberMock);
 
 			// Assert
-			Assert.IsFalse(shouldShow, $"The analyzer will be unexpectedly shown for static symbol '{symbolKind}'");
+			Assert.That(!shouldShow, $"The analyzer will be unexpectedly shown for static symbol '{symbolKind}'");
 		}
 
 		[Test]
@@ -117,7 +117,7 @@ namespace ICSharpCode.ILSpy.Tests.Analyzers
 			var shouldShow = analyzer.Show(memberMock);
 
 			// Assert
-			Assert.IsFalse(shouldShow, $"The analyzer will be unexpectedly shown for symbol '{symbolKind}' and '{typeKind}'");
+			Assert.That(!shouldShow, $"The analyzer will be unexpectedly shown for symbol '{symbolKind}' and '{typeKind}'");
 		}
 
 		[Test]
@@ -134,7 +134,7 @@ namespace ICSharpCode.ILSpy.Tests.Analyzers
 			var shouldShow = analyzer.Show(memberMock);
 
 			// Assert
-			Assert.IsTrue(shouldShow, $"The analyzer will not be shown for symbol '{symbolKind}' and '{typeKind}'");
+			Assert.That(shouldShow, $"The analyzer will not be shown for symbol '{symbolKind}' and '{typeKind}'");
 		}
 
 		[Test]
@@ -148,13 +148,13 @@ namespace ICSharpCode.ILSpy.Tests.Analyzers
 			var results = analyzer.Analyze(symbol, new AnalyzerContext());
 
 			// Assert
-			Assert.IsNotNull(results);
-			Assert.AreEqual(1, results.Count());
+			Assert.That(results, Is.Not.Null);
+			Assert.That(results.Count(), Is.EqualTo(1));
 			var result = results.FirstOrDefault() as IMethod;
-			Assert.IsNotNull(result);
-			Assert.IsNotNull(result.DeclaringTypeDefinition);
-			Assert.AreEqual(TypeKind.Interface, result.DeclaringTypeDefinition.Kind);
-			Assert.AreEqual(nameof(ITestInterface), result.DeclaringTypeDefinition.Name);
+			Assert.That(result, Is.Not.Null);
+			Assert.That(result.DeclaringTypeDefinition, Is.Not.Null);
+			Assert.That(result.DeclaringTypeDefinition.Kind, Is.EqualTo(TypeKind.Interface));
+			Assert.That(result.DeclaringTypeDefinition.Name, Is.EqualTo(nameof(ITestInterface)));
 		}
 
 		private ISymbol SetupSymbolForAnalysis(Type type, string methodName)

ILSpy.Tests/Analyzers/MethodUsesAnalyzerTests.cs

@@ -42,11 +42,11 @@ namespace ICSharpCode.ILSpy.Tests.Analyzers
 
 			var results = new MethodUsesAnalyzer().Analyze(symbol, context).ToList();
 
-			Assert.IsTrue(results.Count == 1);
+			Assert.That(results.Count == 1);
 			var field = results.Single() as IField;
-			Assert.IsNotNull(field);
-			Assert.IsFalse(field.MetadataToken.IsNil);
-			Assert.AreEqual(field.FullName, "System.String.Empty");
+			Assert.That(field, Is.Not.Null);
+			Assert.That(!field.MetadataToken.IsNil);
+			Assert.That("System.String.Empty", Is.EqualTo(field.FullName));
 		}
 	}
 }

ILSpy.Tests/Analyzers/TypeUsedByAnalyzerTests.cs

@@ -59,10 +59,10 @@ namespace ICSharpCode.ILSpy.Tests.Analyzers
 
 			var results = new TypeUsedByAnalyzer().Analyze(symbol, context).ToList();
 
-			Assert.IsNotEmpty(results);
+			Assert.That(results, Is.Not.Empty);
 			var method = results.OfType<IMethod>().SingleOrDefault(m => m.FullName == "ICSharpCode.ILSpy.Tests.Analyzers.TestCases.Main.MainAssembly.UsesInt32");
-			Assert.IsNotNull(method);
-			Assert.IsFalse(method.MetadataToken.IsNil);
+			Assert.That(method, Is.Not.Null);
+			Assert.That(!method.MetadataToken.IsNil);
 		}
 	}
 }

ILSpy.Tests/ILSpy.Tests.csproj

@@ -38,6 +38,7 @@
     <Compile Include="Analyzers\MethodUsesAnalyzerTests.cs" />
     <Compile Include="Analyzers\TestCases\MainAssembly.cs" />
     <Compile Include="Analyzers\TypeUsedByAnalyzerTests.cs" />
+    <Compile Include="Workaround4564.cs" />
   </ItemGroup>
 
   <ItemGroup>