Source file src/github.com/launchdarkly/go-jsonstream/v3/jreader/json_unmarshal_comparative_benchmark_test.go

Documentation: github.com/launchdarkly/go-jsonstream/v3/jreader

     1  package jreader
     2  
     3  import (
     4  	"encoding/json"
     5  	"testing"
     6  
     7  	"github.com/launchdarkly/go-jsonstream/v3/internal/commontest"
     8  )
     9  
    10  // These benchmarks perform equivalent actions to the ones in reader_benchmark_test.go, but using
    11  // the default reflection-based mechanism from the json/encoding package, so we can see how much
    12  // less efficient that is than our default implementation and the easyjson implementation.
    13  
    14  func BenchmarkJSONUnmarshalComparatives(b *testing.B) {
    15  	b.Run("Null", benchmarkReadNullJSONUnmarshal)
    16  	b.Run("Boolean", benchmarkReadBooleanJSONUnmarshal)
    17  	b.Run("NumberInt", benchmarkReadNumberIntJSONUnmarshal)
    18  	b.Run("NumberFloat", benchmarkReadNumberFloatJSONUnmarshal)
    19  	b.Run("String", benchmarkReadStringJSONUnmarshal)
    20  	b.Run("ArrayOfBools", benchmarkReadArrayOfBoolsJSONUnmarshal)
    21  	b.Run("ArrayOfStrings", benchmarkReadArrayOfStringsJSONUnmarshal)
    22  	b.Run("Object", benchmarkReadObjectJSONUnmarshal)
    23  	b.Run("ArrayOfObjects", benchmarkReadArrayOfObjectsJSONUnmarshal)
    24  }
    25  
    26  func benchmarkReadNullJSONUnmarshal(b *testing.B) {
    27  	data := []byte("null")
    28  	var expected interface{} = nil
    29  	b.ResetTimer()
    30  	for i := 0; i < b.N; i++ {
    31  		var val interface{}
    32  		if err := json.Unmarshal(data, &val); err != nil {
    33  			b.Error(err)
    34  			b.FailNow()
    35  		}
    36  		if val != expected {
    37  			b.FailNow()
    38  		}
    39  	}
    40  }
    41  
    42  func benchmarkReadBooleanJSONUnmarshal(b *testing.B) {
    43  	data := []byte("true")
    44  	expected := true
    45  	b.ResetTimer()
    46  	for i := 0; i < b.N; i++ {
    47  		var val bool
    48  		if err := json.Unmarshal(data, &val); err != nil {
    49  			b.Error(err)
    50  			b.FailNow()
    51  		}
    52  		if val != expected {
    53  			b.FailNow()
    54  		}
    55  	}
    56  }
    57  
    58  func benchmarkReadNumberIntJSONUnmarshal(b *testing.B) {
    59  	data := []byte("1234")
    60  	expected := 1234
    61  	b.ResetTimer()
    62  	for i := 0; i < b.N; i++ {
    63  		var val int
    64  		if err := json.Unmarshal(data, &val); err != nil {
    65  			b.Error(err)
    66  			b.FailNow()
    67  		}
    68  		if val != expected {
    69  			b.FailNow()
    70  		}
    71  	}
    72  }
    73  
    74  func benchmarkReadNumberFloatJSONUnmarshal(b *testing.B) {
    75  	data := []byte("1234.5")
    76  	expected := 1234.5
    77  	b.ResetTimer()
    78  	for i := 0; i < b.N; i++ {
    79  		var val float64
    80  		if err := json.Unmarshal(data, &val); err != nil {
    81  			b.Error(err)
    82  			b.FailNow()
    83  		}
    84  		if val != expected {
    85  			b.FailNow()
    86  		}
    87  	}
    88  }
    89  
    90  func benchmarkReadStringJSONUnmarshal(b *testing.B) {
    91  	data := []byte(`"abc"`)
    92  	expected := "abc"
    93  	b.ResetTimer()
    94  	for i := 0; i < b.N; i++ {
    95  		var val string
    96  		if err := json.Unmarshal(data, &val); err != nil {
    97  			b.Error(err)
    98  			b.FailNow()
    99  		}
   100  		if val != expected {
   101  			b.FailNow()
   102  		}
   103  	}
   104  }
   105  
   106  func benchmarkReadArrayOfBoolsJSONUnmarshal(b *testing.B) {
   107  	expected := commontest.MakeBools()
   108  	data := commontest.MakeBoolsJSON(expected)
   109  	b.ResetTimer()
   110  	for i := 0; i < b.N; i++ {
   111  		var vals []bool
   112  		if err := json.Unmarshal(data, &vals); err != nil {
   113  			b.Error(err)
   114  			b.FailNow()
   115  		}
   116  		if len(vals) < len(expected) {
   117  			b.FailNow()
   118  		}
   119  	}
   120  }
   121  
   122  func benchmarkReadArrayOfStringsJSONUnmarshal(b *testing.B) {
   123  	expected := commontest.MakeStrings()
   124  	data := commontest.MakeStringsJSON(expected)
   125  	b.ResetTimer()
   126  	for i := 0; i < b.N; i++ {
   127  		var vals []string
   128  		if err := json.Unmarshal(data, &vals); err != nil {
   129  			b.Error(err)
   130  			b.FailNow()
   131  		}
   132  		if len(vals) < len(expected) {
   133  			b.FailNow()
   134  		}
   135  	}
   136  }
   137  
   138  func benchmarkReadObjectJSONUnmarshal(b *testing.B) {
   139  	for i := 0; i < b.N; i++ {
   140  		var val ExampleStructWrapper
   141  		if err := json.Unmarshal(commontest.ExampleStructData, &val); err != nil {
   142  			b.Error(err)
   143  			b.FailNow()
   144  		}
   145  		if val != ExampleStructWrapper(commontest.ExampleStructValue) {
   146  			b.FailNow()
   147  		}
   148  	}
   149  }
   150  
   151  func benchmarkReadArrayOfObjectsJSONUnmarshal(b *testing.B) {
   152  	rawStructs := commontest.MakeStructs()
   153  	data := commontest.MakeStructsJSON(rawStructs)
   154  	var expected []ExampleStructWrapper
   155  	for _, rawStruct := range rawStructs {
   156  		expected = append(expected, ExampleStructWrapper(rawStruct))
   157  	}
   158  	b.ResetTimer()
   159  	for i := 0; i < b.N; i++ {
   160  		var values []ExampleStructWrapper
   161  		if err := json.Unmarshal(data, &values); err != nil {
   162  			b.Error(err)
   163  			b.FailNow()
   164  		}
   165  		for i, val := range values {
   166  			if val != expected[i] {
   167  				b.FailNow()
   168  			}
   169  		}
   170  	}
   171  }
   172  

View as plain text