codec: fix testEqual support for diff

- introduce testEqualOpts to generalize testEqual function:
  testEqual is for basic diff support, while testEqualFlex adds more config specific to these files
- use testEqualFlex all over values_test_flex, which tracks many known types with "ignore unexported"
- simplify one-off "one pass" execution of encode/decode
- move how wraps and other types will continue to be supported

Author: ugorji

codec/1_init_run_test.go

@@ -13,6 +13,7 @@ import (
 	// . "github.com/ugorji/go/codec"
 
 	gocmp "github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
 )
 
 type testBenchVars struct {
@@ -264,12 +265,28 @@ var errDeepEqualNotMatch = errors.New("not match")
 
 // perform a simple DeepEqual expecting same values
 func testEqual(v1, v2 interface{}) (err error) {
-	if !reflect.DeepEqual(v1, v2) {
-		if testv.UseDiff {
-			err = errors.New(gocmp.Diff(v1, v2))
-		} else {
-			err = errDeepEqualNotMatch
+	return testEqualOpts(v1, v2, false, nil)
+}
+
+func testEqualOpts(v1, v2 interface{}, nilEmptyEqual bool, ignoreUnexportedTypes []interface{}) error {
+	if reflect.DeepEqual(v1, v2) {
+		return nil
+	}
+	if testv.UseDiff {
+		var optarr [4]gocmp.Option
+		var opts = optarr[:0]
+		if nilEmptyEqual {
+			opts = append(opts, cmpopts.EquateEmpty())
 		}
+		if len(ignoreUnexportedTypes) > 0 {
+			// MARKER 2025 - failing (not sure why)
+			opts = append(opts, cmpopts.IgnoreUnexported(ignoreUnexportedTypes...))
+		}
+		s := gocmp.Diff(v1, v2, opts...)
+		if s == "" {
+			return nil
+		}
+		return errors.New(s)
 	}
-	return
+	return errDeepEqualNotMatch
 }

codec/2_init_bench_test.go

@@ -1,4 +1,4 @@
-//go:build !codec.nobench && go1.24
+//go:build !codec.nobench && !nobench && go1.24
 
 // Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.
@@ -155,6 +155,8 @@ func benchOnePassCheck(t *testing.T, name string, encfn benchEncFn, decfn benchD
 	// 	benchOnePassLogf("-------------- %s ----------------", name)
 	// }
 	defer benchOnePassRecoverPanic(name)
+	defer func(b bool) { testv.UseDiff = b }(testv.UseDiff)
+	testv.UseDiff = true // show diffs if not equal
 	runtime.GC()
 	tnow := time.Now()
 	buf, err := encfn(benchTs, nil)
@@ -176,17 +178,8 @@ func benchOnePassCheck(t *testing.T, name string, encfn benchEncFn, decfn benchD
 		return
 	}
 	decDur := time.Since(tnow)
+	benchOnePassLogf("\t%10s: len: %d bytes,\t encode: %v,\t decode: %v, diff: %v", name, encLen, encDur, decDur, testEqualOpts(benchTs, &ts2, true, []interface{}{ts2}))
 	// if benchCheckDoDeepEqual {
-	if benchVerify {
-		if reflect.DeepEqual(benchTs, &ts2) {
-			benchOnePassLogf("\t%10s: len: %d bytes,\t encode: %v,\t decode: %v,\tencoded == decoded", name, encLen, encDur, decDur)
-		} else {
-			err = errDeepEqualNotMatch
-			benchOnePassLogf("\t%10s: len: %d bytes,\t encode: %v,\t decode: %v,\tencoded != decoded: %v", name, encLen, encDur, decDur, err)
-		}
-	} else {
-		benchOnePassLogf("\t%10s: len: %d bytes,\t encode: %v,\t decode: %v", name, encLen, encDur, decDur)
-	}
 }
 
 func benchOnePassLogf(format string, args ...interface{}) {

codec/codec_bench_test.go

@@ -1,4 +1,4 @@
-//go:build !codec.nobench && go1.24
+//go:build !codec.nobench && !nobench && go1.24
 
 // Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
 // Use of this source code is governed by a MIT license found in the LICENSE file.

codec/codec_run_test.go

@@ -50,8 +50,6 @@ import (
 	"sync/atomic"
 	"testing"
 	"time"
-
-	gocmp "github.com/google/go-cmp/cmp"
 )
 
 func init() {
@@ -533,6 +531,10 @@ func testSetupWithChecks(t *testing.T, _ *Handle, allowParallel bool) (fn func()
 	return
 }
 
+func testEqualFlex(v1, v2 interface{}) error {
+	return testEqualOpts(v1, v2, false, testStructsWithStructInfoField)
+}
+
 func testCodecEncode(ts interface{}, bsIn []byte, fn func([]byte) *bytes.Buffer, h Handle, useMust bool) (bs []byte, err error) {
 	return testSharedCodecEncode(ts, bsIn, fn, h, useMust)
 }
@@ -550,7 +552,7 @@ func testCheckErr(t *testing.T, err error) {
 
 func testCheckEqual(t *testing.T, v1 interface{}, v2 interface{}, desc string) {
 	t.Helper()
-	if err := testEqual(v1, v2); err != nil {
+	if err := testEqualFlex(v1, v2); err != nil {
 		t.Logf("Not Equal: %s: %v", desc, err)
 		if testv.Verbose {
 			t.Logf("\tv1: %v, v2: %v", v1, v2)
@@ -922,7 +924,7 @@ func testUnmarshalErr(v interface{}, data []byte, h Handle, t *testing.T, name s
 
 func testDeepEqualErr(v1, v2 interface{}, t *testing.T, name string) {
 	t.Helper()
-	testDeepEqual4Err(v1, v2, t, name, testEqual(v1, v2))
+	testDeepEqual4Err(v1, v2, t, name, testEqualFlex(v1, v2))
 }
 
 func testDeepEqualErrHandle(v1, v2 interface{}, h Handle, t *testing.T, name string) {
@@ -1092,7 +1094,7 @@ func testCodecTableOne(t *testing.T, testNil bool, h Handle,
 			}
 			continue
 		}
-		if err = testEqual(v0check, v1); err == nil {
+		if err = testEqualFlex(v0check, v1); err == nil {
 			if testv.Verbose {
 				t.Logf("++++++++ Before and After marshal matched\n")
 			}
@@ -1242,15 +1244,15 @@ func doTestCodecMiscOne(t *testing.T, h Handle) {
 
 	testCheckEqual(t, p, p2, "p=p2")
 	testCheckEqual(t, m, m2, "m=m2")
-	if err = testEqual(p, p2); err == nil {
+	if err = testEqualFlex(p, p2); err == nil {
 		if testv.Verbose {
 			t.Logf("p and p2 match")
 		}
 	} else {
 		t.Logf("Not Equal: %v. p: %v, p2: %v", err, p, p2)
 		t.FailNow()
 	}
-	if err = testEqual(m, m2); err == nil {
+	if err = testEqualFlex(m, m2); err == nil {
 		if testv.Verbose {
 			t.Logf("m and m2 match")
 		}
@@ -1396,7 +1398,7 @@ func doTestCodecChan(t *testing.T, h Handle) {
 		for j := range ch2 {
 			sl2 = append(sl2, j)
 		}
-		if err := testEqual(sl1, sl2); err != nil {
+		if err := testEqualFlex(sl1, sl2); err != nil {
 			t.Logf("FAIL: Not Match: %v; len: %v, %v", err, len(sl1), len(sl2))
 			if testv.Verbose {
 				t.Logf("sl1: %#v, sl2: %#v", sl1, sl2)
@@ -1429,7 +1431,7 @@ func doTestCodecChan(t *testing.T, h Handle) {
 			// t.Logf(">>>> from chan: is nil? %v, %v", j == nil, j)
 			sl2 = append(sl2, j)
 		}
-		if err := testEqual(sl1, sl2); err != nil {
+		if err := testEqualFlex(sl1, sl2); err != nil {
 			t.Logf("FAIL: Not Match: %v; len: %v, %v", err, len(sl1), len(sl2))
 			if testv.Verbose {
 				t.Logf("sl1: %#v, sl2: %#v", sl1, sl2)
@@ -1460,7 +1462,7 @@ func doTestCodecChan(t *testing.T, h Handle) {
 		for j := range ch2 {
 			sl2 = append(sl2, j)
 		}
-		if err := testEqual(sl1, sl2); err != nil {
+		if err := testEqualFlex(sl1, sl2); err != nil {
 			t.Logf("FAIL: Not Match: %v; len: %v, %v", err, len(sl1), len(sl2))
 			t.FailNow()
 		}
@@ -1488,7 +1490,7 @@ func doTestCodecChan(t *testing.T, h Handle) {
 		for j := range ch2 {
 			sl2 = append(sl2, j)
 		}
-		if err := testEqual(sl1, sl2); err != nil {
+		if err := testEqualFlex(sl1, sl2); err != nil {
 			t.Logf("FAIL: Not Match: %v; len: %v, %v", err, len(sl1), len(sl2))
 			t.FailNow()
 		}
@@ -1724,7 +1726,7 @@ func doTestStdEncIntf(t *testing.T, h Handle) {
 		e.MustEncode(a[0])
 		d := NewDecoderBytes(b, h)
 		d.MustDecode(a[1])
-		if err := testEqual(a[0], a[1]); err == nil {
+		if err := testEqualFlex(a[0], a[1]); err == nil {
 			if testv.Verbose {
 				t.Logf("++++ Objects match")
 			}
@@ -1957,7 +1959,7 @@ func doTestPythonGenStreams(t *testing.T, h Handle) {
 		}
 		//no need to indirect, because we pass a nil ptr, so we already have the value
 		//if v1 != nil { v1 = reflect.Indirect(reflect.ValueOf(v1)).Interface() }
-		if err = testEqual(v, v1); err == nil {
+		if err = testEqualFlex(v, v1); err == nil {
 			if testv.Verbose {
 				t.Logf("++++++++ Objects match: %T, %v", v, v)
 			}
@@ -1976,7 +1978,7 @@ func doTestPythonGenStreams(t *testing.T, h Handle) {
 			t.FailNow()
 			continue
 		}
-		if err = testEqual(bsb, bss); err == nil {
+		if err = testEqualFlex(bsb, bss); err == nil {
 			if testv.Verbose {
 				t.Logf("++++++++ Bytes match")
 			}
@@ -3194,8 +3196,8 @@ func doTestStrucEncDec(t *testing.T, h Handle) {
 	name := h.Name()
 
 	{
-		var ts1 = newTestStruc(2, testv.NumRepeatString, false, !testv.SkipIntf, testv.MapStringKeyOnly)
-		var ts2 TestStruc
+		var ts1 = newTestStrucPlus(2, testv.NumRepeatString, false, !testv.SkipIntf, testv.MapStringKeyOnly)
+		var ts2 TestStrucPlus
 		bs := testMarshalErr(ts1, h, t, name)
 		testUnmarshalErr(&ts2, bs, h, t, name)
 		testDeepEqualErrHandle(ts1, &ts2, h, t, name)
@@ -3501,7 +3503,7 @@ func doTestNextValueBytes(t *testing.T, h Handle) {
 		[]string{"1", "22", "333", "4444"},
 		// use *TestStruc, not *TestStrucFlex, as *TestStrucFlex is harder to compare with deep equal
 		// Remember: *TestStruc was separated for this reason, affording comparing against other libraries
-		newTestStruc(testv.Depth, testv.NumRepeatString, false, false, true),
+		newTestStrucPlus(testv.Depth, testv.NumRepeatString, false, false, true),
 		"1223334444",
 	}
 	var out []byte
@@ -4169,12 +4171,5 @@ func testEqualH(v1, v2 interface{}, h Handle) (err error) {
 	if v1 != nil {
 		v1 = deepcopy(v1).Interface()
 	}
-	if !reflect.DeepEqual(v1, v2) {
-		if testv.UseDiff {
-			err = errors.New(gocmp.Diff(v1, v2))
-		} else {
-			err = errDeepEqualNotMatch
-		}
-	}
-	return
+	return testEqualOpts(v1, v2, false, []interface{}{v1})
 }

codec/github_issue_test.go

@@ -12,8 +12,8 @@ import (
 )
 
 func TestGH417(t *testing.T) {
-	const numMapEntries = 1000 // 1000
-	const numGoroutines = 100  // 100
+	const numMapEntries = 1024 // 1000
+	const numGoroutines = 64   // 100
 
 	type S string
 	type E struct {

codec/values_flex_test.go

@@ -18,6 +18,21 @@ func init() {
 	testWRepeated512 = wrapBytes(testARepeated512[:])
 }
 
+// these have _struct struct{} fields in them
+var testStructsWithStructInfoField = []interface{}{
+	codecgenC{},
+	testStrucKeyTypeT0{},
+	testStrucKeyTypeT1{},
+	testStrucKeyTypeT2{},
+	testStrucKeyTypeT3{},
+	testStrucKeyTypeT4{},
+	Sstructbig{},
+	SstructbigToArray{},
+	TestStrucFlex{},
+	// testSelfExtHelper{},
+	// TestStrucPlus{},
+}
+
 const teststrucflexChanCap = 64
 
 // This file contains values used by tests alone.