Source file src/encoding/base32/base32_test.go

Documentation: encoding/base32

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package base32
     6  
     7  import (
     8  	"bytes"
     9  	"errors"
    10  	"io"
    11  	"strings"
    12  	"testing"
    13  )
    14  
    15  type testpair struct {
    16  	decoded, encoded string
    17  }
    18  
    19  var pairs = []testpair{
    20  	// RFC 4648 examples
    21  	{"", ""},
    22  	{"f", "MY======"},
    23  	{"fo", "MZXQ===="},
    24  	{"foo", "MZXW6==="},
    25  	{"foob", "MZXW6YQ="},
    26  	{"fooba", "MZXW6YTB"},
    27  	{"foobar", "MZXW6YTBOI======"},
    28  
    29  	// Wikipedia examples, converted to base32
    30  	{"sure.", "ON2XEZJO"},
    31  	{"sure", "ON2XEZI="},
    32  	{"sur", "ON2XE==="},
    33  	{"su", "ON2Q===="},
    34  	{"leasure.", "NRSWC43VOJSS4==="},
    35  	{"easure.", "MVQXG5LSMUXA===="},
    36  	{"asure.", "MFZXK4TFFY======"},
    37  	{"sure.", "ON2XEZJO"},
    38  }
    39  
    40  var bigtest = testpair{
    41  	"Twas brillig, and the slithy toves",
    42  	"KR3WC4ZAMJZGS3DMNFTSYIDBNZSCA5DIMUQHG3DJORUHSIDUN53GK4Y=",
    43  }
    44  
    45  func testEqual(t *testing.T, msg string, args ...interface{}) 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 TestEncode(t *testing.T) {
    55  	for _, p := range pairs {
    56  		got := StdEncoding.EncodeToString([]byte(p.decoded))
    57  		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, got, p.encoded)
    58  	}
    59  }
    60  
    61  func TestEncoder(t *testing.T) {
    62  	for _, p := range pairs {
    63  		bb := &bytes.Buffer{}
    64  		encoder := NewEncoder(StdEncoding, bb)
    65  		encoder.Write([]byte(p.decoded))
    66  		encoder.Close()
    67  		testEqual(t, "Encode(%q) = %q, want %q", p.decoded, bb.String(), p.encoded)
    68  	}
    69  }
    70  
    71  func TestEncoderBuffering(t *testing.T) {
    72  	input := []byte(bigtest.decoded)
    73  	for bs := 1; bs <= 12; bs++ {
    74  		bb := &bytes.Buffer{}
    75  		encoder := NewEncoder(StdEncoding, bb)
    76  		for pos := 0; pos < len(input); pos += bs {
    77  			end := pos + bs
    78  			if end > len(input) {
    79  				end = len(input)
    80  			}
    81  			n, err := encoder.Write(input[pos:end])
    82  			testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, error(nil))
    83  			testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos)
    84  		}
    85  		err := encoder.Close()
    86  		testEqual(t, "Close gave error %v, want %v", err, error(nil))
    87  		testEqual(t, "Encoding/%d of %q = %q, want %q", bs, bigtest.decoded, bb.String(), bigtest.encoded)
    88  	}
    89  }
    90  
    91  func TestDecode(t *testing.T) {
    92  	for _, p := range pairs {
    93  		dbuf := make([]byte, StdEncoding.DecodedLen(len(p.encoded)))
    94  		count, end, err := StdEncoding.decode(dbuf, []byte(p.encoded))
    95  		testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, error(nil))
    96  		testEqual(t, "Decode(%q) = length %v, want %v", p.encoded, count, len(p.decoded))
    97  		if len(p.encoded) > 0 {
    98  			testEqual(t, "Decode(%q) = end %v, want %v", p.encoded, end, (p.encoded[len(p.encoded)-1] == '='))
    99  		}
   100  		testEqual(t, "Decode(%q) = %q, want %q", p.encoded,
   101  			string(dbuf[0:count]),
   102  			p.decoded)
   103  
   104  		dbuf, err = StdEncoding.DecodeString(p.encoded)
   105  		testEqual(t, "DecodeString(%q) = error %v, want %v", p.encoded, err, error(nil))
   106  		testEqual(t, "DecodeString(%q) = %q, want %q", p.encoded, string(dbuf), p.decoded)
   107  	}
   108  }
   109  
   110  func TestDecoder(t *testing.T) {
   111  	for _, p := range pairs {
   112  		decoder := NewDecoder(StdEncoding, strings.NewReader(p.encoded))
   113  		dbuf := make([]byte, StdEncoding.DecodedLen(len(p.encoded)))
   114  		count, err := decoder.Read(dbuf)
   115  		if err != nil && err != io.EOF {
   116  			t.Fatal("Read failed", err)
   117  		}
   118  		testEqual(t, "Read from %q = length %v, want %v", p.encoded, count, len(p.decoded))
   119  		testEqual(t, "Decoding of %q = %q, want %q", p.encoded, string(dbuf[0:count]), p.decoded)
   120  		if err != io.EOF {
   121  			_, err = decoder.Read(dbuf)
   122  		}
   123  		testEqual(t, "Read from %q = %v, want %v", p.encoded, err, io.EOF)
   124  	}
   125  }
   126  
   127  type badReader struct {
   128  	data   []byte
   129  	errs   []error
   130  	called int
   131  	limit  int
   132  }
   133  
   134  // Populates p with data, returns a count of the bytes written and an
   135  // error.  The error returned is taken from badReader.errs, with each
   136  // invocation of Read returning the next error in this slice, or io.EOF,
   137  // if all errors from the slice have already been returned.  The
   138  // number of bytes returned is determined by the size of the input buffer
   139  // the test passes to decoder.Read and will be a multiple of 8, unless
   140  // badReader.limit is non zero.
   141  func (b *badReader) Read(p []byte) (int, error) {
   142  	lim := len(p)
   143  	if b.limit != 0 && b.limit < lim {
   144  		lim = b.limit
   145  	}
   146  	if len(b.data) < lim {
   147  		lim = len(b.data)
   148  	}
   149  	for i := range p[:lim] {
   150  		p[i] = b.data[i]
   151  	}
   152  	b.data = b.data[lim:]
   153  	err := io.EOF
   154  	if b.called < len(b.errs) {
   155  		err = b.errs[b.called]
   156  	}
   157  	b.called++
   158  	return lim, err
   159  }
   160  
   161  // TestIssue20044 tests that decoder.Read behaves correctly when the caller
   162  // supplied reader returns an error.
   163  func TestIssue20044(t *testing.T) {
   164  	badErr := errors.New("bad reader error")
   165  	testCases := []struct {
   166  		r       badReader
   167  		res     string
   168  		err     error
   169  		dbuflen int
   170  	}{
   171  		// Check valid input data accompanied by an error is processed and the error is propagated.
   172  		{r: badReader{data: []byte("MY======"), errs: []error{badErr}},
   173  			res: "f", err: badErr},
   174  		// Check a read error accompanied by input data consisting of newlines only is propagated.
   175  		{r: badReader{data: []byte("\n\n\n\n\n\n\n\n"), errs: []error{badErr, nil}},
   176  			res: "", err: badErr},
   177  		// Reader will be called twice.  The first time it will return 8 newline characters.  The
   178  		// second time valid base32 encoded data and an error.  The data should be decoded
   179  		// correctly and the error should be propagated.
   180  		{r: badReader{data: []byte("\n\n\n\n\n\n\n\nMY======"), errs: []error{nil, badErr}},
   181  			res: "f", err: badErr, dbuflen: 8},
   182  		// Reader returns invalid input data (too short) and an error.  Verify the reader
   183  		// error is returned.
   184  		{r: badReader{data: []byte("MY====="), errs: []error{badErr}},
   185  			res: "", err: badErr},
   186  		// Reader returns invalid input data (too short) but no error.  Verify io.ErrUnexpectedEOF
   187  		// is returned.
   188  		{r: badReader{data: []byte("MY====="), errs: []error{nil}},
   189  			res: "", err: io.ErrUnexpectedEOF},
   190  		// Reader returns invalid input data and an error.  Verify the reader and not the
   191  		// decoder error is returned.
   192  		{r: badReader{data: []byte("Ma======"), errs: []error{badErr}},
   193  			res: "", err: badErr},
   194  		// Reader returns valid data and io.EOF.  Check data is decoded and io.EOF is propagated.
   195  		{r: badReader{data: []byte("MZXW6YTB"), errs: []error{io.EOF}},
   196  			res: "fooba", err: io.EOF},
   197  		// Check errors are properly reported when decoder.Read is called multiple times.
   198  		// decoder.Read will be called 8 times, badReader.Read will be called twice, returning
   199  		// valid data both times but an error on the second call.
   200  		{r: badReader{data: []byte("NRSWC43VOJSS4==="), errs: []error{nil, badErr}},
   201  			res: "leasure.", err: badErr, dbuflen: 1},
   202  		// Check io.EOF is properly reported when decoder.Read is called multiple times.
   203  		// decoder.Read will be called 8 times, badReader.Read will be called twice, returning
   204  		// valid data both times but io.EOF on the second call.
   205  		{r: badReader{data: []byte("NRSWC43VOJSS4==="), errs: []error{nil, io.EOF}},
   206  			res: "leasure.", err: io.EOF, dbuflen: 1},
   207  		// The following two test cases check that errors are propagated correctly when more than
   208  		// 8 bytes are read at a time.
   209  		{r: badReader{data: []byte("NRSWC43VOJSS4==="), errs: []error{io.EOF}},
   210  			res: "leasure.", err: io.EOF, dbuflen: 11},
   211  		{r: badReader{data: []byte("NRSWC43VOJSS4==="), errs: []error{badErr}},
   212  			res: "leasure.", err: badErr, dbuflen: 11},
   213  		// Check that errors are correctly propagated when the reader returns valid bytes in
   214  		// groups that are not divisible by 8.  The first read will return 11 bytes and no
   215  		// error.  The second will return 7 and an error.  The data should be decoded correctly
   216  		// and the error should be propagated.
   217  		{r: badReader{data: []byte("NRSWC43VOJSS4==="), errs: []error{nil, badErr}, limit: 11},
   218  			res: "leasure.", err: badErr},
   219  	}
   220  
   221  	for _, tc := range testCases {
   222  		input := tc.r.data
   223  		decoder := NewDecoder(StdEncoding, &tc.r)
   224  		var dbuflen int
   225  		if tc.dbuflen > 0 {
   226  			dbuflen = tc.dbuflen
   227  		} else {
   228  			dbuflen = StdEncoding.DecodedLen(len(input))
   229  		}
   230  		dbuf := make([]byte, dbuflen)
   231  		var err error
   232  		var res []byte
   233  		for err == nil {
   234  			var n int
   235  			n, err = decoder.Read(dbuf)
   236  			if n > 0 {
   237  				res = append(res, dbuf[:n]...)
   238  			}
   239  		}
   240  
   241  		testEqual(t, "Decoding of %q = %q, want %q", string(input), string(res), tc.res)
   242  		testEqual(t, "Decoding of %q err = %v, expected %v", string(input), err, tc.err)
   243  	}
   244  }
   245  
   246  // TestDecoderError verifies decode errors are propagated when there are no read
   247  // errors.
   248  func TestDecoderError(t *testing.T) {
   249  	for _, readErr := range []error{io.EOF, nil} {
   250  		input := "MZXW6YTb"
   251  		dbuf := make([]byte, StdEncoding.DecodedLen(len(input)))
   252  		br := badReader{data: []byte(input), errs: []error{readErr}}
   253  		decoder := NewDecoder(StdEncoding, &br)
   254  		n, err := decoder.Read(dbuf)
   255  		testEqual(t, "Read after EOF, n = %d, expected %d", n, 0)
   256  		if _, ok := err.(CorruptInputError); !ok {
   257  			t.Errorf("Corrupt input error expected.  Found %T", err)
   258  		}
   259  	}
   260  }
   261  
   262  // TestReaderEOF ensures decoder.Read behaves correctly when input data is
   263  // exhausted.
   264  func TestReaderEOF(t *testing.T) {
   265  	for _, readErr := range []error{io.EOF, nil} {
   266  		input := "MZXW6YTB"
   267  		br := badReader{data: []byte(input), errs: []error{nil, readErr}}
   268  		decoder := NewDecoder(StdEncoding, &br)
   269  		dbuf := make([]byte, StdEncoding.DecodedLen(len(input)))
   270  		n, err := decoder.Read(dbuf)
   271  		testEqual(t, "Decoding of %q err = %v, expected %v", string(input), err, error(nil))
   272  		n, err = decoder.Read(dbuf)
   273  		testEqual(t, "Read after EOF, n = %d, expected %d", n, 0)
   274  		testEqual(t, "Read after EOF, err = %v, expected %v", err, io.EOF)
   275  		n, err = decoder.Read(dbuf)
   276  		testEqual(t, "Read after EOF, n = %d, expected %d", n, 0)
   277  		testEqual(t, "Read after EOF, err = %v, expected %v", err, io.EOF)
   278  	}
   279  }
   280  
   281  func TestDecoderBuffering(t *testing.T) {
   282  	for bs := 1; bs <= 12; bs++ {
   283  		decoder := NewDecoder(StdEncoding, strings.NewReader(bigtest.encoded))
   284  		buf := make([]byte, len(bigtest.decoded)+12)
   285  		var total int
   286  		var n int
   287  		var err error
   288  		for total = 0; total < len(bigtest.decoded) && err == nil; {
   289  			n, err = decoder.Read(buf[total : total+bs])
   290  			total += n
   291  		}
   292  		if err != nil && err != io.EOF {
   293  			t.Errorf("Read from %q at pos %d = %d, unexpected error %v", bigtest.encoded, total, n, err)
   294  		}
   295  		testEqual(t, "Decoding/%d of %q = %q, want %q", bs, bigtest.encoded, string(buf[0:total]), bigtest.decoded)
   296  	}
   297  }
   298  
   299  func TestDecodeCorrupt(t *testing.T) {
   300  	testCases := []struct {
   301  		input  string
   302  		offset int // -1 means no corruption.
   303  	}{
   304  		{"", -1},
   305  		{"!!!!", 0},
   306  		{"x===", 0},
   307  		{"AA=A====", 2},
   308  		{"AAA=AAAA", 3},
   309  		{"MMMMMMMMM", 8},
   310  		{"MMMMMM", 0},
   311  		{"A=", 1},
   312  		{"AA=", 3},
   313  		{"AA==", 4},
   314  		{"AA===", 5},
   315  		{"AAAA=", 5},
   316  		{"AAAA==", 6},
   317  		{"AAAAA=", 6},
   318  		{"AAAAA==", 7},
   319  		{"A=======", 1},
   320  		{"AA======", -1},
   321  		{"AAA=====", 3},
   322  		{"AAAA====", -1},
   323  		{"AAAAA===", -1},
   324  		{"AAAAAA==", 6},
   325  		{"AAAAAAA=", -1},
   326  		{"AAAAAAAA", -1},
   327  	}
   328  	for _, tc := range testCases {
   329  		dbuf := make([]byte, StdEncoding.DecodedLen(len(tc.input)))
   330  		_, err := StdEncoding.Decode(dbuf, []byte(tc.input))
   331  		if tc.offset == -1 {
   332  			if err != nil {
   333  				t.Error("Decoder wrongly detected corruption in", tc.input)
   334  			}
   335  			continue
   336  		}
   337  		switch err := err.(type) {
   338  		case CorruptInputError:
   339  			testEqual(t, "Corruption in %q at offset %v, want %v", tc.input, int(err), tc.offset)
   340  		default:
   341  			t.Error("Decoder failed to detect corruption in", tc)
   342  		}
   343  	}
   344  }
   345  
   346  func TestBig(t *testing.T) {
   347  	n := 3*1000 + 1
   348  	raw := make([]byte, n)
   349  	const alpha = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
   350  	for i := 0; i < n; i++ {
   351  		raw[i] = alpha[i%len(alpha)]
   352  	}
   353  	encoded := new(bytes.Buffer)
   354  	w := NewEncoder(StdEncoding, encoded)
   355  	nn, err := w.Write(raw)
   356  	if nn != n || err != nil {
   357  		t.Fatalf("Encoder.Write(raw) = %d, %v want %d, nil", nn, err, n)
   358  	}
   359  	err = w.Close()
   360  	if err != nil {
   361  		t.Fatalf("Encoder.Close() = %v want nil", err)
   362  	}
   363  	decoded, err := io.ReadAll(NewDecoder(StdEncoding, encoded))
   364  	if err != nil {
   365  		t.Fatalf("io.ReadAll(NewDecoder(...)): %v", err)
   366  	}
   367  
   368  	if !bytes.Equal(raw, decoded) {
   369  		var i int
   370  		for i = 0; i < len(decoded) && i < len(raw); i++ {
   371  			if decoded[i] != raw[i] {
   372  				break
   373  			}
   374  		}
   375  		t.Errorf("Decode(Encode(%d-byte string)) failed at offset %d", n, i)
   376  	}
   377  }
   378  
   379  func testStringEncoding(t *testing.T, expected string, examples []string) {
   380  	for _, e := range examples {
   381  		buf, err := StdEncoding.DecodeString(e)
   382  		if err != nil {
   383  			t.Errorf("Decode(%q) failed: %v", e, err)
   384  			continue
   385  		}
   386  		if s := string(buf); s != expected {
   387  			t.Errorf("Decode(%q) = %q, want %q", e, s, expected)
   388  		}
   389  	}
   390  }
   391  
   392  func TestNewLineCharacters(t *testing.T) {
   393  	// Each of these should decode to the string "sure", without errors.
   394  	examples := []string{
   395  		"ON2XEZI=",
   396  		"ON2XEZI=\r",
   397  		"ON2XEZI=\n",
   398  		"ON2XEZI=\r\n",
   399  		"ON2XEZ\r\nI=",
   400  		"ON2X\rEZ\nI=",
   401  		"ON2X\nEZ\rI=",
   402  		"ON2XEZ\nI=",
   403  		"ON2XEZI\n=",
   404  	}
   405  	testStringEncoding(t, "sure", examples)
   406  
   407  	// Each of these should decode to the string "foobar", without errors.
   408  	examples = []string{
   409  		"MZXW6YTBOI======",
   410  		"MZXW6YTBOI=\r\n=====",
   411  	}
   412  	testStringEncoding(t, "foobar", examples)
   413  }
   414  
   415  func TestDecoderIssue4779(t *testing.T) {
   416  	encoded := `JRXXEZLNEBUXA43VNUQGI33MN5ZCA43JOQQGC3LFOQWCAY3PNZZWKY3UMV2HK4
   417  RAMFSGS4DJONUWG2LOM4QGK3DJOQWCA43FMQQGI3YKMVUXK43NN5SCA5DFNVYG64RANFXGG2LENFSH
   418  K3TUEB2XIIDMMFRG64TFEBSXIIDEN5WG64TFEBWWCZ3OMEQGC3DJOF2WCLRAKV2CAZLONFWQUYLEEB
   419  WWS3TJNUQHMZLONFQW2LBAOF2WS4ZANZXXG5DSOVSCAZLYMVZGG2LUMF2GS33OEB2WY3DBNVRW6IDM
   420  MFRG64TJOMQG42LTNEQHK5AKMFWGS4LVNFYCAZLYEBSWCIDDN5WW233EN4QGG33OONSXC5LBOQXCAR
   421  DVNFZSAYLVORSSA2LSOVZGKIDEN5WG64RANFXAU4TFOBZGK2DFNZSGK4TJOQQGS3RAOZXWY5LQORQX
   422  IZJAOZSWY2LUEBSXG43FEBRWS3DMOVWSAZDPNRXXEZJAMV2SAZTVM5UWC5BANZ2WY3DBBJYGC4TJMF
   423  2HK4ROEBCXQY3FOB2GK5LSEBZWS3TUEBXWGY3BMVRWC5BAMN2XA2LEMF2GC5BANZXW4IDQOJXWSZDF
   424  NZ2CYIDTOVXHIIDJNYFGG5LMOBQSA4LVNEQG6ZTGNFRWSYJAMRSXGZLSOVXHIIDNN5WGY2LUEBQW42
   425  LNEBUWIIDFON2CA3DBMJXXE5LNFY==
   426  ====`
   427  	encodedShort := strings.ReplaceAll(encoded, "\n", "")
   428  
   429  	dec := NewDecoder(StdEncoding, strings.NewReader(encoded))
   430  	res1, err := io.ReadAll(dec)
   431  	if err != nil {
   432  		t.Errorf("ReadAll failed: %v", err)
   433  	}
   434  
   435  	dec = NewDecoder(StdEncoding, strings.NewReader(encodedShort))
   436  	var res2 []byte
   437  	res2, err = io.ReadAll(dec)
   438  	if err != nil {
   439  		t.Errorf("ReadAll failed: %v", err)
   440  	}
   441  
   442  	if !bytes.Equal(res1, res2) {
   443  		t.Error("Decoded results not equal")
   444  	}
   445  }
   446  
   447  func BenchmarkEncode(b *testing.B) {
   448  	data := make([]byte, 8192)
   449  	buf := make([]byte, StdEncoding.EncodedLen(len(data)))
   450  	b.SetBytes(int64(len(data)))
   451  	for i := 0; i < b.N; i++ {
   452  		StdEncoding.Encode(buf, data)
   453  	}
   454  }
   455  
   456  func BenchmarkEncodeToString(b *testing.B) {
   457  	data := make([]byte, 8192)
   458  	b.SetBytes(int64(len(data)))
   459  	for i := 0; i < b.N; i++ {
   460  		StdEncoding.EncodeToString(data)
   461  	}
   462  }
   463  
   464  func BenchmarkDecode(b *testing.B) {
   465  	data := make([]byte, StdEncoding.EncodedLen(8192))
   466  	StdEncoding.Encode(data, make([]byte, 8192))
   467  	buf := make([]byte, 8192)
   468  	b.SetBytes(int64(len(data)))
   469  	for i := 0; i < b.N; i++ {
   470  		StdEncoding.Decode(buf, data)
   471  	}
   472  }
   473  func BenchmarkDecodeString(b *testing.B) {
   474  	data := StdEncoding.EncodeToString(make([]byte, 8192))
   475  	b.SetBytes(int64(len(data)))
   476  	for i := 0; i < b.N; i++ {
   477  		StdEncoding.DecodeString(data)
   478  	}
   479  }
   480  
   481  func TestWithCustomPadding(t *testing.T) {
   482  	for _, testcase := range pairs {
   483  		defaultPadding := StdEncoding.EncodeToString([]byte(testcase.decoded))
   484  		customPadding := StdEncoding.WithPadding('@').EncodeToString([]byte(testcase.decoded))
   485  		expected := strings.ReplaceAll(defaultPadding, "=", "@")
   486  
   487  		if expected != customPadding {
   488  			t.Errorf("Expected custom %s, got %s", expected, customPadding)
   489  		}
   490  		if testcase.encoded != defaultPadding {
   491  			t.Errorf("Expected %s, got %s", testcase.encoded, defaultPadding)
   492  		}
   493  	}
   494  }
   495  
   496  func TestWithoutPadding(t *testing.T) {
   497  	for _, testcase := range pairs {
   498  		defaultPadding := StdEncoding.EncodeToString([]byte(testcase.decoded))
   499  		customPadding := StdEncoding.WithPadding(NoPadding).EncodeToString([]byte(testcase.decoded))
   500  		expected := strings.TrimRight(defaultPadding, "=")
   501  
   502  		if expected != customPadding {
   503  			t.Errorf("Expected custom %s, got %s", expected, customPadding)
   504  		}
   505  		if testcase.encoded != defaultPadding {
   506  			t.Errorf("Expected %s, got %s", testcase.encoded, defaultPadding)
   507  		}
   508  	}
   509  }
   510  
   511  func TestDecodeWithPadding(t *testing.T) {
   512  	encodings := []*Encoding{
   513  		StdEncoding,
   514  		StdEncoding.WithPadding('-'),
   515  		StdEncoding.WithPadding(NoPadding),
   516  	}
   517  
   518  	for i, enc := range encodings {
   519  		for _, pair := range pairs {
   520  
   521  			input := pair.decoded
   522  			encoded := enc.EncodeToString([]byte(input))
   523  
   524  			decoded, err := enc.DecodeString(encoded)
   525  			if err != nil {
   526  				t.Errorf("DecodeString Error for encoding %d (%q): %v", i, input, err)
   527  			}
   528  
   529  			if input != string(decoded) {
   530  				t.Errorf("Unexpected result for encoding %d: got %q; want %q", i, decoded, input)
   531  			}
   532  		}
   533  	}
   534  }
   535  
   536  func TestDecodeWithWrongPadding(t *testing.T) {
   537  	encoded := StdEncoding.EncodeToString([]byte("foobar"))
   538  
   539  	_, err := StdEncoding.WithPadding('-').DecodeString(encoded)
   540  	if err == nil {
   541  		t.Error("expected error")
   542  	}
   543  
   544  	_, err = StdEncoding.WithPadding(NoPadding).DecodeString(encoded)
   545  	if err == nil {
   546  		t.Error("expected error")
   547  	}
   548  }
   549  
   550  func TestBufferedDecodingSameError(t *testing.T) {
   551  	testcases := []struct {
   552  		prefix            string
   553  		chunkCombinations [][]string
   554  		expected          error
   555  	}{
   556  		// NBSWY3DPO5XXE3DE == helloworld
   557  		// Test with "ZZ" as extra input
   558  		{"helloworld", [][]string{
   559  			{"NBSW", "Y3DP", "O5XX", "E3DE", "ZZ"},
   560  			{"NBSWY3DPO5XXE3DE", "ZZ"},
   561  			{"NBSWY3DPO5XXE3DEZZ"},
   562  			{"NBS", "WY3", "DPO", "5XX", "E3D", "EZZ"},
   563  			{"NBSWY3DPO5XXE3", "DEZZ"},
   564  		}, io.ErrUnexpectedEOF},
   565  
   566  		// Test with "ZZY" as extra input
   567  		{"helloworld", [][]string{
   568  			{"NBSW", "Y3DP", "O5XX", "E3DE", "ZZY"},
   569  			{"NBSWY3DPO5XXE3DE", "ZZY"},
   570  			{"NBSWY3DPO5XXE3DEZZY"},
   571  			{"NBS", "WY3", "DPO", "5XX", "E3D", "EZZY"},
   572  			{"NBSWY3DPO5XXE3", "DEZZY"},
   573  		}, io.ErrUnexpectedEOF},
   574  
   575  		// Normal case, this is valid input
   576  		{"helloworld", [][]string{
   577  			{"NBSW", "Y3DP", "O5XX", "E3DE"},
   578  			{"NBSWY3DPO5XXE3DE"},
   579  			{"NBS", "WY3", "DPO", "5XX", "E3D", "E"},
   580  			{"NBSWY3DPO5XXE3", "DE"},
   581  		}, nil},
   582  
   583  		// MZXW6YTB = fooba
   584  		{"fooba", [][]string{
   585  			{"MZXW6YTBZZ"},
   586  			{"MZXW6YTBZ", "Z"},
   587  			{"MZXW6YTB", "ZZ"},
   588  			{"MZXW6YT", "BZZ"},
   589  			{"MZXW6Y", "TBZZ"},
   590  			{"MZXW6Y", "TB", "ZZ"},
   591  			{"MZXW6", "YTBZZ"},
   592  			{"MZXW6", "YTB", "ZZ"},
   593  			{"MZXW6", "YT", "BZZ"},
   594  		}, io.ErrUnexpectedEOF},
   595  
   596  		// Normal case, this is valid input
   597  		{"fooba", [][]string{
   598  			{"MZXW6YTB"},
   599  			{"MZXW6YT", "B"},
   600  			{"MZXW6Y", "TB"},
   601  			{"MZXW6", "YTB"},
   602  			{"MZXW6", "YT", "B"},
   603  			{"MZXW", "6YTB"},
   604  			{"MZXW", "6Y", "TB"},
   605  		}, nil},
   606  	}
   607  
   608  	for _, testcase := range testcases {
   609  		for _, chunks := range testcase.chunkCombinations {
   610  			pr, pw := io.Pipe()
   611  
   612  			// Write the encoded chunks into the pipe
   613  			go func() {
   614  				for _, chunk := range chunks {
   615  					pw.Write([]byte(chunk))
   616  				}
   617  				pw.Close()
   618  			}()
   619  
   620  			decoder := NewDecoder(StdEncoding, pr)
   621  			_, err := io.ReadAll(decoder)
   622  
   623  			if err != testcase.expected {
   624  				t.Errorf("Expected %v, got %v; case %s %+v", testcase.expected, err, testcase.prefix, chunks)
   625  			}
   626  		}
   627  	}
   628  }
   629  
   630  func TestEncodedDecodedLen(t *testing.T) {
   631  	type test struct {
   632  		in      int
   633  		wantEnc int
   634  		wantDec int
   635  	}
   636  	data := bytes.Repeat([]byte("x"), 100)
   637  	for _, test := range []struct {
   638  		name  string
   639  		enc   *Encoding
   640  		cases []test
   641  	}{
   642  		{"StdEncoding", StdEncoding, []test{
   643  			{0, 0, 0},
   644  			{1, 8, 5},
   645  			{5, 8, 5},
   646  			{6, 16, 10},
   647  			{10, 16, 10},
   648  		}},
   649  		{"NoPadding", StdEncoding.WithPadding(NoPadding), []test{
   650  			{0, 0, 0},
   651  			{1, 2, 1},
   652  			{2, 4, 2},
   653  			{5, 8, 5},
   654  			{6, 10, 6},
   655  			{7, 12, 7},
   656  			{10, 16, 10},
   657  			{11, 18, 11},
   658  		}},
   659  	} {
   660  		t.Run(test.name, func(t *testing.T) {
   661  			for _, tc := range test.cases {
   662  				encLen := test.enc.EncodedLen(tc.in)
   663  				decLen := test.enc.DecodedLen(encLen)
   664  				enc := test.enc.EncodeToString(data[:tc.in])
   665  				if len(enc) != encLen {
   666  					t.Fatalf("EncodedLen(%d) = %d but encoded to %q (%d)", tc.in, encLen, enc, len(enc))
   667  				}
   668  				if encLen != tc.wantEnc {
   669  					t.Fatalf("EncodedLen(%d) = %d; want %d", tc.in, encLen, tc.wantEnc)
   670  				}
   671  				if decLen != tc.wantDec {
   672  					t.Fatalf("DecodedLen(%d) = %d; want %d", encLen, decLen, tc.wantDec)
   673  				}
   674  			}
   675  		})
   676  	}
   677  }
   678  
   679  func TestWithoutPaddingClose(t *testing.T) {
   680  	encodings := []*Encoding{
   681  		StdEncoding,
   682  		StdEncoding.WithPadding(NoPadding),
   683  	}
   684  
   685  	for _, encoding := range encodings {
   686  		for _, testpair := range pairs {
   687  
   688  			var buf bytes.Buffer
   689  			encoder := NewEncoder(encoding, &buf)
   690  			encoder.Write([]byte(testpair.decoded))
   691  			encoder.Close()
   692  
   693  			expected := testpair.encoded
   694  			if encoding.padChar == NoPadding {
   695  				expected = strings.ReplaceAll(expected, "=", "")
   696  			}
   697  
   698  			res := buf.String()
   699  
   700  			if res != expected {
   701  				t.Errorf("Expected %s got %s; padChar=%d", expected, res, encoding.padChar)
   702  			}
   703  		}
   704  	}
   705  }
   706  
   707  func TestDecodeReadAll(t *testing.T) {
   708  	encodings := []*Encoding{
   709  		StdEncoding,
   710  		StdEncoding.WithPadding(NoPadding),
   711  	}
   712  
   713  	for _, pair := range pairs {
   714  		for encIndex, encoding := range encodings {
   715  			encoded := pair.encoded
   716  			if encoding.padChar == NoPadding {
   717  				encoded = strings.ReplaceAll(encoded, "=", "")
   718  			}
   719  
   720  			decReader, err := io.ReadAll(NewDecoder(encoding, strings.NewReader(encoded)))
   721  			if err != nil {
   722  				t.Errorf("NewDecoder error: %v", err)
   723  			}
   724  
   725  			if pair.decoded != string(decReader) {
   726  				t.Errorf("Expected %s got %s; Encoding %d", pair.decoded, decReader, encIndex)
   727  			}
   728  		}
   729  	}
   730  }
   731  
   732  func TestDecodeSmallBuffer(t *testing.T) {
   733  	encodings := []*Encoding{
   734  		StdEncoding,
   735  		StdEncoding.WithPadding(NoPadding),
   736  	}
   737  
   738  	for bufferSize := 1; bufferSize < 200; bufferSize++ {
   739  		for _, pair := range pairs {
   740  			for encIndex, encoding := range encodings {
   741  				encoded := pair.encoded
   742  				if encoding.padChar == NoPadding {
   743  					encoded = strings.ReplaceAll(encoded, "=", "")
   744  				}
   745  
   746  				decoder := NewDecoder(encoding, strings.NewReader(encoded))
   747  
   748  				var allRead []byte
   749  
   750  				for {
   751  					buf := make([]byte, bufferSize)
   752  					n, err := decoder.Read(buf)
   753  					allRead = append(allRead, buf[0:n]...)
   754  					if err == io.EOF {
   755  						break
   756  					}
   757  					if err != nil {
   758  						t.Error(err)
   759  					}
   760  				}
   761  
   762  				if pair.decoded != string(allRead) {
   763  					t.Errorf("Expected %s got %s; Encoding %d; bufferSize %d", pair.decoded, allRead, encIndex, bufferSize)
   764  				}
   765  			}
   766  		}
   767  	}
   768  }
   769  

View as plain text