How to use Skipf method of got Package

...43func TestCgoCallbackGC(t *testing.T) {44	t.Parallel()45	switch runtime.GOOS {46	case "plan9", "windows":47		t.Skipf("no pthreads on %s", runtime.GOOS)48	}49	if testing.Short() {50		switch {51		case runtime.GOOS == "dragonfly":52			t.Skip("see golang.org/issue/11990")53		case runtime.GOOS == "linux" && runtime.GOARCH == "arm":54			t.Skip("too slow for arm builders")55		case runtime.GOOS == "linux" && (runtime.GOARCH == "mips64" || runtime.GOARCH == "mips64le"):56			t.Skip("too slow for mips64x builders")57		}58	}59	got := runTestProg(t, "testprogcgo", "CgoCallbackGC")60	want := "OK\n"61	if got != want {62		t.Fatalf("expected %q, but got:\n%s", want, got)63	}64}65func TestCgoExternalThreadPanic(t *testing.T) {66	t.Parallel()67	if runtime.GOOS == "plan9" {68		t.Skipf("no pthreads on %s", runtime.GOOS)69	}70	got := runTestProg(t, "testprogcgo", "CgoExternalThreadPanic")71	want := "panic: BOOM"72	if !strings.Contains(got, want) {73		t.Fatalf("want failure containing %q. output:\n%s\n", want, got)74	}75}76func TestCgoExternalThreadSIGPROF(t *testing.T) {77	t.Parallel()78	// issue 9456.79	switch runtime.GOOS {80	case "plan9", "windows":81		t.Skipf("no pthreads on %s", runtime.GOOS)82	}83	if runtime.GOARCH == "ppc64" && runtime.GOOS == "linux" {84		// TODO(austin) External linking not implemented on85		// linux/ppc64 (issue #8912)86		t.Skipf("no external linking on ppc64")87	}88	exe, err := buildTestProg(t, "testprogcgo", "-tags=threadprof")89	if err != nil {90		t.Fatal(err)91	}92	got, err := testenv.CleanCmdEnv(exec.Command(exe, "CgoExternalThreadSIGPROF")).CombinedOutput()93	if err != nil {94		t.Fatalf("exit status: %v\n%s", err, got)95	}96	if want := "OK\n"; string(got) != want {97		t.Fatalf("expected %q, but got:\n%s", want, got)98	}99}100func TestCgoExternalThreadSignal(t *testing.T) {101	t.Parallel()102	// issue 10139103	switch runtime.GOOS {104	case "plan9", "windows":105		t.Skipf("no pthreads on %s", runtime.GOOS)106	}107	exe, err := buildTestProg(t, "testprogcgo", "-tags=threadprof")108	if err != nil {109		t.Fatal(err)110	}111	got, err := testenv.CleanCmdEnv(exec.Command(exe, "CgoExternalThreadSIGPROF")).CombinedOutput()112	if err != nil {113		t.Fatalf("exit status: %v\n%s", err, got)114	}115	want := []byte("OK\n")116	if !bytes.Equal(got, want) {117		t.Fatalf("expected %q, but got:\n%s", want, got)118	}119}120func TestCgoDLLImports(t *testing.T) {121	// test issue 9356122	if runtime.GOOS != "windows" {123		t.Skip("skipping windows specific test")124	}125	got := runTestProg(t, "testprogcgo", "CgoDLLImportsMain")126	want := "OK\n"127	if got != want {128		t.Fatalf("expected %q, but got %v", want, got)129	}130}131func TestCgoExecSignalMask(t *testing.T) {132	t.Parallel()133	// Test issue 13164.134	switch runtime.GOOS {135	case "windows", "plan9":136		t.Skipf("skipping signal mask test on %s", runtime.GOOS)137	}138	got := runTestProg(t, "testprogcgo", "CgoExecSignalMask")139	want := "OK\n"140	if got != want {141		t.Errorf("expected %q, got %v", want, got)142	}143}144func TestEnsureDropM(t *testing.T) {145	t.Parallel()146	// Test for issue 13881.147	switch runtime.GOOS {148	case "windows", "plan9":149		t.Skipf("skipping dropm test on %s", runtime.GOOS)150	}151	got := runTestProg(t, "testprogcgo", "EnsureDropM")152	want := "OK\n"153	if got != want {154		t.Errorf("expected %q, got %v", want, got)155	}156}157// Test for issue 14387.158// Test that the program that doesn't need any cgo pointer checking159// takes about the same amount of time with it as without it.160func TestCgoCheckBytes(t *testing.T) {161	t.Parallel()162	// Make sure we don't count the build time as part of the run time.163	testenv.MustHaveGoBuild(t)164	exe, err := buildTestProg(t, "testprogcgo")165	if err != nil {166		t.Fatal(err)167	}168	// Try it 10 times to avoid flakiness.169	const tries = 10170	var tot1, tot2 time.Duration171	for i := 0; i < tries; i++ {172		cmd := testenv.CleanCmdEnv(exec.Command(exe, "CgoCheckBytes"))173		cmd.Env = append(cmd.Env, "GODEBUG=cgocheck=0", fmt.Sprintf("GO_CGOCHECKBYTES_TRY=%d", i))174		start := time.Now()175		cmd.Run()176		d1 := time.Since(start)177		cmd = testenv.CleanCmdEnv(exec.Command(exe, "CgoCheckBytes"))178		cmd.Env = append(cmd.Env, fmt.Sprintf("GO_CGOCHECKBYTES_TRY=%d", i))179		start = time.Now()180		cmd.Run()181		d2 := time.Since(start)182		if d1*20 > d2 {183			// The slow version (d2) was less than 20 times184			// slower than the fast version (d1), so OK.185			return186		}187		tot1 += d1188		tot2 += d2189	}190	t.Errorf("cgo check too slow: got %v, expected at most %v", tot2/tries, (tot1/tries)*20)191}192func TestCgoPanicDeadlock(t *testing.T) {193	t.Parallel()194	// test issue 14432195	got := runTestProg(t, "testprogcgo", "CgoPanicDeadlock")196	want := "panic: cgo error\n\n"197	if !strings.HasPrefix(got, want) {198		t.Fatalf("output does not start with %q:\n%s", want, got)199	}200}201func TestCgoCCodeSIGPROF(t *testing.T) {202	t.Parallel()203	got := runTestProg(t, "testprogcgo", "CgoCCodeSIGPROF")204	want := "OK\n"205	if got != want {206		t.Errorf("expected %q got %v", want, got)207	}208}209func TestCgoCrashTraceback(t *testing.T) {210	t.Parallel()211	switch platform := runtime.GOOS + "/" + runtime.GOARCH; platform {212	case "darwin/amd64":213	case "linux/amd64":214	case "linux/ppc64le":215	default:216		t.Skipf("not yet supported on %s", platform)217	}218	got := runTestProg(t, "testprogcgo", "CrashTraceback")219	for i := 1; i <= 3; i++ {220		if !strings.Contains(got, fmt.Sprintf("cgo symbolizer:%d", i)) {221			t.Errorf("missing cgo symbolizer:%d", i)222		}223	}224}225func TestCgoTracebackContext(t *testing.T) {226	t.Parallel()227	got := runTestProg(t, "testprogcgo", "TracebackContext")228	want := "OK\n"229	if got != want {230		t.Errorf("expected %q got %v", want, got)231	}232}233func testCgoPprof(t *testing.T, buildArg, runArg, top, bottom string) {234	t.Parallel()235	if runtime.GOOS != "linux" || (runtime.GOARCH != "amd64" && runtime.GOARCH != "ppc64le") {236		t.Skipf("not yet supported on %s/%s", runtime.GOOS, runtime.GOARCH)237	}238	testenv.MustHaveGoRun(t)239	exe, err := buildTestProg(t, "testprogcgo", buildArg)240	if err != nil {241		t.Fatal(err)242	}243	got, err := testenv.CleanCmdEnv(exec.Command(exe, runArg)).CombinedOutput()244	if err != nil {245		if testenv.Builder() == "linux-amd64-alpine" {246			// See Issue 18243 and Issue 19938.247			t.Skipf("Skipping failing test on Alpine (golang.org/issue/18243). Ignoring error: %v", err)248		}249		t.Fatalf("%s\n\n%v", got, err)250	}251	fn := strings.TrimSpace(string(got))252	defer os.Remove(fn)253	for try := 0; try < 2; try++ {254		cmd := testenv.CleanCmdEnv(exec.Command(testenv.GoToolPath(t), "tool", "pprof", "-traces"))255		// Check that pprof works both with and without explicit executable on command line.256		if try == 0 {257			cmd.Args = append(cmd.Args, exe, fn)258		} else {259			cmd.Args = append(cmd.Args, fn)260		}261		found := false262		for i, e := range cmd.Env {263			if strings.HasPrefix(e, "PPROF_TMPDIR=") {264				cmd.Env[i] = "PPROF_TMPDIR=" + os.TempDir()265				found = true266				break267			}268		}269		if !found {270			cmd.Env = append(cmd.Env, "PPROF_TMPDIR="+os.TempDir())271		}272		out, err := cmd.CombinedOutput()273		t.Logf("%s:\n%s", cmd.Args, out)274		if err != nil {275			t.Error(err)276			continue277		}278		trace := findTrace(string(out), top)279		if len(trace) == 0 {280			t.Errorf("%s traceback missing.", top)281			continue282		}283		if trace[len(trace)-1] != bottom {284			t.Errorf("invalid traceback origin: got=%v; want=[%s ... %s]", trace, top, bottom)285		}286	}287}288func TestCgoPprof(t *testing.T) {289	testCgoPprof(t, "", "CgoPprof", "cpuHog", "runtime.main")290}291func TestCgoPprofPIE(t *testing.T) {292	testCgoPprof(t, "-buildmode=pie", "CgoPprof", "cpuHog", "runtime.main")293}294func TestCgoPprofThread(t *testing.T) {295	testCgoPprof(t, "", "CgoPprofThread", "cpuHogThread", "cpuHogThread2")296}297func TestCgoPprofThreadNoTraceback(t *testing.T) {298	testCgoPprof(t, "", "CgoPprofThreadNoTraceback", "cpuHogThread", "runtime._ExternalCode")299}300func TestRaceProf(t *testing.T) {301	if (runtime.GOOS != "linux" && runtime.GOOS != "freebsd") || runtime.GOARCH != "amd64" {302		t.Skipf("not yet supported on %s/%s", runtime.GOOS, runtime.GOARCH)303	}304	testenv.MustHaveGoRun(t)305	// This test requires building various packages with -race, so306	// it's somewhat slow.307	if testing.Short() {308		t.Skip("skipping test in -short mode")309	}310	exe, err := buildTestProg(t, "testprogcgo", "-race")311	if err != nil {312		t.Fatal(err)313	}314	got, err := testenv.CleanCmdEnv(exec.Command(exe, "CgoRaceprof")).CombinedOutput()315	if err != nil {316		t.Fatal(err)317	}318	want := "OK\n"319	if string(got) != want {320		t.Errorf("expected %q got %s", want, got)321	}322}323func TestRaceSignal(t *testing.T) {324	t.Parallel()325	if (runtime.GOOS != "linux" && runtime.GOOS != "freebsd") || runtime.GOARCH != "amd64" {326		t.Skipf("not yet supported on %s/%s", runtime.GOOS, runtime.GOARCH)327	}328	testenv.MustHaveGoRun(t)329	// This test requires building various packages with -race, so330	// it's somewhat slow.331	if testing.Short() {332		t.Skip("skipping test in -short mode")333	}334	exe, err := buildTestProg(t, "testprogcgo", "-race")335	if err != nil {336		t.Fatal(err)337	}338	got, err := testenv.CleanCmdEnv(exec.Command(exe, "CgoRaceSignal")).CombinedOutput()339	if err != nil {340		t.Logf("%s\n", got)341		t.Fatal(err)342	}343	want := "OK\n"344	if string(got) != want {345		t.Errorf("expected %q got %s", want, got)346	}347}348func TestCgoNumGoroutine(t *testing.T) {349	switch runtime.GOOS {350	case "windows", "plan9":351		t.Skipf("skipping numgoroutine test on %s", runtime.GOOS)352	}353	t.Parallel()354	got := runTestProg(t, "testprogcgo", "NumGoroutine")355	want := "OK\n"356	if got != want {357		t.Errorf("expected %q got %v", want, got)358	}359}360func TestCatchPanic(t *testing.T) {361	t.Parallel()362	switch runtime.GOOS {363	case "plan9", "windows":364		t.Skipf("no signals on %s", runtime.GOOS)365	case "darwin":366		if runtime.GOARCH == "amd64" {367			t.Skipf("crash() on darwin/amd64 doesn't raise SIGABRT")368		}369	}370	testenv.MustHaveGoRun(t)371	exe, err := buildTestProg(t, "testprogcgo")372	if err != nil {373		t.Fatal(err)374	}375	for _, early := range []bool{true, false} {376		cmd := testenv.CleanCmdEnv(exec.Command(exe, "CgoCatchPanic"))377		// Make sure a panic results in a crash.378		cmd.Env = append(cmd.Env, "GOTRACEBACK=crash")379		if early {380			// Tell testprogcgo to install an early signal handler for SIGABRT381			cmd.Env = append(cmd.Env, "CGOCATCHPANIC_EARLY_HANDLER=1")382		}383		if out, err := cmd.CombinedOutput(); err != nil {384			t.Errorf("testprogcgo CgoCatchPanic failed: %v\n%s", err, out)385		}386	}387}388func TestCgoLockOSThreadExit(t *testing.T) {389	switch runtime.GOOS {390	case "plan9", "windows":391		t.Skipf("no pthreads on %s", runtime.GOOS)392	}393	t.Parallel()394	testLockOSThreadExit(t, "testprogcgo")395}396func TestWindowsStackMemoryCgo(t *testing.T) {397	if runtime.GOOS != "windows" {398		t.Skip("skipping windows specific test")399	}400	testenv.SkipFlaky(t, 22575)401	o := runTestProg(t, "testprogcgo", "StackMemory")402	stackUsage, err := strconv.Atoi(o)403	if err != nil {404		t.Fatalf("Failed to read stack usage: %v", err)405	}406	if expected, got := 100<<10, stackUsage; got > expected {407		t.Fatalf("expected < %d bytes of memory per thread, got %d", expected, got)408	}409}410func TestSigStackSwapping(t *testing.T) {411	switch runtime.GOOS {412	case "plan9", "windows":413		t.Skipf("no sigaltstack on %s", runtime.GOOS)414	}415	t.Parallel()416	got := runTestProg(t, "testprogcgo", "SigStack")417	want := "OK\n"418	if got != want {419		t.Errorf("expected %q got %v", want, got)420	}421}422func TestCgoTracebackSigpanic(t *testing.T) {423	// Test unwinding over a sigpanic in C code without a C424	// symbolizer. See issue #23576.425	if runtime.GOOS == "windows" {426		// On Windows if we get an exception in C code, we let427		// the Windows exception handler unwind it, rather...

...47		if tc.wantErr && err != nil {48			continue49		}50		if err != nil {51			t.Skipf("%d: got err %v", ti, err)52		}53		if tc.wantKeyMatch && tc.key != ev.Node.Key {54			t.Skipf("%d: %v != %v", ti, tc.key, ev.Node.Key)55		}56		if !tc.wantKeyMatch && !strings.HasPrefix(ev.Node.Key, tc.key) {57			t.Skipf("%d: %v is not prefix of %v", ti, tc.key, ev.Node.Key)58		}59		evg, err := v2.Get(tc.key, false, false)60		if evg.Node.CreatedIndex != ev.Node.CreatedIndex {61			t.Skipf("%d: %v != %v", ti, evg.Node.CreatedIndex, ev.Node.CreatedIndex)62		}63		t.Logf("%d: %v %s %v\n", ti, ev.Node.Key, *ev.Node.Value, ev.Node.CreatedIndex)64	}65}66func TestSetKV(t *testing.T) {67	testCases := []struct {68		key            string69		value          string70		dir            bool71		wantIndexMatch bool72	}{73		{key: "/sdir/set", value: "1", wantIndexMatch: true},74		{key: "/sdir/set", value: "4", wantIndexMatch: false},75	}76	cli, err := clientv3.New(clientv3.Config{Endpoints: endpoints})77	if err != nil {78		log.Fatal(err)79	}80	defer cli.Close()81	v2 := v2v3.NewStore(cli, "")82	for ti, tc := range testCases {83		ev, err := v2.Set(tc.key, false, tc.value, v2store.TTLOptionSet{})84		if err != nil {85			t.Skipf("%d: got err %v", ti, err)86		}87		if tc.value != *ev.Node.Value {88			t.Skipf("%d: %v != %v", ti, tc.value, *ev.Node.Value)89		}90		if tc.wantIndexMatch && ev.Node.CreatedIndex != ev.Node.ModifiedIndex {91			t.Skipf("%d: index %v != %v", ti, ev.Node.CreatedIndex, ev.Node.ModifiedIndex)92		}93		t.Logf("%d: %v %s %v\n", ti, ev.Node.Key, *ev.Node.Value, ev.Node.CreatedIndex)94	}95}96func TestCreateSetDir(t *testing.T) {97	testCases := []struct {98		dir string99	}{100		{dir: "/ddir/1/2/3"},101		{dir: "/ddir/1/2/3"},102	}103	cli, err := clientv3.New(clientv3.Config{Endpoints: endpoints})104	if err != nil {105		log.Fatal(err)106	}107	defer cli.Close()108	v2 := v2v3.NewStore(cli, "")109	for ti, tc := range testCases {110		ev, err := v2.Create(tc.dir, true, "", false, v2store.TTLOptionSet{})111		if err != nil {112			t.Skipf("%d: got err %v", ti, err)113		}114		_, err = v2.Create(tc.dir, true, "", false, v2store.TTLOptionSet{})115		if err == nil {116			t.Skipf("%d: expected err got nil", ti)117		}118		ev, err = v2.Delete("ddir", true, true)119		if err != nil {120			t.Skipf("%d: got err %v", ti, err)121		}122		t.Logf("%d: %v %s %v\n", ti, ev.EtcdIndex, ev.PrevNode.Key, ev.PrevNode.CreatedIndex)123	}124}...

