Debian Codegraph @

coding/base32/base32_unit_test.go

raw
1 package base32
2
3 import (
4 "bytes"
5 "errors"
6 "io"
7 "strings"
8 "testing"
9
10 "github.com/dromara/dongle/internal/mock"
11 "github.com/stretchr/testify/assert"
12 )
13
14 func TestStdEncoder_Encode(t *testing.T) {
15 t.Run("encode empty input", func(t *testing.T) {
16 encoder := NewStdEncoder(StdAlphabet)
17 result := encoder.Encode([]byte{})
18 assert.Nil(t, result)
19 assert.Nil(t, encoder.Error)
20 })
21
22 t.Run("encode simple string", func(t *testing.T) {
23 encoder := NewStdEncoder(StdAlphabet)
24 original := []byte("hello world")
25 encoded := encoder.Encode(original)
26 assert.Equal(t, []byte("NBSWY3DPEB3W64TMMQ======"), encoded)
27 assert.Nil(t, encoder.Error)
28 })
29
30 t.Run("encode unicode string", func(t *testing.T) {
31 encoder := NewStdEncoder(StdAlphabet)
32 original := []byte("你好世界")
33 encoded := encoder.Encode(original)
34 assert.Equal(t, []byte("4S62BZNFXXSLRFXHSWGA===="), encoded)
35 assert.Nil(t, encoder.Error)
36 })
37
38 t.Run("encode binary data", func(t *testing.T) {
39 encoder := NewStdEncoder(StdAlphabet)
40 original := []byte{0x00, 0x01, 0x02, 0x03}
41 encoded := encoder.Encode(original)
42 assert.Equal(t, []byte("AAAQEAY="), encoded)
43 assert.Nil(t, encoder.Error)
44 })
45
46 t.Run("encode single byte", func(t *testing.T) {
47 encoder := NewStdEncoder(StdAlphabet)
48 original := []byte{0x41}
49 encoded := encoder.Encode(original)
50 assert.Equal(t, []byte("IE======"), encoded)
51 assert.Nil(t, encoder.Error)
52 })
53
54 t.Run("encode two bytes", func(t *testing.T) {
55 encoder := NewStdEncoder(StdAlphabet)
56 original := []byte{0x41, 0x42}
57 encoded := encoder.Encode(original)
58 assert.Equal(t, []byte("IFBA===="), encoded)
59 assert.Nil(t, encoder.Error)
60 })
61
62 t.Run("encode with hex alphabet", func(t *testing.T) {
63 encoder := NewStdEncoder(HexAlphabet)
64 original := []byte("hello world")
65 encoded := encoder.Encode(original)
66 // Hex encoding should contain only hex characters (excluding padding)
67 resultStr := string(encoded)
68 for _, char := range resultStr {
69 if char != '=' {
70 assert.Contains(t, "0123456789ABCDEFGHIJKLMNOPQRSTUV", string(char))
71 }
72 }
73 assert.Nil(t, encoder.Error)
74 })
75
76 t.Run("encode large data", func(t *testing.T) {
77 encoder := NewStdEncoder(StdAlphabet)
78 original := bytes.Repeat([]byte("Hello, World! "), 100)
79 encoded := encoder.Encode(original)
80 assert.NotEmpty(t, encoded)
81 assert.Nil(t, encoder.Error)
82 })
83
84 t.Run("encode with leading zeros", func(t *testing.T) {
85 encoder := NewStdEncoder(StdAlphabet)
86 input := []byte{0x00, 0x00, 0x01, 0x02, 0x03}
87 result := encoder.Encode(input)
88 assert.Equal(t, []byte("AAAACAQD"), result)
89 assert.Nil(t, encoder.Error)
90 })
91
92 t.Run("encode with existing error", func(t *testing.T) {
93 encoder := NewStdEncoder("invalid")
94 result := encoder.Encode([]byte("hello"))
95 assert.Nil(t, result)
96 assert.NotNil(t, encoder.Error)
97 })
98
99 t.Run("write multiple times", func(t *testing.T) {
100 file := mock.NewFile(nil, "test.txt")
101 defer file.Close()
102 encoder := NewStreamEncoder(file, StdAlphabet)
103
104 data1 := []byte("hello")
105 data2 := []byte(" world")
106
107 n1, err1 := encoder.Write(data1)
108 n2, err2 := encoder.Write(data2)
109
110 assert.Equal(t, 5, n1)
111 assert.Nil(t, err1)
112 assert.Equal(t, 6, n2)
113 assert.Nil(t, err2)
114
115 err := encoder.Close()
116 assert.Nil(t, err)
117 assert.Equal(t, "NBSWY3DPEB3W64TMMQ======", string(file.Bytes()))
118 })
119
120 t.Run("close with data success", func(t *testing.T) {
121 file := mock.NewFile(nil, "test.txt")
122 defer file.Close()
123 encoder := NewStreamEncoder(file, StdAlphabet)
124
125 encoder.Write([]byte("test"))
126 err := encoder.Close()
127
128 assert.Nil(t, err)
129 assert.Equal(t, "ORSXG5A=", string(file.Bytes()))
130 })
131
132 t.Run("close with single byte", func(t *testing.T) {
133 file := mock.NewFile(nil, "test.txt")
134 defer file.Close()
135 encoder := NewStreamEncoder(file, StdAlphabet)
136
137 encoder.Write([]byte("a"))
138 err := encoder.Close()
139
140 assert.Nil(t, err)
141 assert.Equal(t, "ME======", string(file.Bytes()))
142 })
143
144 t.Run("close with two bytes", func(t *testing.T) {
145 file := mock.NewFile(nil, "test.txt")
146 defer file.Close()
147 encoder := NewStreamEncoder(file, StdAlphabet)
148
149 encoder.Write([]byte("ab"))
150 err := encoder.Close()
151
152 assert.Nil(t, err)
153 assert.Equal(t, "MFRA====", string(file.Bytes()))
154 })
155
156 t.Run("close with data", func(t *testing.T) {
157 file := mock.NewFile(nil, "test.txt")
158 defer file.Close()
159 encoder := NewStreamEncoder(file, StdAlphabet)
160
161 encoder.Write([]byte("hello"))
162 err := encoder.Close()
163
164 assert.Nil(t, err)
165 assert.Equal(t, "NBSWY3DP", string(file.Bytes()))
166 })
167 }
168
169 func TestStdDecoder_Decode(t *testing.T) {
170 t.Run("decode empty input", func(t *testing.T) {
171 decoder := NewStdDecoder(StdAlphabet)
172 result, err := decoder.Decode([]byte{})
173 assert.Nil(t, err)
174 assert.Nil(t, result)
175 })
176
177 t.Run("decode simple string", func(t *testing.T) {
178 decoder := NewStdDecoder(StdAlphabet)
179 encoded := []byte("NBSWY3DPEB3W64TMMQ======")
180 decoded, err := decoder.Decode(encoded)
181 assert.Nil(t, err)
182 assert.Equal(t, []byte("hello world"), decoded)
183 })
184
185 t.Run("decode unicode string", func(t *testing.T) {
186 decoder := NewStdDecoder(StdAlphabet)
187 encoded := []byte("4S62BZNFXXSLRFXHSWGA====")
188 decoded, err := decoder.Decode(encoded)
189 assert.Nil(t, err)
190 assert.Equal(t, []byte("你好世界"), decoded)
191 })
192
193 t.Run("decode binary data", func(t *testing.T) {
194 decoder := NewStdDecoder(StdAlphabet)
195 encoded := []byte("AAAQEAY=")
196 decoded, err := decoder.Decode(encoded)
197 assert.Nil(t, err)
198 assert.Equal(t, []byte{0x00, 0x01, 0x02, 0x03}, decoded)
199 })
200
201 t.Run("decode single character", func(t *testing.T) {
202 decoder := NewStdDecoder(StdAlphabet)
203 encoded := []byte("IE======")
204 decoded, err := decoder.Decode(encoded)
205 assert.Nil(t, err)
206 assert.Equal(t, []byte{0x41}, decoded)
207 })
208
209 t.Run("decode two characters", func(t *testing.T) {
210 decoder := NewStdDecoder(StdAlphabet)
211 encoded := []byte("IFBA====")
212 decoded, err := decoder.Decode(encoded)
213 assert.Nil(t, err)
214 assert.Equal(t, []byte{0x41, 0x42}, decoded)
215 })
216
217 t.Run("decode with hex alphabet", func(t *testing.T) {
218 // First encode some data with hex alphabet
219 input := []byte("hello world")
220 encoder := NewStdEncoder(HexAlphabet)
221 encoded := encoder.Encode(input)
222
223 // Then decode it
224 decoder := NewStdDecoder(HexAlphabet)
225 result, err := decoder.Decode(encoded)
226
227 assert.Nil(t, err)
228 assert.Equal(t, input, result)
229 })
230
231 t.Run("decode large data", func(t *testing.T) {
232 decoder := NewStdDecoder(StdAlphabet)
233 original := strings.Repeat("Hello, World! ", 100)
234 encoder := NewStdEncoder(StdAlphabet)
235 encoded := encoder.Encode([]byte(original))
236 decoded, err := decoder.Decode(encoded)
237 assert.Nil(t, err)
238 assert.Equal(t, []byte(original), decoded)
239 })
240
241 t.Run("decode invalid base32", func(t *testing.T) {
242 decoder := NewStdDecoder(StdAlphabet)
243 result, err := decoder.Decode([]byte("invalid!"))
244 assert.Error(t, err)
245 assert.Nil(t, result)
246 assert.Contains(t, err.Error(), "illegal data")
247 })
248
249 t.Run("decode invalid padding", func(t *testing.T) {
250 decoder := NewStdDecoder(StdAlphabet)
251 result, err := decoder.Decode([]byte("NBSWY3DPEB3W64TMMQ=====!"))
252 assert.Error(t, err)
253 assert.Nil(t, result)
254 assert.Contains(t, err.Error(), "illegal data")
255 })
256
257 t.Run("decode with existing error", func(t *testing.T) {
258 decoder := NewStdDecoder("invalid")
259 result, err := decoder.Decode([]byte("JBSWY3DP"))
260 assert.Nil(t, result)
261 assert.NotNil(t, err)
262 assert.Equal(t, "coding/base32: invalid alphabet, the alphabet length must be 32, got 7", err.Error())
263 })
264 }
265
266 func TestStreamEncoder_Write(t *testing.T) {
267 t.Run("write data", func(t *testing.T) {
268 file := mock.NewFile(nil, "test.txt")
269 defer file.Close()
270 encoder := NewStreamEncoder(file, StdAlphabet)
271
272 data := []byte("hello")
273 n, err := encoder.Write(data)
274
275 assert.Equal(t, 5, n)
276 assert.Nil(t, err)
277 })
278
279 t.Run("write multiple times", func(t *testing.T) {
280 file := mock.NewFile(nil, "test.txt")
281 defer file.Close()
282 encoder := NewStreamEncoder(file, StdAlphabet)
283
284 data1 := []byte("hello")
285 data2 := []byte(" world")
286
287 n1, err1 := encoder.Write(data1)
288 n2, err2 := encoder.Write(data2)
289
290 assert.Equal(t, 5, n1)
291 assert.Nil(t, err1)
292 assert.Equal(t, 6, n2)
293 assert.Nil(t, err2)
294 })
295
296 t.Run("write with error", func(t *testing.T) {
297 // Since NewStreamEncoder returns standard library type, we can't test Error field directly
298 // This test is removed as it's not applicable to the current implementation
299 })
300
301 t.Run("write empty data", func(t *testing.T) {
302 file := mock.NewFile(nil, "test.txt")
303 defer file.Close()
304 encoder := NewStreamEncoder(file, StdAlphabet)
305
306 var data []byte
307 n, err := encoder.Write(data)
308
309 assert.Equal(t, 0, n)
310 assert.Nil(t, err)
311 })
312
313 t.Run("write with hex alphabet", func(t *testing.T) {
314 file := mock.NewFile(nil, "test.txt")
315 defer file.Close()
316 encoder := NewStreamEncoder(file, HexAlphabet)
317
318 data := []byte("hello world")
319 n, err := encoder.Write(data)
320
321 assert.Equal(t, 11, n)
322 assert.Nil(t, err)
323 })
324
325 t.Run("write with writer error", func(t *testing.T) {
326 // Test that Write properly handles writer errors
327 errorWriter := mock.NewErrorWriteCloser(errors.New("writer error"))
328 encoder := NewStreamEncoder(errorWriter, StdAlphabet)
329
330 // Write data that will trigger encoding and writing
331 data := []byte("hello") // 5 bytes = complete block
332 n, err := encoder.Write(data)
333
334 assert.Equal(t, 5, n)
335 assert.Error(t, err)
336 assert.Equal(t, "writer error", err.Error())
337 })
338
339 t.Run("write with invalid alphabet length", func(t *testing.T) {
340 // Test NewStreamEncoder with invalid alphabet length
341 encoder := NewStreamEncoder(nil, "invalid")
342 // Type assert to access Error field
343 streamEncoder := encoder.(*StreamEncoder)
344 assert.Error(t, streamEncoder.Error)
345 assert.Contains(t, streamEncoder.Error.Error(), "invalid alphabet")
346 })
347
348 t.Run("write with exact block size", func(t *testing.T) {
349 file := mock.NewFile(nil, "test.txt")
350 defer file.Close()
351 encoder := NewStreamEncoder(file, StdAlphabet)
352
353 // Write exactly 5 bytes (complete block, no remainder)
354 data := []byte("hello") // 5 bytes = complete block
355 n, err := encoder.Write(data)
356
357 assert.Equal(t, 5, n)
358 assert.Nil(t, err)
359 assert.NotEmpty(t, string(file.Bytes())) // Should have written encoded data
360 })
361
362 t.Run("write with multiple complete blocks", func(t *testing.T) {
363 file := mock.NewFile(nil, "test.txt")
364 defer file.Close()
365 encoder := NewStreamEncoder(file, StdAlphabet)
366
367 // Write 10 bytes (2 complete blocks, no remainder)
368 data := []byte("helloworld") // 10 bytes = 2 complete blocks
369 n, err := encoder.Write(data)
370
371 assert.Equal(t, 10, n)
372 assert.Nil(t, err)
373 assert.NotEmpty(t, string(file.Bytes())) // Should have written encoded data
374 })
375
376 t.Run("write with existing error", func(t *testing.T) {
377 // Test Write when encoder already has an error
378 encoder := &StreamEncoder{Error: errors.New("existing error")}
379
380 data := []byte("hello")
381 n, err := encoder.Write(data)
382
383 assert.Equal(t, 0, n)
384 assert.Error(t, err)
385 assert.Equal(t, "existing error", err.Error())
386 })
387
388 t.Run("write with no remainder", func(t *testing.T) {
389 file := mock.NewFile(nil, "test.txt")
390 defer file.Close()
391 encoder := NewStreamEncoder(file, StdAlphabet)
392
393 // Write exactly 5 bytes (complete block, no remainder)
394 data := []byte("hello") // 5 bytes = complete block
395 n, err := encoder.Write(data)
396
397 assert.Equal(t, 5, n)
398 assert.Nil(t, err)
399 assert.NotEmpty(t, string(file.Bytes()))
400 // Verify that no bytes are buffered (remainder = 0)
401 streamEncoder := encoder.(*StreamEncoder)
402 assert.Empty(t, streamEncoder.buffer)
403 })
404 }
405
406 func TestStreamEncoder_Close(t *testing.T) {
407 t.Run("close with data", func(t *testing.T) {
408 file := mock.NewFile(nil, "test.txt")
409 defer file.Close()
410 encoder := NewStreamEncoder(file, StdAlphabet)
411
412 encoder.Write([]byte("hello"))
413 err := encoder.Close()
414
415 assert.Nil(t, err)
416 assert.Equal(t, "NBSWY3DP", string(file.Bytes()))
417 })
418
419 t.Run("close without data", func(t *testing.T) {
420 file := mock.NewFile(nil, "test.txt")
421 defer file.Close()
422 encoder := NewStreamEncoder(file, StdAlphabet)
423
424 err := encoder.Close()
425 assert.Nil(t, err)
426 assert.Empty(t, string(file.Bytes()))
427 })
428
429 t.Run("close with error", func(t *testing.T) {
430 // Since NewStreamEncoder returns standard library type, we can't test Error field directly
431 // This test is removed as it's not applicable to the current implementation
432 })
433
434 t.Run("close with write error", func(t *testing.T) {
435 errorWriter := mock.NewErrorWriteCloser(errors.New("write error"))
436 encoder := NewStreamEncoder(errorWriter, StdAlphabet)
437
438 // Write 1 byte (incomplete block) so it gets buffered
439 encoder.Write([]byte("a"))
440 err := encoder.Close()
441
442 assert.Error(t, err)
443 assert.Equal(t, "write error", err.Error())
444 })
445
446 t.Run("close with 3 bytes buffered", func(t *testing.T) {
447 file := mock.NewFile(nil, "test.txt")
448 defer file.Close()
449 encoder := NewStreamEncoder(file, StdAlphabet)
450
451 // Write 3 bytes (incomplete block)
452 encoder.Write([]byte("abc"))
453 err := encoder.Close()
454
455 assert.Nil(t, err)
456 // 3 bytes should produce 5 characters + 3 padding
457 assert.Contains(t, string(file.Bytes()), "===")
458 })
459
460 t.Run("close with 4 bytes buffered", func(t *testing.T) {
461 file := mock.NewFile(nil, "test.txt")
462 defer file.Close()
463 encoder := NewStreamEncoder(file, StdAlphabet)
464
465 // Write 4 bytes (incomplete block)
466 encoder.Write([]byte("abcd"))
467 err := encoder.Close()
468
469 assert.Nil(t, err)
470 // 4 bytes should produce 7 characters + 1 padding
471 assert.Contains(t, string(file.Bytes()), "=")
472 })
473
474 t.Run("close with no buffered data", func(t *testing.T) {
475 file := mock.NewFile(nil, "test.txt")
476 defer file.Close()
477 encoder := NewStreamEncoder(file, StdAlphabet)
478
479 // Write complete blocks only, no remainder
480 encoder.Write([]byte("hello")) // 5 bytes = complete block
481 err := encoder.Close()
482
483 assert.Nil(t, err)
484 // Should have written the complete block
485 assert.NotEmpty(t, string(file.Bytes()))
486 })
487
488 t.Run("close with write error during padding", func(t *testing.T) {
489 // Test that Close properly handles write errors when encoding padded data
490 errorWriter := mock.NewErrorWriteCloser(errors.New("padding write error"))
491 encoder := NewStreamEncoder(errorWriter, StdAlphabet)
492
493 // Write 1 byte (incomplete block) so it gets buffered
494 encoder.Write([]byte("a"))
495 err := encoder.Close()
496
497 assert.Error(t, err)
498 assert.Equal(t, "padding write error", err.Error())
499 })
500
501 t.Run("close with write error during padding for 2 bytes", func(t *testing.T) {
502 // Test that Close properly handles write errors when encoding 2-byte padded data
503 errorWriter := mock.NewErrorWriteCloser(errors.New("padding write error 2"))
504 encoder := NewStreamEncoder(errorWriter, StdAlphabet)
505
506 // Write 2 bytes (incomplete block) so it gets buffered
507 encoder.Write([]byte("ab"))
508 err := encoder.Close()
509
510 assert.Error(t, err)
511 assert.Equal(t, "padding write error 2", err.Error())
512 })
513
514 t.Run("close with write error during padding for 3 bytes", func(t *testing.T) {
515 // Test that Close properly handles write errors when encoding 3-byte padded data
516 errorWriter := mock.NewErrorWriteCloser(errors.New("padding write error 3"))
517 encoder := NewStreamEncoder(errorWriter, StdAlphabet)
518
519 // Write 3 bytes (incomplete block) so it gets buffered
520 encoder.Write([]byte("abc"))
521 err := encoder.Close()
522
523 assert.Error(t, err)
524 assert.Equal(t, "padding write error 3", err.Error())
525 })
526
527 t.Run("close with write error during padding for 4 bytes", func(t *testing.T) {
528 // Test that Close properly handles write errors when encoding 4-byte padded data
529 errorWriter := mock.NewErrorWriteCloser(errors.New("padding write error 4"))
530 encoder := NewStreamEncoder(errorWriter, StdAlphabet)
531
532 // Write 4 bytes (incomplete block) so it gets buffered
533 encoder.Write([]byte("abcd"))
534 err := encoder.Close()
535
536 assert.Error(t, err)
537 assert.Equal(t, "padding write error 4", err.Error())
538 })
539
540 t.Run("close with existing error", func(t *testing.T) {
541 // Test Close when encoder already has an error
542 encoder := &StreamEncoder{Error: errors.New("existing close error")}
543
544 err := encoder.Close()
545
546 assert.Error(t, err)
547 assert.Equal(t, "existing close error", err.Error())
548 })
549 }
550
551 func TestStreamDecoder_Read(t *testing.T) {
552 t.Run("read decoded data", func(t *testing.T) {
553 encoded := "NBSWY3DP"
554 file := mock.NewFile([]byte(encoded), "test.txt")
555 defer file.Close()
556 decoder := NewStreamDecoder(file, StdAlphabet)
557
558 buf := make([]byte, 20)
559 n, err := decoder.Read(buf)
560
561 assert.Equal(t, 5, n)
562 assert.Nil(t, err)
563 assert.Equal(t, []byte("hello"), buf[:n])
564 })
565
566 t.Run("read with large buffer", func(t *testing.T) {
567 encoded := "NBSWY3DP"
568 file := mock.NewFile([]byte(encoded), "test.txt")
569 defer file.Close()
570 decoder := NewStreamDecoder(file, StdAlphabet)
571
572 buf := make([]byte, 100)
573 n, err := decoder.Read(buf)
574
575 assert.Equal(t, 5, n)
576 assert.Nil(t, err)
577 assert.Equal(t, []byte("hello"), buf[:n])
578 })
579
580 t.Run("read with small buffer", func(t *testing.T) {
581 encoded := "NBSWY3DP"
582 file := mock.NewFile([]byte(encoded), "test.txt")
583 defer file.Close()
584 decoder := NewStreamDecoder(file, StdAlphabet)
585
586 buf := make([]byte, 3)
587 n, err := decoder.Read(buf)
588
589 assert.Equal(t, 3, n)
590 assert.Nil(t, err)
591 assert.Equal(t, []byte("hel"), buf)
592
593 n2, err2 := decoder.Read(buf)
594 assert.Equal(t, 2, n2)
595 assert.Nil(t, err2)
596 assert.Equal(t, []byte("lo"), buf[:n2])
597 })
598
599 t.Run("read with error", func(t *testing.T) {
600 // Since NewStreamDecoder returns standard library type, we can't test Error field directly
601 // This test is removed as it's not applicable to the current implementation
602 })
603
604 t.Run("read with decode error", func(t *testing.T) {
605 file := mock.NewFile([]byte("invalid!"), "test.txt")
606 defer file.Close()
607 decoder := NewStreamDecoder(file, StdAlphabet)
608
609 buf := make([]byte, 10)
610 n, err := decoder.Read(buf)
611
612 assert.Equal(t, 0, n)
613 assert.Error(t, err)
614 assert.Contains(t, err.Error(), "illegal base32 data")
615 })
616
617 t.Run("read with reader error", func(t *testing.T) {
618 errorReader := mock.NewErrorFile(errors.New("read error"))
619 decoder := NewStreamDecoder(errorReader, StdAlphabet)
620
621 buf := make([]byte, 10)
622 n, err := decoder.Read(buf)
623
624 assert.Equal(t, 0, n)
625 assert.Error(t, err)
626 assert.Equal(t, "read error", err.Error())
627 })
628
629 t.Run("read eof", func(t *testing.T) {
630 file := mock.NewFile([]byte{}, "test.txt")
631 defer file.Close()
632 decoder := NewStreamDecoder(file, StdAlphabet)
633
634 buf := make([]byte, 10)
635 n, err := decoder.Read(buf)
636
637 assert.Equal(t, 0, n)
638 assert.Equal(t, io.EOF, err)
639 })
640
641 t.Run("read with hex alphabet", func(t *testing.T) {
642 // First encode with hex alphabet
643 file := mock.NewFile(nil, "test.txt")
644 defer file.Close()
645 encoder := NewStreamEncoder(file, HexAlphabet)
646 _, err := encoder.Write([]byte("hello world"))
647 assert.Nil(t, err)
648 err = encoder.Close()
649 assert.Nil(t, err)
650
651 // Reset file position for reading
652 file.Reset()
653
654 // Then decode with hex alphabet
655 decoder := NewStreamDecoder(file, HexAlphabet)
656
657 buf := make([]byte, 20)
658 n, err := decoder.Read(buf)
659 assert.Nil(t, err)
660 assert.Equal(t, 11, n)
661 assert.Equal(t, []byte("hello world"), buf[:n])
662 })
663
664 t.Run("read with decode error", func(t *testing.T) {
665 // Test that Read properly handles decode errors
666 file := mock.NewFile([]byte("INVALID!"), "test.txt")
667 defer file.Close()
668 decoder := NewStreamDecoder(file, StdAlphabet)
669
670 buf := make([]byte, 10)
671 n, err := decoder.Read(buf)
672
673 assert.Equal(t, 0, n)
674 assert.Error(t, err)
675 assert.Contains(t, err.Error(), "illegal base32 data")
676 })
677
678 t.Run("read with invalid alphabet length", func(t *testing.T) {
679 // Test NewStreamDecoder with invalid alphabet length
680 decoder := NewStreamDecoder(nil, "invalid")
681 // Type assert to access Error field
682 streamDecoder := decoder.(*StreamDecoder)
683 assert.Error(t, streamDecoder.Error)
684 assert.Contains(t, streamDecoder.Error.Error(), "invalid alphabet")
685 })
686
687 t.Run("read with large buffer fits all data", func(t *testing.T) {
688 // Test that Read handles case where buffer can fit all decoded data
689 encoded := "NBSWY3DP"
690 file := mock.NewFile([]byte(encoded), "test.txt")
691 defer file.Close()
692 decoder := NewStreamDecoder(file, StdAlphabet)
693
694 // Use a large buffer that can fit all decoded data
695 buf := make([]byte, 100)
696 n, err := decoder.Read(buf)
697
698 assert.Equal(t, 5, n)
699 assert.Nil(t, err)
700 assert.Equal(t, []byte("hello"), buf[:n])
701 })
702
703 t.Run("read with existing error", func(t *testing.T) {
704 // Test Read when decoder already has an error
705 decoder := &StreamDecoder{Error: errors.New("existing error")}
706
707 buf := make([]byte, 10)
708 n, err := decoder.Read(buf)
709
710 assert.Equal(t, 0, n)
711 assert.Error(t, err)
712 assert.Equal(t, "existing error", err.Error())
713 })
714 }
715
716 func TestStdError(t *testing.T) {
717 t.Run("decode invalid character", func(t *testing.T) {
718 decoder := NewStdDecoder(StdAlphabet)
719 result, err := decoder.Decode([]byte("invalid!"))
720 assert.Error(t, err)
721 assert.Nil(t, result)
722 })
723
724 t.Run("decode invalid padding", func(t *testing.T) {
725 decoder := NewStdDecoder(StdAlphabet)
726 result, err := decoder.Decode([]byte("NBSWY3DPEB3W64TMMQ=====!"))
727 assert.Error(t, err)
728 assert.Nil(t, result)
729 })
730
731 t.Run("encoder invalid alphabet", func(t *testing.T) {
732 encoder := NewStdEncoder("invalid")
733 assert.NotNil(t, encoder.Error)
734 assert.Equal(t, "coding/base32: invalid alphabet, the alphabet length must be 32, got 7", encoder.Error.Error())
735 })
736
737 t.Run("decoder invalid alphabet", func(t *testing.T) {
738 decoder := NewStdDecoder("invalid")
739 assert.NotNil(t, decoder.Error)
740 assert.Equal(t, "coding/base32: invalid alphabet, the alphabet length must be 32, got 7", decoder.Error.Error())
741 })
742
743 t.Run("invalid alphabet error message", func(t *testing.T) {
744 err := AlphabetSizeError(30)
745 expected := "coding/base32: invalid alphabet, the alphabet length must be 32, got 30"
746 assert.Equal(t, expected, err.Error())
747 })
748
749 t.Run("corrupt input error message", func(t *testing.T) {
750 err := CorruptInputError(5)
751 expected := "coding/base32: illegal data at input byte 5"
752 assert.Equal(t, expected, err.Error())
753 })
754
755 t.Run("corrupt input error with zero", func(t *testing.T) {
756 err := CorruptInputError(0)
757 expected := "coding/base32: illegal data at input byte 0"
758 assert.Equal(t, expected, err.Error())
759 })
760 }
761
762 func TestStreamError(t *testing.T) {
763 t.Run("stream encoder close with writer error", func(t *testing.T) {
764 errorWriter := mock.NewErrorWriteCloser(assert.AnError)
765 encoder := NewStreamEncoder(errorWriter, StdAlphabet)
766 _, err := encoder.Write([]byte("test"))
767 assert.NoError(t, err)
768
769 err = encoder.Close()
770 assert.Equal(t, assert.AnError, err)
771 })
772
773 t.Run("stream decoder with reader error", func(t *testing.T) {
774 errorReader := mock.NewErrorFile(assert.AnError)
775 decoder := NewStreamDecoder(errorReader, StdAlphabet)
776
777 buf := make([]byte, 10)
778 n, err := decoder.Read(buf)
779 assert.Equal(t, assert.AnError, err)
780 assert.Equal(t, 0, n)
781 })
782
783 t.Run("stream decoder with decode error", func(t *testing.T) {
784 file := mock.NewFile([]byte("invalid!"), "test.txt")
785 defer file.Close()
786 decoder := NewStreamDecoder(file, StdAlphabet)
787
788 buf := make([]byte, 10)
789 n, err := decoder.Read(buf)
790 assert.Error(t, err)
791 assert.Equal(t, 0, n)
792 })
793
794 t.Run("stream decoder with mock error reader", func(t *testing.T) {
795 errorReader := mock.NewErrorReadWriteCloser(assert.AnError)
796 decoder := NewStreamDecoder(errorReader, StdAlphabet)
797
798 buf := make([]byte, 10)
799 n, err := decoder.Read(buf)
800 assert.Equal(t, assert.AnError, err)
801 assert.Equal(t, 0, n)
802 })
803
804 t.Run("read with invalid data", func(t *testing.T) {
805 file := mock.NewFile([]byte("invalid!"), "test.txt")
806 defer file.Close()
807 decoder := NewStreamDecoder(file, StdAlphabet)
808
809 buf := make([]byte, 10)
810 n, err := decoder.Read(buf)
811 assert.Error(t, err)
812 assert.Equal(t, 0, n)
813 })
814
815 t.Run("stream encoder with existing error", func(t *testing.T) {
816 // Since NewStreamEncoder returns standard library type, we can't test Error field directly
817 // This test is removed as it's not applicable to the current implementation
818 })
819
820 t.Run("stream encoder close with existing error", func(t *testing.T) {
821 // Since NewStreamEncoder returns standard library type, we can't test Error field directly
822 // This test is removed as it's not applicable to the current implementation
823 })
824
825 t.Run("stream decoder with existing error", func(t *testing.T) {
826 // Since NewStreamDecoder returns standard library type, we can't test Error field directly
827 // This test is removed as it's not applicable to the current implementation
828 })
829 }
830
831 func TestCustomAlphabets(t *testing.T) {
832 t.Run("verify custom alphabets", func(t *testing.T) {
833 // Test that they produce different results
834 testData := []byte("hello world")
835
836 stdEncoder := NewStdEncoder(StdAlphabet)
837 assert.Nil(t, stdEncoder.Error)
838 stdResult := stdEncoder.Encode(testData)
839
840 hexEncoder := NewStdEncoder(HexAlphabet)
841 assert.Nil(t, hexEncoder.Error)
842 hexResult := hexEncoder.Encode(testData)
843
844 // Results should be different
845 assert.NotEqual(t, string(stdResult), string(hexResult))
846 })
847
848 t.Run("alphabet length verification", func(t *testing.T) {
849 assert.Equal(t, 32, len(StdAlphabet))
850 assert.Equal(t, 32, len(HexAlphabet))
851 })
852
853 t.Run("alphabet character uniqueness", func(t *testing.T) {
854 // Check StdAlphabet uniqueness
855 seen := make(map[rune]bool)
856 for _, char := range StdAlphabet {
857 assert.False(t, seen[char], "Duplicate character in StdAlphabet: %c", char)
858 seen[char] = true
859 }
860
861 // Check HexAlphabet uniqueness
862 seen = make(map[rune]bool)
863 for _, char := range HexAlphabet {
864 assert.False(t, seen[char], "Duplicate character in HexAlphabet: %c", char)
865 seen[char] = true
866 }
867 })
868 }
869
870 func TestRoundTrip(t *testing.T) {
871 t.Run("std encoder decoder round trip", func(t *testing.T) {
872 testData := []byte("Hello, World! 你好世界")
873
874 encoder := NewStdEncoder(StdAlphabet)
875 assert.Nil(t, encoder.Error)
876 encoded := encoder.Encode(testData)
877
878 decoder := NewStdDecoder(StdAlphabet)
879 assert.Nil(t, decoder.Error)
880 decoded, err := decoder.Decode(encoded)
881
882 assert.NoError(t, err)
883 assert.Equal(t, testData, decoded)
884 })
885
886 t.Run("hex encoder decoder round trip", func(t *testing.T) {
887 testData := []byte("Hello, World! 你好世界")
888
889 encoder := NewStdEncoder(HexAlphabet)
890 assert.Nil(t, encoder.Error)
891 encoded := encoder.Encode(testData)
892
893 decoder := NewStdDecoder(HexAlphabet)
894 assert.Nil(t, decoder.Error)
895 decoded, err := decoder.Decode(encoded)
896
897 assert.NoError(t, err)
898 assert.Equal(t, testData, decoded)
899 })
900
901 t.Run("stream encoder decoder round trip", func(t *testing.T) {
902 testData := []byte("Hello, World! 你好世界")
903
904 // Encode
905 file := mock.NewFile(nil, "test.txt")
906 defer file.Close()
907 encoder := NewStreamEncoder(file, StdAlphabet)
908 _, err := encoder.Write(testData)
909 assert.NoError(t, err)
910 err = encoder.Close()
911 assert.NoError(t, err)
912
913 // Reset file position for reading
914 file.Reset()
915
916 // Decode
917 decoder := NewStreamDecoder(file, StdAlphabet)
918
919 buf := make([]byte, 1024)
920 n, err := decoder.Read(buf)
921 assert.NoError(t, err)
922
923 assert.Equal(t, testData, buf[:n])
924 })
925 }
926
927 func TestEdgeCases(t *testing.T) {
928 t.Run("very large data", func(t *testing.T) {
929 // Create large test data
930 largeData := bytes.Repeat([]byte("Hello, World! "), 1000)
931
932 encoder := NewStdEncoder(StdAlphabet)
933 assert.Nil(t, encoder.Error)
934 encoded := encoder.Encode(largeData)
935
936 decoder := NewStdDecoder(StdAlphabet)
937 assert.Nil(t, decoder.Error)
938 decoded, err := decoder.Decode(encoded)
939
940 assert.NoError(t, err)
941 assert.Equal(t, largeData, decoded)
942 })
943
944 t.Run("single character encoding", func(t *testing.T) {
945 encoder := NewStdEncoder(StdAlphabet)
946 assert.Nil(t, encoder.Error)
947 result := encoder.Encode([]byte("A"))
948 assert.NotEmpty(t, result)
949 assert.True(t, strings.HasSuffix(string(result), "======"))
950 })
951
952 t.Run("padding edge cases", func(t *testing.T) {
953 // Test different padding scenarios
954 testCases := []struct {
955 input []byte
956 expected string
957 }{
958 {[]byte{0x00}, "AA======"},
959 {[]byte{0x00, 0x00}, "AAAA===="},
960 {[]byte{0x00, 0x00, 0x00}, "AAAAA==="},
961 {[]byte{0x00, 0x00, 0x00, 0x00}, "AAAAAAA="},
962 }
963
964 encoder := NewStdEncoder(StdAlphabet)
965 assert.Nil(t, encoder.Error)
966
967 for _, tc := range testCases {
968 result := encoder.Encode(tc.input)
969 assert.Equal(t, tc.expected, string(result))
970 }
971 })
972
973 t.Run("nil input handling", func(t *testing.T) {
974 encoder := NewStdEncoder(StdAlphabet)
975 assert.Nil(t, encoder.Error)
976 result := encoder.Encode(nil)
977 assert.Nil(t, result)
978
979 decoder := NewStdDecoder(StdAlphabet)
980 assert.Nil(t, decoder.Error)
981 result2, err := decoder.Decode(nil)
982 assert.Nil(t, err)
983 assert.Nil(t, result2)
984 })
985 }