encode_number_test.go (14876B)
1 package gojay 2 3 import ( 4 "strings" 5 "testing" 6 7 "fmt" 8 "math" 9 10 "github.com/stretchr/testify/assert" 11 ) 12 13 func TestEncoderNumberEncodeAPI(t *testing.T) { 14 t.Run("encoder-int", func(t *testing.T) { 15 builder := &strings.Builder{} 16 enc := NewEncoder(builder) 17 err := enc.EncodeInt(1) 18 assert.Nil(t, err, "Error should be nil") 19 assert.Equal( 20 t, 21 `1`, 22 builder.String(), 23 "Result of marshalling is different as the one expected") 24 }) 25 t.Run("encode-int64", func(t *testing.T) { 26 builder := &strings.Builder{} 27 enc := NewEncoder(builder) 28 err := enc.EncodeInt64(math.MaxInt64) 29 assert.Nil(t, err, "Error should be nil") 30 assert.Equal( 31 t, 32 fmt.Sprintf("%d", math.MaxInt64), 33 builder.String(), 34 "Result of marshalling is different as the one expected") 35 }) 36 t.Run("encode-uint64", func(t *testing.T) { 37 builder := &strings.Builder{} 38 enc := NewEncoder(builder) 39 err := enc.EncodeUint64(uint64(math.MaxUint64)) 40 assert.Nil(t, err, "Error should be nil") 41 assert.Equal( 42 t, 43 fmt.Sprintf("%d", uint64(math.MaxUint64)), 44 builder.String(), 45 "Result of marshalling is different as the one expected") 46 }) 47 t.Run("encode-float64", func(t *testing.T) { 48 builder := &strings.Builder{} 49 enc := NewEncoder(builder) 50 err := enc.EncodeFloat(float64(1.1)) 51 assert.Nil(t, err, "Error should be nil") 52 assert.Equal( 53 t, 54 `1.1`, 55 builder.String(), 56 "Result of marshalling is different as the one expected") 57 }) 58 t.Run("encode-float32", func(t *testing.T) { 59 builder := &strings.Builder{} 60 enc := NewEncoder(builder) 61 err := enc.EncodeFloat32(float32(1.12)) 62 assert.Nil(t, err, "Error should be nil") 63 assert.Equal( 64 t, 65 `1.12`, 66 builder.String(), 67 "Result of marshalling is different as the one expected") 68 69 }) 70 } 71 72 func TestEncoderNumberEncodeAPIErrors(t *testing.T) { 73 t.Run("encode-int-pool-error", func(t *testing.T) { 74 builder := &strings.Builder{} 75 enc := NewEncoder(builder) 76 enc.isPooled = 1 77 defer func() { 78 err := recover() 79 assert.NotNil(t, err, "err should not be nil") 80 assert.IsType(t, InvalidUsagePooledEncoderError(""), err, "err should be of type InvalidUsagePooledEncoderError") 81 }() 82 _ = enc.EncodeInt(1) 83 assert.True(t, false, "should not be called as encoder should have panicked") 84 }) 85 t.Run("encode-int-write-error", func(t *testing.T) { 86 w := TestWriterError("") 87 enc := NewEncoder(w) 88 err := enc.EncodeInt(1) 89 assert.NotNil(t, err, "err should not be nil") 90 assert.Equal(t, "Test Error", err.Error(), "err should be of type InvalidUsagePooledEncoderError") 91 }) 92 t.Run("encode-int64-pool-error", func(t *testing.T) { 93 builder := &strings.Builder{} 94 enc := NewEncoder(builder) 95 enc.isPooled = 1 96 defer func() { 97 err := recover() 98 assert.NotNil(t, err, "err should not be nil") 99 assert.IsType(t, InvalidUsagePooledEncoderError(""), err, "err should be of type InvalidUsagePooledEncoderError") 100 }() 101 _ = enc.EncodeInt64(1) 102 assert.True(t, false, "should not be called as encoder should have panicked") 103 }) 104 t.Run("encode-int64-write-error", func(t *testing.T) { 105 w := TestWriterError("") 106 enc := NewEncoder(w) 107 err := enc.EncodeInt64(1) 108 assert.NotNil(t, err, "err should not be nil") 109 assert.Equal(t, "Test Error", err.Error(), "err should be of type InvalidUsagePooledEncoderError") 110 111 }) 112 t.Run("encode-uint64-pool-error", func(t *testing.T) { 113 builder := &strings.Builder{} 114 enc := NewEncoder(builder) 115 enc.isPooled = 1 116 defer func() { 117 err := recover() 118 assert.NotNil(t, err, "err should not be nil") 119 assert.IsType(t, InvalidUsagePooledEncoderError(""), err, "err should be of type InvalidUsagePooledEncoderError") 120 }() 121 _ = enc.EncodeUint64(1) 122 assert.True(t, false, "should not be called as encoder should have panicked") 123 }) 124 t.Run("encode-unt64-write-error", func(t *testing.T) { 125 w := TestWriterError("") 126 enc := NewEncoder(w) 127 err := enc.EncodeUint64(1) 128 assert.NotNil(t, err, "err should not be nil") 129 assert.Equal(t, "Test Error", err.Error(), "err should be of type InvalidUsagePooledEncoderError") 130 131 }) 132 t.Run("encode-float64-pool-error", func(t *testing.T) { 133 builder := &strings.Builder{} 134 enc := NewEncoder(builder) 135 enc.isPooled = 1 136 defer func() { 137 err := recover() 138 assert.NotNil(t, err, "err should not be nil") 139 assert.IsType(t, InvalidUsagePooledEncoderError(""), err, "err should be of type InvalidUsagePooledEncoderError") 140 }() 141 _ = enc.EncodeFloat(1.1) 142 assert.True(t, false, "should not be called as encoder should have panicked") 143 }) 144 t.Run("encode-float64-write-error", func(t *testing.T) { 145 w := TestWriterError("") 146 enc := NewEncoder(w) 147 err := enc.EncodeFloat(1.1) 148 assert.NotNil(t, err, "err should not be nil") 149 assert.Equal(t, "Test Error", err.Error(), "err should be of type InvalidUsagePooledEncoderError") 150 }) 151 t.Run("encode-float32-pool-error", func(t *testing.T) { 152 builder := &strings.Builder{} 153 enc := NewEncoder(builder) 154 enc.isPooled = 1 155 defer func() { 156 err := recover() 157 assert.NotNil(t, err, "err should not be nil") 158 assert.IsType(t, InvalidUsagePooledEncoderError(""), err, "err should be of type InvalidUsagePooledEncoderError") 159 }() 160 _ = enc.EncodeFloat32(float32(1.1)) 161 assert.True(t, false, "should not be called as encoder should have panicked") 162 }) 163 t.Run("encode-float32-write-error", func(t *testing.T) { 164 w := TestWriterError("") 165 enc := NewEncoder(w) 166 err := enc.EncodeFloat32(float32(1.1)) 167 assert.NotNil(t, err, "err should not be nil") 168 assert.Equal(t, "Test Error", err.Error(), "err should be of type InvalidUsagePooledEncoderError") 169 }) 170 } 171 172 func TestEncoderNumberMarshalAPI(t *testing.T) { 173 t.Run("int", func(t *testing.T) { 174 r, err := Marshal(1) 175 assert.Nil(t, err, "Error should be nil") 176 assert.Equal( 177 t, 178 `1`, 179 string(r), 180 "Result of marshalling is different as the one expected") 181 }) 182 t.Run("int64", func(t *testing.T) { 183 r, err := Marshal(int64(1)) 184 assert.Nil(t, err, "Error should be nil") 185 assert.Equal( 186 t, 187 `1`, 188 string(r), 189 "Result of marshalling is different as the one expected") 190 }) 191 t.Run("int32", func(t *testing.T) { 192 r, err := Marshal(int32(1)) 193 assert.Nil(t, err, "Error should be nil") 194 assert.Equal( 195 t, 196 `1`, 197 string(r), 198 "Result of marshalling is different as the one expected") 199 }) 200 t.Run("int16", func(t *testing.T) { 201 r, err := Marshal(int16(1)) 202 assert.Nil(t, err, "Error should be nil") 203 assert.Equal( 204 t, 205 `1`, 206 string(r), 207 "Result of marshalling is different as the one expected") 208 }) 209 t.Run("int8", func(t *testing.T) { 210 r, err := Marshal(int8(1)) 211 assert.Nil(t, err, "Error should be nil") 212 assert.Equal( 213 t, 214 `1`, 215 string(r), 216 "Result of marshalling is different as the one expected") 217 }) 218 t.Run("uint64", func(t *testing.T) { 219 r, err := Marshal(uint64(1)) 220 assert.Nil(t, err, "Error should be nil") 221 assert.Equal( 222 t, 223 `1`, 224 string(r), 225 "Result of marshalling is different as the one expected") 226 }) 227 t.Run("uint32", func(t *testing.T) { 228 r, err := Marshal(uint32(1)) 229 assert.Nil(t, err, "Error should be nil") 230 assert.Equal( 231 t, 232 `1`, 233 string(r), 234 "Result of marshalling is different as the one expected") 235 }) 236 t.Run("uint16", func(t *testing.T) { 237 r, err := Marshal(uint16(1)) 238 assert.Nil(t, err, "Error should be nil") 239 assert.Equal( 240 t, 241 `1`, 242 string(r), 243 "Result of marshalling is different as the one expected") 244 }) 245 t.Run("uint8", func(t *testing.T) { 246 r, err := Marshal(uint8(1)) 247 assert.Nil(t, err, "Error should be nil") 248 assert.Equal( 249 t, 250 `1`, 251 string(r), 252 "Result of marshalling is different as the one expected") 253 }) 254 t.Run("float64", func(t *testing.T) { 255 r, err := Marshal(1.1) 256 assert.Nil(t, err, "Error should be nil") 257 assert.Equal( 258 t, 259 `1.1`, 260 string(r), 261 "Result of marshalling is different as the one expected") 262 }) 263 } 264 265 func TestAddNumberFunc(t *testing.T) { 266 t.Run("int64-key", func(t *testing.T) { 267 builder := &strings.Builder{} 268 enc := BorrowEncoder(builder) 269 enc.writeByte('{') 270 enc.AddInt64Key("test", 10) 271 _, err := enc.Write() 272 assert.Nil(t, err, "err should be nil") 273 assert.Equal(t, `{"test":10`, builder.String(), `builder.String() should be equal to {"test":10"`) 274 }) 275 t.Run("int64-key-2", func(t *testing.T) { 276 builder := &strings.Builder{} 277 enc := BorrowEncoder(builder) 278 enc.writeBytes([]byte(`{"test":1`)) 279 enc.AddInt64Key("test", 10) 280 _, err := enc.Write() 281 assert.Nil(t, err, "err should be nil") 282 assert.Equal(t, `{"test":1,"test":10`, builder.String(), `builder.String() should be equal to {"test":10"`) 283 }) 284 285 t.Run("int64-key-omit-empty", func(t *testing.T) { 286 builder := &strings.Builder{} 287 enc := BorrowEncoder(builder) 288 enc.writeByte('{') 289 enc.AddInt64KeyOmitEmpty("test", 10) 290 _, err := enc.Write() 291 assert.Nil(t, err, "err should be nil") 292 assert.Equal(t, `{"test":10`, builder.String(), `builder.String() should be equal to {"test":10"`) 293 }) 294 t.Run("int64-key-omit-empty-2", func(t *testing.T) { 295 builder := &strings.Builder{} 296 enc := BorrowEncoder(builder) 297 enc.writeBytes([]byte(`{"test":1`)) 298 enc.AddInt64KeyOmitEmpty("test", 10) 299 _, err := enc.Write() 300 assert.Nil(t, err, "err should be nil") 301 assert.Equal(t, `{"test":1,"test":10`, builder.String(), `builder.String() should be equal to {"test":10"`) 302 }) 303 t.Run("int64-key-omit-empty-3", func(t *testing.T) { 304 builder := &strings.Builder{} 305 enc := BorrowEncoder(builder) 306 enc.writeByte('{') 307 enc.AddInt64KeyOmitEmpty("test", 0) 308 _, err := enc.Write() 309 assert.Nil(t, err, "err should be nil") 310 assert.Equal(t, `{`, builder.String(), `builder.String() should be equal to {"test":10"`) 311 }) 312 t.Run("int64", func(t *testing.T) { 313 builder := &strings.Builder{} 314 enc := BorrowEncoder(builder) 315 enc.writeByte('[') 316 enc.AddInt64(10) 317 _, err := enc.Write() 318 assert.Nil(t, err, "err should be nil") 319 assert.Equal(t, `[10`, builder.String(), `builder.String() should be equal to {"test":10"`) 320 }) 321 t.Run("int64-2", func(t *testing.T) { 322 builder := &strings.Builder{} 323 enc := BorrowEncoder(builder) 324 enc.writeBytes([]byte(`[1`)) 325 enc.AddInt64(10) 326 _, err := enc.Write() 327 assert.Nil(t, err, "err should be nil") 328 assert.Equal(t, `[1,10`, builder.String(), `builder.String() should be equal to {"test":10"`) 329 }) 330 331 t.Run("int64-omit-empty", func(t *testing.T) { 332 builder := &strings.Builder{} 333 enc := BorrowEncoder(builder) 334 enc.writeByte('[') 335 enc.AddInt64OmitEmpty(10) 336 _, err := enc.Write() 337 assert.Nil(t, err, "err should be nil") 338 assert.Equal(t, `[10`, builder.String(), `builder.String() should be equal to {"test":10"`) 339 }) 340 t.Run("int64-omit-empty-2", func(t *testing.T) { 341 builder := &strings.Builder{} 342 enc := BorrowEncoder(builder) 343 enc.writeBytes([]byte(`[1`)) 344 enc.AddInt64OmitEmpty(10) 345 _, err := enc.Write() 346 assert.Nil(t, err, "err should be nil") 347 assert.Equal(t, `[1,10`, builder.String(), `builder.String() should be equal to {"test":10"`) 348 }) 349 t.Run("int64-omit-empty-3", func(t *testing.T) { 350 builder := &strings.Builder{} 351 enc := BorrowEncoder(builder) 352 enc.writeByte('[') 353 enc.AddInt64OmitEmpty(0) 354 _, err := enc.Write() 355 assert.Nil(t, err, "err should be nil") 356 assert.Equal(t, `[`, builder.String(), `builder.String() should be equal to {"test":10"`) 357 }) 358 } 359 360 func TestEncodeUint64(t *testing.T) { 361 builder := &strings.Builder{} 362 enc := BorrowEncoder(builder) 363 err := enc.Encode(uint64(145509)) 364 assert.Nil(t, err, "err should be nil") 365 assert.Equal(t, "145509", builder.String(), "builder.String() should be 145509") 366 } 367 368 func TestUint64Add(t *testing.T) { 369 t.Run("uint64-key", func(t *testing.T) { 370 builder := &strings.Builder{} 371 enc := BorrowEncoder(builder) 372 enc.writeByte('{') 373 enc.AddUint64Key("test", 10) 374 _, err := enc.Write() 375 assert.Nil(t, err, "err should be nil") 376 assert.Equal(t, `{"test":10`, builder.String(), `builder.String() should be equal to {"test":10"`) 377 }) 378 t.Run("uint64-key-2", func(t *testing.T) { 379 builder := &strings.Builder{} 380 enc := BorrowEncoder(builder) 381 enc.writeBytes([]byte(`{"test":1`)) 382 enc.AddUint64Key("test", 10) 383 _, err := enc.Write() 384 assert.Nil(t, err, "err should be nil") 385 assert.Equal(t, `{"test":1,"test":10`, builder.String(), `builder.String() should be equal to {"test":10"`) 386 }) 387 388 t.Run("uint64-key-omit-empty", func(t *testing.T) { 389 builder := &strings.Builder{} 390 enc := BorrowEncoder(builder) 391 enc.writeByte('{') 392 enc.AddUint64KeyOmitEmpty("test", 10) 393 _, err := enc.Write() 394 assert.Nil(t, err, "err should be nil") 395 assert.Equal(t, `{"test":10`, builder.String(), `builder.String() should be equal to {"test":10"`) 396 }) 397 t.Run("uint64-key-omit-empty-2", func(t *testing.T) { 398 builder := &strings.Builder{} 399 enc := BorrowEncoder(builder) 400 enc.writeBytes([]byte(`{"test":1`)) 401 enc.AddUint64KeyOmitEmpty("test", 10) 402 _, err := enc.Write() 403 assert.Nil(t, err, "err should be nil") 404 assert.Equal(t, `{"test":1,"test":10`, builder.String(), `builder.String() should be equal to {"test":10"`) 405 }) 406 t.Run("uint64-key-omit-empty-3", func(t *testing.T) { 407 builder := &strings.Builder{} 408 enc := BorrowEncoder(builder) 409 enc.writeByte('{') 410 enc.AddUint64KeyOmitEmpty("test", 0) 411 _, err := enc.Write() 412 assert.Nil(t, err, "err should be nil") 413 assert.Equal(t, `{`, builder.String(), `builder.String() should be equal to {"test":10"`) 414 }) 415 t.Run("uint64", func(t *testing.T) { 416 builder := &strings.Builder{} 417 enc := BorrowEncoder(builder) 418 enc.writeByte('[') 419 enc.AddUint64(10) 420 _, err := enc.Write() 421 assert.Nil(t, err, "err should be nil") 422 assert.Equal(t, `[10`, builder.String(), `builder.String() should be equal to {"test":10"`) 423 }) 424 t.Run("uint64-2", func(t *testing.T) { 425 builder := &strings.Builder{} 426 enc := BorrowEncoder(builder) 427 enc.writeBytes([]byte(`[1`)) 428 enc.AddUint64(10) 429 _, err := enc.Write() 430 assert.Nil(t, err, "err should be nil") 431 assert.Equal(t, `[1,10`, builder.String(), `builder.String() should be equal to {"test":10"`) 432 }) 433 434 t.Run("uint64-omit-empty", func(t *testing.T) { 435 builder := &strings.Builder{} 436 enc := BorrowEncoder(builder) 437 enc.writeByte('[') 438 enc.AddUint64OmitEmpty(10) 439 _, err := enc.Write() 440 assert.Nil(t, err, "err should be nil") 441 assert.Equal(t, `[10`, builder.String(), `builder.String() should be equal to {"test":10"`) 442 }) 443 t.Run("uint64-omit-empty-2", func(t *testing.T) { 444 builder := &strings.Builder{} 445 enc := BorrowEncoder(builder) 446 enc.writeBytes([]byte(`[1`)) 447 enc.AddUint64OmitEmpty(10) 448 _, err := enc.Write() 449 assert.Nil(t, err, "err should be nil") 450 assert.Equal(t, `[1,10`, builder.String(), `builder.String() should be equal to {"test":10"`) 451 }) 452 t.Run("uint64-omit-empty-3", func(t *testing.T) { 453 builder := &strings.Builder{} 454 enc := BorrowEncoder(builder) 455 enc.writeByte('[') 456 enc.AddUint64OmitEmpty(0) 457 _, err := enc.Write() 458 assert.Nil(t, err, "err should be nil") 459 assert.Equal(t, `[`, builder.String(), `builder.String() should be equal to {"test":10"`) 460 }) 461 }