chore: add benchmark tests for more functions

added more benchmark tests to try and find bottleneck

Author: evilmonkeyinc

jsonpath_test.go

@@ -8,7 +8,6 @@ import (
 )
 
 func Benchmark_Selector(b *testing.B) {
-
 	selectors := []string{
 		"$.store.book[*].author",
 		"$..author",
@@ -25,17 +24,62 @@ func Benchmark_Selector(b *testing.B) {
 		"$..*",
 	}
 
-	for _, selector := range selectors {
-		b.Run(fmt.Sprintf("%s", selector), func(b *testing.B) {
-			var err error
-			for i := 0; i < b.N; i++ {
-				_, err = QueryString(selector, sampleDataString)
-				if err != nil {
-					b.Error()
+	b.Run("QueryString", func(b *testing.B) {
+		for _, selector := range selectors {
+			b.Run(fmt.Sprintf("%s", selector), func(b *testing.B) {
+				var err error
+				for i := 0; i < b.N; i++ {
+					_, err = QueryString(selector, sampleDataString)
+					if err != nil {
+						b.Error()
+					}
 				}
-			}
-		})
-	}
+			})
+		}
+	})
+
+	compiledSelectors := make([]*Selector, 0)
+	b.Run("Compile", func(b *testing.B) {
+		for _, selector := range selectors {
+			b.Run(fmt.Sprintf("%s", selector), func(b *testing.B) {
+				var err error
+				var compiled *Selector
+				for i := 0; i < b.N; i++ {
+					compiled, err = Compile(selector)
+					if err != nil {
+						b.Error()
+					}
+				}
+				compiledSelectors = append(compiledSelectors, compiled)
+			})
+		}
+	})
+
+	b.Run("Selector.QueryString", func(b *testing.B) {
+		for _, selector := range compiledSelectors {
+			b.Run(fmt.Sprintf("%s", selector.selector), func(b *testing.B) {
+				for i := 0; i < b.N; i++ {
+					_, err := selector.QueryString(sampleDataString)
+					if err != nil {
+						b.Error()
+					}
+				}
+			})
+		}
+	})
+
+	b.Run("Selector.Query", func(b *testing.B) {
+		for _, selector := range compiledSelectors {
+			b.Run(fmt.Sprintf("%s", selector.selector), func(b *testing.B) {
+				for i := 0; i < b.N; i++ {
+					_, err := selector.Query(sampleDataObject)
+					if err != nil {
+						b.Error()
+					}
+				}
+			})
+		}
+	})
 }
 
 // Tests designed after the examples in the specification document

token/current_test.go

@@ -21,39 +21,42 @@ func Test_CurrentToken_Type(t *testing.T) {
 	assert.Equal(t, "current", (&currentToken{}).Type())
 }
 
-func Test_CurrentToken_Apply(t *testing.T) {
-
-	tests := []*tokenTest{
-		{
-			token: &currentToken{},
-			input: input{
-				current: map[string]interface{}{
-					"name": "first",
-				},
+var currentTests = []*tokenTest{
+	{
+		token: &currentToken{},
+		input: input{
+			current: map[string]interface{}{
+				"name": "first",
 			},
-			expected: expected{
-				value: map[string]interface{}{
-					"name": "first",
-				},
+		},
+		expected: expected{
+			value: map[string]interface{}{
+				"name": "first",
 			},
 		},
-		{
-			token: &currentToken{},
-			input: input{
-				current: map[string]interface{}{
-					"name": "first",
-				},
-				tokens: []Token{
-					&keyToken{
-						key: "name",
-					},
-				},
+	},
+	{
+		token: &currentToken{},
+		input: input{
+			current: map[string]interface{}{
+				"name": "first",
 			},
-			expected: expected{
-				value: "first",
+			tokens: []Token{
+				&keyToken{
+					key: "name",
+				},
 			},
 		},
-	}
+		expected: expected{
+			value: "first",
+		},
+	},
+}
+
+func Test_CurrentToken_Apply(t *testing.T) {
+	batchTokenTests(t, currentTests)
+}
 
-	batchTokenTests(t, tests)
+func Benchmark_CurrentToken_Apply(b *testing.B) {
+	batchTokenBenchmarks(b, currentTests)
 }

token/expression_test.go

@@ -72,49 +72,52 @@ func Test_ExpressionToken_Type(t *testing.T) {
 	assert.Equal(t, "expression", (&expressionToken{}).Type())
 }
 
-func Test_ExpressionToken_Apply(t *testing.T) {
-
-	tests := []*tokenTest{
-		{
-			token: &expressionToken{},
-			input: input{},
-			expected: expected{
-				err: "invalid expression. is empty",
-			},
+var expressionTests = []*tokenTest{
+	{
+		token: &expressionToken{},
+		input: input{},
+		expected: expected{
+			err: "invalid expression. is empty",
 		},
-		{
-			token: &expressionToken{
-				expression:         "any",
-				compiledExpression: &testCompiledExpression{err: fmt.Errorf("engine error")},
-			},
-			input: input{},
-			expected: expected{
-				err: "invalid expression. engine error",
-			},
+	},
+	{
+		token: &expressionToken{
+			expression:         "any",
+			compiledExpression: &testCompiledExpression{err: fmt.Errorf("engine error")},
 		},
-		{
-			token: &expressionToken{
-				expression:         "any",
-				compiledExpression: &testCompiledExpression{response: true},
-			},
-			input: input{},
-			expected: expected{
-				value: true,
-			},
+		input: input{},
+		expected: expected{
+			err: "invalid expression. engine error",
 		},
-		{
-			token: &expressionToken{
-				expression:         "any",
-				compiledExpression: &testCompiledExpression{response: false},
-			},
-			input: input{
-				tokens: []Token{&currentToken{}},
-			},
-			expected: expected{
-				value: false,
-			},
+	},
+	{
+		token: &expressionToken{
+			expression:         "any",
+			compiledExpression: &testCompiledExpression{response: true},
 		},
-	}
+		input: input{},
+		expected: expected{
+			value: true,
+		},
+	},
+	{
+		token: &expressionToken{
+			expression:         "any",
+			compiledExpression: &testCompiledExpression{response: false},
+		},
+		input: input{
+			tokens: []Token{&currentToken{}},
+		},
+		expected: expected{
+			value: false,
+		},
+	},
+}
+
+func Test_ExpressionToken_Apply(t *testing.T) {
+	batchTokenTests(t, expressionTests)
+}
 
-	batchTokenTests(t, tests)
+func Benchmark_ExpressionToken_Apply(b *testing.B) {
+	batchTokenBenchmarks(b, expressionTests)
 }