Remove many classic asserts

Author: SteveGilham

altcode.test/altcode.test.nunit/NUnit.fs

@@ -30,192 +30,192 @@ type AltAssert =
       message,
       [<ParamArray>] args: Object[]
     ) =
-    ClassicAssert.AreEqual(x.Expected, x.Actual, delta, message, args)
+    Assert.That(x.Actual, Is.EqualTo(x.Expected).Within(delta), String.Format(message, args))
 
   static member AreEqual(x: AssertionMatch<double>, delta) =
-    ClassicAssert.AreEqual(x.Expected, x.Actual, delta)
+    Assert.That(x.Actual, Is.EqualTo(x.Expected).Within(delta))
 
   static member AreEqual(x: AssertionMatch<'a>, message, [<ParamArray>] args: Object[]) =
-    ClassicAssert.AreEqual(x.Expected, x.Actual, message, args)
+    Assert.That(x.Actual, Is.EqualTo(x.Expected),NUnitString(String.Format(message, args)))
 
   static member AreEqual(x: AssertionMatch<'a>) =
-    ClassicAssert.AreEqual(x.Expected, x.Actual)
+    Assert.That(x.Actual, Is.EqualTo(x.Expected))
 
   static member AreNotEqual
     (
       x: AssertionMatch<'a>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    ClassicAssert.AreNotEqual(x.Expected, x.Actual, message, args)
+    Assert.That(x.Actual, Is.Not.EqualTo x.Expected,NUnitString(String.Format(message, args)))
 
   static member AreNotEqual(x: AssertionMatch<'a>) =
-    ClassicAssert.AreNotEqual(x.Expected, x.Actual)
+    Assert.That(x.Actual, Is.Not.EqualTo(x.Expected))
 
   static member AreSame(x: AssertionMatch<'a>, message, [<ParamArray>] args: Object[]) =
-    ClassicAssert.AreSame(x.Expected, x.Actual, message, args)
+    Assert.That(x.Actual, Is.SameAs x.Expected, NUnitString(String.Format(message, args)))
 
   static member AreSame(x: AssertionMatch<'a>) =
-    ClassicAssert.AreSame(x.Expected, x.Actual)
+    Assert.That(x.Actual, Is.SameAs x.Expected)
 
   static member AreNotSame
     (
       x: AssertionMatch<'a>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    ClassicAssert.AreNotSame(x.Expected, x.Actual, message, args)
+    Assert.That(x.Actual, Is.Not.SameAs x.Expected, NUnitString(String.Format(message, args)))
 
   static member AreNotSame(x: AssertionMatch<'a>) =
-    ClassicAssert.AreNotSame(x.Expected, x.Actual)
+    Assert.That(x.Actual, Is.Not.SameAs x.Expected)
 
   static member Greater(x: AssertionMatch<'a>, message, [<ParamArray>] args: Object[]) =
-    ClassicAssert.Greater(x.Actual, x.Expected, message, args)
+    Assert.That(x.Actual, Is.GreaterThan x.Expected, NUnitString(String.Format(message, args)))
 
   static member Greater(x: AssertionMatch<'a>) =
-    ClassicAssert.Greater(x.Actual, x.Expected)
+    Assert.That(x.Actual, Is.GreaterThan x.Expected)
 
   static member GreaterOrEqual
     (
       x: AssertionMatch<'a>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    ClassicAssert.GreaterOrEqual(x.Actual, x.Expected, message, args)
+    Assert.That(x.Actual, Is.GreaterThanOrEqualTo x.Expected, NUnitString(String.Format(message, args)))
 
   static member GreaterOrEqual(x: AssertionMatch<'a>) =
-    ClassicAssert.GreaterOrEqual(x.Actual, x.Expected)
+    Assert.That(x.Actual, Is.GreaterThanOrEqualTo x.Expected)
 
   static member Less(x: AssertionMatch<'a>, message, [<ParamArray>] args: Object[]) =
-    ClassicAssert.Less(x.Actual, x.Expected, message, args)
+    Assert.That(x.Actual, Is.LessThan x.Expected, NUnitString(String.Format(message, args)))
 
   static member Less(x: AssertionMatch<'a>) =
-    ClassicAssert.Less(x.Actual, x.Expected)
+    Assert.That(x.Actual, Is.LessThan x.Expected)
 
   static member LessOrEqual
     (
       x: AssertionMatch<'a>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    ClassicAssert.LessOrEqual(x.Actual, x.Expected, message, args)
+    Assert.That(x.Actual, Is.LessThanOrEqualTo x.Expected, NUnitString(String.Format(message, args)))
 
   static member LessOrEqual(x: AssertionMatch<'a>) =
-    ClassicAssert.LessOrEqual(x.Actual, x.Expected)
+    Assert.That(x.Actual, Is.LessThanOrEqualTo x.Expected)
 
 [<AbstractClass; Sealed>]
 type AltCollectionAssert =
   static member AreEqual<'a when 'a :> IEnumerable>(x: AssertionMatch<'a>) =
-    CollectionAssert.AreEqual(x.Expected, x.Actual)
+    Assert.That(x.Actual, Is.EqualTo x.Expected)
 
-  static member AreEqual<'a when 'a :> IEnumerable>(x: AssertionMatch<'a>, comparer) =
-    CollectionAssert.AreEqual(x.Expected, x.Actual, comparer)
+  static member AreEqual<'a when 'a :> IEnumerable>(x: AssertionMatch<'a>, comparer:IComparer) =
+    Assert.That(x.Actual, Is.EqualTo(x.Expected).Using(comparer))
 
   static member AreEqual<'a when 'a :> IEnumerable>
     (
       x: AssertionMatch<'a>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    CollectionAssert.AreEqual(x.Expected, x.Actual, message, args)
+    Assert.That(x.Actual, Is.EqualTo x.Expected, NUnitString(String.Format(message, args)))
 
   static member AreEqual<'a when 'a :> IEnumerable>
     (
       x: AssertionMatch<'a>,
-      comparer,
+      comparer:IComparer,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    CollectionAssert.AreEqual(x.Expected, x.Actual, comparer, message, args)
+    Assert.That(x.Actual, Is.EqualTo(x.Expected).Using(comparer), NUnitString(String.Format(message, args)))
 
   static member AreEquivalent<'a when 'a :> IEnumerable>(x: AssertionMatch<'a>) =
-    CollectionAssert.AreEquivalent(x.Expected, x.Actual)
+    Assert.That(x.Actual, Is.EquivalentTo x.Expected)
 
   static member AreEquivalent<'a when 'a :> IEnumerable>
     (
       x: AssertionMatch<'a>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    CollectionAssert.AreEquivalent(x.Expected, x.Actual, message, args)
+    Assert.That(x.Actual, Is.EquivalentTo x.Expected, NUnitString(String.Format(message, args)))
 
   static member AreNotEqual<'a when 'a :> IEnumerable>(x: AssertionMatch<'a>) =
-    CollectionAssert.AreNotEqual(x.Expected, x.Actual)
+    Assert.That(x.Actual, Is.Not.EqualTo x.Expected)
 
-  static member AreNotEqual<'a when 'a :> IEnumerable>(x: AssertionMatch<'a>, comparer) =
-    CollectionAssert.AreNotEqual(x.Expected, x.Actual, comparer)
+  static member AreNotEqual<'a when 'a :> IEnumerable>(x: AssertionMatch<'a>, comparer:IComparer) =
+    Assert.That(x.Actual, Is.Not.EqualTo(x.Expected).Using(comparer))
 
   static member AreNotEqual<'a when 'a :> IEnumerable>
     (
       x: AssertionMatch<'a>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    CollectionAssert.AreNotEqual(x.Expected, x.Actual, message, args)
+    Assert.That(x.Actual, Is.Not.EqualTo x.Expected, NUnitString(String.Format(message, args)))
 
   static member AreNotEqual<'a when 'a :> IEnumerable>
     (
       x: AssertionMatch<'a>,
-      comparer,
+      comparer:IComparer,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    CollectionAssert.AreNotEqual(x.Expected, x.Actual, comparer, message, args)
+    Assert.That(x.Actual, Is.Not.EqualTo(x.Expected).Using(comparer), NUnitString(String.Format(message, args)))
 
   static member AreNotEquivalent<'a when 'a :> IEnumerable>(x: AssertionMatch<'a>) =
-    CollectionAssert.AreNotEquivalent(x.Expected, x.Actual)
+    Assert.That(x.Actual, Is.Not.EquivalentTo x.Expected)
 
   static member AreNotEquivalent<'a when 'a :> IEnumerable>
     (
       x: AssertionMatch<'a>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    CollectionAssert.AreNotEquivalent(x.Expected, x.Actual, message, args)
+    Assert.That(x.Actual, Is.Not.EquivalentTo x.Expected, NUnitString(String.Format(message, args)))
 
   static member IsNotSubsetOf<'a when 'a :> IEnumerable>(x: AssertionMatch<'a>) =
-    CollectionAssert.IsNotSubsetOf(x.Actual, x.Expected)
+    Assert.That(x.Actual, Is.Not.SubsetOf x.Expected)
 
   static member IsNotSubsetOf<'a when 'a :> IEnumerable>
     (
       x: AssertionMatch<'a>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    CollectionAssert.IsNotSubsetOf(x.Actual, x.Expected, message, args)
+    Assert.That(x.Actual, Is.Not.SubsetOf x.Expected, NUnitString(String.Format(message, args)))
 
   static member IsNotSupersetOf<'a when 'a :> IEnumerable>(x: AssertionMatch<'a>) =
-    CollectionAssert.IsNotSupersetOf(x.Actual, x.Expected)
+    Assert.That(x.Actual, Is.Not.SupersetOf x.Expected)
 
   static member IsNotSupersetOf<'a when 'a :> IEnumerable>
     (
       x: AssertionMatch<'a>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    CollectionAssert.IsNotSupersetOf(x.Actual, x.Expected, message, args)
+    Assert.That(x.Actual, Is.Not.SupersetOf x.Expected, NUnitString(String.Format(message, args)))
 
   static member IsSubsetOf<'a when 'a :> IEnumerable>(x: AssertionMatch<'a>) =
-    CollectionAssert.IsSubsetOf(x.Actual, x.Expected)
+    Assert.That(x.Actual, Is.SubsetOf x.Expected)
 
   static member IsSubsetOf<'a when 'a :> IEnumerable>
     (
       x: AssertionMatch<'a>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    CollectionAssert.IsSubsetOf(x.Actual, x.Expected, message, args)
+    Assert.That(x.Actual, Is.SubsetOf x.Expected, NUnitString(String.Format(message, args)))
 
   static member IsSupersetOf<'a when 'a :> IEnumerable>(x: AssertionMatch<'a>) =
-    CollectionAssert.IsSupersetOf(x.Actual, x.Expected)
+    Assert.That(x.Actual, Is.SupersetOf x.Expected)
 
   static member IsSupersetOf<'a when 'a :> IEnumerable>
     (
       x: AssertionMatch<'a>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    CollectionAssert.IsSupersetOf(x.Actual, x.Expected, message, args)
+    Assert.That(x.Actual, Is.SupersetOf x.Expected, NUnitString(String.Format(message, args)))
 
 [<AbstractClass; Sealed>]
 type AltDirectoryAssert =
@@ -334,91 +334,91 @@ type AltStringAssert =
     StringAssert.AreNotEqualIgnoringCase(x.Expected, x.Actual, message, args)
 
   static member Contains(x: AssertionMatch<String>) =
-    StringAssert.Contains(x.Expected, x.Actual)
+    Assert.That(x.Actual, Does.Contain x.Expected)
 
   static member Contains
     (
       x: AssertionMatch<String>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    StringAssert.Contains(x.Expected, x.Actual, message, args)
+    Assert.That(x.Actual, Does.Contain x.Expected, NUnitString(String.Format(message, args)))
 
   static member DoesNotContain(x: AssertionMatch<String>) =
-    StringAssert.DoesNotContain(x.Expected, x.Actual)
+    Assert.That(x.Actual, Does.Not.Contain x.Expected)
 
   static member DoesNotContain
     (
       x: AssertionMatch<String>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    StringAssert.DoesNotContain(x.Expected, x.Actual, message, args)
+    Assert.That(x.Actual, Does.Not.Contain x.Expected, NUnitString(String.Format(message, args)))
 
   static member DoesNotEndWith(x: AssertionMatch<String>) =
-    StringAssert.DoesNotEndWith(x.Expected, x.Actual)
+    Assert.That(x.Actual, Does.Not.EndWith x.Expected)
 
   static member DoesNotEndWith
     (
       x: AssertionMatch<String>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    StringAssert.DoesNotEndWith(x.Expected, x.Actual, message, args)
+    Assert.That(x.Actual, Does.Not.EndWith x.Expected, NUnitString(String.Format(message, args)))
 
   static member DoesNotMatch(x: AssertionMatch<String>) =
-    StringAssert.DoesNotMatch(x.Expected, x.Actual)
+    Assert.That(x.Actual, Does.Not.Match x.Expected)
 
   static member DoesNotMatch
     (
       x: AssertionMatch<String>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    StringAssert.DoesNotMatch(x.Expected, x.Actual, message, args)
+    Assert.That(x.Actual, Does.Not.Match x.Expected, NUnitString(String.Format(message, args)))
 
   static member DoesNotStartWith(x: AssertionMatch<String>) =
-    StringAssert.DoesNotStartWith(x.Expected, x.Actual)
+    Assert.That(x.Actual, Does.Not.StartWith x.Expected)
 
   static member DoesNotStartWith
     (
       x: AssertionMatch<String>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    StringAssert.DoesNotStartWith(x.Expected, x.Actual, message, args)
+    Assert.That(x.Actual, Does.Not.StartWith x.Expected, NUnitString(String.Format(message, args)))
 
   static member EndsWith(x: AssertionMatch<String>) =
-    StringAssert.EndsWith(x.Expected, x.Actual)
+    Assert.That(x.Actual, Does.EndWith x.Expected)
 
   static member EndsWith
     (
       x: AssertionMatch<String>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    StringAssert.EndsWith(x.Expected, x.Actual, message, args)
+    Assert.That(x.Actual, Does.EndWith x.Expected, NUnitString(String.Format(message, args)))
 
   static member IsMatch(x: AssertionMatch<String>) =
-    StringAssert.IsMatch(x.Expected, x.Actual)
+   Assert.That(x.Actual, Does.Match x.Expected)
 
   static member IsMatch
     (
       x: AssertionMatch<String>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    StringAssert.IsMatch(x.Expected, x.Actual, message, args)
+    Assert.That(x.Actual, Does.Match x.Expected, NUnitString(String.Format(message, args)))
 
   static member StartsWith(x: AssertionMatch<String>) =
-    StringAssert.StartsWith(x.Expected, x.Actual)
+    Assert.That(x.Actual, Does.StartWith x.Expected)
 
   static member StartsWith
     (
       x: AssertionMatch<String>,
       message,
       [<ParamArray>] args: Object[]
     ) =
-    StringAssert.StartsWith(x.Expected, x.Actual, message, args)
+    Assert.That(x.Actual, Does.StartWith x.Expected, NUnitString(String.Format(message, args)))
 
 //