1
2
3
4
5 package ascii85
6
7 import (
8 "bytes"
9 "io"
10 "strings"
11 "testing"
12 )
13
14 type testpair struct {
15 decoded, encoded string
16 }
17
18 var bigtest = testpair{
19 "Man is distinguished, not only by his reason, but by this singular passion from " +
20 "other animals, which is a lust of the mind, that by a perseverance of delight in " +
21 "the continued and indefatigable generation of knowledge, exceeds the short " +
22 "vehemence of any carnal pleasure.",
23 "9jqo^BlbD-BleB1DJ+*+F(f,q/0JhKF<GL>Cj@.4Gp$d7F!,L7@<6@)/0JDEF<G%<+EV:2F!,\n" +
24 "O<DJ+*.@<*K0@<6L(Df-\\0Ec5e;DffZ(EZee.Bl.9pF\"AGXBPCsi+DGm>@3BB/F*&OCAfu2/AKY\n" +
25 "i(DIb:@FD,*)+C]U=@3BN#EcYf8ATD3s@q?d$AftVqCh[NqF<G:8+EV:.+Cf>-FD5W8ARlolDIa\n" +
26 "l(DId<j@<?3r@:F%a+D58'ATD4$Bl@l3De:,-DJs`8ARoFb/0JMK@qB4^F!,R<AKZ&-DfTqBG%G\n" +
27 ">uD.RTpAKYo'+CT/5+Cei#DII?(E,9)oF*2M7/c\n",
28 }
29
30 var pairs = []testpair{
31
32 {
33 "",
34 "",
35 },
36
37 bigtest,
38
39 {
40 "\000\000\000\000",
41 "z",
42 },
43 }
44
45 func testEqual(t *testing.T, msg string, args ...any) bool {
46 t.Helper()
47 if args[len(args)-2] != args[len(args)-1] {
48 t.Errorf(msg, args...)
49 return false
50 }
51 return true
52 }
53
54 func strip85(s string) string {
55 t := make([]byte, len(s))
56 w := 0
57 for r := 0; r < len(s); r++ {
58 c := s[r]
59 if c > ' ' {
60 t[w] = c
61 w++
62 }
63 }
64 return string(t[0:w])
65 }
66
67 func TestEncode(t *testing.T) {
68 for _, p := range pairs {
69 buf := make([]byte, MaxEncodedLen(len(p.decoded)))
70 n := Encode(buf, []byte(p.decoded))
71 buf = buf[0:n]
72 testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(string(buf)), strip85(p.encoded))
73 }
74 }
75
76 func TestEncoder(t *testing.T) {
77 for _, p := range pairs {
78 bb := &strings.Builder{}
79 encoder := NewEncoder(bb)
80 encoder.Write([]byte(p.decoded))
81 encoder.Close()
82 testEqual(t, "Encode(%q) = %q, want %q", p.decoded, strip85(bb.String()), strip85(p.encoded))
83 }
84 }
85
86 func TestEncoderBuffering(t *testing.T) {
87 input := []byte(bigtest.decoded)
88 for bs := 1; bs <= 12; bs++ {
89 bb := &strings.Builder{}
90 encoder := NewEncoder(bb)
91 for pos := 0; pos < len(input); pos += bs {
92 end := pos + bs
93 if end > len(input) {
94 end = len(input)
95 }
96 n, err := encoder.Write(input[pos:end])
97 testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, error(nil))
98 testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos)
99 }
100 err := encoder.Close()
101 testEqual(t, "Close gave error %v, want %v", err, error(nil))
102 testEqual(t, "Encoding/%d of %q = %q, want %q", bs, bigtest.decoded, strip85(bb.String()), strip85(bigtest.encoded))
103 }
104 }
105
106 func TestDecode(t *testing.T) {
107 for _, p := range pairs {
108 dbuf := make([]byte, 4*len(p.encoded))
109 ndst, nsrc, err := Decode(dbuf, []byte(p.encoded), true)
110 testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, error(nil))
111 testEqual(t, "Decode(%q) = nsrc %v, want %v", p.encoded, nsrc, len(p.encoded))
112 testEqual(t, "Decode(%q) = ndst %v, want %v", p.encoded, ndst, len(p.decoded))
113 testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:ndst]), p.decoded)
114 }
115 }
116
117 func TestDecoder(t *testing.T) {
118 for _, p := range pairs {
119 decoder := NewDecoder(strings.NewReader(p.encoded))
120 dbuf, err := io.ReadAll(decoder)
121 if err != nil {
122 t.Fatalf("Read from %q = %v, want nil", p.encoded, err)
123 }
124 testEqual(t, "Read from %q = length %v, want %v", p.encoded, len(dbuf), len(p.decoded))
125 testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf), p.decoded)
126 }
127 }
128
129 func TestDecoderBuffering(t *testing.T) {
130 for bs := 1; bs <= 12; bs++ {
131 decoder := NewDecoder(strings.NewReader(bigtest.encoded))
132 buf := make([]byte, len(bigtest.decoded)+12)
133 var total int
134 var n int
135 var err error
136 for total = 0; total < len(bigtest.decoded) && err == nil; {
137 n, err = decoder.Read(buf[total : total+bs])
138 total += n
139 }
140 if err != nil && err != io.EOF {
141 t.Errorf("Read from %q at pos %d = %d, unexpected error %v", bigtest.encoded, total, n, err)
142 }
143 testEqual(t, "Decoding/%d of %q = %q, want %q", bs, bigtest.encoded, string(buf[0:total]), bigtest.decoded)
144 }
145 }
146
147 func TestDecodeCorrupt(t *testing.T) {
148 type corrupt struct {
149 e string
150 p int
151 }
152 examples := []corrupt{
153 {"v", 0},
154 {"!z!!!!!!!!!", 1},
155 }
156
157 for _, e := range examples {
158 dbuf := make([]byte, 4*len(e.e))
159 _, _, err := Decode(dbuf, []byte(e.e), true)
160 switch err := err.(type) {
161 case CorruptInputError:
162 testEqual(t, "Corruption in %q at offset %v, want %v", e.e, int(err), e.p)
163 default:
164 t.Error("Decoder failed to detect corruption in", e)
165 }
166 }
167 }
168
169 func TestBig(t *testing.T) {
170 n := 3*1000 + 1
171 raw := make([]byte, n)
172 const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
173 for i := 0; i < n; i++ {
174 raw[i] = alpha[i%len(alpha)]
175 }
176 encoded := new(bytes.Buffer)
177 w := NewEncoder(encoded)
178 nn, err := w.Write(raw)
179 if nn != n || err != nil {
180 t.Fatalf("Encoder.Write(raw) = %d, %v want %d, nil", nn, err, n)
181 }
182 err = w.Close()
183 if err != nil {
184 t.Fatalf("Encoder.Close() = %v want nil", err)
185 }
186 decoded, err := io.ReadAll(NewDecoder(encoded))
187 if err != nil {
188 t.Fatalf("io.ReadAll(NewDecoder(...)): %v", err)
189 }
190
191 if !bytes.Equal(raw, decoded) {
192 var i int
193 for i = 0; i < len(decoded) && i < len(raw); i++ {
194 if decoded[i] != raw[i] {
195 break
196 }
197 }
198 t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i)
199 }
200 }
201
202 func TestDecoderInternalWhitespace(t *testing.T) {
203 s := strings.Repeat(" ", 2048) + "z"
204 decoded, err := io.ReadAll(NewDecoder(strings.NewReader(s)))
205 if err != nil {
206 t.Errorf("Decode gave error %v", err)
207 }
208 if want := []byte("\000\000\000\000"); !bytes.Equal(want, decoded) {
209 t.Errorf("Decode failed: got %v, want %v", decoded, want)
210 }
211 }
212
View as plain text