Merge branch 'master' into release/v1

SteveGilham · SteveGilham · commit 13e19768666e · 2019-11-03T09:37:13.000Z
# Conflicts:
#	ReleaseNotes.md
diff --git a/README.md b/README.md
@@ -7,7 +7,7 @@ A core type
 ```
 namespace AltCode.Test.Common
 
-type Match<'a> =
+type AssertionMatch<'a> =
   {
     Actual : 'a
     Expected : 'a
@@ -24,15 +24,15 @@ providing a F# and C#-friendly API for naming arguments
 
 # For Expecto
 
-Module `AltCode.Test.Expecto.AltExpect` which provides wrappers for `Expecto.Expect` with an appropriate `Match`-typed argument in place of actual and template expectation
+Module `AltCode.Test.Expecto.AltExpect` which provides wrappers for `Expecto.Expect` and `AltCode.Test.Expecto.AltFlipExpect` for `Expecto.Flip.Expect` with an appropriate `AssertionMatch`-typed argument in place of actual and template expectation
 
 # For Xunit
 
-Module `AltCode.Test.Xunit.AltAssert` which provides wrappers for `Xunit.Assert` with an appropriate `Match`-typed argument in place of actual and template expectation
+Class `AltCode.Test.Xunit.AltAssert` which provides wrappers for `Xunit.Assert` with an appropriate `AssertionMatch`-typed argument in place of actual and template expectation
 
 # For NUnit
 
-Module `AltCode.Test.NUnit.AltAssert` which provides wrappers for `NUnit.Framework.Assert` with an appropriate `Match`-typed argument in place of actual and template expectation; also 
+Classes `AltCode.Test.NUnit.Alt*Assert` which provide wrappers for the corresponding `NUnit.Framework.*Assert` for `*` = `''`, `'Directory'`, `'File'` and `'String'`  with an appropriate `AssertionMatch`-typed argument in place of actual and template expectation; also 
 ```
 type Constraint<'a> =
   {
@@ -70,7 +70,7 @@ Then `dotnet fake run ./Build/setup.fsx` to do the rest of the set-up.
 
 ### Normal builds
 
-Running `dotnet fake run ./Build/build.fsx` performs a full build/test/package process.
+Running `dotnet fake run ./Build/build.fsx` performs a full build/package process.
 
 Use `dotnet fake run ./Build/build.fsx --target <targetname>` to run to a specific target.
 
diff --git a/ReleaseNotes.md b/ReleaseNotes.md
@@ -2,6 +2,12 @@ Q. Never mind the fluff -- how do I get started?
 
 A. Start with the README : https://github.com/SteveGilham/altcode.test/blob/master/README.md
 
+# 1.0.6
+* [BREAKING] `Match` -> `AssertionMatch`
+* `altcode.test.expecto` -- add `Expecto.Flip` support
+* `altcode.test.nunit` -- add `DirectoryAssert`, `FileAssert` and `StringAssert` support
+* `altcode.test.xunit` -- add `AltAssert.Same`
+
 # 1.0.4
 * [NEW PACKAGE] `altcode.test.expecto` -- named argument helper for Expecto >= 8.12.0
 * [NEW PACKAGE] `altcode.test.nunit` -- named argument helper for NUnit >= 3.12.0
diff --git a/altcode.test/altcode.test.common/Common.fs b/altcode.test/altcode.test.common/Common.fs
@@ -1,6 +1,6 @@
 ﻿namespace AltCode.Test.Common
 
-type Match<'a> =
+type AssertionMatch<'a> =
   {
     Actual : 'a
     Expected : 'a
diff --git a/altcode.test/altcode.test.expecto/Expecto.fs b/altcode.test/altcode.test.expecto/Expecto.fs
@@ -8,41 +8,76 @@ open Expecto
 
 [<RequireQualifiedAccess>]
 module AltExpect =
-  let containsAll (x : Match<IEnumerable<'a>>) message =
+  let containsAll (x : AssertionMatch<IEnumerable<'a>>) message =
     Expect.containsAll x.Actual x.Expected message
-  let equal (x : Match<'a>) message =
+  let equal (x : AssertionMatch<'a>) message =
     Expect.equal x.Actual x.Expected message
-  let floatClose accuracy (x : Match<double>) message =
+  let floatClose accuracy (x : AssertionMatch<double>) message =
     Expect.floatClose accuracy x.Actual x.Expected message
-  let floatGreaterThanOrClose accuracy (x : Match<double>) message =
+  let floatGreaterThanOrClose accuracy (x : AssertionMatch<double>) message =
     Expect.floatGreaterThanOrClose accuracy x.Actual x.Expected message
-  let floatLessThanOrClose accuracy (x : Match<double>) message =
+  let floatLessThanOrClose accuracy (x : AssertionMatch<double>) message =
     Expect.floatLessThanOrClose accuracy x.Actual x.Expected message
-  let isMatch (x : Match<string>) message =
+  let isMatch (x : AssertionMatch<string>) message =
     Expect.isMatch x.Actual x.Expected message
-  let isMatchGroups (x : Match<string>) matchesOperator message =
+  let isMatchGroups (x : AssertionMatch<string>) matchesOperator message =
     Expect.isMatchGroups x.Actual x.Expected matchesOperator message
-  let isNotMatch (x : Match<string>) message =
+  let isNotMatch (x : AssertionMatch<string>) message =
     Expect.isNotMatch x.Actual x.Expected message
-  let notEqual (x : Match<'a>) message =
+  let notEqual (x : AssertionMatch<'a>) message =
     Expect.notEqual x.Actual x.Expected message
-  let sequenceContainsOrder (x : Match<IEnumerable<'a>>) message =
+  let sequenceContainsOrder (x : AssertionMatch<IEnumerable<'a>>) message =
     Expect.sequenceContainsOrder x.Actual x.Expected message
-  let sequenceEqual (x : Match<IEnumerable<'a>>) message =
+  let sequenceEqual (x : AssertionMatch<IEnumerable<'a>>) message =
     Expect.sequenceEqual x.Actual x.Expected message
-  let sequenceStarts (x : Match<IEnumerable<'a>>) message =
+  let sequenceStarts (x : AssertionMatch<IEnumerable<'a>>) message =
     Expect.sequenceStarts x.Actual x.Expected message
-  let streamsEqual (x : Match<Stream>) message =
+  let streamsEqual (x : AssertionMatch<Stream>) message =
     Expect.streamsEqual x.Actual x.Expected message
-  let stringContains (x : Match<string>) message =
+  let stringContains (x : AssertionMatch<string>) message =
     Expect.stringContains x.Actual x.Expected message
-  let stringEnds (x : Match<string>) message =
+  let stringEnds (x : AssertionMatch<string>) message =
     Expect.stringEnds x.Actual x.Expected message
-  let stringStarts (x : Match<IEnumerable<char>>) message =
+  let stringStarts (x : AssertionMatch<IEnumerable<char>>) message =
     Expect.stringStarts x.Actual x.Expected message
   [<Obsolete("Please use the more general AltExpect.floatClose")>]
-  let floatEqual (x : Match<double>) epsilon message =
+  let floatEqual (x : AssertionMatch<double>) epsilon message =
     let epsilon2 = match epsilon with
                    | Some d -> d
                    | None -> 0.001
-    Expect.floatClose {absolute = epsilon2; relative =  0.0} x.Actual x.Expected message
+    Expect.floatClose {absolute = epsilon2; relative =  0.0} x.Actual x.Expected message
+
+[<RequireQualifiedAccess>]
+module AltFlipExpect =
+  let equal message (x : AssertionMatch<'a>) =
+    Expecto.Flip.Expect.equal message x.Expected x.Actual
+  let floatClose message accuracy (x : AssertionMatch<double>) =
+    Expecto.Flip.Expect.floatClose message accuracy x.Expected x.Actual
+  let floatGreaterThanOrClose message accuracy (x : AssertionMatch<double>) =
+    Expecto.Flip.Expect.floatGreaterThanOrClose message accuracy x.Expected x.Actual
+  let floatLessThanOrClose message accuracy (x : AssertionMatch<double>) =
+    Expecto.Flip.Expect.floatLessThanOrClose message accuracy x.Expected x.Actual
+  let isMatch message (x : AssertionMatch<string>) =
+    Expecto.Flip.Expect.isMatch message x.Expected x.Actual
+  let isMatchGroups message matchesOperator (x : AssertionMatch<string>) =
+    Expecto.Flip.Expect.isMatchGroups message matchesOperator x.Expected x.Actual
+  let isNotMatch message (x : AssertionMatch<string>) =
+    Expecto.Flip.Expect.isNotMatch message x.Expected x.Actual
+  let notEqual message (x : AssertionMatch<'a>) =
+    Expecto.Flip.Expect.notEqual message x.Expected x.Actual
+  let sequenceContainsOrder message (x : AssertionMatch<IEnumerable<'a>>) =
+    Expecto.Flip.Expect.sequenceContainsOrder message x.Expected x.Actual
+  let sequenceEqual message (x : AssertionMatch<IEnumerable<'a>>) =
+    Expecto.Flip.Expect.sequenceEqual message x.Expected x.Actual
+  let sequenceStarts message (x : AssertionMatch<IEnumerable<'a>>) =
+    Expecto.Flip.Expect.sequenceStarts message x.Expected x.Actual
+  let streamsEqual message (x : AssertionMatch<Stream>) =
+    Expecto.Flip.Expect.streamsEqual message x.Expected x.Actual
+  let stringContains message (x : AssertionMatch<string>) =
+    Expecto.Flip.Expect.stringContains message x.Expected x.Actual
+  let stringEnds message (x : AssertionMatch<string>) =
+    Expecto.Flip.Expect.stringEnds message x.Expected x.Actual
+  let stringStarts message (x : AssertionMatch<IEnumerable<char>>) =
+    Expecto.Flip.Expect.stringStarts message x.Expected x.Actual
+
+  //
diff --git a/altcode.test/altcode.test.nunit/NUnit.fs b/altcode.test/altcode.test.nunit/NUnit.fs
@@ -1,6 +1,8 @@
 ﻿namespace AltCode.Test.Nunit
 
 open System
+open System.Collections
+open System.IO
 open AltCode.Test.Common
 open NUnit.Framework
 
@@ -25,27 +27,155 @@ type AltAssert =
     Assert.That(x.Actual, x.Constraint, message, args)
   static member That(x: Constraint<'a>, getExceptionMessage) =
     Assert.That(x.Actual, x.Constraint, getExceptionMessage)
-  static member AreEqual(x : Match<double>, delta, message, args) =
+  static member AreEqual(x : AssertionMatch<double>, delta, message, args) =
     Assert.AreEqual(x.Expected, x.Actual, delta, message, args)
-  static member AreEqual(x : Match<double>, delta) =
+  static member AreEqual(x : AssertionMatch<double>, delta) =
     Assert.AreEqual(x.Expected, x.Actual, delta)
-  static member AreEqual(x : Match<Nullable<double>>, delta, message, args) =
+  static member AreEqual(x : AssertionMatch<Nullable<double>>, delta, message, args) =
+    if not x.Expected.HasValue then ArgumentNullException "Expected" |> raise
     Assert.AreEqual(x.Expected.Value, x.Actual, delta, message, args)
-  static member AreEqual(x : Match<Nullable<double>>, delta) =
+  static member AreEqual(x : AssertionMatch<Nullable<double>>, delta) =
+    if not x.Expected.HasValue then ArgumentNullException "Expected" |> raise
     Assert.AreEqual(x.Expected.Value, x.Actual, delta)
-  static member AreEqual(x : Match<'a>, message, args) =
+  static member AreEqual(x : AssertionMatch<'a>, message, args) =
     Assert.AreEqual(x.Expected, x.Actual, message, args)
-  static member AreEqual(x : Match<'a>) =
+  static member AreEqual(x : AssertionMatch<'a>) =
     Assert.AreEqual(x.Expected, x.Actual)
-  static member AreNotEqual(x : Match<'a>, message, args) =
+  static member AreNotEqual(x : AssertionMatch<'a>, message, args) =
     Assert.AreNotEqual(x.Expected, x.Actual, message, args)
-  static member AreNotEqual(x : Match<'a>) =
+  static member AreNotEqual(x : AssertionMatch<'a>) =
     Assert.AreNotEqual(x.Expected, x.Actual)
-  static member AreSame(x : Match<'a>, message, args) =
+  static member AreSame(x : AssertionMatch<'a>, message, args) =
     Assert.AreSame(x.Expected, x.Actual, message, args)
-  static member AreSame(x : Match<'a>) =
+  static member AreSame(x : AssertionMatch<'a>) =
     Assert.AreSame(x.Expected, x.Actual)
-  static member AreNotSame(x : Match<'a>, message, args) =
+  static member AreNotSame(x : AssertionMatch<'a>, message, args) =
     Assert.AreNotSame(x.Expected, x.Actual, message, args)
-  static member AreNotSame(x : Match<'a>) =
-    Assert.AreNotSame(x.Expected, x.Actual)
+  static member AreNotSame(x : AssertionMatch<'a>) =
+    Assert.AreNotSame(x.Expected, x.Actual)
+
+[<AbstractClass; Sealed>]
+type AltCollectionAssert =
+  static member AreEqual<'a when 'a :> IEnumerable>(x : AssertionMatch<'a>) =
+    CollectionAssert.AreEqual(x.Expected, x.Actual)
+  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>, message, args) =
+    CollectionAssert.AreEqual(x.Expected, x.Actual, message, args)
+  static member AreEqual<'a when 'a :> IEnumerable>(x : AssertionMatch<'a>, comparer, message, args) =
+    CollectionAssert.AreEqual(x.Expected, x.Actual, comparer, message, args)
+  static member AreEquivalent<'a when 'a :> IEnumerable>(x : AssertionMatch<'a>) =
+    CollectionAssert.AreEquivalent(x.Expected, x.Actual)
+  static member AreEquivalent<'a when 'a :> IEnumerable>(x : AssertionMatch<'a>, message, args) =
+    CollectionAssert.AreEquivalent(x.Expected, x.Actual, message, args)
+  static member AreNotEqual<'a when 'a :> IEnumerable>(x : AssertionMatch<'a>) =
+    CollectionAssert.AreNotEqual(x.Expected, x.Actual)
+  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>, message, args) =
+    CollectionAssert.AreNotEqual(x.Expected, x.Actual, message, args)
+  static member AreNotEqual<'a when 'a :> IEnumerable>(x : AssertionMatch<'a>, comparer, message, args) =
+    CollectionAssert.AreNotEqual(x.Expected, x.Actual, comparer, message, args)
+  static member AreNotEquivalent<'a when 'a :> IEnumerable>(x : AssertionMatch<'a>) =
+    CollectionAssert.AreNotEquivalent(x.Expected, x.Actual)
+  static member AreNotEquivalent<'a when 'a :> IEnumerable>(x : AssertionMatch<'a>, message, args) =
+    CollectionAssert.AreNotEquivalent(x.Expected, x.Actual, message, args)
+  static member IsNotSubsetOf<'a when 'a :> IEnumerable> (x : AssertionMatch<'a>) =
+    CollectionAssert.IsNotSubsetOf(x.Actual, x.Expected)
+  static member IsNotSubsetOf<'a when 'a :> IEnumerable> (x : AssertionMatch<'a>, message, args) =
+    CollectionAssert.IsNotSubsetOf(x.Actual, x.Expected, message, args)
+  static member IsNotSupersetOf<'a when 'a :> IEnumerable> (x : AssertionMatch<'a>) =
+    CollectionAssert.IsNotSupersetOf(x.Actual, x.Expected)
+  static member IsNotSupersetOf<'a when 'a :> IEnumerable> (x : AssertionMatch<'a>, message, args) =
+    CollectionAssert.IsNotSupersetOf(x.Actual, x.Expected, message, args)
+  static member IsSubsetOf<'a when 'a :> IEnumerable> (x : AssertionMatch<'a>) =
+    CollectionAssert.IsSubsetOf(x.Actual, x.Expected)
+  static member IsSubsetOf<'a when 'a :> IEnumerable> (x : AssertionMatch<'a>, message, args) =
+    CollectionAssert.IsSubsetOf(x.Actual, x.Expected, message, args)
+  static member IsSupersetOf<'a when 'a :> IEnumerable> (x : AssertionMatch<'a>) =
+    CollectionAssert.IsSupersetOf(x.Actual, x.Expected)
+  static member IsSupersetOf<'a when 'a :> IEnumerable> (x : AssertionMatch<'a>, message, args) =
+    CollectionAssert.IsSupersetOf(x.Actual, x.Expected, message, args)
+
+[<AbstractClass; Sealed>]
+type AltDirectoryAssert =
+  static member AreEqual(x : AssertionMatch<DirectoryInfo>) =
+    DirectoryAssert.AreEqual(x.Expected, x.Actual)
+  static member AreEqual(x : AssertionMatch<DirectoryInfo>, message, args) =
+    DirectoryAssert.AreEqual(x.Expected, x.Actual, message, args)
+  static member AreNotEqual(x : AssertionMatch<DirectoryInfo>) =
+    DirectoryAssert.AreNotEqual(x.Expected, x.Actual)
+  static member AreNotEqual(x : AssertionMatch<DirectoryInfo>, message, args) =
+    DirectoryAssert.AreNotEqual(x.Expected, x.Actual, message, args)
+
+[<AbstractClass; Sealed>]
+type AltFileAssert =
+  static member AreEqual(x : AssertionMatch<FileInfo>) =
+    FileAssert.AreEqual(x.Expected, x.Actual)
+  static member AreEqual(x : AssertionMatch<FileInfo>, message, args) =
+    FileAssert.AreEqual(x.Expected, x.Actual, message, args)
+  static member AreEqual(x : AssertionMatch<Stream>) =
+    FileAssert.AreEqual(x.Expected, x.Actual)
+  static member AreEqual(x : AssertionMatch<Stream>, message, args) =
+    FileAssert.AreEqual(x.Expected, x.Actual, message, args)
+  static member AreEqual(x : AssertionMatch<String>) =
+    FileAssert.AreEqual(x.Expected, x.Actual)
+  static member AreEqual(x : AssertionMatch<String>, message, args) =
+    FileAssert.AreEqual(x.Expected, x.Actual, message, args)
+  static member AreNotEqual(x : AssertionMatch<FileInfo>) =
+    FileAssert.AreNotEqual(x.Expected, x.Actual)
+  static member AreNotEqual(x : AssertionMatch<FileInfo>, message, args) =
+    FileAssert.AreNotEqual(x.Expected, x.Actual, message, args)
+  static member AreNotEqual(x : AssertionMatch<Stream>) =
+    FileAssert.AreNotEqual(x.Expected, x.Actual)
+  static member AreNotEqual(x : AssertionMatch<Stream>, message, args) =
+    FileAssert.AreNotEqual(x.Expected, x.Actual, message, args)
+  static member AreNotEqual(x : AssertionMatch<String>) =
+    FileAssert.AreNotEqual(x.Expected, x.Actual)
+  static member AreNotEqual(x : AssertionMatch<String>, message, args) =
+    FileAssert.AreNotEqual(x.Expected, x.Actual, message, args)
+
+[<AbstractClass; Sealed>]
+type AltStringAssert =
+  static member AreEqualIgnoringCase(x : AssertionMatch<String>) =
+    StringAssert.AreEqualIgnoringCase(x.Expected, x.Actual)
+  static member AreEqualIgnoringCase(x : AssertionMatch<String>, message, args) =
+    StringAssert.AreEqualIgnoringCase(x.Expected, x.Actual, message, args)
+  static member AreNotEqualIgnoringCase(x : AssertionMatch<String>) =
+    StringAssert.AreNotEqualIgnoringCase(x.Expected, x.Actual)
+  static member AreNotEqualIgnoringCase(x : AssertionMatch<String>, message, args) =
+    StringAssert.AreNotEqualIgnoringCase(x.Expected, x.Actual, message, args)
+  static member Contains(x : AssertionMatch<String>) =
+    StringAssert.Contains(x.Expected, x.Actual)
+  static member Contains(x : AssertionMatch<String>, message, args) =
+    StringAssert.Contains(x.Expected, x.Actual, message, args)
+  static member DoesNotContain(x : AssertionMatch<String>) =
+    StringAssert.DoesNotContain(x.Expected, x.Actual)
+  static member DoesNotContain(x : AssertionMatch<String>, message, args) =
+    StringAssert.DoesNotContain(x.Expected, x.Actual, message, args)
+  static member DoesNotEndWith(x : AssertionMatch<String>) =
+    StringAssert.DoesNotEndWith(x.Expected, x.Actual)
+  static member DoesNotEndWith(x : AssertionMatch<String>, message, args) =
+    StringAssert.DoesNotEndWith(x.Expected, x.Actual, message, args)
+  static member DoesNotMatch(x : AssertionMatch<String>) =
+    StringAssert.DoesNotMatch(x.Expected, x.Actual)
+  static member DoesNotMatch(x : AssertionMatch<String>, message, args) =
+    StringAssert.DoesNotMatch(x.Expected, x.Actual, message, args)
+  static member DoesNotStartWith(x : AssertionMatch<String>) =
+    StringAssert.DoesNotStartWith(x.Expected, x.Actual)
+  static member DoesNotStartWith(x : AssertionMatch<String>, message, args) =
+    StringAssert.DoesNotStartWith(x.Expected, x.Actual, message, args)
+  static member EndsWith(x : AssertionMatch<String>) =
+    StringAssert.EndsWith(x.Expected, x.Actual)
+  static member EndsWith(x : AssertionMatch<String>, message, args) =
+    StringAssert.EndsWith(x.Expected, x.Actual, message, args)
+  static member IsMatch(x : AssertionMatch<String>) =
+    StringAssert.IsMatch(x.Expected, x.Actual)
+  static member IsMatch(x : AssertionMatch<String>, message, args) =
+    StringAssert.IsMatch(x.Expected, x.Actual, message, args)
+  static member StartsWith(x : AssertionMatch<String>) =
+    StringAssert.StartsWith(x.Expected, x.Actual)
+  static member StartsWith(x : AssertionMatch<String>, message, args) =
+    StringAssert.StartsWith(x.Expected, x.Actual, message, args)
+
+    //
diff --git a/altcode.test/altcode.test.xunit/XUnit.fs b/altcode.test/altcode.test.xunit/XUnit.fs

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`namespace AltCode.Test.Common`
`2`	`2`
`3`		`-type Match<'a> =`
	`3`	`+type AssertionMatch<'a> =`
`4`	`4`	`{`
`5`	`5`	`Actual : 'a`
`6`	`6`	`Expected : 'a`