temporarily remove test ordering

To comply with the changes in go1.20, Cleanup is no longer an option to call Spec.Finish,
which means for the time being, tests will be executed in sync order.

Author: adamluzsi

Spec.go

@@ -395,7 +395,9 @@ func (spec *Spec) runTB(tb testing.TB, blk func(*T)) {
 
 	retryHandler, ok := spec.lookupRetryFlaky()
 	if ok {
-		retryHandler.Assert(tb, func(it assert.It) { test(it) })
+		retryHandler.Assert(tb, func(it assert.It) {
+			test(it)
+		})
 	} else {
 		test(tb)
 	}
@@ -525,17 +527,12 @@ func (spec *Spec) specsFromCurrent() []*Spec {
 	return specs
 }
 
-func (spec *Spec) lookupParentSpecContext() (*Spec, bool) {
+func (spec *Spec) lookupParent() (*Spec, bool) {
 	spec.testingTB.Helper()
-	var CurrentContextSkipped bool
 	for _, s := range spec.specsFromCurrent() {
 		if s.isTest {
 			continue
 		}
-		if !CurrentContextSkipped {
-			CurrentContextSkipped = true
-			continue
-		}
 		return s, true
 	}
 	return nil, false
@@ -554,7 +551,12 @@ func (spec *Spec) getTagSet() map[string]struct{} {
 
 func (spec *Spec) addTest(blk func()) {
 	spec.testingTB.Helper()
-	spec.tests = append(spec.tests, blk)
+	blk()
+	//if parent, ok := spec.lookupParent(); ok && parent.parent == nil {
+	//	blk()
+	//	return
+	//}
+	//spec.tests = append(spec.tests, blk)
 }
 
 var escapeNameRGX = regexp.MustCompile(`\\.`)

Spec_test.go

@@ -1068,6 +1068,15 @@ func TestSpec_Test_flakyByRetry_willRunAgainWithTheProvidedRetry(t *testing.T) {
 	assert.Must(t).True(retryUsed)
 }
 
+func TestSpec_Test_smoke(t *testing.T) {
+	s := testcase.NewSpec(t)
+
+	var count int
+	s.Test(``, func(t *testcase.T) { count++ })
+
+	assert.Equal(t, 1, count)
+}
+
 func TestSpec_Test_flakyByStrategy_willRunAgainBasedOnTheStrategy(t *testing.T) {
 	s := testcase.NewSpec(t)
 
@@ -1082,14 +1091,18 @@ func TestSpec_Test_flakyByStrategy_willRunAgainBasedOnTheStrategy(t *testing.T)
 	// we need a truly random generation,
 	// because *testcase.T.Random is deterministic.
 	rnd := random.New(random.CryptoSeed{})
+
 	s.Test(``, func(t *testcase.T) {
 		testCount++
 		if rnd.Bool() {
 			t.FailNow()
 		}
 	}, testcase.Flaky(strategy))
 
-	assert.Must(t).Equal(strategyCallCount, testCount)
+	assert.Must(t).AnyOf(func(a *assert.AnyOf) {
+		a.Test(func(t assert.It) { t.Must.Equal(strategyCallCount, testCount) })
+		a.Test(func(t assert.It) { t.Must.Equal(strategyCallCount+1, testCount) }) // when there is no error, the total
+	})
 }
 
 func TestSpec_Test_flakyFlagWithInvalidValue_willPanics(t *testing.T) {
@@ -1147,6 +1160,8 @@ func TestSpec_Parallel_testPrepareActionsExecutedInParallel(t *testing.T) {
 }
 
 func TestSpec_nonParallelTestExecutionOrder_isRandom(t *testing.T) {
+	t.Skip("go1.20")
+
 	assert.Eventually{RetryStrategy: assert.Waiter{WaitDuration: time.Second}}.Assert(t, func(it assert.It) {
 
 		s := testcase.NewSpec(it)
@@ -1167,6 +1182,8 @@ func TestSpec_nonParallelTestExecutionOrder_isRandom(t *testing.T) {
 }
 
 func TestSpec_Finish(t *testing.T) {
+	t.Skip("go1.20")
+
 	s := testcase.NewSpec(t)
 	var ran bool
 	s.Test(``, func(t *testcase.T) { ran = true })
@@ -1191,6 +1208,8 @@ func TestSpec_Finish_finishedSpecIsImmutable(t *testing.T) {
 }
 
 func TestSpec_Finish_runOnlyOnce(t *testing.T) {
+	t.Skip("go1.20")
+
 	s := testcase.NewSpec(t)
 	var count int
 	s.Test(``, func(t *testcase.T) { count++ })
@@ -1226,6 +1245,8 @@ func TestSpec_eachContextRunsOnce(t *testing.T) {
 }
 
 func TestSpec_Finish_describeBlocksRunWhenTheyCloseAndNotAfter(t *testing.T) {
+	t.Skip("go1.20")
+
 	var (
 		testInDescribe int
 		testOnTopLevel int
@@ -1341,6 +1362,8 @@ func TestNewSpec_withTestcaseT_InheritContext(t *testing.T) {
 }
 
 func TestSpec_Test_whenTestingTBIsGivenThatDoesNotSupportTBRunner_executesOnFinish(t *testing.T) {
+	t.Skip("go1.20")
+
 	s := testcase.NewSpec(t)
 	var ran bool
 	s.Test(``, func(t *testcase.T) { ran = true })
@@ -1350,6 +1373,8 @@ func TestSpec_Test_whenTestingTBIsGivenThatDoesNotSupportTBRunner_executesOnFini
 }
 
 func TestSpec_Test_testingTBNoTBRunner_ordered(t *testing.T) {
+	t.Skip("go1.20")
+
 	testcase.SetEnv(t, testcase.EnvKeySeed, "42")
 	testcase.SetEnv(t, testcase.EnvKeyOrdering, string(testcase.OrderingAsRandom))
 	s := testcase.NewSpec(t)

T_test.go

@@ -127,12 +127,15 @@ func TestT_Defer(t *testing.T) {
 //
 //goland:noinspection GoDeferGo
 func TestT_Defer_failNowWillNotHang(t *testing.T) {
+	t.Skip("WIP")
+	
 	var wg sync.WaitGroup
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
 		defer recover()
-		s := testcase.NewSpec(&doubles.RecorderTB{})
+
+		s := testcase.NewSpec(&doubles.RecorderTB{TB: &doubles.TB{}})
 
 		s.Before(func(t *testcase.T) {
 			t.Defer(func() { t.FailNow() })

TableTest_test.go

@@ -9,6 +9,8 @@ import (
 )
 
 func TestTableTest_orderIsDeterministic(t *testing.T) {
+	t.Skip("go1.20")
+	
 	t.Setenv(testcase.EnvKeySeed, "42")
 
 	var (

hooks.go

@@ -83,5 +83,4 @@ func (spec *Spec) BeforeAll(blk func(tb testing.TB)) {
 		Block: func() { once.Do(func() { blk(spec.testingTB) }) },
 		Frame: frame,
 	})
-
 }

hooks_test.go

@@ -75,24 +75,18 @@ func TestSpec_BeforeAll_blkRunsOnlyOnce(t *testing.T) {
 		s.Test(``, blk)
 		s.Test(``, blk)
 	})
-	s.Finish()
 
 	assert.Must(t).Equal(1, counter)
 }
 
 func TestSpec_BeforeAll_failIfDefinedAfterTestCases(t *testing.T) {
-	var isAnyOfTheTestCaseRan bool
-	blk := func(t *testcase.T) { isAnyOfTheTestCaseRan = true }
 	stub := &doubles.TB{}
-
 	sandbox.Run(func() {
 		s := testcase.NewSpec(stub)
-		s.Test(``, blk)
+		s.Test(``, func(t *testcase.T) {})
 		s.BeforeAll(func(tb testing.TB) {})
-		s.Test(``, blk)
+		s.Test(``, func(t *testcase.T) {})
 		s.Finish()
 	})
-
 	assert.Must(t).True(stub.IsFailed)
-	assert.Must(t).True(!isAnyOfTheTestCaseRan)
 }