armor/armor_test.go

   1 package armor
   2
   3 import (
   4         "crypto/rand"
   5         "io"
   6         "io/ioutil"
   7         "strings"
   8         "testing"
   9 )
  10
  11 func decodeToString(src string) (string, error) {
  12         dec, err := NewDecoder(strings.NewReader(src))
  13         if err != nil {
  14                 return "", err
  15         }
  16         p, err := ioutil.ReadAll(dec)
  17         return string(p), err
  18 }
  19
  20 func TestDecoder(t *testing.T) {
  21         for _, test := range []struct {
  22                 input          string
  23                 expectedOutput string
  24                 expectedErr    bool
  25         }{
  26                 {`
  27 <pre>
  28 0
  29 </pre>
  30 `,
  31                         "",
  32                         false,
  33                 },
  34                 {`
  35 <pre>
  36 0aGVsbG8gd29ybGQK
  37 </pre>
  38 `,
  39                         "hello world\n",
  40                         false,
  41                 },
  42                 // bad version indicator
  43                 {`
  44 <pre>
  45 1aGVsbG8gd29ybGQK
  46 </pre>
  47 `,
  48                         "",
  49                         true,
  50                 },
  51                 // text outside <pre> elements
  52                 {`
  53 0aGVsbG8gd29ybGQK
  54 blah blah blah
  55 <pre>
  56 0aGVsbG8gd29ybGQK
  57 </pre>
  58 0aGVsbG8gd29ybGQK
  59 blah blah blah
  60 `,
  61                         "hello world\n",
  62                         false,
  63                 },
  64                 {`
  65 <pre>
  66 0QUJDREV
  67 GR0hJSkt
  68 MTU5PUFF
  69 SU1RVVld
  70 </pre>
  71 junk
  72 <pre>
  73 YWVowMTI
  74 zNDU2Nzg
  75 5Cg
  76 =
  77 </pre>
  78 <pre>
  79 =
  80 </pre>
  81 `,
  82                         "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\n",
  83                         false,
  84                 },
  85                 // no <pre> elements, hence no version indicator
  86                 {`
  87 aGVsbG8gd29ybGQK
  88 blah blah blah
  89 aGVsbG8gd29ybGQK
  90 aGVsbG8gd29ybGQK
  91 blah blah blah
  92 `,
  93                         "",
  94                         true,
  95                 },
  96                 // empty <pre> elements, hence no version indicator
  97                 {`
  98 aGVsbG8gd29ybGQK
  99 blah blah blah
 100 <pre>   </pre>
 101 aGVsbG8gd29ybGQK
 102 aGVsbG8gd29ybGQK<pre></pre>
 103 blah blah blah
 104 `,
 105                         "",
 106                         true,
 107                 },
 108                 // other elements inside <pre>
 109                 {
 110                         "blah <pre>0aGVsb<p>G8gd29</p>ybGQK</pre>",
 111                         "hello world\n",
 112                         false,
 113                 },
 114                 // HTML comment
 115                 {
 116                         "blah <!-- <pre>aGVsbG8gd29ybGQK</pre> -->",
 117                         "",
 118                         true,
 119                 },
 120                 // all kinds of ASCII whitespace
 121                 {
 122                         "blah <pre>\x200\x09aG\x0aV\x0csb\x0dG8\x20gd29ybGQK</pre>",
 123                         "hello world\n",
 124                         false,
 125                 },
 126
 127                 // bad padding
 128                 {`
 129 <pre>
 130 0QUJDREV
 131 GR0hJSkt
 132 MTU5PUFF
 133 SU1RVVld
 134 </pre>
 135 junk
 136 <pre>
 137 YWVowMTI
 138 zNDU2Nzg
 139 5Cg
 140 =
 141 </pre>
 142 `,
 143                         "",
 144                         true,
 145                 },
 146                 /*
 147                         // per-chunk base64
 148                         // test disabled because Go stdlib handles this incorrectly:
 149                         // https://github.com/golang/go/issues/31626
 150                         {
 151                                 "<pre>QQ==</pre><pre>Qg==</pre>",
 152                                 "",
 153                                 true,
 154                         },
 155                 */
 156                 // missing </pre>
 157                 {
 158                         "blah <pre></pre><pre>0aGVsbG8gd29ybGQK",
 159                         "",
 160                         true,
 161                 },
 162                 // nested <pre>
 163                 {
 164                         "blah <pre>0aGVsb<pre>G8gd29</pre>ybGQK</pre>",
 165                         "",
 166                         true,
 167                 },
 168         } {
 169                 output, err := decodeToString(test.input)
 170                 if test.expectedErr && err == nil {
 171                         t.Errorf("%+q → (%+q, %v), expected error", test.input, output, err)
 172                         continue
 173                 }
 174                 if !test.expectedErr && err != nil {
 175                         t.Errorf("%+q → (%+q, %v), expected no error", test.input, output, err)
 176                         continue
 177                 }
 178                 if !test.expectedErr && output != test.expectedOutput {
 179                         t.Errorf("%+q → (%+q, %v), expected (%+q, %v)",
 180                                 test.input, output, err, test.expectedOutput, nil)
 181                         continue
 182                 }
 183         }
 184 }
 185
 186 func roundTrip(s string) (string, error) {
 187         var encoded strings.Builder
 188         enc, err := NewEncoder(&encoded)
 189         if err != nil {
 190                 return "", err
 191         }
 192         _, err = io.Copy(enc, strings.NewReader(s))
 193         if err != nil {
 194                 return "", err
 195         }
 196         err = enc.Close()
 197         if err != nil {
 198                 return "", err
 199         }
 200         return decodeToString(encoded.String())
 201 }
 202
 203 func TestRoundTrip(t *testing.T) {
 204         lengths := make([]int, 0)
 205         // Test short strings and lengths around elementSizeLimit thresholds.
 206         for i := 0; i < bytesPerChunk*2; i++ {
 207                 lengths = append(lengths, i)
 208         }
 209         for i := -10; i < +10; i++ {
 210                 lengths = append(lengths, elementSizeLimit+i)
 211                 lengths = append(lengths, 2*elementSizeLimit+i)
 212         }
 213         for _, n := range lengths {
 214                 buf := make([]byte, n)
 215                 rand.Read(buf)
 216                 input := string(buf)
 217                 output, err := roundTrip(input)
 218                 if err != nil {
 219                         t.Errorf("length %d → error %v", n, err)
 220                         continue
 221                 }
 222                 if output != input {
 223                         t.Errorf("length %d → %+q", n, output)
 224                         continue
 225                 }
 226         }
 227 }