github.com/bingoohuang/gg@v0.0.0-20240325092523-45da7dee9335/pkg/jsoni/iter_skip_sloppy_test.go (about)

     1  //go:build jsoniter_sloppy
     2  // +build jsoniter_sloppy
     3  
     4  package jsoni
     5  
     6  import (
     7  	"io"
     8  	"testing"
     9  
    10  	"github.com/stretchr/testify/require"
    11  )
    12  
    13  func Test_string_end(t *testing.T) {
    14  	end, escaped := ParseString(ConfigDefault, `abc"`).findStringEnd()
    15  	if end != 4 {
    16  		t.Fatal(end)
    17  	}
    18  	if escaped != false {
    19  		t.Fatal(escaped)
    20  	}
    21  	end, escaped = ParseString(ConfigDefault, `abc\\"`).findStringEnd()
    22  	if end != 6 {
    23  		t.Fatal(end)
    24  	}
    25  	if escaped != true {
    26  		t.Fatal(escaped)
    27  	}
    28  	end, escaped = ParseString(ConfigDefault, `abc\\\\"`).findStringEnd()
    29  	if end != 8 {
    30  		t.Fatal(end)
    31  	}
    32  	if escaped != true {
    33  		t.Fatal(escaped)
    34  	}
    35  	end, escaped = ParseString(ConfigDefault, `abc\"`).findStringEnd()
    36  	if end != -1 {
    37  		t.Fatal(end)
    38  	}
    39  	if escaped != false {
    40  		t.Fatal(escaped)
    41  	}
    42  	end, escaped = ParseString(ConfigDefault, `abc\`).findStringEnd()
    43  	if end != -1 {
    44  		t.Fatal(end)
    45  	}
    46  	if escaped != true {
    47  		t.Fatal(escaped)
    48  	}
    49  	end, escaped = ParseString(ConfigDefault, `abc\\`).findStringEnd()
    50  	if end != -1 {
    51  		t.Fatal(end)
    52  	}
    53  	if escaped != false {
    54  		t.Fatal(escaped)
    55  	}
    56  	end, escaped = ParseString(ConfigDefault, `\\`).findStringEnd()
    57  	if end != -1 {
    58  		t.Fatal(end)
    59  	}
    60  	if escaped != false {
    61  		t.Fatal(escaped)
    62  	}
    63  	end, escaped = ParseString(ConfigDefault, `\`).findStringEnd()
    64  	if end != -1 {
    65  		t.Fatal(end)
    66  	}
    67  	if escaped != true {
    68  		t.Fatal(escaped)
    69  	}
    70  }
    71  
    72  type StagedReader struct {
    73  	r1 string
    74  	r2 string
    75  	r3 string
    76  	r  int
    77  }
    78  
    79  func (reader *StagedReader) Read(p []byte) (n int, err error) {
    80  	reader.r++
    81  	switch reader.r {
    82  	case 1:
    83  		copy(p, []byte(reader.r1))
    84  		return len(reader.r1), nil
    85  	case 2:
    86  		copy(p, []byte(reader.r2))
    87  		return len(reader.r2), nil
    88  	case 3:
    89  		copy(p, []byte(reader.r3))
    90  		return len(reader.r3), nil
    91  	default:
    92  		return 0, io.EOF
    93  	}
    94  }
    95  
    96  func Test_skip_string(t *testing.T) {
    97  	should := require.New(t)
    98  	iter := ParseString(ConfigDefault, `"abc`)
    99  	iter.skipString()
   100  	should.Equal(1, iter.head)
   101  	iter = ParseString(ConfigDefault, `\""abc`)
   102  	iter.skipString()
   103  	should.Equal(3, iter.head)
   104  	reader := &StagedReader{
   105  		r1: `abc`,
   106  		r2: `"`,
   107  	}
   108  	iter = Parse(ConfigDefault, reader, 4096)
   109  	iter.skipString()
   110  	should.Equal(1, iter.head)
   111  	reader = &StagedReader{
   112  		r1: `abc`,
   113  		r2: `1"`,
   114  	}
   115  	iter = Parse(ConfigDefault, reader, 4096)
   116  	iter.skipString()
   117  	should.Equal(2, iter.head)
   118  	reader = &StagedReader{
   119  		r1: `abc\`,
   120  		r2: `"`,
   121  	}
   122  	iter = Parse(ConfigDefault, reader, 4096)
   123  	iter.skipString()
   124  	should.NotNil(iter.Error)
   125  	reader = &StagedReader{
   126  		r1: `abc\`,
   127  		r2: `""`,
   128  	}
   129  	iter = Parse(ConfigDefault, reader, 4096)
   130  	iter.skipString()
   131  	should.Equal(2, iter.head)
   132  }
   133  
   134  func Test_skip_object(t *testing.T) {
   135  	iter := ParseString(ConfigDefault, `}`)
   136  	iter.skipObject()
   137  	if iter.head != 1 {
   138  		t.Fatal(iter.head)
   139  	}
   140  	iter = ParseString(ConfigDefault, `a}`)
   141  	iter.skipObject()
   142  	if iter.head != 2 {
   143  		t.Fatal(iter.head)
   144  	}
   145  	iter = ParseString(ConfigDefault, `{}}a`)
   146  	iter.skipObject()
   147  	if iter.head != 3 {
   148  		t.Fatal(iter.head)
   149  	}
   150  	reader := &StagedReader{
   151  		r1: `{`,
   152  		r2: `}}a`,
   153  	}
   154  	iter = Parse(ConfigDefault, reader, 4096)
   155  	iter.skipObject()
   156  	if iter.head != 2 {
   157  		t.Fatal(iter.head)
   158  	}
   159  	iter = ParseString(ConfigDefault, `"}"}a`)
   160  	iter.skipObject()
   161  	if iter.head != 4 {
   162  		t.Fatal(iter.head)
   163  	}
   164  }