first bench tests for currentX() that uses TLS which is slow

Author: lainio

assert/assert.go

@@ -137,13 +137,17 @@ func init() {
 }
 
 type (
+	mapAsserter = map[int]asserter
+
 	testersMap = map[int]testing.TB
 	function   = func()
 )
 
 var (
 	// testers must be set if assertion package is used for the unit testing.
 	testers = x.NewRWMap[testersMap]()
+
+	asserterMap = x.NewRWMap[mapAsserter]()
 )
 
 const (
@@ -286,6 +290,38 @@ func ThatNot(term bool, a ...any) {
 	}
 }
 
+func ThatX(term bool, a ...any) {
+	if !term {
+		thatXDo(a)
+	}
+}
+
+func ZeroX[T Number](val T, a ...any) {
+	if val != 0 {
+		doZeroX(val, a)
+	}
+}
+
+func doZeroX[T Number](val T, a []any) {
+	defMsg := fmt.Sprintf(assertionMsg+": got '%v', want (== '0')", val)
+	currentX().reportAssertionFault(1, defMsg, a)
+}
+
+func thatXDo(a []any) {
+	defMsg := assertionMsg
+	currentX().reportAssertionFault(1, defMsg, a)
+}
+
+func currentX() asserter {
+	// we need thread local storage, maybe we'll implement that to x.package?
+	// study `tester` and copy ideas from it.
+	return asserterMap.Get(goid())
+}
+
+func SetDefaultX(i defInd) {
+	asserterMap.Set(goid(), defAsserter[i])
+}
+
 // That asserts that the term is true. If not it panics with the given
 // formatting string. Thanks to inlining, the performance penalty is equal to a
 // single 'if-statement' that is almost nothing.
@@ -884,11 +920,26 @@ func NoError(err error, a ...any) {
 // are used to override the auto-generated assert violation message.
 func Error(err error, a ...any) {
 	if err == nil {
-		defMsg := "Error:" + assertionMsg + ": missing error"
-		current().reportAssertionFault(0, defMsg, a)
+		doErrorX(a)
+	}
+}
+
+func ErrorX(err error, a ...any) {
+	if err == nil {
+		doError(a)
 	}
 }
 
+func doErrorX(a []any) {
+	defMsg := "Error:" + assertionMsg + ": missing error"
+	currentX().reportAssertionFault(0, defMsg, a)
+}
+
+func doError(a []any) {
+	defMsg := "Error:" + assertionMsg + ": missing error"
+	current().reportAssertionFault(0, defMsg, a)
+}
+
 // Greater asserts that the value is greater than want. If it is not it panics
 // and builds a violation message. Thanks to inlining, the performance penalty
 // is equal to a single 'if-statement' that is almost nothing.

assert/assert_test.go

@@ -401,27 +401,37 @@ func BenchmarkThat(b *testing.B) {
 	}
 }
 
-func BenchmarkGreater(b *testing.B) {
+func BenchmarkZeroX(b *testing.B) {
+	assert.SetDefaultX(assert.Production)
+	const zero = 0
 	for n := 0; n < b.N; n++ {
-		assert.Greater(1, 0)
+		assert.ZeroX(zero)
 	}
 }
 
-func BenchmarkLess(b *testing.B) {
+func BenchmarkZero(b *testing.B) {
+	const zero = 0
 	for n := 0; n < b.N; n++ {
-		assert.Less(0, 1)
+		assert.Zero(zero)
 	}
 }
 
-func BenchmarkZero(b *testing.B) {
+func BenchmarkGreater(b *testing.B) {
 	for n := 0; n < b.N; n++ {
-		assert.Zero(0)
+		assert.Greater(1, 0)
+	}
+}
+
+func BenchmarkLess(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		assert.Less(0, 1)
 	}
 }
 
-func BenchmarkNotZero(b *testing.B) {
+func BenchmarkErrorX(b *testing.B) {
+	assert.SetDefaultX(assert.Production)
 	for n := 0; n < b.N; n++ {
-		assert.NotZero(n + 1)
+		assert.ErrorX(err2.ErrNotAccess)
 	}
 }