6 "github.com/davecgh/go-spew/spew"
8 "github.com/vapor/errors"
9 "github.com/vapor/testutil"
12 func TestOutputIDAndNonceOp(t *testing.T) {
14 outputID := mustDecodeHex("0a60f9b12950c84c221012a808ef7782823b7e16b71fe2ba01811cda96a217df")
16 prog := []byte{uint8(OP_OUTPUTID)}
17 vm := &virtualMachine{
20 context: &Context{SpentOutputID: &outputID},
28 expectedStack := [][]byte{outputID}
29 if !testutil.DeepEqual(gotVM.dataStack, expectedStack) {
30 t.Errorf("expected stack %v, got %v; vm is:\n%s", expectedStack, gotVM.dataStack, spew.Sdump(vm))
33 prog = []byte{uint8(OP_OUTPUTID)}
37 context: &Context{SpentOutputID: nil},
40 if err != ErrContext {
41 t.Errorf("expected ErrContext, got %v", err)
45 func TestBlockHeight(t *testing.T) {
46 var blockHeight uint64 = 6666
48 prog, err := Assemble("BLOCKHEIGHT 6666 NUMEQUAL")
52 vm := &virtualMachine{
55 context: &Context{BlockHeight: &blockHeight},
59 t.Errorf("got error %s, expected none", err)
62 t.Error("result is false, want success")
65 prog, err = Assemble("BLOCKHEIGHT 7777 NUMEQUAL")
72 context: &Context{BlockHeight: &blockHeight},
75 if err == nil && vm.falseResult() {
76 err = ErrFalseVMResult
80 t.Error("got ok result, expected failure")
81 case ErrFalseVMResult:
84 t.Errorf("got error %s, expected ErrFalseVMResult", err)
88 func TestIntrospectionOps(t *testing.T) {
90 entryID := mustDecodeHex("2e68d78cdeaa98944c12512cf9c719eb4881e9afb61e4b766df5f369aee6392c")
91 assetID := mustDecodeHex("0100000000000000000000000000000000000000000000000000000000000000")
93 type testStruct struct {
95 startVM *virtualMachine
97 wantVM *virtualMachine
99 cases := []testStruct{{
101 startVM: &virtualMachine{
105 append([]byte{9}, make([]byte, 31)...),
107 []byte("missingprog"),
110 CheckOutput: func(uint64, uint64, []byte, uint64, []byte, bool) (bool, error) {
115 wantVM: &virtualMachine{
118 dataStack: [][]byte{{}},
122 startVM: &virtualMachine{
125 mustDecodeHex("1f2a05f881ed9fa0c9068a84823677409f863891a2196eb55dbfbb677a566374"),
127 append([]byte{2}, make([]byte, 31)...),
129 []byte("controlprog"),
133 wantErr: ErrBadValue,
136 startVM: &virtualMachine{
139 mustDecodeHex("1f2a05f881ed9fa0c9068a84823677409f863891a2196eb55dbfbb677a566374"),
141 append([]byte{2}, make([]byte, 31)...),
143 []byte("controlprog"),
147 wantErr: ErrBadValue,
150 startVM: &virtualMachine{
153 mustDecodeHex("1f2a05f881ed9fa0c9068a84823677409f863891a2196eb55dbfbb677a566374"),
155 append([]byte{2}, make([]byte, 31)...),
157 []byte("controlprog"),
161 wantErr: ErrBadValue,
164 startVM: &virtualMachine{
167 mustDecodeHex("1f2a05f881ed9fa0c9068a84823677409f863891a2196eb55dbfbb677a566374"),
169 append([]byte{2}, make([]byte, 31)...),
171 []byte("controlprog"),
174 CheckOutput: func(uint64, uint64, []byte, uint64, []byte, bool) (bool, error) {
175 return false, ErrBadValue
179 wantErr: ErrBadValue,
182 startVM: &virtualMachine{
186 mustDecodeHex("1f2a05f881ed9fa0c9068a84823677409f863891a2196eb55dbfbb677a566374"),
188 append([]byte{2}, make([]byte, 31)...),
190 []byte("controlprog"),
194 wantErr: ErrRunLimitExceeded,
197 startVM: &virtualMachine{
198 context: &Context{AssetID: &assetID},
200 wantVM: &virtualMachine{
203 dataStack: [][]byte{assetID},
207 startVM: &virtualMachine{
208 context: &Context{Amount: uint64ptr(5)},
210 wantVM: &virtualMachine{
213 dataStack: [][]byte{{5}},
217 startVM: &virtualMachine{
218 program: []byte("spendprog"),
219 context: &Context{Code: []byte("spendprog")},
221 wantVM: &virtualMachine{
224 dataStack: [][]byte{[]byte("spendprog")},
228 startVM: &virtualMachine{
229 program: []byte("issueprog"),
231 context: &Context{Code: []byte("issueprog")},
233 wantVM: &virtualMachine{
236 dataStack: [][]byte{[]byte("issueprog")},
240 startVM: &virtualMachine{
241 context: &Context{DestPos: new(uint64)},
243 wantVM: &virtualMachine{
246 dataStack: [][]byte{[]byte{}},
250 startVM: &virtualMachine{
251 context: &Context{EntryID: entryID},
253 wantVM: &virtualMachine{
256 dataStack: [][]byte{entryID},
261 OP_CHECKOUTPUT, OP_ASSET, OP_AMOUNT, OP_PROGRAM,
262 OP_INDEX, OP_OUTPUTID,
265 for _, op := range txops {
266 cases = append(cases, testStruct{
268 startVM: &virtualMachine{
272 wantErr: ErrRunLimitExceeded,
276 for i, c := range cases {
278 prog := []byte{byte(c.op)}
280 if c.wantErr != ErrRunLimitExceeded {
285 switch errors.Root(err) {
289 t.Errorf("case %d, op %s: got no error, want %v", i, ops[c.op].name, c.wantErr)
291 t.Errorf("case %d, op %s: got err = %v want %v", i, ops[c.op].name, err, c.wantErr)
293 if c.wantErr != nil {
298 c.wantVM.program = prog
301 c.wantVM.context = gotVM.context
303 if !testutil.DeepEqual(gotVM, c.wantVM) {
304 t.Errorf("case %d, op %s: unexpected vm result\n\tgot: %+v\n\twant: %+v\nstartVM is:\n%s", i, ops[c.op].name, gotVM, c.wantVM, spew.Sdump(c.startVM))
309 func uint64ptr(n uint64) *uint64 { return &n }