super performance! Split assert functions go get inlining

Author: lainio

assert/assert.go

@@ -438,8 +438,7 @@ func MNotNil[M ~map[T]U, T comparable, U any](m M, a ...any) {
 // assert violation message.
 func NotEqual[T comparable](val, want T, a ...any) {
 	if want == val {
-		defMsg := fmt.Sprintf(assertionMsg+": got '%v' want (!= '%v')", val, want)
-		current().reportAssertionFault(defMsg, a)
+		doShouldNotBeEqual(val, want, a)
 	}
 }
 
@@ -451,11 +450,20 @@ func NotEqual[T comparable](val, want T, a ...any) {
 // are used to override the auto-generated assert violation message.
 func Equal[T comparable](val, want T, a ...any) {
 	if want != val {
-		defMsg := fmt.Sprintf(assertionMsg+gotWantFmt, val, want)
-		current().reportAssertionFault(defMsg, a)
+		doShouldBeEqual(val, want, a)
 	}
 }
 
+func doShouldBeEqual[T comparable](val, want T, a []any) {
+	defMsg := fmt.Sprintf(assertionMsg+gotWantFmt, val, want)
+	current().newReportAssertionFault(defMsg, a)
+}
+
+func doShouldNotBeEqual[T comparable](val, want T, a []any) {
+	defMsg := fmt.Sprintf(assertionMsg+": got '%v' want (!= '%v')", val, want)
+	current().reportAssertionFault(defMsg, a)
+}
+
 // DeepEqual asserts that the (whatever) values are equal. If not it
 // panics/errors (according the current Asserter) with the auto-generated
 // message. You can append the generated got-want message by using optional
@@ -503,8 +511,7 @@ func Len(obj string, length int, a ...any) {
 	l := len(obj)
 
 	if l != length {
-		defMsg := fmt.Sprintf(assertionMsg+gotWantFmt, l, length)
-		current().reportAssertionFault(defMsg, a)
+		doShouldBeEqual(l, length, a)
 	}
 }
 
@@ -560,8 +567,7 @@ func SLen[S ~[]T, T any](obj S, length int, a ...any) {
 	l := len(obj)
 
 	if l != length {
-		defMsg := fmt.Sprintf(assertionMsg+gotWantFmt, l, length)
-		current().reportAssertionFault(defMsg, a)
+		doShouldBeEqual(l, length, a)
 	}
 }
 
@@ -617,8 +623,7 @@ func MLen[M ~map[T]U, T comparable, U any](obj M, length int, a ...any) {
 	l := len(obj)
 
 	if l != length {
-		defMsg := fmt.Sprintf(assertionMsg+gotWantFmt, l, length)
-		current().reportAssertionFault(defMsg, a)
+		doShouldBeEqual(l, length, a)
 	}
 }
 
@@ -916,11 +921,15 @@ func doZero[T Number](val T, a []any) {
 // are used to override the auto-generated assert violation message.
 func NotZero[T Number](val T, a ...any) {
 	if val == 0 {
-		defMsg := fmt.Sprintf(assertionMsg+": got '%v', want (!= 0)", val)
-		current().reportAssertionFault(defMsg, a)
+		doNotZero(val, a)
 	}
 }
 
+func doNotZero[T Number](val T, a []any) {
+	defMsg := fmt.Sprintf(assertionMsg+": got '%v', want (!= 0)", val)
+	current().newReportAssertionFault(defMsg, a)
+}
+
 // current returns a current default asserter used for package-level
 // functions like assert.That().
 //

assert/assert_test.go

@@ -221,20 +221,17 @@ func ExampleGreater() {
 	// Output: sample: assert_test.go:215: ExampleGreater.func1(): assertion violation: got '2', want <= '2'
 }
 
-func assertZero(i int) {
-	assert.Zero(i)
-}
-
-func assertZeroGen(i int) {
-	assert.Equal(i, 0)
-}
-
-func assertMLen(b map[byte]byte, l int) {
-	assert.MLen(b, l)
-}
+func ExampleNotZero() {
+	sample := func(b int8) (err error) {
+		defer err2.Handle(&err, "sample")
 
-func assertEqualInt2(b int) {
-	assert.Equal(b, 2)
+		assert.NotZero(b)
+		return err
+	}
+	var b int8
+	err := sample(b)
+	fmt.Printf("%v", err)
+	// Output: sample: assert_test.go:228: ExampleNotZero.func1(): assertion violation: got '0', want (!= 0)
 }
 
 func BenchmarkSNotNil(b *testing.B) {
@@ -267,13 +264,19 @@ func BenchmarkNotEmpty(b *testing.B) {
 
 func BenchmarkZero(b *testing.B) {
 	for n := 0; n < b.N; n++ {
-		assertZero(0)
+		assert.Zero(0)
+	}
+}
+
+func BenchmarkNotZero(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		assert.NotZero(n + 1)
 	}
 }
 
 func BenchmarkEqual(b *testing.B) {
 	for n := 0; n < b.N; n++ {
-		assertZeroGen(0)
+		assert.Equal(n, n)
 	}
 }
 
@@ -292,7 +295,7 @@ func BenchmarkAsserter_TrueIfVersion(b *testing.B) {
 func BenchmarkMLen(b *testing.B) {
 	d := map[byte]byte{1: 1, 2: 2}
 	for n := 0; n < b.N; n++ {
-		assertMLen(d, 2)
+		assert.MLen(d, 2)
 	}
 }
 
@@ -317,10 +320,17 @@ func BenchmarkSLen_thatVersion(b *testing.B) {
 	}
 }
 
+func BenchmarkNotEqualInt(b *testing.B) {
+	const d = 2
+	for n := 0; n < b.N; n++ {
+		assert.NotEqual(d, 3)
+	}
+}
+
 func BenchmarkEqualInt(b *testing.B) {
 	const d = 2
 	for n := 0; n < b.N; n++ {
-		assertEqualInt2(d)
+		assert.Equal(d, 2)
 	}
 }