1import (2func TestSkipf(t *testing.T) {3    t.Skipf("Skipping test %s", "TestSkipf")4}5import (6func TestSkipNow(t *testing.T) {7    t.SkipNow()8}9import (10func TestFailNow(t *testing.T) {11    t.FailNow()12}13import (14func TestFatal(t *testing.T) {15    t.Fatal("Fatal error")16}17import (18func TestErrorf(t *testing.T) {19    t.Errorf("Error occured")20}21import (22func TestError(t *testing.T) {23    t.Error("Error occured")24}25import (26func TestFail(t *testing.T) {27    t.Fail()28}29import (30func TestFailNow(t *testing.T) {31    t.FailNow()32}33import (34func TestLogf(t *testing.T) {35    t.Logf("Log message: %s", "TestLogf")36}37import (38func TestLog(t *testing.T) {39    t.Log("Log message")40}41import (42func TestParallel(t *testing.T) {43    t.Parallel()44}

1import "testing"2func TestSkipf(t *testing.T) {3    t.Skipf("Skipping this test")4}5--- SKIP: TestSkipf (0.00s)6import "testing"7func TestSkipNow(t *testing.T) {8    t.SkipNow()9}10--- SKIP: TestSkipNow (0.00s)11import "testing"12func TestSkip(t *testing.T) {13    t.Skip()14}15--- SKIP: TestSkip (0.00s)16import "testing"17func TestFatal(t *testing.T) {18    t.Fatal("Fatal error")19}20--- FAIL: TestFatal (0.00s)21import "testing"22func TestFatal(t *testing.T) {23    t.Fatal("Fatal error")24}25--- FAIL: TestFatal (0.00s)26import "testing

1import (2func TestSkipf(t *testing.T) {3	t.Skipf("Test case is skipped")4}5import (6func TestSkip(t *testing.T) {7	t.Skip()8}9import (10func TestRun(t *testing.T) {11	t.Run("TestRun", func(t *testing.T) {12		t.Log("Test case is running")13	})14}15import (16func TestRun(t *testing.T) {17	t.Run("TestRun", func(t *testing.T) {18		t.Log("Test case is running")19	})20}21import (22func TestRun(t *testing.T) {23	t.Run("TestRun", func(t *testing.T) {24		t.Log("Test case is running")25	})26}27import (28func TestRun(t *testing.T) {29	t.Run("TestRun", func(t *testing.T) {30		t.Log("Test case is running")31	})32}33import (34func TestRun(t *testing.T) {35	t.Run("TestRun", func(t *testing.T) {36		t.Log("Test case is running")37	})38}39import (40func TestRun(t *testing.T) {41	t.Run("TestRun", func(t *testing.T) {42		t.Log("Test case is running")43	})44}45import (46func TestRun(t *testing.T) {47	t.Run("TestRun", func(t *testing.T) {48		t.Log("Test case is running")49	})50}

1import (2func TestSkipf(t *testing.T) {3	t.Skipf("Test is skipped")4	fmt.Println("Test is skipped")5}6import (7func TestSkipNow(t *testing.T) {8	t.SkipNow()9	fmt.Println("Test is skipped")10}11import (12func TestSkip(t *testing.T) {13	t.Skip("Test is skipped")14	fmt.Println("Test is skipped")15}16import (17func TestSkipf(t *testing.T) {18	t.Skipf("Test is skipped")19	fmt.Println("Test is skipped")20}21import (22func TestSkipNow(t *testing.T) {23	t.SkipNow()24	fmt.Println("Test is skipped")25}26import (27func TestSkip(t *testing.T) {28	t.Skip("Test is skipped")29	fmt.Println("Test is skipped")30}31import (32func TestSkipf(t *testing.T) {33	t.Skipf("Test is skipped")34	fmt.Println("Test is skipped")35}36import (37func TestSkipNow(t *testing.T) {38	t.SkipNow()39	fmt.Println("Test is skipped")40}41import (42func TestSkip(t *testing.T) {43	t.Skip("Test is skipped")44	fmt.Println("Test is skipped")45}46import (

1import (2func TestSkip(t *testing.T) {3	if 1 == 1 {4		t.Skipf("This test is skipped")5	}6	fmt.Println("This test is not skipped")7}8import (9func TestSkip(t *testing.T) {10	if 1 == 1 {11		t.SkipNow()12	}13	fmt.Println("This test is not skipped")14}15import (16func TestSkip(t *testing.T) {17	if 1 == 1 {18		t.Skip()19	}20	fmt.Println("This test is not skipped")21}22import (23func TestSkip(t *testing.T) {24	if 1 == 1 {25		t.Skip("This test is skipped")26	}27	fmt.Println("This test is not skipped")28}29import (30func TestSkip(t *testing.T) {31	if 1 == 1 {32		t.SkipNow()33	}34	fmt.Println("This test is not skipped")35}

1import (2func TestSkipf(t *testing.T) {3	t.Skipf("Test is skipped")4	fmt.Println("This statement will not be printed")5}6func main() {7	TestSkipf(new(testing.T))8}

1import (2func TestSkipf(t *testing.T) {3	t.Skipf("Skipping TestSkipf")4	fmt.Println("This line will not be executed")5}6import (7func TestSkipNow(t *testing.T) {8	t.SkipNow()9	fmt.Println("This line will not be executed")10}11import (12func TestSkip(t *testing.T) {13	t.Skip()14	fmt.Println("This line will not be executed")15}16import (17func TestFatal(t *testing.T) {18	t.Fatal("This is a fatal error")19	fmt.Println("This line will not be executed")20}21import (22func TestFatalf(t *testing.T) {23	t.Fatalf("This is a fatal error")24	fmt.Println("This line will not be executed")25}26import (27func TestError(t *testing.T) {28	t.Error("This is an error")29	fmt.Println("This line will be executed")30}31import (32func TestErrorf(t *testing.T) {33	t.Errorf("This is an error")34	fmt.Println("This line will be executed")35}36import (37func TestFailNow(t *testing.T) {38	t.FailNow()39	fmt.Println("This line will not be executed")40}41import (42func TestFail(t *testing.T) {43	t.Fail()44	fmt.Println("This line will be executed")45}

1import (2func TestSkipf(t *testing.T) {3	t.Skipf("Skipping this test")4	fmt.Println("This is a test")5}6--- SKIP: TestSkipf (0.00s)7import (8func TestSkipNow(t *testing.T) {9	t.SkipNow()10	fmt.Println("This is a test")11}12--- SKIP: TestSkipNow (0.00s)13import (14func TestLog(t *testing.T) {15	t.Log("This is a log")16	fmt.Println("This is a test")17}18--- PASS: TestLog (0.00s)19import (20func TestLogf(t *testing.T) {21	t.Logf("This is a log")22	fmt.Println("This is a test")23}24--- PASS: TestLogf (0.00s)

1import (2func TestSkipf(t *testing.T) {3	t.Skipf("Skipping test")4}5func (t *T) SkipNow()6import (7func TestSkipNow(t *testing.T) {8	t.SkipNow()9}10func (t *T) Skip(args ...interface{})11import (12func TestSkip(t *testing.T) {13	t.Skip("Skipping test")14}15func (t *T) Skipf(format string, args ...interface{})16import (17func TestSkipf(t *testing.T) {18	t.Skipf("Skipping test")19}20func (t *T) Run(name string, f func(t *T)) bool21import (22func TestRun(t *testing.T) {23	t.Run("subtest", func(t *testing.T) {24		t.Log("subtest")25	})26}