protocol/vm/pushdata_test.go

   1 package vm
   2
   3 import (
   4         "bytes"
   5         "testing"
   6
   7         "github.com/bytom/bytom/testutil"
   8 )
   9
  10 func TestPushdataOps(t *testing.T) {
  11         type testStruct struct {
  12                 op      Op
  13                 startVM *virtualMachine
  14                 wantErr error
  15                 wantVM  *virtualMachine
  16         }
  17         cases := []testStruct{{
  18                 op: OP_FALSE,
  19                 startVM: &virtualMachine{
  20                         runLimit:  50000,
  21                         dataStack: [][]byte{},
  22                 },
  23                 wantVM: &virtualMachine{
  24                         runLimit:  49991,
  25                         dataStack: [][]byte{{}},
  26                 },
  27         }, {
  28                 op: OP_FALSE,
  29                 startVM: &virtualMachine{
  30                         runLimit:  1,
  31                         dataStack: [][]byte{},
  32                 },
  33                 wantErr: ErrRunLimitExceeded,
  34         }, {
  35                 op: OP_1NEGATE,
  36                 startVM: &virtualMachine{
  37                         runLimit:  50000,
  38                         dataStack: [][]byte{},
  39                 },
  40                 wantVM: &virtualMachine{
  41                         runLimit:  49983,
  42                         dataStack: [][]byte{Int64Bytes(-1)},
  43                 },
  44         }, {
  45                 op: OP_1NEGATE,
  46                 startVM: &virtualMachine{
  47                         runLimit:  1,
  48                         dataStack: [][]byte{},
  49                 },
  50                 wantErr: ErrRunLimitExceeded,
  51         }}
  52
  53         pushdataops := []Op{OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4}
  54         for i := 1; i <= 75; i++ {
  55                 pushdataops = append(pushdataops, Op(i))
  56         }
  57         for _, op := range pushdataops {
  58                 cases = append(cases, testStruct{
  59                         op: op,
  60                         startVM: &virtualMachine{
  61                                 runLimit:  50000,
  62                                 dataStack: [][]byte{},
  63                                 data:      []byte("data"),
  64                         },
  65                         wantVM: &virtualMachine{
  66                                 runLimit:  49987,
  67                                 dataStack: [][]byte{[]byte("data")},
  68                                 data:      []byte("data"),
  69                         },
  70                 }, testStruct{
  71                         op: op,
  72                         startVM: &virtualMachine{
  73                                 runLimit:  1,
  74                                 dataStack: [][]byte{},
  75                                 data:      []byte("data"),
  76                         },
  77                         wantErr: ErrRunLimitExceeded,
  78                 })
  79         }
  80
  81         pushops := append(pushdataops, OP_FALSE, OP_1NEGATE, OP_NOP)
  82         for _, op := range pushops {
  83                 cases = append(cases, testStruct{
  84                         op: op,
  85                         startVM: &virtualMachine{
  86                                 runLimit:  0,
  87                                 dataStack: [][]byte{},
  88                         },
  89                         wantErr: ErrRunLimitExceeded,
  90                 })
  91         }
  92
  93         for i, c := range cases {
  94                 err := ops[c.op].fn(c.startVM)
  95
  96                 if err != c.wantErr {
  97                         t.Errorf("case %d, op %s: got err = %v want %v", i, ops[c.op].name, err, c.wantErr)
  98                         continue
  99                 }
 100                 if c.wantErr != nil {
 101                         continue
 102                 }
 103
 104                 if !testutil.DeepEqual(c.startVM, c.wantVM) {
 105                         t.Errorf("case %d, op %s: unexpected vm result\n\tgot:  %+v\n\twant: %+v\n", i, ops[c.op].name, c.startVM, c.wantVM)
 106                 }
 107         }
 108 }
 109
 110 func TestPushDataBytes(t *testing.T) {
 111         type test struct {
 112                 data []byte
 113                 want []byte
 114         }
 115         cases := []test{
 116                 {
 117                         data: nil,
 118                         want: []byte{byte(OP_0)},
 119                 },
 120                 {
 121                         data: make([]byte, 255),
 122                         want: append([]byte{byte(OP_PUSHDATA1), 0xff}, make([]byte, 255)...),
 123                 },
 124                 {
 125                         data: make([]byte, 1<<8),
 126                         want: append([]byte{byte(OP_PUSHDATA2), 0, 1}, make([]byte, 1<<8)...),
 127                 },
 128                 {
 129                         data: make([]byte, 1<<16),
 130                         want: append([]byte{byte(OP_PUSHDATA4), 0, 0, 1, 0}, make([]byte, 1<<16)...),
 131                 },
 132                 {
 133                         data: make([]byte, 1<<16),
 134                         want: append([]byte{byte(OP_PUSHDATA4), 0, 0, 1, 0}, make([]byte, 1<<16)...),
 135                 },
 136         }
 137
 138         for i := 1; i <= 75; i++ {
 139                 cases = append(cases, test{
 140                         data: make([]byte, i),
 141                         want: append([]byte{byte(OP_DATA_1) - 1 + byte(i)}, make([]byte, i)...),
 142                 })
 143         }
 144
 145         for _, c := range cases {
 146                 got := PushDataBytes(c.data)
 147
 148                 dl := len(c.data)
 149                 if dl > 10 {
 150                         dl = 10
 151                 }
 152                 if !bytes.Equal(got, c.want) {
 153                         t.Errorf("PushDataBytes(%x...) = %x...[%d] want %x...[%d]", c.data[:dl], got[:dl], len(got), c.want[:dl], len(c.want))
 154                 }
 155         }
 156 }
 157
 158 func TestPushdataInt64(t *testing.T) {
 159         type test struct {
 160                 num  int64
 161                 want []byte
 162         }
 163         cases := []test{{
 164                 num:  0,
 165                 want: []byte{byte(OP_0)},
 166         }, {
 167                 num:  17,
 168                 want: []byte{byte(OP_DATA_1), 0x11},
 169         }, {
 170                 num:  255,
 171                 want: []byte{byte(OP_DATA_1), 0xff},
 172         }, {
 173                 num:  256,
 174                 want: []byte{byte(OP_DATA_2), 0x00, 0x01},
 175         }, {
 176                 num:  -1,
 177                 want: []byte{byte(OP_DATA_8), 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
 178         }, {
 179                 num:  -2,
 180                 want: []byte{byte(OP_DATA_8), 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
 181         }}
 182
 183         for i := 1; i <= 16; i++ {
 184                 cases = append(cases, test{
 185                         num:  int64(i),
 186                         want: []byte{byte(OP_1) - 1 + byte(i)},
 187                 })
 188         }
 189
 190         for _, c := range cases {
 191                 got := PushDataInt64(c.num)
 192
 193                 if !bytes.Equal(got, c.want) {
 194                         t.Errorf("PushDataInt64(%d) = %x want %x", c.num, got, c.want)
 195                 }
 196         }
 197 }