Assertive enhancements

This brings a set of enhancements to assertive:
- function name simplifications
- generics-ifying of some functions that can be used on comparables
- additional methods (Match, DoesNotMatch)
- debugging output is made clear, along with OCS8 link to the test file
- all methods can now elect to Fail later instead of FailNow
- Check method is removed (^ because of above)
- all methods can now elect to silence output on success

Other Tigron files are updated to adopt these changes:
- method names update
- comparators move away from Check and now fully leverages assertive

This also adds a large number of tests for assertive, leveraging mimicry.

Signed-off-by: apostasie <[email protected]>

Author: apostasie

mod/tigron/expect/comparators.go

@@ -14,13 +14,12 @@
    limitations under the License.
 */
 
+//revive:disable:package-comments // annoying false positive behavior
+//nolint:thelper // FIXME: remove when we move to tig.T
 package expect
 
 import (
-	"encoding/hex"
-	"fmt"
 	"regexp"
-	"strings"
 	"testing"
 
 	"github.com/containerd/nerdctl/mod/tigron/internal/assertive"
@@ -29,7 +28,6 @@ import (
 
 // All can be used as a parameter for expected.Output to group a set of comparators.
 func All(comparators ...test.Comparator) test.Comparator {
-	//nolint:thelper
 	return func(stdout, info string, t *testing.T) {
 		t.Helper()
 
@@ -39,57 +37,35 @@ func All(comparators ...test.Comparator) test.Comparator {
 	}
 }
 
-// Contains can be used as a parameter for expected.Output and ensures a comparison string
-// is found contained in the output.
+// Contains can be used as a parameter for expected.Output and ensures a comparison string is found contained in the
+// output.
 func Contains(compare string) test.Comparator {
-	//nolint:thelper
 	return func(stdout, info string, t *testing.T) {
 		t.Helper()
-		assertive.Check(t, strings.Contains(stdout, compare),
-			fmt.Sprintf("Output does not contain: %q", compare),
-			info)
+		assertive.Contains(assertive.WithFailLater(t), stdout, compare, info)
 	}
 }
 
-// DoesNotContain is to be used for expected.Output to ensure a comparison string is NOT found in
-// the output.
+// DoesNotContain is to be used for expected.Output to ensure a comparison string is NOT found in the output.
 func DoesNotContain(compare string) test.Comparator {
-	//nolint:thelper
 	return func(stdout, info string, t *testing.T) {
 		t.Helper()
-		assertive.Check(t, !strings.Contains(stdout, compare),
-			fmt.Sprintf("Output should not contain: %q", compare), info)
+		assertive.DoesNotContain(assertive.WithFailLater(t), stdout, compare, info)
 	}
 }
 
 // Equals is to be used for expected.Output to ensure it is exactly the output.
 func Equals(compare string) test.Comparator {
-	//nolint:thelper
 	return func(stdout, info string, t *testing.T) {
 		t.Helper()
-
-		hexdump := hex.Dump([]byte(stdout))
-		assertive.Check(
-			t,
-			compare == stdout,
-			fmt.Sprintf("Output is not equal to: %q", compare),
-			"\n"+hexdump,
-			info,
-		)
+		assertive.IsEqual(assertive.WithFailLater(t), stdout, compare, info)
 	}
 }
 
 // Match is to be used for expected.Output to ensure we match a regexp.
-// Provisional - expected use, but have not seen it so far.
 func Match(reg *regexp.Regexp) test.Comparator {
-	//nolint:thelper
 	return func(stdout, info string, t *testing.T) {
 		t.Helper()
-		assertive.Check(
-			t,
-			reg.MatchString(stdout),
-			fmt.Sprintf("Output does not match: %q", reg.String()),
-			info,
-		)
+		assertive.Match(assertive.WithFailLater(t), stdout, reg, info)
 	}
 }