vendor/golang.org/x/crypto/cryptobyte/cryptobyte_test.go

   1 // Copyright 2017 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 cryptobyte
   6
   7 import (
   8         "bytes"
   9         "fmt"
  10         "testing"
  11 )
  12
  13 func builderBytesEq(b *Builder, want ...byte) error {
  14         got := b.BytesOrPanic()
  15         if !bytes.Equal(got, want) {
  16                 return fmt.Errorf("Bytes() = %v, want %v", got, want)
  17         }
  18         return nil
  19 }
  20
  21 func TestBytes(t *testing.T) {
  22         var b Builder
  23         v := []byte("foobarbaz")
  24         b.AddBytes(v[0:3])
  25         b.AddBytes(v[3:4])
  26         b.AddBytes(v[4:9])
  27         if err := builderBytesEq(&b, v...); err != nil {
  28                 t.Error(err)
  29         }
  30         s := String(b.BytesOrPanic())
  31         for _, w := range []string{"foo", "bar", "baz"} {
  32                 var got []byte
  33                 if !s.ReadBytes(&got, 3) {
  34                         t.Errorf("ReadBytes() = false, want true (w = %v)", w)
  35                 }
  36                 want := []byte(w)
  37                 if !bytes.Equal(got, want) {
  38                         t.Errorf("ReadBytes(): got = %v, want %v", got, want)
  39                 }
  40         }
  41         if len(s) != 0 {
  42                 t.Errorf("len(s) = %d, want 0", len(s))
  43         }
  44 }
  45
  46 func TestUint8(t *testing.T) {
  47         var b Builder
  48         b.AddUint8(42)
  49         if err := builderBytesEq(&b, 42); err != nil {
  50                 t.Error(err)
  51         }
  52
  53         var s String = b.BytesOrPanic()
  54         var v uint8
  55         if !s.ReadUint8(&v) {
  56                 t.Error("ReadUint8() = false, want true")
  57         }
  58         if v != 42 {
  59                 t.Errorf("v = %d, want 42", v)
  60         }
  61         if len(s) != 0 {
  62                 t.Errorf("len(s) = %d, want 0", len(s))
  63         }
  64 }
  65
  66 func TestUint16(t *testing.T) {
  67         var b Builder
  68         b.AddUint16(65534)
  69         if err := builderBytesEq(&b, 255, 254); err != nil {
  70                 t.Error(err)
  71         }
  72         var s String = b.BytesOrPanic()
  73         var v uint16
  74         if !s.ReadUint16(&v) {
  75                 t.Error("ReadUint16() == false, want true")
  76         }
  77         if v != 65534 {
  78                 t.Errorf("v = %d, want 65534", v)
  79         }
  80         if len(s) != 0 {
  81                 t.Errorf("len(s) = %d, want 0", len(s))
  82         }
  83 }
  84
  85 func TestUint24(t *testing.T) {
  86         var b Builder
  87         b.AddUint24(0xfffefd)
  88         if err := builderBytesEq(&b, 255, 254, 253); err != nil {
  89                 t.Error(err)
  90         }
  91
  92         var s String = b.BytesOrPanic()
  93         var v uint32
  94         if !s.ReadUint24(&v) {
  95                 t.Error("ReadUint8() = false, want true")
  96         }
  97         if v != 0xfffefd {
  98                 t.Errorf("v = %d, want fffefd", v)
  99         }
 100         if len(s) != 0 {
 101                 t.Errorf("len(s) = %d, want 0", len(s))
 102         }
 103 }
 104
 105 func TestUint24Truncation(t *testing.T) {
 106         var b Builder
 107         b.AddUint24(0x10111213)
 108         if err := builderBytesEq(&b, 0x11, 0x12, 0x13); err != nil {
 109                 t.Error(err)
 110         }
 111 }
 112
 113 func TestUint32(t *testing.T) {
 114         var b Builder
 115         b.AddUint32(0xfffefdfc)
 116         if err := builderBytesEq(&b, 255, 254, 253, 252); err != nil {
 117                 t.Error(err)
 118         }
 119
 120         var s String = b.BytesOrPanic()
 121         var v uint32
 122         if !s.ReadUint32(&v) {
 123                 t.Error("ReadUint8() = false, want true")
 124         }
 125         if v != 0xfffefdfc {
 126                 t.Errorf("v = %x, want fffefdfc", v)
 127         }
 128         if len(s) != 0 {
 129                 t.Errorf("len(s) = %d, want 0", len(s))
 130         }
 131 }
 132
 133 func TestUMultiple(t *testing.T) {
 134         var b Builder
 135         b.AddUint8(23)
 136         b.AddUint32(0xfffefdfc)
 137         b.AddUint16(42)
 138         if err := builderBytesEq(&b, 23, 255, 254, 253, 252, 0, 42); err != nil {
 139                 t.Error(err)
 140         }
 141
 142         var s String = b.BytesOrPanic()
 143         var (
 144                 x uint8
 145                 y uint32
 146                 z uint16
 147         )
 148         if !s.ReadUint8(&x) || !s.ReadUint32(&y) || !s.ReadUint16(&z) {
 149                 t.Error("ReadUint8() = false, want true")
 150         }
 151         if x != 23 || y != 0xfffefdfc || z != 42 {
 152                 t.Errorf("x, y, z = %d, %d, %d; want 23, 4294901244, 5", x, y, z)
 153         }
 154         if len(s) != 0 {
 155                 t.Errorf("len(s) = %d, want 0", len(s))
 156         }
 157 }
 158
 159 func TestUint8LengthPrefixedSimple(t *testing.T) {
 160         var b Builder
 161         b.AddUint8LengthPrefixed(func(c *Builder) {
 162                 c.AddUint8(23)
 163                 c.AddUint8(42)
 164         })
 165         if err := builderBytesEq(&b, 2, 23, 42); err != nil {
 166                 t.Error(err)
 167         }
 168
 169         var base, child String = b.BytesOrPanic(), nil
 170         var x, y uint8
 171         if !base.ReadUint8LengthPrefixed(&child) || !child.ReadUint8(&x) ||
 172                 !child.ReadUint8(&y) {
 173                 t.Error("parsing failed")
 174         }
 175         if x != 23 || y != 42 {
 176                 t.Errorf("want x, y == 23, 42; got %d, %d", x, y)
 177         }
 178         if len(base) != 0 {
 179                 t.Errorf("len(base) = %d, want 0", len(base))
 180         }
 181         if len(child) != 0 {
 182                 t.Errorf("len(child) = %d, want 0", len(child))
 183         }
 184 }
 185
 186 func TestUint8LengthPrefixedMulti(t *testing.T) {
 187         var b Builder
 188         b.AddUint8LengthPrefixed(func(c *Builder) {
 189                 c.AddUint8(23)
 190                 c.AddUint8(42)
 191         })
 192         b.AddUint8(5)
 193         b.AddUint8LengthPrefixed(func(c *Builder) {
 194                 c.AddUint8(123)
 195                 c.AddUint8(234)
 196         })
 197         if err := builderBytesEq(&b, 2, 23, 42, 5, 2, 123, 234); err != nil {
 198                 t.Error(err)
 199         }
 200
 201         var s, child String = b.BytesOrPanic(), nil
 202         var u, v, w, x, y uint8
 203         if !s.ReadUint8LengthPrefixed(&child) || !child.ReadUint8(&u) || !child.ReadUint8(&v) ||
 204                 !s.ReadUint8(&w) || !s.ReadUint8LengthPrefixed(&child) || !child.ReadUint8(&x) || !child.ReadUint8(&y) {
 205                 t.Error("parsing failed")
 206         }
 207         if u != 23 || v != 42 || w != 5 || x != 123 || y != 234 {
 208                 t.Errorf("u, v, w, x, y = %d, %d, %d, %d, %d; want 23, 42, 5, 123, 234",
 209                         u, v, w, x, y)
 210         }
 211         if len(s) != 0 {
 212                 t.Errorf("len(s) = %d, want 0", len(s))
 213         }
 214         if len(child) != 0 {
 215                 t.Errorf("len(child) = %d, want 0", len(child))
 216         }
 217 }
 218
 219 func TestUint8LengthPrefixedNested(t *testing.T) {
 220         var b Builder
 221         b.AddUint8LengthPrefixed(func(c *Builder) {
 222                 c.AddUint8(5)
 223                 c.AddUint8LengthPrefixed(func(d *Builder) {
 224                         d.AddUint8(23)
 225                         d.AddUint8(42)
 226                 })
 227                 c.AddUint8(123)
 228         })
 229         if err := builderBytesEq(&b, 5, 5, 2, 23, 42, 123); err != nil {
 230                 t.Error(err)
 231         }
 232
 233         var base, child1, child2 String = b.BytesOrPanic(), nil, nil
 234         var u, v, w, x uint8
 235         if !base.ReadUint8LengthPrefixed(&child1) {
 236                 t.Error("parsing base failed")
 237         }
 238         if !child1.ReadUint8(&u) || !child1.ReadUint8LengthPrefixed(&child2) || !child1.ReadUint8(&x) {
 239                 t.Error("parsing child1 failed")
 240         }
 241         if !child2.ReadUint8(&v) || !child2.ReadUint8(&w) {
 242                 t.Error("parsing child2 failed")
 243         }
 244         if u != 5 || v != 23 || w != 42 || x != 123 {
 245                 t.Errorf("u, v, w, x = %d, %d, %d, %d, want 5, 23, 42, 123",
 246                         u, v, w, x)
 247         }
 248         if len(base) != 0 {
 249                 t.Errorf("len(base) = %d, want 0", len(base))
 250         }
 251         if len(child1) != 0 {
 252                 t.Errorf("len(child1) = %d, want 0", len(child1))
 253         }
 254         if len(base) != 0 {
 255                 t.Errorf("len(child2) = %d, want 0", len(child2))
 256         }
 257 }
 258
 259 func TestPreallocatedBuffer(t *testing.T) {
 260         var buf [5]byte
 261         b := NewBuilder(buf[0:0])
 262         b.AddUint8(1)
 263         b.AddUint8LengthPrefixed(func(c *Builder) {
 264                 c.AddUint8(3)
 265                 c.AddUint8(4)
 266         })
 267         b.AddUint16(1286) // Outgrow buf by one byte.
 268         want := []byte{1, 2, 3, 4, 0}
 269         if !bytes.Equal(buf[:], want) {
 270                 t.Errorf("buf = %v want %v", buf, want)
 271         }
 272         if err := builderBytesEq(b, 1, 2, 3, 4, 5, 6); err != nil {
 273                 t.Error(err)
 274         }
 275 }
 276
 277 func TestWriteWithPendingChild(t *testing.T) {
 278         var b Builder
 279         b.AddUint8LengthPrefixed(func(c *Builder) {
 280                 c.AddUint8LengthPrefixed(func(d *Builder) {
 281                         defer func() {
 282                                 if recover() == nil {
 283                                         t.Errorf("recover() = nil, want error; c.AddUint8() did not panic")
 284                                 }
 285                         }()
 286                         c.AddUint8(2) // panics
 287
 288                         defer func() {
 289                                 if recover() == nil {
 290                                         t.Errorf("recover() = nil, want error; b.AddUint8() did not panic")
 291                                 }
 292                         }()
 293                         b.AddUint8(2) // panics
 294                 })
 295
 296                 defer func() {
 297                         if recover() == nil {
 298                                 t.Errorf("recover() = nil, want error; b.AddUint8() did not panic")
 299                         }
 300                 }()
 301                 b.AddUint8(2) // panics
 302         })
 303 }
 304
 305 // ASN.1
 306
 307 func TestASN1Int64(t *testing.T) {
 308         tests := []struct {
 309                 in   int64
 310                 want []byte
 311         }{
 312                 {-0x800000, []byte{2, 3, 128, 0, 0}},
 313                 {-256, []byte{2, 2, 255, 0}},
 314                 {-129, []byte{2, 2, 255, 127}},
 315                 {-128, []byte{2, 1, 128}},
 316                 {-1, []byte{2, 1, 255}},
 317                 {0, []byte{2, 1, 0}},
 318                 {1, []byte{2, 1, 1}},
 319                 {2, []byte{2, 1, 2}},
 320                 {127, []byte{2, 1, 127}},
 321                 {128, []byte{2, 2, 0, 128}},
 322                 {256, []byte{2, 2, 1, 0}},
 323                 {0x800000, []byte{2, 4, 0, 128, 0, 0}},
 324         }
 325         for i, tt := range tests {
 326                 var b Builder
 327                 b.AddASN1Int64(tt.in)
 328                 if err := builderBytesEq(&b, tt.want...); err != nil {
 329                         t.Errorf("%v, (i = %d; in = %v)", err, i, tt.in)
 330                 }
 331
 332                 var n int64
 333                 s := String(b.BytesOrPanic())
 334                 ok := s.ReadASN1Integer(&n)
 335                 if !ok || n != tt.in {
 336                         t.Errorf("s.ReadASN1Integer(&n) = %v, n = %d; want true, n = %d (i = %d)",
 337                                 ok, n, tt.in, i)
 338                 }
 339                 if len(s) != 0 {
 340                         t.Errorf("len(s) = %d, want 0", len(s))
 341                 }
 342         }
 343 }
 344
 345 func TestASN1Uint64(t *testing.T) {
 346         tests := []struct {
 347                 in   uint64
 348                 want []byte
 349         }{
 350                 {0, []byte{2, 1, 0}},
 351                 {1, []byte{2, 1, 1}},
 352                 {2, []byte{2, 1, 2}},
 353                 {127, []byte{2, 1, 127}},
 354                 {128, []byte{2, 2, 0, 128}},
 355                 {256, []byte{2, 2, 1, 0}},
 356                 {0x800000, []byte{2, 4, 0, 128, 0, 0}},
 357                 {0x7fffffffffffffff, []byte{2, 8, 127, 255, 255, 255, 255, 255, 255, 255}},
 358                 {0x8000000000000000, []byte{2, 9, 0, 128, 0, 0, 0, 0, 0, 0, 0}},
 359                 {0xffffffffffffffff, []byte{2, 9, 0, 255, 255, 255, 255, 255, 255, 255, 255}},
 360         }
 361         for i, tt := range tests {
 362                 var b Builder
 363                 b.AddASN1Uint64(tt.in)
 364                 if err := builderBytesEq(&b, tt.want...); err != nil {
 365                         t.Errorf("%v, (i = %d; in = %v)", err, i, tt.in)
 366                 }
 367
 368                 var n uint64
 369                 s := String(b.BytesOrPanic())
 370                 ok := s.ReadASN1Integer(&n)
 371                 if !ok || n != tt.in {
 372                         t.Errorf("s.ReadASN1Integer(&n) = %v, n = %d; want true, n = %d (i = %d)",
 373                                 ok, n, tt.in, i)
 374                 }
 375                 if len(s) != 0 {
 376                         t.Errorf("len(s) = %d, want 0", len(s))
 377                 }
 378         }
 379 }