encode_slice_test.go (4706B)
1 package gojay 2 3 import ( 4 "strings" 5 "testing" 6 7 "github.com/stretchr/testify/require" 8 ) 9 10 func (s *slicesTestObject) MarshalJSONObject(enc *Encoder) { 11 enc.AddSliceStringKey("sliceString", s.sliceString) 12 enc.AddSliceIntKey("sliceInt", s.sliceInt) 13 enc.AddSliceFloat64Key("sliceFloat64", s.sliceFloat64) 14 enc.AddSliceBoolKey("sliceBool", s.sliceBool) 15 } 16 17 func (s *slicesTestObject) IsNil() bool { 18 return s == nil 19 } 20 21 func TestMarshalerJSONObjectArray(t *testing.T) { 22 testCases := []struct { 23 name string 24 json string 25 obj []*slicesTestObject 26 }{ 27 { 28 name: "basic slice", 29 json: `[{ 30 "sliceString": ["foo","bar"], 31 "sliceInt": [], 32 "sliceFloat64": [], 33 "sliceBool": [] 34 }]`, 35 obj: []*slicesTestObject{{ 36 sliceString: []string{"foo", "bar"}, 37 }}, 38 }, 39 { 40 name: "many slices", 41 json: `[{ 42 "sliceString": ["foo1","bar"], 43 "sliceInt": [], 44 "sliceFloat64": [], 45 "sliceBool": [] 46 }, { 47 "sliceString": ["foo2","bar"], 48 "sliceInt": [], 49 "sliceFloat64": [], 50 "sliceBool": [] 51 }, { 52 "sliceString": ["foo3","bar"], 53 "sliceInt": [], 54 "sliceFloat64": [], 55 "sliceBool": [] 56 }]`, 57 obj: []*slicesTestObject{{ 58 sliceString: []string{"foo1", "bar"}, 59 }, { 60 sliceString: []string{"foo2", "bar"}, 61 }, { 62 sliceString: []string{"foo3", "bar"}, 63 }}, 64 }, 65 } 66 67 for _, testCase := range testCases { 68 t.Run( 69 testCase.name, 70 func(t *testing.T) { 71 b := strings.Builder{} 72 enc := BorrowEncoder(&b) 73 err := enc.EncodeArray(MarshalerJSONObjectArray(testCase.obj)) 74 require.Nil(t, err, "err should be nil") 75 require.JSONEq(t, testCase.json, b.String()) 76 }, 77 ) 78 } 79 } 80 81 func TestEncodeSlices(t *testing.T) { 82 testCases := []struct { 83 name string 84 json string 85 obj slicesTestObject 86 }{ 87 { 88 name: "basic slice string", 89 json: `{ 90 "sliceString": ["foo","bar"], 91 "sliceInt": [], 92 "sliceFloat64": [], 93 "sliceBool": [] 94 }`, 95 obj: slicesTestObject{ 96 sliceString: []string{"foo", "bar"}, 97 }, 98 }, 99 { 100 name: "basic slice bool", 101 json: `{ 102 "sliceString": [], 103 "sliceInt": [], 104 "sliceFloat64": [], 105 "sliceBool": [true,false] 106 }`, 107 obj: slicesTestObject{ 108 sliceBool: []bool{true, false}, 109 }, 110 }, 111 { 112 name: "basic slice int", 113 json: `{ 114 "sliceString": [], 115 "sliceFloat64": [], 116 "sliceInt": [1,2,3], 117 "sliceBool": [] 118 }`, 119 obj: slicesTestObject{ 120 sliceInt: []int{1, 2, 3}, 121 }, 122 }, 123 { 124 name: "basic slice float64", 125 json: `{ 126 "sliceString": [], 127 "sliceFloat64": [1.3,2.4,3.1], 128 "sliceInt": [], 129 "sliceBool": [] 130 }`, 131 obj: slicesTestObject{ 132 sliceFloat64: []float64{1.3, 2.4, 3.1}, 133 }, 134 }, 135 } 136 137 for _, testCase := range testCases { 138 t.Run( 139 testCase.name, 140 func(t *testing.T) { 141 b := strings.Builder{} 142 enc := BorrowEncoder(&b) 143 err := enc.Encode(&testCase.obj) 144 require.Nil(t, err, "err should be nil") 145 require.JSONEq(t, testCase.json, b.String()) 146 }, 147 ) 148 } 149 } 150 151 type testSliceSliceString [][]string 152 153 func (t testSliceSliceString) MarshalJSONArray(enc *Encoder) { 154 for _, s := range t { 155 enc.AddSliceString(s) 156 } 157 } 158 159 func (t testSliceSliceString) IsNil() bool { 160 return t == nil 161 } 162 163 type testSliceSliceBool [][]bool 164 165 func (t testSliceSliceBool) MarshalJSONArray(enc *Encoder) { 166 for _, s := range t { 167 enc.AddSliceBool(s) 168 } 169 } 170 171 func (t testSliceSliceBool) IsNil() bool { 172 return t == nil 173 } 174 175 type testSliceSliceInt [][]int 176 177 func (t testSliceSliceInt) MarshalJSONArray(enc *Encoder) { 178 for _, s := range t { 179 enc.AddSliceInt(s) 180 } 181 } 182 183 func (t testSliceSliceInt) IsNil() bool { 184 return t == nil 185 } 186 187 type testSliceSliceFloat64 [][]float64 188 189 func (t testSliceSliceFloat64) MarshalJSONArray(enc *Encoder) { 190 for _, s := range t { 191 enc.AddSliceFloat64(s) 192 } 193 } 194 195 func (t testSliceSliceFloat64) IsNil() bool { 196 return t == nil 197 } 198 199 func TestEncodeSliceSlices(t *testing.T) { 200 testCases := []struct { 201 name string 202 s MarshalerJSONArray 203 json string 204 }{ 205 { 206 name: "slice of strings", 207 s: testSliceSliceString{ 208 []string{"foo", "bar"}, 209 }, 210 json: `[["foo","bar"]]`, 211 }, 212 { 213 name: "slice of ints", 214 s: testSliceSliceInt{ 215 []int{1, 2}, 216 }, 217 json: `[[1,2]]`, 218 }, 219 { 220 name: "slice of float", 221 s: testSliceSliceFloat64{ 222 []float64{1.1, 1.2}, 223 }, 224 json: `[[1.1,1.2]]`, 225 }, 226 { 227 name: "slice of bool", 228 s: testSliceSliceBool{ 229 []bool{true, false}, 230 }, 231 json: `[[true,false]]`, 232 }, 233 } 234 235 for _, testCase := range testCases { 236 t.Run( 237 testCase.name, 238 func(t *testing.T) { 239 b := strings.Builder{} 240 enc := BorrowEncoder(&b) 241 err := enc.Encode(testCase.s) 242 require.Nil(t, err, "err should be nil") 243 require.JSONEq(t, testCase.json, b.String()) 244 }, 245 ) 246 } 247 }