test: refactor benchmarks by document size

.gitignore

@@ -52,4 +52,4 @@ Godeps/
 benchstats
 .benchruns
 coverage.txt
-dist/
+dist/

.goreleaser.yml

@@ -8,4 +8,4 @@ release:
   draft: true
   prerelease: auto
 env_files:
-  github_token: ~/.goreleaser_github_token
+  github_token: ~/.goreleaser_github_token

README.md

@@ -365,13 +365,13 @@ For example, the `UnmarshalFunc` option can be used to set up a custom JSON [`De
 
 ```go
 patch, err := jsondiff.CompareJSONOpts(
-	source,
-	target,
-	jsondiff.UnmarshalFunc(func(b []byte, v any) error {
-		dec := json.NewDecoder(bytes.NewReader(b))
-		dec.UseNumber()
-		return dec.Decode(v)
-	}),
+    source,
+    target,
+    jsondiff.UnmarshalFunc(func(b []byte, v any) error {
+        dec := json.NewDecoder(bytes.NewReader(b))
+        dec.UseNumber()
+        return dec.Decode(v)
+    }),
 )
 ```
 

bench_test.go

@@ -3,99 +3,105 @@ package jsondiff
 import (
 	"encoding/json"
 	"os"
+	"path/filepath"
 	"testing"
 )
 
-func BenchmarkMedium(b *testing.B) {
-	beforeBytes, err := os.ReadFile("testdata/benchs/medium/before.json")
+const benchsDir = "testdata/benchs"
+
+func BenchmarkSmall(b *testing.B)  { benchmark(b, "small") }
+func BenchmarkMedium(b *testing.B) { benchmark(b, "medium") }
+
+func benchmark(b *testing.B, dir string) {
+	src, err := os.ReadFile(filepath.Join(benchsDir, dir, "source.json"))
 	if err != nil {
 		b.Fatal(err)
 	}
-	afterBytesOrdered, err := os.ReadFile("testdata/benchs/medium/after-ordered.json")
+	tgt, err := os.ReadFile(filepath.Join(benchsDir, dir, "target.json"))
 	if err != nil {
 		b.Fatal(err)
 	}
-	afterBytesUnordered, err := os.ReadFile("testdata/benchs/medium/after-unordered.json")
+	tgtUnordered, err := os.ReadFile(filepath.Join(benchsDir, dir, "target.unordered.json"))
 	if err != nil {
 		b.Fatal(err)
 	}
+	subBenchmarks(b, src, tgt, tgtUnordered)
+}
+
+func subBenchmarks(b *testing.B, src, tgt, tgtUnordered []byte) {
 	makeopts := func(opts ...Option) []Option { return opts }
 
 	for _, bb := range []struct {
 		name       string
 		opts       []Option
 		afterBytes []byte
 	}{
-		{"default-ordered", nil, afterBytesOrdered},
-		{"default-unordered", nil, afterBytesUnordered},
-		{"invertible", makeopts(Invertible()), afterBytesOrdered},
-		{"factorize", makeopts(Factorize()), afterBytesOrdered},
-		{"rationalize", makeopts(Rationalize()), afterBytesOrdered},
-		{"equivalent-ordered", makeopts(Equivalent()), afterBytesOrdered},
-		{"equivalent-unordered", makeopts(Equivalent()), afterBytesUnordered},
-		{"factor+ratio", makeopts(Factorize(), Rationalize()), afterBytesOrdered},
-		{"all-ordered", makeopts(Factorize(), Rationalize(), Invertible(), Equivalent()), afterBytesOrdered},
-		{"all-unordered", makeopts(Factorize(), Rationalize(), Invertible(), Equivalent()), afterBytesUnordered},
+		{"default", nil, tgt},
+		{"default-unordered", nil, tgtUnordered},
+		{"invertible", makeopts(Invertible()), tgt},
+		{"factorize", makeopts(Factorize()), tgt},
+		{"rationalize", makeopts(Rationalize()), tgt},
+		{"equivalent", makeopts(Equivalent()), tgt},
+		{"equivalent-unordered", makeopts(Equivalent()), tgtUnordered},
+		{"factor+ratio", makeopts(Factorize(), Rationalize()), tgt},
+		{"all", makeopts(Factorize(), Rationalize(), Invertible(), Equivalent()), tgt},
+		{"all-unordered", makeopts(Factorize(), Rationalize(), Invertible(), Equivalent()), tgtUnordered},
 	} {
 		var before, after interface{}
-		err = json.Unmarshal(beforeBytes, &before)
-		if err != nil {
+
+		if err := json.Unmarshal(src, &before); err != nil {
 			b.Fatal(err)
 		}
-		err = json.Unmarshal(bb.afterBytes, &after)
-		if err != nil {
+		if err := json.Unmarshal(bb.afterBytes, &after); err != nil {
 			b.Fatal(err)
 		}
-		b.Run("Compare/"+bb.name, func(b *testing.B) {
-			if testing.Short() {
-				b.Skip()
+		b.ResetTimer()
+
+		b.Run("DifferReset/"+bb.name, func(b *testing.B) {
+			d := Differ{targetBytes: bb.afterBytes}
+			for _, opt := range bb.opts {
+				opt(&d)
 			}
+			b.ReportAllocs()
+			b.ResetTimer()
+
 			for i := 0; i < b.N; i++ {
-				patch, err := CompareOpts(before, after, bb.opts...)
-				if err != nil {
-					b.Error(err)
+				d.Compare(before, after)
+				d.Reset()
+			}
+		})
+		b.Run("Differ/"+bb.name, func(b *testing.B) {
+			b.ReportAllocs()
+			for i := 0; i < b.N; i++ {
+				d := Differ{targetBytes: bb.afterBytes}
+				for _, opt := range bb.opts {
+					opt(&d)
 				}
-				_ = patch
+				d.Compare(before, after)
 			}
 		})
 		b.Run("CompareJSON/"+bb.name, func(b *testing.B) {
 			if testing.Short() {
 				b.Skip()
 			}
 			for i := 0; i < b.N; i++ {
-				patch, err := CompareJSONOpts(beforeBytes, bb.afterBytes, bb.opts...)
+				patch, err := CompareJSONOpts(src, bb.afterBytes, bb.opts...)
 				if err != nil {
 					b.Error(err)
 				}
 				_ = patch
 			}
 		})
-		b.Run("DifferCompare/"+bb.name, func(b *testing.B) {
+		b.Run("Compare/"+bb.name, func(b *testing.B) {
 			if testing.Short() {
 				b.Skip()
 			}
-			b.ReportAllocs()
-			b.ResetTimer()
-
 			for i := 0; i < b.N; i++ {
-				d := Differ{targetBytes: bb.afterBytes}
-				for _, opt := range bb.opts {
-					opt(&d)
+				patch, err := CompareOpts(before, after, bb.opts...)
+				if err != nil {
+					b.Error(err)
 				}
-				d.Compare(before, after)
-			}
-		})
-		b.Run("DifferResetCompare/"+bb.name, func(b *testing.B) {
-			d := Differ{targetBytes: bb.afterBytes}
-			for _, opt := range bb.opts {
-				opt(&d)
-			}
-			b.ReportAllocs()
-			b.ResetTimer()
-
-			for i := 0; i < b.N; i++ {
-				d.Compare(before, after)
-				d.Reset()
+				_ = patch
 			}
 		})
 	}

testdata/benchs/medium/source.json

@@ -0,0 +1,50 @@
+[
+    {
+        "ready": 1918714331,
+        "different": -1830651766,
+        "alive": {
+            "speak": "flew",
+            "those": true,
+            "author": "dress",
+            "aboard": 827904935.2808893,
+            "birds": {
+                "party": "dream",
+                "line": "fellow",
+                "zoo": {
+                    "blanket": "hardly",
+                    "felt": "ask",
+                    "pleasant": "tent",
+                    "taught": -1039126516,
+                    "trail": false,
+                    "product": true
+                },
+                "season": 828358559,
+                "family": [
+                    [
+                        false,
+                        true,
+                        true,
+                        "negative",
+                        false,
+                        "minerals"
+                    ],
+                    true,
+                    false,
+                    false,
+                    true,
+                    false
+                ],
+                "seeing": 1629544026.9829543
+            },
+            "nice": -673674204
+        },
+        "mass": true,
+        "exclaimed": 1247797388,
+        "orange": false
+    },
+    true,
+    "all",
+    true,
+    true,
+    956421075
+]