github.com/neilotoole/jsoncolor@v0.6.0/parse_test.go (about)

     1  package jsoncolor
     2  
     3  import (
     4  	"bytes"
     5  	"strings"
     6  	"testing"
     7  )
     8  
     9  func TestParseString(t *testing.T) {
    10  	tests := []struct {
    11  		in  string
    12  		out string
    13  		ext string
    14  	}{
    15  		{`""`, `""`, ``},
    16  		{`"1234567890"`, `"1234567890"`, ``},
    17  		{`"Hello World!"`, `"Hello World!"`, ``},
    18  		{`"Hello\"World!"`, `"Hello\"World!"`, ``},
    19  		{`"\\"`, `"\\"`, ``},
    20  	}
    21  
    22  	for _, test := range tests {
    23  		t.Run(test.in, func(t *testing.T) {
    24  			out, ext, err := parseString([]byte(test.in))
    25  
    26  			if err != nil {
    27  				t.Errorf("%s => %s", test.in, err)
    28  				return
    29  			}
    30  
    31  			if s := string(out); s != test.out {
    32  				t.Error("invalid output")
    33  				t.Logf("expected: %s", test.out)
    34  				t.Logf("found:    %s", s)
    35  			}
    36  
    37  			if s := string(ext); s != test.ext {
    38  				t.Error("invalid extra bytes")
    39  				t.Logf("expected: %s", test.ext)
    40  				t.Logf("found:    %s", s)
    41  			}
    42  		})
    43  	}
    44  }
    45  
    46  func TestAppendToLower(t *testing.T) {
    47  	tests := []string{
    48  		"",
    49  		"A",
    50  		"a",
    51  		"__segment_internal",
    52  		"someFieldWithALongBName",
    53  		"Hello World!",
    54  		"Hello\"World!",
    55  		"Hello\\World!",
    56  		"Hello\nWorld!",
    57  		"Hello\rWorld!",
    58  		"Hello\tWorld!",
    59  		"Hello\bWorld!",
    60  		"Hello\fWorld!",
    61  		"你好",
    62  		"<",
    63  		">",
    64  		"&",
    65  		"\u001944",
    66  		"\u00c2e>",
    67  		"\u00c2V?",
    68  		"\u000e=8",
    69  		"\u001944\u00c2e>\u00c2V?\u000e=8",
    70  		"ir\u001bQJ\u007f\u0007y\u0015)",
    71  	}
    72  
    73  	for _, test := range tests {
    74  		s1 := strings.ToLower(test)
    75  		s2 := string(appendToLower(nil, []byte(test)))
    76  
    77  		if s1 != s2 {
    78  			t.Error("lowercase values mismatch")
    79  			t.Log("expected:", s1)
    80  			t.Log("found:   ", s2)
    81  		}
    82  	}
    83  }
    84  
    85  func BenchmarkParseString(b *testing.B) {
    86  	s := []byte(`"__segment_internal"`)
    87  
    88  	for i := 0; i != b.N; i++ {
    89  		parseString(s)
    90  	}
    91  }
    92  
    93  func BenchmarkToLower(b *testing.B) {
    94  	s := []byte("someFieldWithALongName")
    95  
    96  	for i := 0; i != b.N; i++ {
    97  		bytes.ToLower(s)
    98  	}
    99  }
   100  
   101  func BenchmarkAppendToLower(b *testing.B) {
   102  	a := []byte(nil)
   103  	s := []byte("someFieldWithALongName")
   104  
   105  	for i := 0; i != b.N; i++ {
   106  		a = appendToLower(a[:0], s)
   107  	}
   108  }
   109  
   110  var benchmarkHasPrefixString = []byte("some random string")
   111  var benchmarkHasPrefixResult = false
   112  
   113  func BenchmarkHasPrefix(b *testing.B) {
   114  	for i := 0; i < b.N; i++ {
   115  		benchmarkHasPrefixResult = hasPrefix(benchmarkHasPrefixString, "null")
   116  	}
   117  }
   118  
   119  func BenchmarkHasNullPrefix(b *testing.B) {
   120  	for i := 0; i < b.N; i++ {
   121  		benchmarkHasPrefixResult = hasNullPrefix(benchmarkHasPrefixString)
   122  	}
   123  }
   124  
   125  func BenchmarkHasTruePrefix(b *testing.B) {
   126  	for i := 0; i < b.N; i++ {
   127  		benchmarkHasPrefixResult = hasTruePrefix(benchmarkHasPrefixString)
   128  	}
   129  }
   130  
   131  func BenchmarkHasFalsePrefix(b *testing.B) {
   132  	for i := 0; i < b.N; i++ {
   133  		benchmarkHasPrefixResult = hasFalsePrefix(benchmarkHasPrefixString)
   134  	}
   135  }
   136  
   137  func BenchmarkParseStringEscapeNone(b *testing.B) {
   138  	var j = []byte(`"` + strings.Repeat(`a`, 1000) + `"`)
   139  	var s string
   140  	b.SetBytes(int64(len(j)))
   141  
   142  	for i := 0; i < b.N; i++ {
   143  		if err := Unmarshal(j, &s); err != nil {
   144  			b.Fatal(err)
   145  		}
   146  		s = ""
   147  	}
   148  }
   149  
   150  func BenchmarkParseStringEscapeOne(b *testing.B) {
   151  	var j = []byte(`"` + strings.Repeat(`a`, 998) + `\n"`)
   152  	var s string
   153  	b.SetBytes(int64(len(j)))
   154  
   155  	for i := 0; i < b.N; i++ {
   156  		if err := Unmarshal(j, &s); err != nil {
   157  			b.Fatal(err)
   158  		}
   159  		s = ""
   160  	}
   161  }
   162  
   163  func BenchmarkParseStringEscapeAll(b *testing.B) {
   164  	var j = []byte(`"` + strings.Repeat(`\`, 1000) + `"`)
   165  	var s string
   166  	b.SetBytes(int64(len(j)))
   167  
   168  	for i := 0; i < b.N; i++ {
   169  		if err := Unmarshal(j, &s); err != nil {
   170  			b.Fatal(err)
   171  		}
   172  		s = ""
   173  	}
   174  }