From 822d6e10aeaf2c324dcf0e2d10778131c4fccad6 Mon Sep 17 00:00:00 2001 From: Jim Myhrberg Date: Mon, 22 Nov 2021 03:07:59 +0000 Subject: [PATCH] docs(examples): update and flesh out example functions --- README.md | 24 ++- example_test.go | 189 ----------------- t_example_test.go | 520 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 534 insertions(+), 199 deletions(-) delete mode 100644 example_test.go create mode 100644 t_example_test.go diff --git a/README.md b/README.md index e554e23..60851c7 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ import "github.com/jimeh/go-mocktesting" ## Usage ```go -func Example_basic() { +func ExampleT_Error() { assertTrue := func(t testing.TB, v bool) { if v != true { t.Error("expected false to be true") @@ -58,7 +58,7 @@ func Example_basic() { ``` ```go -func Example_fatal() { +func ExampleT_Fatal() { requireTrue := func(t testing.TB, v bool) { if v != true { t.Fatal("expected false to be true") @@ -66,20 +66,20 @@ func Example_fatal() { } mt := mocktesting.NewT("TestMyBoolean1") - requireTrue(mt, true) fmt.Printf("Name: %s\n", mt.Name()) + requireTrue(mt, true) fmt.Printf("Failed: %+v\n", mt.Failed()) fmt.Printf("Aborted: %+v\n", mt.Aborted()) mt = mocktesting.NewT("TestMyBoolean2") + fmt.Printf("Name: %s\n", mt.Name()) mocktesting.Go(func() { requireTrue(mt, false) fmt.Println("This is never executed.") }) - fmt.Printf("Name: %s\n", mt.Name()) fmt.Printf("Failed: %+v\n", mt.Failed()) fmt.Printf("Aborted: %+v\n", mt.Aborted()) - fmt.Printf("Output: %s\n", strings.Join(mt.Output(), "")) + fmt.Printf("Output:\n - %s\n", strings.Join(mt.Output(), "\n - ")) // Output: // Name: TestMyBoolean1 @@ -88,12 +88,13 @@ func Example_fatal() { // Name: TestMyBoolean2 // Failed: true // Aborted: true - // Output: expected false to be true + // Output: + // - expected false to be true } ``` ```go -func Example_subtests() { +func ExampleT_Run() { requireTrue := func(t testing.TB, v bool) { if v != true { t.Fatal("expected false to be true") @@ -101,10 +102,10 @@ func Example_subtests() { } mt := mocktesting.NewT("TestMyBoolean") + fmt.Printf("Name: %s\n", mt.Name()) mt.Run("true", func(t testing.TB) { requireTrue(t, true) }) - fmt.Printf("Name: %s\n", mt.Name()) fmt.Printf("Failed: %+v\n", mt.Failed()) fmt.Printf("Sub1-Name: %s\n", mt.Subtests()[0].Name()) fmt.Printf("Sub1-Failed: %+v\n", mt.Subtests()[0].Failed()) @@ -118,7 +119,9 @@ func Example_subtests() { fmt.Printf("Sub2-Name: %s\n", mt.Subtests()[1].Name()) fmt.Printf("Sub2-Failed: %+v\n", mt.Subtests()[1].Failed()) fmt.Printf("Sub2-Aborted: %+v\n", mt.Subtests()[1].Aborted()) - fmt.Printf("Sub2-Output: %s\n", strings.Join(mt.Subtests()[1].Output(), "")) + fmt.Printf("Sub2-Output:\n - %s\n", + strings.Join(mt.Subtests()[1].Output(), "\n - "), + ) // Output: // Name: TestMyBoolean @@ -130,7 +133,8 @@ func Example_subtests() { // Sub2-Name: TestMyBoolean/false // Sub2-Failed: true // Sub2-Aborted: true - // Sub2-Output: expected false to be true + // Sub2-Output: + // - expected false to be true } ``` diff --git a/example_test.go b/example_test.go deleted file mode 100644 index 58942e1..0000000 --- a/example_test.go +++ /dev/null @@ -1,189 +0,0 @@ -package mocktesting_test - -import ( - "fmt" - "strings" - "testing" - - "github.com/jimeh/go-mocktesting" -) - -func Example_basic() { - assertTrue := func(t testing.TB, v bool) { - if v != true { - t.Error("expected false to be true") - } - } - - mt := mocktesting.NewT("TestMyBoolean1") - assertTrue(mt, true) - fmt.Printf("Name: %s\n", mt.Name()) - fmt.Printf("Failed: %+v\n", mt.Failed()) - fmt.Printf("Aborted: %+v\n", mt.Aborted()) - - mt = mocktesting.NewT("TestMyBoolean2") - assertTrue(mt, false) - fmt.Printf("Name: %s\n", mt.Name()) - fmt.Printf("Failed: %+v\n", mt.Failed()) - fmt.Printf("Aborted: %+v\n", mt.Aborted()) - fmt.Printf("Output: %s\n", strings.Join(mt.Output(), "")) - - // Output: - // Name: TestMyBoolean1 - // Failed: false - // Aborted: false - // Name: TestMyBoolean2 - // Failed: true - // Aborted: false - // Output: expected false to be true -} - -func Example_fatal() { - requireTrue := func(t testing.TB, v bool) { - if v != true { - t.Fatal("expected false to be true") - } - } - - mt := mocktesting.NewT("TestMyBoolean1") - requireTrue(mt, true) - fmt.Printf("Name: %s\n", mt.Name()) - fmt.Printf("Failed: %+v\n", mt.Failed()) - fmt.Printf("Aborted: %+v\n", mt.Aborted()) - - mt = mocktesting.NewT("TestMyBoolean2") - mocktesting.Go(func() { - requireTrue(mt, false) - fmt.Println("This is never executed.") - }) - fmt.Printf("Name: %s\n", mt.Name()) - fmt.Printf("Failed: %+v\n", mt.Failed()) - fmt.Printf("Aborted: %+v\n", mt.Aborted()) - fmt.Printf("Output: %s\n", strings.Join(mt.Output(), "")) - - // Output: - // Name: TestMyBoolean1 - // Failed: false - // Aborted: false - // Name: TestMyBoolean2 - // Failed: true - // Aborted: true - // Output: expected false to be true -} - -func Example_subtests() { - requireTrue := func(t testing.TB, v bool) { - if v != true { - t.Fatal("expected false to be true") - } - } - - mt := mocktesting.NewT("TestMyBoolean") - mt.Run("true", func(t testing.TB) { - requireTrue(t, true) - }) - fmt.Printf("Name: %s\n", mt.Name()) - fmt.Printf("Failed: %+v\n", mt.Failed()) - fmt.Printf("Sub1-Name: %s\n", mt.Subtests()[0].Name()) - fmt.Printf("Sub1-Failed: %+v\n", mt.Subtests()[0].Failed()) - fmt.Printf("Sub1-Aborted: %+v\n", mt.Subtests()[0].Aborted()) - - mt.Run("false", func(t testing.TB) { - requireTrue(t, false) - fmt.Println("This is never executed.") - }) - fmt.Printf("Failed: %+v\n", mt.Failed()) - fmt.Printf("Sub2-Name: %s\n", mt.Subtests()[1].Name()) - fmt.Printf("Sub2-Failed: %+v\n", mt.Subtests()[1].Failed()) - fmt.Printf("Sub2-Aborted: %+v\n", mt.Subtests()[1].Aborted()) - fmt.Printf("Sub2-Output: %s\n", strings.Join(mt.Subtests()[1].Output(), "")) - - // Output: - // Name: TestMyBoolean - // Failed: false - // Sub1-Name: TestMyBoolean/true - // Sub1-Failed: false - // Sub1-Aborted: false - // Failed: true - // Sub2-Name: TestMyBoolean/false - // Sub2-Failed: true - // Sub2-Aborted: true - // Sub2-Output: expected false to be true -} - -func Example_subtests_in_subtests() { - assertGreaterThan := func(t testing.TB, got int, min int) { - if got <= min { - t.Errorf("expected %d to be greater than %d", got, min) - } - } - - mt := mocktesting.NewT("TestMyBoolean") - mt.Run("positive", func(t testing.TB) { - subMT, _ := t.(*mocktesting.T) - - subMT.Run("greater than", func(t testing.TB) { - assertGreaterThan(t, 5, 4) - }) - subMT.Run("equal", func(t testing.TB) { - assertGreaterThan(t, 5, 5) - }) - subMT.Run("less than", func(t testing.TB) { - assertGreaterThan(t, 4, 5) - }) - }) - fmt.Printf("Name: %s\n", mt.Name()) - fmt.Printf("Failed: %+v\n", mt.Failed()) - fmt.Printf("Sub1-Name: %s\n", mt.Subtests()[0].Name()) - fmt.Printf("Sub1-Failed: %+v\n", mt.Subtests()[0].Failed()) - fmt.Printf("Sub1-Aborted: %+v\n", mt.Subtests()[0].Aborted()) - fmt.Printf("Sub1-Sub1-Name: %s\n", mt.Subtests()[0].Subtests()[0].Name()) - fmt.Printf( - "Sub1-Sub1-Failed: %+v\n", mt.Subtests()[0].Subtests()[0].Failed(), - ) - fmt.Printf( - "Sub1-Sub1-Aborted: %+v\n", mt.Subtests()[0].Subtests()[0].Aborted(), - ) - fmt.Printf("Sub1-Sub1-Name: %s\n", mt.Subtests()[0].Subtests()[1].Name()) - fmt.Printf( - "Sub1-Sub2-Failed: %+v\n", mt.Subtests()[0].Subtests()[1].Failed(), - ) - fmt.Printf( - "Sub1-Sub2-Aborted: %+v\n", mt.Subtests()[0].Subtests()[1].Aborted(), - ) - fmt.Printf( - "Sub1-Sub3-Output: %s\n", strings.TrimSpace( - strings.Join(mt.Subtests()[0].Subtests()[1].Output(), ""), - ), - ) - fmt.Printf("Sub1-Sub1-Name: %s\n", mt.Subtests()[0].Subtests()[2].Name()) - fmt.Printf( - "Sub1-Sub3-Failed: %+v\n", mt.Subtests()[0].Subtests()[2].Failed(), - ) - fmt.Printf( - "Sub1-Sub3-Aborted: %+v\n", mt.Subtests()[0].Subtests()[2].Aborted(), - ) - fmt.Printf( - "Sub1-Sub3-Output: %s\n", strings.TrimSpace( - strings.Join(mt.Subtests()[0].Subtests()[2].Output(), ""), - ), - ) - - // Output: - // Name: TestMyBoolean - // Failed: true - // Sub1-Name: TestMyBoolean/positive - // Sub1-Failed: true - // Sub1-Aborted: false - // Sub1-Sub1-Name: TestMyBoolean/positive/greater_than - // Sub1-Sub1-Failed: false - // Sub1-Sub1-Aborted: false - // Sub1-Sub1-Name: TestMyBoolean/positive/equal - // Sub1-Sub2-Failed: true - // Sub1-Sub2-Aborted: false - // Sub1-Sub3-Output: expected 5 to be greater than 5 - // Sub1-Sub1-Name: TestMyBoolean/positive/less_than - // Sub1-Sub3-Failed: true - // Sub1-Sub3-Aborted: false - // Sub1-Sub3-Output: expected 4 to be greater than 5 -} diff --git a/t_example_test.go b/t_example_test.go new file mode 100644 index 0000000..169d646 --- /dev/null +++ b/t_example_test.go @@ -0,0 +1,520 @@ +package mocktesting_test + +import ( + "fmt" + "strings" + "testing" + + "github.com/jimeh/go-mocktesting" +) + +func ExampleT_Error() { + assertTrue := func(t testing.TB, v bool) { + if v != true { + t.Error("expected false to be true") + } + } + + mt := mocktesting.NewT("TestMyBoolean1") + assertTrue(mt, true) + fmt.Printf("Name: %s\n", mt.Name()) + fmt.Printf("Failed: %+v\n", mt.Failed()) + fmt.Printf("Aborted: %+v\n", mt.Aborted()) + + mt = mocktesting.NewT("TestMyBoolean2") + assertTrue(mt, false) + fmt.Printf("Name: %s\n", mt.Name()) + fmt.Printf("Failed: %+v\n", mt.Failed()) + fmt.Printf("Aborted: %+v\n", mt.Aborted()) + fmt.Printf("Output: %s\n", strings.Join(mt.Output(), "")) + + // Output: + // Name: TestMyBoolean1 + // Failed: false + // Aborted: false + // Name: TestMyBoolean2 + // Failed: true + // Aborted: false + // Output: expected false to be true +} + +func ExampleT_Errorf() { + assertGreaterThan := func(t testing.TB, got int, min int) { + if got <= min { + t.Errorf("expected %d to be greater than %d", got, min) + } + } + + mt := mocktesting.NewT("TestMyBoolean1") + assertGreaterThan(mt, 6, 5) + fmt.Printf("Name: %s\n", mt.Name()) + fmt.Printf("Failed: %+v\n", mt.Failed()) + fmt.Printf("Aborted: %+v\n", mt.Aborted()) + + mt = mocktesting.NewT("TestMyBoolean2") + assertGreaterThan(mt, 4, 5) + fmt.Printf("Name: %s\n", mt.Name()) + fmt.Printf("Failed: %+v\n", mt.Failed()) + fmt.Printf("Aborted: %+v\n", mt.Aborted()) + fmt.Printf("Output:\n - %s\n", strings.Join(mt.Output(), "\n - ")) + + // Output: + // Name: TestMyBoolean1 + // Failed: false + // Aborted: false + // Name: TestMyBoolean2 + // Failed: true + // Aborted: false + // Output: + // - expected 4 to be greater than 5 +} + +func ExampleT_Fail() { + assertTrue := func(t testing.TB, v bool) { + if v != true { + t.Fail() + } + } + + mt := mocktesting.NewT("TestMyBoolean1") + fmt.Printf("Name: %s\n", mt.Name()) + assertTrue(mt, false) + fmt.Printf("Failed: %+v\n", mt.Failed()) + + // Output: + // Name: TestMyBoolean1 + // Failed: true +} + +func ExampleT_FailNow() { + requireTrue := func(t testing.TB, v bool) { + if v != true { + t.FailNow() + } + } + + mt := mocktesting.NewT("TestMyBoolean1") + fmt.Printf("Name: %s\n", mt.Name()) + halted := true + mocktesting.Go(func() { + requireTrue(mt, false) + halted = false + }) + fmt.Printf("Failed: %+v\n", mt.Failed()) + fmt.Printf("Halted: %+v\n", halted) + + // Output: + // Name: TestMyBoolean1 + // Failed: true + // Halted: true +} + +func ExampleT_Fatal() { + requireTrue := func(t testing.TB, v bool) { + if v != true { + t.Fatal("expected false to be true") + } + } + + mt := mocktesting.NewT("TestMyBoolean1") + fmt.Printf("Name: %s\n", mt.Name()) + requireTrue(mt, true) + fmt.Printf("Failed: %+v\n", mt.Failed()) + fmt.Printf("Aborted: %+v\n", mt.Aborted()) + + mt = mocktesting.NewT("TestMyBoolean2") + fmt.Printf("Name: %s\n", mt.Name()) + mocktesting.Go(func() { + requireTrue(mt, false) + fmt.Println("This is never executed.") + }) + fmt.Printf("Failed: %+v\n", mt.Failed()) + fmt.Printf("Aborted: %+v\n", mt.Aborted()) + fmt.Printf("Output:\n - %s\n", strings.Join(mt.Output(), "\n - ")) + + // Output: + // Name: TestMyBoolean1 + // Failed: false + // Aborted: false + // Name: TestMyBoolean2 + // Failed: true + // Aborted: true + // Output: + // - expected false to be true +} + +func ExampleT_Fatalf() { + requireGreaterThan := func(t testing.TB, got int, min int) { + if got <= min { + t.Fatalf("expected %d to be greater than %d", got, min) + } + } + + mt := mocktesting.NewT("TestMyGT1") + fmt.Printf("Name: %s\n", mt.Name()) + halted := true + mocktesting.Go(func() { + requireGreaterThan(mt, 6, 5) + halted = false + }) + fmt.Printf("Failed: %+v\n", mt.Failed()) + fmt.Printf("Halted: %+v\n", halted) + + mt = mocktesting.NewT("TestMyGT2") + fmt.Printf("Name: %s\n", mt.Name()) + halted = true + mocktesting.Go(func() { + requireGreaterThan(mt, 4, 5) + halted = false + }) + fmt.Printf("Failed: %+v\n", mt.Failed()) + fmt.Printf("Halted: %+v\n", halted) + fmt.Printf("Output:\n - %s\n", strings.Join(mt.Output(), "\n - ")) + + // Output: + // Name: TestMyGT1 + // Failed: false + // Halted: false + // Name: TestMyGT2 + // Failed: true + // Halted: true + // Output: + // - expected 4 to be greater than 5 +} + +func ExampleT_Log() { + logHello := func(t testing.TB) { + t.Log("hello world") + } + + mt := mocktesting.NewT("TestMyLog") + fmt.Printf("Name: %s\n", mt.Name()) + logHello(mt) + fmt.Printf("Output:\n - %s\n", strings.Join(mt.Output(), "\n - ")) + + // Output: + // Name: TestMyLog + // Output: + // - hello world +} + +func ExampleT_Logf() { + logHello := func(t testing.TB, name string) { + t.Logf("hello, %s", name) + } + + mt := mocktesting.NewT("TestMyLogf") + fmt.Printf("Name: %s\n", mt.Name()) + logHello(mt, "Abel") + fmt.Printf("Output:\n - %s\n", strings.Join(mt.Output(), "\n - ")) + + // Output: + // Name: TestMyLogf + // Output: + // - hello, Abel +} + +func ExampleT_Parallel() { + logHello := func(t testing.TB, name string) { + mt, _ := t.(*mocktesting.T) + mt.Parallel() + mt.Logf("hello, %s", name) + } + + mt := mocktesting.NewT("TestMyLogf") + fmt.Printf("Name: %s\n", mt.Name()) + fmt.Printf("Parallel (before): %+v\n", mt.Paralleled()) + logHello(mt, "Abel") + fmt.Printf("Parallel (after): %+v\n", mt.Paralleled()) + + // Output: + // Name: TestMyLogf + // Parallel (before): false + // Parallel (after): true +} + +func ExampleT_Skip() { + logHello := func(t testing.TB, name string) { + if name == "" { + t.Skip("no name given to say hello to") + } + t.Logf("hello, %s", name) + } + + mt := mocktesting.NewT("TestMyLog1") + fmt.Printf("Name: %s\n", mt.Name()) + halted := true + mocktesting.Go(func() { + logHello(mt, "Abel") + halted = false + }) + fmt.Printf("Skipped: %+v\n", mt.Skipped()) + fmt.Printf("Halted: %+v\n", halted) + + mt = mocktesting.NewT("TestMyLog2") + fmt.Printf("Name: %s\n", mt.Name()) + halted = true + mocktesting.Go(func() { + logHello(mt, "") + halted = false + }) + fmt.Printf("Skipped: %+v\n", mt.Skipped()) + fmt.Printf("Halted: %+v\n", halted) + fmt.Printf("Output:\n - %s\n", strings.Join(mt.Output(), "\n - ")) + + // Output: + // Name: TestMyLog1 + // Skipped: false + // Halted: false + // Name: TestMyLog2 + // Skipped: true + // Halted: true + // Output: + // - no name given to say hello to +} + +func ExampleT_Skipf() { + logHello := func(t testing.TB, name string) { + if name != "Jane" { + t.Skipf("I only say hello to Jane, you are %s", name) + } + } + + mt := mocktesting.NewT("TestMyLog1") + fmt.Printf("Name: %s\n", mt.Name()) + halted := true + mocktesting.Go(func() { + logHello(mt, "Jane") + halted = false + }) + fmt.Printf("Skipped: %+v\n", mt.Skipped()) + fmt.Printf("Halted: %+v\n", halted) + + mt = mocktesting.NewT("TestMyLog2") + fmt.Printf("Name: %s\n", mt.Name()) + halted = true + mocktesting.Go(func() { + logHello(mt, "John") + halted = false + }) + fmt.Printf("Skipped: %+v\n", mt.Skipped()) + fmt.Printf("Halted: %+v\n", halted) + fmt.Printf("Output:\n - %s\n", strings.Join(mt.Output(), "\n - ")) + + // Output: + // Name: TestMyLog1 + // Skipped: false + // Halted: false + // Name: TestMyLog2 + // Skipped: true + // Halted: true + // Output: + // - I only say hello to Jane, you are John +} + +func ExampleT_SkipNow() { + logHello := func(t testing.TB, name string) { + if name == "" { + t.SkipNow() + } + } + + mt := mocktesting.NewT("TestMyLog1") + fmt.Printf("Name: %s\n", mt.Name()) + halted := true + mocktesting.Go(func() { + logHello(mt, "Abel") + halted = false + }) + fmt.Printf("Skipped: %+v\n", mt.Skipped()) + fmt.Printf("Halted: %+v\n", halted) + + mt = mocktesting.NewT("TestMyLog2") + fmt.Printf("Name: %s\n", mt.Name()) + halted = true + mocktesting.Go(func() { + logHello(mt, "") + halted = false + }) + fmt.Printf("Skipped: %+v\n", mt.Skipped()) + fmt.Printf("Halted: %+v\n", halted) + + // Output: + // Name: TestMyLog1 + // Skipped: false + // Halted: false + // Name: TestMyLog2 + // Skipped: true + // Halted: true +} + +func ExampleT_Helper() { + assertTrue := func(t testing.TB, v bool) { + t.Helper() + + if v != true { + t.Error("expected false to be true") + } + } + + mt := mocktesting.NewT("TestMyBoolean1") + assertTrue(mt, true) + assertTrue(mt, true) + fmt.Printf("Name: %s\n", mt.Name()) + fmt.Printf("Helpers:\n - %s\n", strings.Join(mt.HelperNames(), "\n - ")) + + // Output: + // Name: TestMyBoolean1 + // Helpers: + // - github.com/jimeh/go-mocktesting_test.ExampleT_Helper.func1 + // - github.com/jimeh/go-mocktesting_test.ExampleT_Helper.func1 +} + +func ExampleT_Cleanup() { + cleanup1 := func() { + fmt.Println("running cleanup1") + } + cleanup2 := func() { + fmt.Println("running cleanup2") + } + + mt := mocktesting.NewT("TestMyCleanup") + mt.Cleanup(cleanup1) + mt.Cleanup(cleanup2) + fmt.Printf("Name: %s\n", mt.Name()) + fmt.Printf( + "CleanupNames:\n - %s\n", strings.Join(mt.CleanupNames(), "\n - "), + ) + mt.CleanupFuncs()[1]() + mt.CleanupFuncs()[0]() + + // Output: + // Name: TestMyCleanup + // CleanupNames: + // - github.com/jimeh/go-mocktesting_test.ExampleT_Cleanup.func1 + // - github.com/jimeh/go-mocktesting_test.ExampleT_Cleanup.func2 + // running cleanup2 + // running cleanup1 +} + +func ExampleT_Run() { + requireTrue := func(t testing.TB, v bool) { + if v != true { + t.Fatal("expected false to be true") + } + } + + mt := mocktesting.NewT("TestMyBoolean") + fmt.Printf("Name: %s\n", mt.Name()) + mt.Run("true", func(t testing.TB) { + requireTrue(t, true) + }) + fmt.Printf("Failed: %+v\n", mt.Failed()) + fmt.Printf("Sub1-Name: %s\n", mt.Subtests()[0].Name()) + fmt.Printf("Sub1-Failed: %+v\n", mt.Subtests()[0].Failed()) + fmt.Printf("Sub1-Aborted: %+v\n", mt.Subtests()[0].Aborted()) + + mt.Run("false", func(t testing.TB) { + requireTrue(t, false) + fmt.Println("This is never executed.") + }) + fmt.Printf("Failed: %+v\n", mt.Failed()) + fmt.Printf("Sub2-Name: %s\n", mt.Subtests()[1].Name()) + fmt.Printf("Sub2-Failed: %+v\n", mt.Subtests()[1].Failed()) + fmt.Printf("Sub2-Aborted: %+v\n", mt.Subtests()[1].Aborted()) + fmt.Printf("Sub2-Output:\n - %s\n", + strings.Join(mt.Subtests()[1].Output(), "\n - "), + ) + + // Output: + // Name: TestMyBoolean + // Failed: false + // Sub1-Name: TestMyBoolean/true + // Sub1-Failed: false + // Sub1-Aborted: false + // Failed: true + // Sub2-Name: TestMyBoolean/false + // Sub2-Failed: true + // Sub2-Aborted: true + // Sub2-Output: + // - expected false to be true +} + +func ExampleT_Run_nested() { + assertGreaterThan := func(t testing.TB, got int, min int) { + if got <= min { + t.Errorf("expected %d to be greater than %d", got, min) + } + } + + mt := mocktesting.NewT("TestMyBoolean") + mt.Run("positive", func(t testing.TB) { + subMT, _ := t.(*mocktesting.T) + + subMT.Run("greater than", func(t testing.TB) { + assertGreaterThan(t, 5, 4) + }) + subMT.Run("equal", func(t testing.TB) { + assertGreaterThan(t, 5, 5) + }) + subMT.Run("less than", func(t testing.TB) { + assertGreaterThan(t, 4, 5) + }) + }) + fmt.Printf("Name: %s\n", mt.Name()) + fmt.Printf("Failed: %+v\n", mt.Failed()) + fmt.Printf("Sub1-Name: %s\n", mt.Subtests()[0].Name()) + fmt.Printf("Sub1-Failed: %+v\n", mt.Subtests()[0].Failed()) + fmt.Printf("Sub1-Aborted: %+v\n", mt.Subtests()[0].Aborted()) + fmt.Printf("Sub1-Sub1-Name: %s\n", mt.Subtests()[0].Subtests()[0].Name()) + fmt.Printf( + "Sub1-Sub1-Failed: %+v\n", mt.Subtests()[0].Subtests()[0].Failed(), + ) + fmt.Printf( + "Sub1-Sub1-Aborted: %+v\n", mt.Subtests()[0].Subtests()[0].Aborted(), + ) + fmt.Printf("Sub1-Sub1-Name: %s\n", mt.Subtests()[0].Subtests()[1].Name()) + fmt.Printf( + "Sub1-Sub2-Failed: %+v\n", mt.Subtests()[0].Subtests()[1].Failed(), + ) + fmt.Printf( + "Sub1-Sub2-Aborted: %+v\n", mt.Subtests()[0].Subtests()[1].Aborted(), + ) + fmt.Printf( + "Sub1-Sub3-Output:\n - %s\n", strings.TrimSpace( + strings.Join(mt.Subtests()[0].Subtests()[1].Output(), "\n - "), + ), + ) + fmt.Printf("Sub1-Sub1-Name: %s\n", mt.Subtests()[0].Subtests()[2].Name()) + fmt.Printf( + "Sub1-Sub3-Failed: %+v\n", mt.Subtests()[0].Subtests()[2].Failed(), + ) + fmt.Printf( + "Sub1-Sub3-Aborted: %+v\n", mt.Subtests()[0].Subtests()[2].Aborted(), + ) + fmt.Printf( + "Sub1-Sub3-Output:\n - %s\n", strings.TrimSpace( + strings.Join(mt.Subtests()[0].Subtests()[2].Output(), "\n - "), + ), + ) + + // Output: + // Name: TestMyBoolean + // Failed: true + // Sub1-Name: TestMyBoolean/positive + // Sub1-Failed: true + // Sub1-Aborted: false + // Sub1-Sub1-Name: TestMyBoolean/positive/greater_than + // Sub1-Sub1-Failed: false + // Sub1-Sub1-Aborted: false + // Sub1-Sub1-Name: TestMyBoolean/positive/equal + // Sub1-Sub2-Failed: true + // Sub1-Sub2-Aborted: false + // Sub1-Sub3-Output: + // - expected 5 to be greater than 5 + // Sub1-Sub1-Name: TestMyBoolean/positive/less_than + // Sub1-Sub3-Failed: true + // Sub1-Sub3-Aborted: false + // Sub1-Sub3-Output: + // - expected 4 to be greater than 5 +}