vendor/github.com/lunixbochs/struc/packable_test.go

   1 package struc
   2
   3 import (
   4         "bytes"
   5         "fmt"
   6         "testing"
   7 )
   8
   9 var packableReference = []byte{
  10         1, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 5, 0, 6, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 8,
  11         9, 10, 11, 12, 13, 14, 15, 16,
  12         0, 17, 0, 18, 0, 19, 0, 20, 0, 21, 0, 22, 0, 23, 0, 24,
  13 }
  14
  15 func TestPackable(t *testing.T) {
  16         var (
  17                 buf bytes.Buffer
  18
  19                 i8  int8   = 1
  20                 i16 int16  = 2
  21                 i32 int32  = 3
  22                 i64 int64  = 4
  23                 u8  uint8  = 5
  24                 u16 uint16 = 6
  25                 u32 uint32 = 7
  26                 u64 uint64 = 8
  27
  28                 u8a  = [8]uint8{9, 10, 11, 12, 13, 14, 15, 16}
  29                 u16a = [8]uint16{17, 18, 19, 20, 21, 22, 23, 24}
  30         )
  31         // pack tests
  32         if err := Pack(&buf, i8); err != nil {
  33                 t.Fatal(err)
  34         }
  35         if err := Pack(&buf, i16); err != nil {
  36                 t.Fatal(err)
  37         }
  38         if err := Pack(&buf, i32); err != nil {
  39                 t.Fatal(err)
  40         }
  41         if err := Pack(&buf, i64); err != nil {
  42                 t.Fatal(err)
  43         }
  44         if err := Pack(&buf, u8); err != nil {
  45                 t.Fatal(err)
  46         }
  47         if err := Pack(&buf, u16); err != nil {
  48                 t.Fatal(err)
  49         }
  50         if err := Pack(&buf, u32); err != nil {
  51                 t.Fatal(err)
  52         }
  53         if err := Pack(&buf, u64); err != nil {
  54                 t.Fatal(err)
  55         }
  56         if err := Pack(&buf, u8a[:]); err != nil {
  57                 t.Fatal(err)
  58         }
  59         if err := Pack(&buf, u16a[:]); err != nil {
  60                 t.Fatal(err)
  61         }
  62         if !bytes.Equal(buf.Bytes(), packableReference) {
  63                 fmt.Println(buf.Bytes())
  64                 fmt.Println(packableReference)
  65                 t.Fatal("Packable Pack() did not match reference.")
  66         }
  67         // unpack tests
  68         i8 = 0
  69         i16 = 0
  70         i32 = 0
  71         i64 = 0
  72         u8 = 0
  73         u16 = 0
  74         u32 = 0
  75         u64 = 0
  76         if err := Unpack(&buf, &i8); err != nil {
  77                 t.Fatal(err)
  78         }
  79         if err := Unpack(&buf, &i16); err != nil {
  80                 t.Fatal(err)
  81         }
  82         if err := Unpack(&buf, &i32); err != nil {
  83                 t.Fatal(err)
  84         }
  85         if err := Unpack(&buf, &i64); err != nil {
  86                 t.Fatal(err)
  87         }
  88         if err := Unpack(&buf, &u8); err != nil {
  89                 t.Fatal(err)
  90         }
  91         if err := Unpack(&buf, &u16); err != nil {
  92                 t.Fatal(err)
  93         }
  94         if err := Unpack(&buf, &u32); err != nil {
  95                 t.Fatal(err)
  96         }
  97         if err := Unpack(&buf, &u64); err != nil {
  98                 t.Fatal(err)
  99         }
 100         if err := Unpack(&buf, u8a[:]); err != nil {
 101                 t.Fatal(err)
 102         }
 103         if err := Unpack(&buf, u16a[:]); err != nil {
 104                 t.Fatal(err)
 105         }
 106         // unpack checks
 107         if i8 != 1 || i16 != 2 || i32 != 3 || i64 != 4 {
 108                 t.Fatal("Signed integer unpack failed.")
 109         }
 110         if u8 != 5 || u16 != 6 || u32 != 7 || u64 != 8 {
 111                 t.Fatal("Unsigned integer unpack failed.")
 112         }
 113         for i := 0; i < 8; i++ {
 114                 if u8a[i] != uint8(i+9) {
 115                         t.Fatal("uint8 array unpack failed.")
 116                 }
 117         }
 118         for i := 0; i < 8; i++ {
 119                 if u16a[i] != uint16(i+17) {
 120                         t.Fatal("uint16 array unpack failed.")
 121                 }
 122         }
 123 }