script_test.go raw

   1  package txscript
   2  
   3  import (
   4  	"bytes"
   5  	"reflect"
   6  	"testing"
   7  )
   8  
   9  // TestParseOpcode tests for opcode parsing with bad data templates.
  10  func TestParseOpcode(t *testing.T) {
  11  	// Deep copy the array and make one of the opcodes invalid by setting it to the wrong length.
  12  	fakeArray := OpcodeArray
  13  	fakeArray[OP_PUSHDATA4] = opcode{value: OP_PUSHDATA4,
  14  		name: "OP_PUSHDATA4", length: -8, opfunc: opcodePushData,
  15  	}
  16  	// This script would be fine if -8 was a valid length.
  17  	_, e := ParseScriptTemplate([]byte{OP_PUSHDATA4, 0x1, 0x00, 0x00,
  18  		0x00, 0x00, 0x00, 0x00, 0x00,
  19  	}, &fakeArray,
  20  	)
  21  	if e == nil {
  22  		t.Errorf("no error with dodgy opcode array!")
  23  	}
  24  }
  25  
  26  // TestUnparsingInvalidOpcodes tests for errors when unparsing invalid parsed opcodes.
  27  func TestUnparsingInvalidOpcodes(t *testing.T) {
  28  	tests := []struct {
  29  		name        string
  30  		pop         *parsedOpcode
  31  		expectedErr error
  32  	}{
  33  		{
  34  			name: "OP_FALSE",
  35  			pop: &parsedOpcode{
  36  				opcode: &OpcodeArray[OP_FALSE],
  37  				data:   nil,
  38  			},
  39  			expectedErr: nil,
  40  		},
  41  		{
  42  			name: "OP_FALSE long",
  43  			pop: &parsedOpcode{
  44  				opcode: &OpcodeArray[OP_FALSE],
  45  				data:   make([]byte, 1),
  46  			},
  47  			expectedErr: scriptError(ErrInternal, ""),
  48  		},
  49  		{
  50  			name: "OP_DATA_1 short",
  51  			pop: &parsedOpcode{
  52  				opcode: &OpcodeArray[OP_DATA_1],
  53  				data:   nil,
  54  			},
  55  			expectedErr: scriptError(ErrInternal, ""),
  56  		},
  57  		{
  58  			name: "OP_DATA_1",
  59  			pop: &parsedOpcode{
  60  				opcode: &OpcodeArray[OP_DATA_1],
  61  				data:   make([]byte, 1),
  62  			},
  63  			expectedErr: nil,
  64  		},
  65  		{
  66  			name: "OP_DATA_1 long",
  67  			pop: &parsedOpcode{
  68  				opcode: &OpcodeArray[OP_DATA_1],
  69  				data:   make([]byte, 2),
  70  			},
  71  			expectedErr: scriptError(ErrInternal, ""),
  72  		},
  73  		{
  74  			name: "OP_DATA_2 short",
  75  			pop: &parsedOpcode{
  76  				opcode: &OpcodeArray[OP_DATA_2],
  77  				data:   make([]byte, 1),
  78  			},
  79  			expectedErr: scriptError(ErrInternal, ""),
  80  		},
  81  		{
  82  			name: "OP_DATA_2",
  83  			pop: &parsedOpcode{
  84  				opcode: &OpcodeArray[OP_DATA_2],
  85  				data:   make([]byte, 2),
  86  			},
  87  			expectedErr: nil,
  88  		},
  89  		{
  90  			name: "OP_DATA_2 long",
  91  			pop: &parsedOpcode{
  92  				opcode: &OpcodeArray[OP_DATA_2],
  93  				data:   make([]byte, 3),
  94  			},
  95  			expectedErr: scriptError(ErrInternal, ""),
  96  		},
  97  		{
  98  			name: "OP_DATA_3 short",
  99  			pop: &parsedOpcode{
 100  				opcode: &OpcodeArray[OP_DATA_3],
 101  				data:   make([]byte, 2),
 102  			},
 103  			expectedErr: scriptError(ErrInternal, ""),
 104  		},
 105  		{
 106  			name: "OP_DATA_3",
 107  			pop: &parsedOpcode{
 108  				opcode: &OpcodeArray[OP_DATA_3],
 109  				data:   make([]byte, 3),
 110  			},
 111  			expectedErr: nil,
 112  		},
 113  		{
 114  			name: "OP_DATA_3 long",
 115  			pop: &parsedOpcode{
 116  				opcode: &OpcodeArray[OP_DATA_3],
 117  				data:   make([]byte, 4),
 118  			},
 119  			expectedErr: scriptError(ErrInternal, ""),
 120  		},
 121  		{
 122  			name: "OP_DATA_4 short",
 123  			pop: &parsedOpcode{
 124  				opcode: &OpcodeArray[OP_DATA_4],
 125  				data:   make([]byte, 3),
 126  			},
 127  			expectedErr: scriptError(ErrInternal, ""),
 128  		},
 129  		{
 130  			name: "OP_DATA_4",
 131  			pop: &parsedOpcode{
 132  				opcode: &OpcodeArray[OP_DATA_4],
 133  				data:   make([]byte, 4),
 134  			},
 135  			expectedErr: nil,
 136  		},
 137  		{
 138  			name: "OP_DATA_4 long",
 139  			pop: &parsedOpcode{
 140  				opcode: &OpcodeArray[OP_DATA_4],
 141  				data:   make([]byte, 5),
 142  			},
 143  			expectedErr: scriptError(ErrInternal, ""),
 144  		},
 145  		{
 146  			name: "OP_DATA_5 short",
 147  			pop: &parsedOpcode{
 148  				opcode: &OpcodeArray[OP_DATA_5],
 149  				data:   make([]byte, 4),
 150  			},
 151  			expectedErr: scriptError(ErrInternal, ""),
 152  		},
 153  		{
 154  			name: "OP_DATA_5",
 155  			pop: &parsedOpcode{
 156  				opcode: &OpcodeArray[OP_DATA_5],
 157  				data:   make([]byte, 5),
 158  			},
 159  			expectedErr: nil,
 160  		},
 161  		{
 162  			name: "OP_DATA_5 long",
 163  			pop: &parsedOpcode{
 164  				opcode: &OpcodeArray[OP_DATA_5],
 165  				data:   make([]byte, 6),
 166  			},
 167  			expectedErr: scriptError(ErrInternal, ""),
 168  		},
 169  		{
 170  			name: "OP_DATA_6 short",
 171  			pop: &parsedOpcode{
 172  				opcode: &OpcodeArray[OP_DATA_6],
 173  				data:   make([]byte, 5),
 174  			},
 175  			expectedErr: scriptError(ErrInternal, ""),
 176  		},
 177  		{
 178  			name: "OP_DATA_6",
 179  			pop: &parsedOpcode{
 180  				opcode: &OpcodeArray[OP_DATA_6],
 181  				data:   make([]byte, 6),
 182  			},
 183  			expectedErr: nil,
 184  		},
 185  		{
 186  			name: "OP_DATA_6 long",
 187  			pop: &parsedOpcode{
 188  				opcode: &OpcodeArray[OP_DATA_6],
 189  				data:   make([]byte, 7),
 190  			},
 191  			expectedErr: scriptError(ErrInternal, ""),
 192  		},
 193  		{
 194  			name: "OP_DATA_7 short",
 195  			pop: &parsedOpcode{
 196  				opcode: &OpcodeArray[OP_DATA_7],
 197  				data:   make([]byte, 6),
 198  			},
 199  			expectedErr: scriptError(ErrInternal, ""),
 200  		},
 201  		{
 202  			name: "OP_DATA_7",
 203  			pop: &parsedOpcode{
 204  				opcode: &OpcodeArray[OP_DATA_7],
 205  				data:   make([]byte, 7),
 206  			},
 207  			expectedErr: nil,
 208  		},
 209  		{
 210  			name: "OP_DATA_7 long",
 211  			pop: &parsedOpcode{
 212  				opcode: &OpcodeArray[OP_DATA_7],
 213  				data:   make([]byte, 8),
 214  			},
 215  			expectedErr: scriptError(ErrInternal, ""),
 216  		},
 217  		{
 218  			name: "OP_DATA_8 short",
 219  			pop: &parsedOpcode{
 220  				opcode: &OpcodeArray[OP_DATA_8],
 221  				data:   make([]byte, 7),
 222  			},
 223  			expectedErr: scriptError(ErrInternal, ""),
 224  		},
 225  		{
 226  			name: "OP_DATA_8",
 227  			pop: &parsedOpcode{
 228  				opcode: &OpcodeArray[OP_DATA_8],
 229  				data:   make([]byte, 8),
 230  			},
 231  			expectedErr: nil,
 232  		},
 233  		{
 234  			name: "OP_DATA_8 long",
 235  			pop: &parsedOpcode{
 236  				opcode: &OpcodeArray[OP_DATA_8],
 237  				data:   make([]byte, 9),
 238  			},
 239  			expectedErr: scriptError(ErrInternal, ""),
 240  		},
 241  		{
 242  			name: "OP_DATA_9 short",
 243  			pop: &parsedOpcode{
 244  				opcode: &OpcodeArray[OP_DATA_9],
 245  				data:   make([]byte, 8),
 246  			},
 247  			expectedErr: scriptError(ErrInternal, ""),
 248  		},
 249  		{
 250  			name: "OP_DATA_9",
 251  			pop: &parsedOpcode{
 252  				opcode: &OpcodeArray[OP_DATA_9],
 253  				data:   make([]byte, 9),
 254  			},
 255  			expectedErr: nil,
 256  		},
 257  		{
 258  			name: "OP_DATA_9 long",
 259  			pop: &parsedOpcode{
 260  				opcode: &OpcodeArray[OP_DATA_9],
 261  				data:   make([]byte, 10),
 262  			},
 263  			expectedErr: scriptError(ErrInternal, ""),
 264  		},
 265  		{
 266  			name: "OP_DATA_10 short",
 267  			pop: &parsedOpcode{
 268  				opcode: &OpcodeArray[OP_DATA_10],
 269  				data:   make([]byte, 9),
 270  			},
 271  			expectedErr: scriptError(ErrInternal, ""),
 272  		},
 273  		{
 274  			name: "OP_DATA_10",
 275  			pop: &parsedOpcode{
 276  				opcode: &OpcodeArray[OP_DATA_10],
 277  				data:   make([]byte, 10),
 278  			},
 279  			expectedErr: nil,
 280  		},
 281  		{
 282  			name: "OP_DATA_10 long",
 283  			pop: &parsedOpcode{
 284  				opcode: &OpcodeArray[OP_DATA_10],
 285  				data:   make([]byte, 11),
 286  			},
 287  			expectedErr: scriptError(ErrInternal, ""),
 288  		},
 289  		{
 290  			name: "OP_DATA_11 short",
 291  			pop: &parsedOpcode{
 292  				opcode: &OpcodeArray[OP_DATA_11],
 293  				data:   make([]byte, 10),
 294  			},
 295  			expectedErr: scriptError(ErrInternal, ""),
 296  		},
 297  		{
 298  			name: "OP_DATA_11",
 299  			pop: &parsedOpcode{
 300  				opcode: &OpcodeArray[OP_DATA_11],
 301  				data:   make([]byte, 11),
 302  			},
 303  			expectedErr: nil,
 304  		},
 305  		{
 306  			name: "OP_DATA_11 long",
 307  			pop: &parsedOpcode{
 308  				opcode: &OpcodeArray[OP_DATA_11],
 309  				data:   make([]byte, 12),
 310  			},
 311  			expectedErr: scriptError(ErrInternal, ""),
 312  		},
 313  		{
 314  			name: "OP_DATA_12 short",
 315  			pop: &parsedOpcode{
 316  				opcode: &OpcodeArray[OP_DATA_12],
 317  				data:   make([]byte, 11),
 318  			},
 319  			expectedErr: scriptError(ErrInternal, ""),
 320  		},
 321  		{
 322  			name: "OP_DATA_12",
 323  			pop: &parsedOpcode{
 324  				opcode: &OpcodeArray[OP_DATA_12],
 325  				data:   make([]byte, 12),
 326  			},
 327  			expectedErr: nil,
 328  		},
 329  		{
 330  			name: "OP_DATA_12 long",
 331  			pop: &parsedOpcode{
 332  				opcode: &OpcodeArray[OP_DATA_12],
 333  				data:   make([]byte, 13),
 334  			},
 335  			expectedErr: scriptError(ErrInternal, ""),
 336  		},
 337  		{
 338  			name: "OP_DATA_13 short",
 339  			pop: &parsedOpcode{
 340  				opcode: &OpcodeArray[OP_DATA_13],
 341  				data:   make([]byte, 12),
 342  			},
 343  			expectedErr: scriptError(ErrInternal, ""),
 344  		},
 345  		{
 346  			name: "OP_DATA_13",
 347  			pop: &parsedOpcode{
 348  				opcode: &OpcodeArray[OP_DATA_13],
 349  				data:   make([]byte, 13),
 350  			},
 351  			expectedErr: nil,
 352  		},
 353  		{
 354  			name: "OP_DATA_13 long",
 355  			pop: &parsedOpcode{
 356  				opcode: &OpcodeArray[OP_DATA_13],
 357  				data:   make([]byte, 14),
 358  			},
 359  			expectedErr: scriptError(ErrInternal, ""),
 360  		},
 361  		{
 362  			name: "OP_DATA_14 short",
 363  			pop: &parsedOpcode{
 364  				opcode: &OpcodeArray[OP_DATA_14],
 365  				data:   make([]byte, 13),
 366  			},
 367  			expectedErr: scriptError(ErrInternal, ""),
 368  		},
 369  		{
 370  			name: "OP_DATA_14",
 371  			pop: &parsedOpcode{
 372  				opcode: &OpcodeArray[OP_DATA_14],
 373  				data:   make([]byte, 14),
 374  			},
 375  			expectedErr: nil,
 376  		},
 377  		{
 378  			name: "OP_DATA_14 long",
 379  			pop: &parsedOpcode{
 380  				opcode: &OpcodeArray[OP_DATA_14],
 381  				data:   make([]byte, 15),
 382  			},
 383  			expectedErr: scriptError(ErrInternal, ""),
 384  		},
 385  		{
 386  			name: "OP_DATA_15 short",
 387  			pop: &parsedOpcode{
 388  				opcode: &OpcodeArray[OP_DATA_15],
 389  				data:   make([]byte, 14),
 390  			},
 391  			expectedErr: scriptError(ErrInternal, ""),
 392  		},
 393  		{
 394  			name: "OP_DATA_15",
 395  			pop: &parsedOpcode{
 396  				opcode: &OpcodeArray[OP_DATA_15],
 397  				data:   make([]byte, 15),
 398  			},
 399  			expectedErr: nil,
 400  		},
 401  		{
 402  			name: "OP_DATA_15 long",
 403  			pop: &parsedOpcode{
 404  				opcode: &OpcodeArray[OP_DATA_15],
 405  				data:   make([]byte, 16),
 406  			},
 407  			expectedErr: scriptError(ErrInternal, ""),
 408  		},
 409  		{
 410  			name: "OP_DATA_16 short",
 411  			pop: &parsedOpcode{
 412  				opcode: &OpcodeArray[OP_DATA_16],
 413  				data:   make([]byte, 15),
 414  			},
 415  			expectedErr: scriptError(ErrInternal, ""),
 416  		},
 417  		{
 418  			name: "OP_DATA_16",
 419  			pop: &parsedOpcode{
 420  				opcode: &OpcodeArray[OP_DATA_16],
 421  				data:   make([]byte, 16),
 422  			},
 423  			expectedErr: nil,
 424  		},
 425  		{
 426  			name: "OP_DATA_16 long",
 427  			pop: &parsedOpcode{
 428  				opcode: &OpcodeArray[OP_DATA_16],
 429  				data:   make([]byte, 17),
 430  			},
 431  			expectedErr: scriptError(ErrInternal, ""),
 432  		},
 433  		{
 434  			name: "OP_DATA_17 short",
 435  			pop: &parsedOpcode{
 436  				opcode: &OpcodeArray[OP_DATA_17],
 437  				data:   make([]byte, 16),
 438  			},
 439  			expectedErr: scriptError(ErrInternal, ""),
 440  		},
 441  		{
 442  			name: "OP_DATA_17",
 443  			pop: &parsedOpcode{
 444  				opcode: &OpcodeArray[OP_DATA_17],
 445  				data:   make([]byte, 17),
 446  			},
 447  			expectedErr: nil,
 448  		},
 449  		{
 450  			name: "OP_DATA_17 long",
 451  			pop: &parsedOpcode{
 452  				opcode: &OpcodeArray[OP_DATA_17],
 453  				data:   make([]byte, 18),
 454  			},
 455  			expectedErr: scriptError(ErrInternal, ""),
 456  		},
 457  		{
 458  			name: "OP_DATA_18 short",
 459  			pop: &parsedOpcode{
 460  				opcode: &OpcodeArray[OP_DATA_18],
 461  				data:   make([]byte, 17),
 462  			},
 463  			expectedErr: scriptError(ErrInternal, ""),
 464  		},
 465  		{
 466  			name: "OP_DATA_18",
 467  			pop: &parsedOpcode{
 468  				opcode: &OpcodeArray[OP_DATA_18],
 469  				data:   make([]byte, 18),
 470  			},
 471  			expectedErr: nil,
 472  		},
 473  		{
 474  			name: "OP_DATA_18 long",
 475  			pop: &parsedOpcode{
 476  				opcode: &OpcodeArray[OP_DATA_18],
 477  				data:   make([]byte, 19),
 478  			},
 479  			expectedErr: scriptError(ErrInternal, ""),
 480  		},
 481  		{
 482  			name: "OP_DATA_19 short",
 483  			pop: &parsedOpcode{
 484  				opcode: &OpcodeArray[OP_DATA_19],
 485  				data:   make([]byte, 18),
 486  			},
 487  			expectedErr: scriptError(ErrInternal, ""),
 488  		},
 489  		{
 490  			name: "OP_DATA_19",
 491  			pop: &parsedOpcode{
 492  				opcode: &OpcodeArray[OP_DATA_19],
 493  				data:   make([]byte, 19),
 494  			},
 495  			expectedErr: nil,
 496  		},
 497  		{
 498  			name: "OP_DATA_19 long",
 499  			pop: &parsedOpcode{
 500  				opcode: &OpcodeArray[OP_DATA_19],
 501  				data:   make([]byte, 20),
 502  			},
 503  			expectedErr: scriptError(ErrInternal, ""),
 504  		},
 505  		{
 506  			name: "OP_DATA_20 short",
 507  			pop: &parsedOpcode{
 508  				opcode: &OpcodeArray[OP_DATA_20],
 509  				data:   make([]byte, 19),
 510  			},
 511  			expectedErr: scriptError(ErrInternal, ""),
 512  		},
 513  		{
 514  			name: "OP_DATA_20",
 515  			pop: &parsedOpcode{
 516  				opcode: &OpcodeArray[OP_DATA_20],
 517  				data:   make([]byte, 20),
 518  			},
 519  			expectedErr: nil,
 520  		},
 521  		{
 522  			name: "OP_DATA_20 long",
 523  			pop: &parsedOpcode{
 524  				opcode: &OpcodeArray[OP_DATA_20],
 525  				data:   make([]byte, 21),
 526  			},
 527  			expectedErr: scriptError(ErrInternal, ""),
 528  		},
 529  		{
 530  			name: "OP_DATA_21 short",
 531  			pop: &parsedOpcode{
 532  				opcode: &OpcodeArray[OP_DATA_21],
 533  				data:   make([]byte, 20),
 534  			},
 535  			expectedErr: scriptError(ErrInternal, ""),
 536  		},
 537  		{
 538  			name: "OP_DATA_21",
 539  			pop: &parsedOpcode{
 540  				opcode: &OpcodeArray[OP_DATA_21],
 541  				data:   make([]byte, 21),
 542  			},
 543  			expectedErr: nil,
 544  		},
 545  		{
 546  			name: "OP_DATA_21 long",
 547  			pop: &parsedOpcode{
 548  				opcode: &OpcodeArray[OP_DATA_21],
 549  				data:   make([]byte, 22),
 550  			},
 551  			expectedErr: scriptError(ErrInternal, ""),
 552  		},
 553  		{
 554  			name: "OP_DATA_22 short",
 555  			pop: &parsedOpcode{
 556  				opcode: &OpcodeArray[OP_DATA_22],
 557  				data:   make([]byte, 21),
 558  			},
 559  			expectedErr: scriptError(ErrInternal, ""),
 560  		},
 561  		{
 562  			name: "OP_DATA_22",
 563  			pop: &parsedOpcode{
 564  				opcode: &OpcodeArray[OP_DATA_22],
 565  				data:   make([]byte, 22),
 566  			},
 567  			expectedErr: nil,
 568  		},
 569  		{
 570  			name: "OP_DATA_22 long",
 571  			pop: &parsedOpcode{
 572  				opcode: &OpcodeArray[OP_DATA_22],
 573  				data:   make([]byte, 23),
 574  			},
 575  			expectedErr: scriptError(ErrInternal, ""),
 576  		},
 577  		{
 578  			name: "OP_DATA_23 short",
 579  			pop: &parsedOpcode{
 580  				opcode: &OpcodeArray[OP_DATA_23],
 581  				data:   make([]byte, 22),
 582  			},
 583  			expectedErr: scriptError(ErrInternal, ""),
 584  		},
 585  		{
 586  			name: "OP_DATA_23",
 587  			pop: &parsedOpcode{
 588  				opcode: &OpcodeArray[OP_DATA_23],
 589  				data:   make([]byte, 23),
 590  			},
 591  			expectedErr: nil,
 592  		},
 593  		{
 594  			name: "OP_DATA_23 long",
 595  			pop: &parsedOpcode{
 596  				opcode: &OpcodeArray[OP_DATA_23],
 597  				data:   make([]byte, 24),
 598  			},
 599  			expectedErr: scriptError(ErrInternal, ""),
 600  		},
 601  		{
 602  			name: "OP_DATA_24 short",
 603  			pop: &parsedOpcode{
 604  				opcode: &OpcodeArray[OP_DATA_24],
 605  				data:   make([]byte, 23),
 606  			},
 607  			expectedErr: scriptError(ErrInternal, ""),
 608  		},
 609  		{
 610  			name: "OP_DATA_24",
 611  			pop: &parsedOpcode{
 612  				opcode: &OpcodeArray[OP_DATA_24],
 613  				data:   make([]byte, 24),
 614  			},
 615  			expectedErr: nil,
 616  		},
 617  		{
 618  			name: "OP_DATA_24 long",
 619  			pop: &parsedOpcode{
 620  				opcode: &OpcodeArray[OP_DATA_24],
 621  				data:   make([]byte, 25),
 622  			},
 623  			expectedErr: scriptError(ErrInternal, ""),
 624  		},
 625  		{
 626  			name: "OP_DATA_25 short",
 627  			pop: &parsedOpcode{
 628  				opcode: &OpcodeArray[OP_DATA_25],
 629  				data:   make([]byte, 24),
 630  			},
 631  			expectedErr: scriptError(ErrInternal, ""),
 632  		},
 633  		{
 634  			name: "OP_DATA_25",
 635  			pop: &parsedOpcode{
 636  				opcode: &OpcodeArray[OP_DATA_25],
 637  				data:   make([]byte, 25),
 638  			},
 639  			expectedErr: nil,
 640  		},
 641  		{
 642  			name: "OP_DATA_25 long",
 643  			pop: &parsedOpcode{
 644  				opcode: &OpcodeArray[OP_DATA_25],
 645  				data:   make([]byte, 26),
 646  			},
 647  			expectedErr: scriptError(ErrInternal, ""),
 648  		},
 649  		{
 650  			name: "OP_DATA_26 short",
 651  			pop: &parsedOpcode{
 652  				opcode: &OpcodeArray[OP_DATA_26],
 653  				data:   make([]byte, 25),
 654  			},
 655  			expectedErr: scriptError(ErrInternal, ""),
 656  		},
 657  		{
 658  			name: "OP_DATA_26",
 659  			pop: &parsedOpcode{
 660  				opcode: &OpcodeArray[OP_DATA_26],
 661  				data:   make([]byte, 26),
 662  			},
 663  			expectedErr: nil,
 664  		},
 665  		{
 666  			name: "OP_DATA_26 long",
 667  			pop: &parsedOpcode{
 668  				opcode: &OpcodeArray[OP_DATA_26],
 669  				data:   make([]byte, 27),
 670  			},
 671  			expectedErr: scriptError(ErrInternal, ""),
 672  		},
 673  		{
 674  			name: "OP_DATA_27 short",
 675  			pop: &parsedOpcode{
 676  				opcode: &OpcodeArray[OP_DATA_27],
 677  				data:   make([]byte, 26),
 678  			},
 679  			expectedErr: scriptError(ErrInternal, ""),
 680  		},
 681  		{
 682  			name: "OP_DATA_27",
 683  			pop: &parsedOpcode{
 684  				opcode: &OpcodeArray[OP_DATA_27],
 685  				data:   make([]byte, 27),
 686  			},
 687  			expectedErr: nil,
 688  		},
 689  		{
 690  			name: "OP_DATA_27 long",
 691  			pop: &parsedOpcode{
 692  				opcode: &OpcodeArray[OP_DATA_27],
 693  				data:   make([]byte, 28),
 694  			},
 695  			expectedErr: scriptError(ErrInternal, ""),
 696  		},
 697  		{
 698  			name: "OP_DATA_28 short",
 699  			pop: &parsedOpcode{
 700  				opcode: &OpcodeArray[OP_DATA_28],
 701  				data:   make([]byte, 27),
 702  			},
 703  			expectedErr: scriptError(ErrInternal, ""),
 704  		},
 705  		{
 706  			name: "OP_DATA_28",
 707  			pop: &parsedOpcode{
 708  				opcode: &OpcodeArray[OP_DATA_28],
 709  				data:   make([]byte, 28),
 710  			},
 711  			expectedErr: nil,
 712  		},
 713  		{
 714  			name: "OP_DATA_28 long",
 715  			pop: &parsedOpcode{
 716  				opcode: &OpcodeArray[OP_DATA_28],
 717  				data:   make([]byte, 29),
 718  			},
 719  			expectedErr: scriptError(ErrInternal, ""),
 720  		},
 721  		{
 722  			name: "OP_DATA_29 short",
 723  			pop: &parsedOpcode{
 724  				opcode: &OpcodeArray[OP_DATA_29],
 725  				data:   make([]byte, 28),
 726  			},
 727  			expectedErr: scriptError(ErrInternal, ""),
 728  		},
 729  		{
 730  			name: "OP_DATA_29",
 731  			pop: &parsedOpcode{
 732  				opcode: &OpcodeArray[OP_DATA_29],
 733  				data:   make([]byte, 29),
 734  			},
 735  			expectedErr: nil,
 736  		},
 737  		{
 738  			name: "OP_DATA_29 long",
 739  			pop: &parsedOpcode{
 740  				opcode: &OpcodeArray[OP_DATA_29],
 741  				data:   make([]byte, 30),
 742  			},
 743  			expectedErr: scriptError(ErrInternal, ""),
 744  		},
 745  		{
 746  			name: "OP_DATA_30 short",
 747  			pop: &parsedOpcode{
 748  				opcode: &OpcodeArray[OP_DATA_30],
 749  				data:   make([]byte, 29),
 750  			},
 751  			expectedErr: scriptError(ErrInternal, ""),
 752  		},
 753  		{
 754  			name: "OP_DATA_30",
 755  			pop: &parsedOpcode{
 756  				opcode: &OpcodeArray[OP_DATA_30],
 757  				data:   make([]byte, 30),
 758  			},
 759  			expectedErr: nil,
 760  		},
 761  		{
 762  			name: "OP_DATA_30 long",
 763  			pop: &parsedOpcode{
 764  				opcode: &OpcodeArray[OP_DATA_30],
 765  				data:   make([]byte, 31),
 766  			},
 767  			expectedErr: scriptError(ErrInternal, ""),
 768  		},
 769  		{
 770  			name: "OP_DATA_31 short",
 771  			pop: &parsedOpcode{
 772  				opcode: &OpcodeArray[OP_DATA_31],
 773  				data:   make([]byte, 30),
 774  			},
 775  			expectedErr: scriptError(ErrInternal, ""),
 776  		},
 777  		{
 778  			name: "OP_DATA_31",
 779  			pop: &parsedOpcode{
 780  				opcode: &OpcodeArray[OP_DATA_31],
 781  				data:   make([]byte, 31),
 782  			},
 783  			expectedErr: nil,
 784  		},
 785  		{
 786  			name: "OP_DATA_31 long",
 787  			pop: &parsedOpcode{
 788  				opcode: &OpcodeArray[OP_DATA_31],
 789  				data:   make([]byte, 32),
 790  			},
 791  			expectedErr: scriptError(ErrInternal, ""),
 792  		},
 793  		{
 794  			name: "OP_DATA_32 short",
 795  			pop: &parsedOpcode{
 796  				opcode: &OpcodeArray[OP_DATA_32],
 797  				data:   make([]byte, 31),
 798  			},
 799  			expectedErr: scriptError(ErrInternal, ""),
 800  		},
 801  		{
 802  			name: "OP_DATA_32",
 803  			pop: &parsedOpcode{
 804  				opcode: &OpcodeArray[OP_DATA_32],
 805  				data:   make([]byte, 32),
 806  			},
 807  			expectedErr: nil,
 808  		},
 809  		{
 810  			name: "OP_DATA_32 long",
 811  			pop: &parsedOpcode{
 812  				opcode: &OpcodeArray[OP_DATA_32],
 813  				data:   make([]byte, 33),
 814  			},
 815  			expectedErr: scriptError(ErrInternal, ""),
 816  		},
 817  		{
 818  			name: "OP_DATA_33 short",
 819  			pop: &parsedOpcode{
 820  				opcode: &OpcodeArray[OP_DATA_33],
 821  				data:   make([]byte, 32),
 822  			},
 823  			expectedErr: scriptError(ErrInternal, ""),
 824  		},
 825  		{
 826  			name: "OP_DATA_33",
 827  			pop: &parsedOpcode{
 828  				opcode: &OpcodeArray[OP_DATA_33],
 829  				data:   make([]byte, 33),
 830  			},
 831  			expectedErr: nil,
 832  		},
 833  		{
 834  			name: "OP_DATA_33 long",
 835  			pop: &parsedOpcode{
 836  				opcode: &OpcodeArray[OP_DATA_33],
 837  				data:   make([]byte, 34),
 838  			},
 839  			expectedErr: scriptError(ErrInternal, ""),
 840  		},
 841  		{
 842  			name: "OP_DATA_34 short",
 843  			pop: &parsedOpcode{
 844  				opcode: &OpcodeArray[OP_DATA_34],
 845  				data:   make([]byte, 33),
 846  			},
 847  			expectedErr: scriptError(ErrInternal, ""),
 848  		},
 849  		{
 850  			name: "OP_DATA_34",
 851  			pop: &parsedOpcode{
 852  				opcode: &OpcodeArray[OP_DATA_34],
 853  				data:   make([]byte, 34),
 854  			},
 855  			expectedErr: nil,
 856  		},
 857  		{
 858  			name: "OP_DATA_34 long",
 859  			pop: &parsedOpcode{
 860  				opcode: &OpcodeArray[OP_DATA_34],
 861  				data:   make([]byte, 35),
 862  			},
 863  			expectedErr: scriptError(ErrInternal, ""),
 864  		},
 865  		{
 866  			name: "OP_DATA_35 short",
 867  			pop: &parsedOpcode{
 868  				opcode: &OpcodeArray[OP_DATA_35],
 869  				data:   make([]byte, 34),
 870  			},
 871  			expectedErr: scriptError(ErrInternal, ""),
 872  		},
 873  		{
 874  			name: "OP_DATA_35",
 875  			pop: &parsedOpcode{
 876  				opcode: &OpcodeArray[OP_DATA_35],
 877  				data:   make([]byte, 35),
 878  			},
 879  			expectedErr: nil,
 880  		},
 881  		{
 882  			name: "OP_DATA_35 long",
 883  			pop: &parsedOpcode{
 884  				opcode: &OpcodeArray[OP_DATA_35],
 885  				data:   make([]byte, 36),
 886  			},
 887  			expectedErr: scriptError(ErrInternal, ""),
 888  		},
 889  		{
 890  			name: "OP_DATA_36 short",
 891  			pop: &parsedOpcode{
 892  				opcode: &OpcodeArray[OP_DATA_36],
 893  				data:   make([]byte, 35),
 894  			},
 895  			expectedErr: scriptError(ErrInternal, ""),
 896  		},
 897  		{
 898  			name: "OP_DATA_36",
 899  			pop: &parsedOpcode{
 900  				opcode: &OpcodeArray[OP_DATA_36],
 901  				data:   make([]byte, 36),
 902  			},
 903  			expectedErr: nil,
 904  		},
 905  		{
 906  			name: "OP_DATA_36 long",
 907  			pop: &parsedOpcode{
 908  				opcode: &OpcodeArray[OP_DATA_36],
 909  				data:   make([]byte, 37),
 910  			},
 911  			expectedErr: scriptError(ErrInternal, ""),
 912  		},
 913  		{
 914  			name: "OP_DATA_37 short",
 915  			pop: &parsedOpcode{
 916  				opcode: &OpcodeArray[OP_DATA_37],
 917  				data:   make([]byte, 36),
 918  			},
 919  			expectedErr: scriptError(ErrInternal, ""),
 920  		},
 921  		{
 922  			name: "OP_DATA_37",
 923  			pop: &parsedOpcode{
 924  				opcode: &OpcodeArray[OP_DATA_37],
 925  				data:   make([]byte, 37),
 926  			},
 927  			expectedErr: nil,
 928  		},
 929  		{
 930  			name: "OP_DATA_37 long",
 931  			pop: &parsedOpcode{
 932  				opcode: &OpcodeArray[OP_DATA_37],
 933  				data:   make([]byte, 38),
 934  			},
 935  			expectedErr: scriptError(ErrInternal, ""),
 936  		},
 937  		{
 938  			name: "OP_DATA_38 short",
 939  			pop: &parsedOpcode{
 940  				opcode: &OpcodeArray[OP_DATA_38],
 941  				data:   make([]byte, 37),
 942  			},
 943  			expectedErr: scriptError(ErrInternal, ""),
 944  		},
 945  		{
 946  			name: "OP_DATA_38",
 947  			pop: &parsedOpcode{
 948  				opcode: &OpcodeArray[OP_DATA_38],
 949  				data:   make([]byte, 38),
 950  			},
 951  			expectedErr: nil,
 952  		},
 953  		{
 954  			name: "OP_DATA_38 long",
 955  			pop: &parsedOpcode{
 956  				opcode: &OpcodeArray[OP_DATA_38],
 957  				data:   make([]byte, 39),
 958  			},
 959  			expectedErr: scriptError(ErrInternal, ""),
 960  		},
 961  		{
 962  			name: "OP_DATA_39 short",
 963  			pop: &parsedOpcode{
 964  				opcode: &OpcodeArray[OP_DATA_39],
 965  				data:   make([]byte, 38),
 966  			},
 967  			expectedErr: scriptError(ErrInternal, ""),
 968  		},
 969  		{
 970  			name: "OP_DATA_39",
 971  			pop: &parsedOpcode{
 972  				opcode: &OpcodeArray[OP_DATA_39],
 973  				data:   make([]byte, 39),
 974  			},
 975  			expectedErr: nil,
 976  		},
 977  		{
 978  			name: "OP_DATA_39 long",
 979  			pop: &parsedOpcode{
 980  				opcode: &OpcodeArray[OP_DATA_39],
 981  				data:   make([]byte, 40),
 982  			},
 983  			expectedErr: scriptError(ErrInternal, ""),
 984  		},
 985  		{
 986  			name: "OP_DATA_40 short",
 987  			pop: &parsedOpcode{
 988  				opcode: &OpcodeArray[OP_DATA_40],
 989  				data:   make([]byte, 39),
 990  			},
 991  			expectedErr: scriptError(ErrInternal, ""),
 992  		},
 993  		{
 994  			name: "OP_DATA_40",
 995  			pop: &parsedOpcode{
 996  				opcode: &OpcodeArray[OP_DATA_40],
 997  				data:   make([]byte, 40),
 998  			},
 999  			expectedErr: nil,
1000  		},
1001  		{
1002  			name: "OP_DATA_40 long",
1003  			pop: &parsedOpcode{
1004  				opcode: &OpcodeArray[OP_DATA_40],
1005  				data:   make([]byte, 41),
1006  			},
1007  			expectedErr: scriptError(ErrInternal, ""),
1008  		},
1009  		{
1010  			name: "OP_DATA_41 short",
1011  			pop: &parsedOpcode{
1012  				opcode: &OpcodeArray[OP_DATA_41],
1013  				data:   make([]byte, 40),
1014  			},
1015  			expectedErr: scriptError(ErrInternal, ""),
1016  		},
1017  		{
1018  			name: "OP_DATA_41",
1019  			pop: &parsedOpcode{
1020  				opcode: &OpcodeArray[OP_DATA_41],
1021  				data:   make([]byte, 41),
1022  			},
1023  			expectedErr: nil,
1024  		},
1025  		{
1026  			name: "OP_DATA_41 long",
1027  			pop: &parsedOpcode{
1028  				opcode: &OpcodeArray[OP_DATA_41],
1029  				data:   make([]byte, 42),
1030  			},
1031  			expectedErr: scriptError(ErrInternal, ""),
1032  		},
1033  		{
1034  			name: "OP_DATA_42 short",
1035  			pop: &parsedOpcode{
1036  				opcode: &OpcodeArray[OP_DATA_42],
1037  				data:   make([]byte, 41),
1038  			},
1039  			expectedErr: scriptError(ErrInternal, ""),
1040  		},
1041  		{
1042  			name: "OP_DATA_42",
1043  			pop: &parsedOpcode{
1044  				opcode: &OpcodeArray[OP_DATA_42],
1045  				data:   make([]byte, 42),
1046  			},
1047  			expectedErr: nil,
1048  		},
1049  		{
1050  			name: "OP_DATA_42 long",
1051  			pop: &parsedOpcode{
1052  				opcode: &OpcodeArray[OP_DATA_42],
1053  				data:   make([]byte, 43),
1054  			},
1055  			expectedErr: scriptError(ErrInternal, ""),
1056  		},
1057  		{
1058  			name: "OP_DATA_43 short",
1059  			pop: &parsedOpcode{
1060  				opcode: &OpcodeArray[OP_DATA_43],
1061  				data:   make([]byte, 42),
1062  			},
1063  			expectedErr: scriptError(ErrInternal, ""),
1064  		},
1065  		{
1066  			name: "OP_DATA_43",
1067  			pop: &parsedOpcode{
1068  				opcode: &OpcodeArray[OP_DATA_43],
1069  				data:   make([]byte, 43),
1070  			},
1071  			expectedErr: nil,
1072  		},
1073  		{
1074  			name: "OP_DATA_43 long",
1075  			pop: &parsedOpcode{
1076  				opcode: &OpcodeArray[OP_DATA_43],
1077  				data:   make([]byte, 44),
1078  			},
1079  			expectedErr: scriptError(ErrInternal, ""),
1080  		},
1081  		{
1082  			name: "OP_DATA_44 short",
1083  			pop: &parsedOpcode{
1084  				opcode: &OpcodeArray[OP_DATA_44],
1085  				data:   make([]byte, 43),
1086  			},
1087  			expectedErr: scriptError(ErrInternal, ""),
1088  		},
1089  		{
1090  			name: "OP_DATA_44",
1091  			pop: &parsedOpcode{
1092  				opcode: &OpcodeArray[OP_DATA_44],
1093  				data:   make([]byte, 44),
1094  			},
1095  			expectedErr: nil,
1096  		},
1097  		{
1098  			name: "OP_DATA_44 long",
1099  			pop: &parsedOpcode{
1100  				opcode: &OpcodeArray[OP_DATA_44],
1101  				data:   make([]byte, 45),
1102  			},
1103  			expectedErr: scriptError(ErrInternal, ""),
1104  		},
1105  		{
1106  			name: "OP_DATA_45 short",
1107  			pop: &parsedOpcode{
1108  				opcode: &OpcodeArray[OP_DATA_45],
1109  				data:   make([]byte, 44),
1110  			},
1111  			expectedErr: scriptError(ErrInternal, ""),
1112  		},
1113  		{
1114  			name: "OP_DATA_45",
1115  			pop: &parsedOpcode{
1116  				opcode: &OpcodeArray[OP_DATA_45],
1117  				data:   make([]byte, 45),
1118  			},
1119  			expectedErr: nil,
1120  		},
1121  		{
1122  			name: "OP_DATA_45 long",
1123  			pop: &parsedOpcode{
1124  				opcode: &OpcodeArray[OP_DATA_45],
1125  				data:   make([]byte, 46),
1126  			},
1127  			expectedErr: scriptError(ErrInternal, ""),
1128  		},
1129  		{
1130  			name: "OP_DATA_46 short",
1131  			pop: &parsedOpcode{
1132  				opcode: &OpcodeArray[OP_DATA_46],
1133  				data:   make([]byte, 45),
1134  			},
1135  			expectedErr: scriptError(ErrInternal, ""),
1136  		},
1137  		{
1138  			name: "OP_DATA_46",
1139  			pop: &parsedOpcode{
1140  				opcode: &OpcodeArray[OP_DATA_46],
1141  				data:   make([]byte, 46),
1142  			},
1143  			expectedErr: nil,
1144  		},
1145  		{
1146  			name: "OP_DATA_46 long",
1147  			pop: &parsedOpcode{
1148  				opcode: &OpcodeArray[OP_DATA_46],
1149  				data:   make([]byte, 47),
1150  			},
1151  			expectedErr: scriptError(ErrInternal, ""),
1152  		},
1153  		{
1154  			name: "OP_DATA_47 short",
1155  			pop: &parsedOpcode{
1156  				opcode: &OpcodeArray[OP_DATA_47],
1157  				data:   make([]byte, 46),
1158  			},
1159  			expectedErr: scriptError(ErrInternal, ""),
1160  		},
1161  		{
1162  			name: "OP_DATA_47",
1163  			pop: &parsedOpcode{
1164  				opcode: &OpcodeArray[OP_DATA_47],
1165  				data:   make([]byte, 47),
1166  			},
1167  			expectedErr: nil,
1168  		},
1169  		{
1170  			name: "OP_DATA_47 long",
1171  			pop: &parsedOpcode{
1172  				opcode: &OpcodeArray[OP_DATA_47],
1173  				data:   make([]byte, 48),
1174  			},
1175  			expectedErr: scriptError(ErrInternal, ""),
1176  		},
1177  		{
1178  			name: "OP_DATA_48 short",
1179  			pop: &parsedOpcode{
1180  				opcode: &OpcodeArray[OP_DATA_48],
1181  				data:   make([]byte, 47),
1182  			},
1183  			expectedErr: scriptError(ErrInternal, ""),
1184  		},
1185  		{
1186  			name: "OP_DATA_48",
1187  			pop: &parsedOpcode{
1188  				opcode: &OpcodeArray[OP_DATA_48],
1189  				data:   make([]byte, 48),
1190  			},
1191  			expectedErr: nil,
1192  		},
1193  		{
1194  			name: "OP_DATA_48 long",
1195  			pop: &parsedOpcode{
1196  				opcode: &OpcodeArray[OP_DATA_48],
1197  				data:   make([]byte, 49),
1198  			},
1199  			expectedErr: scriptError(ErrInternal, ""),
1200  		},
1201  		{
1202  			name: "OP_DATA_49 short",
1203  			pop: &parsedOpcode{
1204  				opcode: &OpcodeArray[OP_DATA_49],
1205  				data:   make([]byte, 48),
1206  			},
1207  			expectedErr: scriptError(ErrInternal, ""),
1208  		},
1209  		{
1210  			name: "OP_DATA_49",
1211  			pop: &parsedOpcode{
1212  				opcode: &OpcodeArray[OP_DATA_49],
1213  				data:   make([]byte, 49),
1214  			},
1215  			expectedErr: nil,
1216  		},
1217  		{
1218  			name: "OP_DATA_49 long",
1219  			pop: &parsedOpcode{
1220  				opcode: &OpcodeArray[OP_DATA_49],
1221  				data:   make([]byte, 50),
1222  			},
1223  			expectedErr: scriptError(ErrInternal, ""),
1224  		},
1225  		{
1226  			name: "OP_DATA_50 short",
1227  			pop: &parsedOpcode{
1228  				opcode: &OpcodeArray[OP_DATA_50],
1229  				data:   make([]byte, 49),
1230  			},
1231  			expectedErr: scriptError(ErrInternal, ""),
1232  		},
1233  		{
1234  			name: "OP_DATA_50",
1235  			pop: &parsedOpcode{
1236  				opcode: &OpcodeArray[OP_DATA_50],
1237  				data:   make([]byte, 50),
1238  			},
1239  			expectedErr: nil,
1240  		},
1241  		{
1242  			name: "OP_DATA_50 long",
1243  			pop: &parsedOpcode{
1244  				opcode: &OpcodeArray[OP_DATA_50],
1245  				data:   make([]byte, 51),
1246  			},
1247  			expectedErr: scriptError(ErrInternal, ""),
1248  		},
1249  		{
1250  			name: "OP_DATA_51 short",
1251  			pop: &parsedOpcode{
1252  				opcode: &OpcodeArray[OP_DATA_51],
1253  				data:   make([]byte, 50),
1254  			},
1255  			expectedErr: scriptError(ErrInternal, ""),
1256  		},
1257  		{
1258  			name: "OP_DATA_51",
1259  			pop: &parsedOpcode{
1260  				opcode: &OpcodeArray[OP_DATA_51],
1261  				data:   make([]byte, 51),
1262  			},
1263  			expectedErr: nil,
1264  		},
1265  		{
1266  			name: "OP_DATA_51 long",
1267  			pop: &parsedOpcode{
1268  				opcode: &OpcodeArray[OP_DATA_51],
1269  				data:   make([]byte, 52),
1270  			},
1271  			expectedErr: scriptError(ErrInternal, ""),
1272  		},
1273  		{
1274  			name: "OP_DATA_52 short",
1275  			pop: &parsedOpcode{
1276  				opcode: &OpcodeArray[OP_DATA_52],
1277  				data:   make([]byte, 51),
1278  			},
1279  			expectedErr: scriptError(ErrInternal, ""),
1280  		},
1281  		{
1282  			name: "OP_DATA_52",
1283  			pop: &parsedOpcode{
1284  				opcode: &OpcodeArray[OP_DATA_52],
1285  				data:   make([]byte, 52),
1286  			},
1287  			expectedErr: nil,
1288  		},
1289  		{
1290  			name: "OP_DATA_52 long",
1291  			pop: &parsedOpcode{
1292  				opcode: &OpcodeArray[OP_DATA_52],
1293  				data:   make([]byte, 53),
1294  			},
1295  			expectedErr: scriptError(ErrInternal, ""),
1296  		},
1297  		{
1298  			name: "OP_DATA_53 short",
1299  			pop: &parsedOpcode{
1300  				opcode: &OpcodeArray[OP_DATA_53],
1301  				data:   make([]byte, 52),
1302  			},
1303  			expectedErr: scriptError(ErrInternal, ""),
1304  		},
1305  		{
1306  			name: "OP_DATA_53",
1307  			pop: &parsedOpcode{
1308  				opcode: &OpcodeArray[OP_DATA_53],
1309  				data:   make([]byte, 53),
1310  			},
1311  			expectedErr: nil,
1312  		},
1313  		{
1314  			name: "OP_DATA_53 long",
1315  			pop: &parsedOpcode{
1316  				opcode: &OpcodeArray[OP_DATA_53],
1317  				data:   make([]byte, 54),
1318  			},
1319  			expectedErr: scriptError(ErrInternal, ""),
1320  		},
1321  		{
1322  			name: "OP_DATA_54 short",
1323  			pop: &parsedOpcode{
1324  				opcode: &OpcodeArray[OP_DATA_54],
1325  				data:   make([]byte, 53),
1326  			},
1327  			expectedErr: scriptError(ErrInternal, ""),
1328  		},
1329  		{
1330  			name: "OP_DATA_54",
1331  			pop: &parsedOpcode{
1332  				opcode: &OpcodeArray[OP_DATA_54],
1333  				data:   make([]byte, 54),
1334  			},
1335  			expectedErr: nil,
1336  		},
1337  		{
1338  			name: "OP_DATA_54 long",
1339  			pop: &parsedOpcode{
1340  				opcode: &OpcodeArray[OP_DATA_54],
1341  				data:   make([]byte, 55),
1342  			},
1343  			expectedErr: scriptError(ErrInternal, ""),
1344  		},
1345  		{
1346  			name: "OP_DATA_55 short",
1347  			pop: &parsedOpcode{
1348  				opcode: &OpcodeArray[OP_DATA_55],
1349  				data:   make([]byte, 54),
1350  			},
1351  			expectedErr: scriptError(ErrInternal, ""),
1352  		},
1353  		{
1354  			name: "OP_DATA_55",
1355  			pop: &parsedOpcode{
1356  				opcode: &OpcodeArray[OP_DATA_55],
1357  				data:   make([]byte, 55),
1358  			},
1359  			expectedErr: nil,
1360  		},
1361  		{
1362  			name: "OP_DATA_55 long",
1363  			pop: &parsedOpcode{
1364  				opcode: &OpcodeArray[OP_DATA_55],
1365  				data:   make([]byte, 56),
1366  			},
1367  			expectedErr: scriptError(ErrInternal, ""),
1368  		},
1369  		{
1370  			name: "OP_DATA_56 short",
1371  			pop: &parsedOpcode{
1372  				opcode: &OpcodeArray[OP_DATA_56],
1373  				data:   make([]byte, 55),
1374  			},
1375  			expectedErr: scriptError(ErrInternal, ""),
1376  		},
1377  		{
1378  			name: "OP_DATA_56",
1379  			pop: &parsedOpcode{
1380  				opcode: &OpcodeArray[OP_DATA_56],
1381  				data:   make([]byte, 56),
1382  			},
1383  			expectedErr: nil,
1384  		},
1385  		{
1386  			name: "OP_DATA_56 long",
1387  			pop: &parsedOpcode{
1388  				opcode: &OpcodeArray[OP_DATA_56],
1389  				data:   make([]byte, 57),
1390  			},
1391  			expectedErr: scriptError(ErrInternal, ""),
1392  		},
1393  		{
1394  			name: "OP_DATA_57 short",
1395  			pop: &parsedOpcode{
1396  				opcode: &OpcodeArray[OP_DATA_57],
1397  				data:   make([]byte, 56),
1398  			},
1399  			expectedErr: scriptError(ErrInternal, ""),
1400  		},
1401  		{
1402  			name: "OP_DATA_57",
1403  			pop: &parsedOpcode{
1404  				opcode: &OpcodeArray[OP_DATA_57],
1405  				data:   make([]byte, 57),
1406  			},
1407  			expectedErr: nil,
1408  		},
1409  		{
1410  			name: "OP_DATA_57 long",
1411  			pop: &parsedOpcode{
1412  				opcode: &OpcodeArray[OP_DATA_57],
1413  				data:   make([]byte, 58),
1414  			},
1415  			expectedErr: scriptError(ErrInternal, ""),
1416  		},
1417  		{
1418  			name: "OP_DATA_58 short",
1419  			pop: &parsedOpcode{
1420  				opcode: &OpcodeArray[OP_DATA_58],
1421  				data:   make([]byte, 57),
1422  			},
1423  			expectedErr: scriptError(ErrInternal, ""),
1424  		},
1425  		{
1426  			name: "OP_DATA_58",
1427  			pop: &parsedOpcode{
1428  				opcode: &OpcodeArray[OP_DATA_58],
1429  				data:   make([]byte, 58),
1430  			},
1431  			expectedErr: nil,
1432  		},
1433  		{
1434  			name: "OP_DATA_58 long",
1435  			pop: &parsedOpcode{
1436  				opcode: &OpcodeArray[OP_DATA_58],
1437  				data:   make([]byte, 59),
1438  			},
1439  			expectedErr: scriptError(ErrInternal, ""),
1440  		},
1441  		{
1442  			name: "OP_DATA_59 short",
1443  			pop: &parsedOpcode{
1444  				opcode: &OpcodeArray[OP_DATA_59],
1445  				data:   make([]byte, 58),
1446  			},
1447  			expectedErr: scriptError(ErrInternal, ""),
1448  		},
1449  		{
1450  			name: "OP_DATA_59",
1451  			pop: &parsedOpcode{
1452  				opcode: &OpcodeArray[OP_DATA_59],
1453  				data:   make([]byte, 59),
1454  			},
1455  			expectedErr: nil,
1456  		},
1457  		{
1458  			name: "OP_DATA_59 long",
1459  			pop: &parsedOpcode{
1460  				opcode: &OpcodeArray[OP_DATA_59],
1461  				data:   make([]byte, 60),
1462  			},
1463  			expectedErr: scriptError(ErrInternal, ""),
1464  		},
1465  		{
1466  			name: "OP_DATA_60 short",
1467  			pop: &parsedOpcode{
1468  				opcode: &OpcodeArray[OP_DATA_60],
1469  				data:   make([]byte, 59),
1470  			},
1471  			expectedErr: scriptError(ErrInternal, ""),
1472  		},
1473  		{
1474  			name: "OP_DATA_60",
1475  			pop: &parsedOpcode{
1476  				opcode: &OpcodeArray[OP_DATA_60],
1477  				data:   make([]byte, 60),
1478  			},
1479  			expectedErr: nil,
1480  		},
1481  		{
1482  			name: "OP_DATA_60 long",
1483  			pop: &parsedOpcode{
1484  				opcode: &OpcodeArray[OP_DATA_60],
1485  				data:   make([]byte, 61),
1486  			},
1487  			expectedErr: scriptError(ErrInternal, ""),
1488  		},
1489  		{
1490  			name: "OP_DATA_61 short",
1491  			pop: &parsedOpcode{
1492  				opcode: &OpcodeArray[OP_DATA_61],
1493  				data:   make([]byte, 60),
1494  			},
1495  			expectedErr: scriptError(ErrInternal, ""),
1496  		},
1497  		{
1498  			name: "OP_DATA_61",
1499  			pop: &parsedOpcode{
1500  				opcode: &OpcodeArray[OP_DATA_61],
1501  				data:   make([]byte, 61),
1502  			},
1503  			expectedErr: nil,
1504  		},
1505  		{
1506  			name: "OP_DATA_61 long",
1507  			pop: &parsedOpcode{
1508  				opcode: &OpcodeArray[OP_DATA_61],
1509  				data:   make([]byte, 62),
1510  			},
1511  			expectedErr: scriptError(ErrInternal, ""),
1512  		},
1513  		{
1514  			name: "OP_DATA_62 short",
1515  			pop: &parsedOpcode{
1516  				opcode: &OpcodeArray[OP_DATA_62],
1517  				data:   make([]byte, 61),
1518  			},
1519  			expectedErr: scriptError(ErrInternal, ""),
1520  		},
1521  		{
1522  			name: "OP_DATA_62",
1523  			pop: &parsedOpcode{
1524  				opcode: &OpcodeArray[OP_DATA_62],
1525  				data:   make([]byte, 62),
1526  			},
1527  			expectedErr: nil,
1528  		},
1529  		{
1530  			name: "OP_DATA_62 long",
1531  			pop: &parsedOpcode{
1532  				opcode: &OpcodeArray[OP_DATA_62],
1533  				data:   make([]byte, 63),
1534  			},
1535  			expectedErr: scriptError(ErrInternal, ""),
1536  		},
1537  		{
1538  			name: "OP_DATA_63 short",
1539  			pop: &parsedOpcode{
1540  				opcode: &OpcodeArray[OP_DATA_63],
1541  				data:   make([]byte, 62),
1542  			},
1543  			expectedErr: scriptError(ErrInternal, ""),
1544  		},
1545  		{
1546  			name: "OP_DATA_63",
1547  			pop: &parsedOpcode{
1548  				opcode: &OpcodeArray[OP_DATA_63],
1549  				data:   make([]byte, 63),
1550  			},
1551  			expectedErr: nil,
1552  		},
1553  		{
1554  			name: "OP_DATA_63 long",
1555  			pop: &parsedOpcode{
1556  				opcode: &OpcodeArray[OP_DATA_63],
1557  				data:   make([]byte, 64),
1558  			},
1559  			expectedErr: scriptError(ErrInternal, ""),
1560  		},
1561  		{
1562  			name: "OP_DATA_64 short",
1563  			pop: &parsedOpcode{
1564  				opcode: &OpcodeArray[OP_DATA_64],
1565  				data:   make([]byte, 63),
1566  			},
1567  			expectedErr: scriptError(ErrInternal, ""),
1568  		},
1569  		{
1570  			name: "OP_DATA_64",
1571  			pop: &parsedOpcode{
1572  				opcode: &OpcodeArray[OP_DATA_64],
1573  				data:   make([]byte, 64),
1574  			},
1575  			expectedErr: nil,
1576  		},
1577  		{
1578  			name: "OP_DATA_64 long",
1579  			pop: &parsedOpcode{
1580  				opcode: &OpcodeArray[OP_DATA_64],
1581  				data:   make([]byte, 65),
1582  			},
1583  			expectedErr: scriptError(ErrInternal, ""),
1584  		},
1585  		{
1586  			name: "OP_DATA_65 short",
1587  			pop: &parsedOpcode{
1588  				opcode: &OpcodeArray[OP_DATA_65],
1589  				data:   make([]byte, 64),
1590  			},
1591  			expectedErr: scriptError(ErrInternal, ""),
1592  		},
1593  		{
1594  			name: "OP_DATA_65",
1595  			pop: &parsedOpcode{
1596  				opcode: &OpcodeArray[OP_DATA_65],
1597  				data:   make([]byte, 65),
1598  			},
1599  			expectedErr: nil,
1600  		},
1601  		{
1602  			name: "OP_DATA_65 long",
1603  			pop: &parsedOpcode{
1604  				opcode: &OpcodeArray[OP_DATA_65],
1605  				data:   make([]byte, 66),
1606  			},
1607  			expectedErr: scriptError(ErrInternal, ""),
1608  		},
1609  		{
1610  			name: "OP_DATA_66 short",
1611  			pop: &parsedOpcode{
1612  				opcode: &OpcodeArray[OP_DATA_66],
1613  				data:   make([]byte, 65),
1614  			},
1615  			expectedErr: scriptError(ErrInternal, ""),
1616  		},
1617  		{
1618  			name: "OP_DATA_66",
1619  			pop: &parsedOpcode{
1620  				opcode: &OpcodeArray[OP_DATA_66],
1621  				data:   make([]byte, 66),
1622  			},
1623  			expectedErr: nil,
1624  		},
1625  		{
1626  			name: "OP_DATA_66 long",
1627  			pop: &parsedOpcode{
1628  				opcode: &OpcodeArray[OP_DATA_66],
1629  				data:   make([]byte, 67),
1630  			},
1631  			expectedErr: scriptError(ErrInternal, ""),
1632  		},
1633  		{
1634  			name: "OP_DATA_67 short",
1635  			pop: &parsedOpcode{
1636  				opcode: &OpcodeArray[OP_DATA_67],
1637  				data:   make([]byte, 66),
1638  			},
1639  			expectedErr: scriptError(ErrInternal, ""),
1640  		},
1641  		{
1642  			name: "OP_DATA_67",
1643  			pop: &parsedOpcode{
1644  				opcode: &OpcodeArray[OP_DATA_67],
1645  				data:   make([]byte, 67),
1646  			},
1647  			expectedErr: nil,
1648  		},
1649  		{
1650  			name: "OP_DATA_67 long",
1651  			pop: &parsedOpcode{
1652  				opcode: &OpcodeArray[OP_DATA_67],
1653  				data:   make([]byte, 68),
1654  			},
1655  			expectedErr: scriptError(ErrInternal, ""),
1656  		},
1657  		{
1658  			name: "OP_DATA_68 short",
1659  			pop: &parsedOpcode{
1660  				opcode: &OpcodeArray[OP_DATA_68],
1661  				data:   make([]byte, 67),
1662  			},
1663  			expectedErr: scriptError(ErrInternal, ""),
1664  		},
1665  		{
1666  			name: "OP_DATA_68",
1667  			pop: &parsedOpcode{
1668  				opcode: &OpcodeArray[OP_DATA_68],
1669  				data:   make([]byte, 68),
1670  			},
1671  			expectedErr: nil,
1672  		},
1673  		{
1674  			name: "OP_DATA_68 long",
1675  			pop: &parsedOpcode{
1676  				opcode: &OpcodeArray[OP_DATA_68],
1677  				data:   make([]byte, 69),
1678  			},
1679  			expectedErr: scriptError(ErrInternal, ""),
1680  		},
1681  		{
1682  			name: "OP_DATA_69 short",
1683  			pop: &parsedOpcode{
1684  				opcode: &OpcodeArray[OP_DATA_69],
1685  				data:   make([]byte, 68),
1686  			},
1687  			expectedErr: scriptError(ErrInternal, ""),
1688  		},
1689  		{
1690  			name: "OP_DATA_69",
1691  			pop: &parsedOpcode{
1692  				opcode: &OpcodeArray[OP_DATA_69],
1693  				data:   make([]byte, 69),
1694  			},
1695  			expectedErr: nil,
1696  		},
1697  		{
1698  			name: "OP_DATA_69 long",
1699  			pop: &parsedOpcode{
1700  				opcode: &OpcodeArray[OP_DATA_69],
1701  				data:   make([]byte, 70),
1702  			},
1703  			expectedErr: scriptError(ErrInternal, ""),
1704  		},
1705  		{
1706  			name: "OP_DATA_70 short",
1707  			pop: &parsedOpcode{
1708  				opcode: &OpcodeArray[OP_DATA_70],
1709  				data:   make([]byte, 69),
1710  			},
1711  			expectedErr: scriptError(ErrInternal, ""),
1712  		},
1713  		{
1714  			name: "OP_DATA_70",
1715  			pop: &parsedOpcode{
1716  				opcode: &OpcodeArray[OP_DATA_70],
1717  				data:   make([]byte, 70),
1718  			},
1719  			expectedErr: nil,
1720  		},
1721  		{
1722  			name: "OP_DATA_70 long",
1723  			pop: &parsedOpcode{
1724  				opcode: &OpcodeArray[OP_DATA_70],
1725  				data:   make([]byte, 71),
1726  			},
1727  			expectedErr: scriptError(ErrInternal, ""),
1728  		},
1729  		{
1730  			name: "OP_DATA_71 short",
1731  			pop: &parsedOpcode{
1732  				opcode: &OpcodeArray[OP_DATA_71],
1733  				data:   make([]byte, 70),
1734  			},
1735  			expectedErr: scriptError(ErrInternal, ""),
1736  		},
1737  		{
1738  			name: "OP_DATA_71",
1739  			pop: &parsedOpcode{
1740  				opcode: &OpcodeArray[OP_DATA_71],
1741  				data:   make([]byte, 71),
1742  			},
1743  			expectedErr: nil,
1744  		},
1745  		{
1746  			name: "OP_DATA_71 long",
1747  			pop: &parsedOpcode{
1748  				opcode: &OpcodeArray[OP_DATA_71],
1749  				data:   make([]byte, 72),
1750  			},
1751  			expectedErr: scriptError(ErrInternal, ""),
1752  		},
1753  		{
1754  			name: "OP_DATA_72 short",
1755  			pop: &parsedOpcode{
1756  				opcode: &OpcodeArray[OP_DATA_72],
1757  				data:   make([]byte, 71),
1758  			},
1759  			expectedErr: scriptError(ErrInternal, ""),
1760  		},
1761  		{
1762  			name: "OP_DATA_72",
1763  			pop: &parsedOpcode{
1764  				opcode: &OpcodeArray[OP_DATA_72],
1765  				data:   make([]byte, 72),
1766  			},
1767  			expectedErr: nil,
1768  		},
1769  		{
1770  			name: "OP_DATA_72 long",
1771  			pop: &parsedOpcode{
1772  				opcode: &OpcodeArray[OP_DATA_72],
1773  				data:   make([]byte, 73),
1774  			},
1775  			expectedErr: scriptError(ErrInternal, ""),
1776  		},
1777  		{
1778  			name: "OP_DATA_73 short",
1779  			pop: &parsedOpcode{
1780  				opcode: &OpcodeArray[OP_DATA_73],
1781  				data:   make([]byte, 72),
1782  			},
1783  			expectedErr: scriptError(ErrInternal, ""),
1784  		},
1785  		{
1786  			name: "OP_DATA_73",
1787  			pop: &parsedOpcode{
1788  				opcode: &OpcodeArray[OP_DATA_73],
1789  				data:   make([]byte, 73),
1790  			},
1791  			expectedErr: nil,
1792  		},
1793  		{
1794  			name: "OP_DATA_73 long",
1795  			pop: &parsedOpcode{
1796  				opcode: &OpcodeArray[OP_DATA_73],
1797  				data:   make([]byte, 74),
1798  			},
1799  			expectedErr: scriptError(ErrInternal, ""),
1800  		},
1801  		{
1802  			name: "OP_DATA_74 short",
1803  			pop: &parsedOpcode{
1804  				opcode: &OpcodeArray[OP_DATA_74],
1805  				data:   make([]byte, 73),
1806  			},
1807  			expectedErr: scriptError(ErrInternal, ""),
1808  		},
1809  		{
1810  			name: "OP_DATA_74",
1811  			pop: &parsedOpcode{
1812  				opcode: &OpcodeArray[OP_DATA_74],
1813  				data:   make([]byte, 74),
1814  			},
1815  			expectedErr: nil,
1816  		},
1817  		{
1818  			name: "OP_DATA_74 long",
1819  			pop: &parsedOpcode{
1820  				opcode: &OpcodeArray[OP_DATA_74],
1821  				data:   make([]byte, 75),
1822  			},
1823  			expectedErr: scriptError(ErrInternal, ""),
1824  		},
1825  		{
1826  			name: "OP_DATA_75 short",
1827  			pop: &parsedOpcode{
1828  				opcode: &OpcodeArray[OP_DATA_75],
1829  				data:   make([]byte, 74),
1830  			},
1831  			expectedErr: scriptError(ErrInternal, ""),
1832  		},
1833  		{
1834  			name: "OP_DATA_75",
1835  			pop: &parsedOpcode{
1836  				opcode: &OpcodeArray[OP_DATA_75],
1837  				data:   make([]byte, 75),
1838  			},
1839  			expectedErr: nil,
1840  		},
1841  		{
1842  			name: "OP_DATA_75 long",
1843  			pop: &parsedOpcode{
1844  				opcode: &OpcodeArray[OP_DATA_75],
1845  				data:   make([]byte, 76),
1846  			},
1847  			expectedErr: scriptError(ErrInternal, ""),
1848  		},
1849  		{
1850  			name: "OP_PUSHDATA1",
1851  			pop: &parsedOpcode{
1852  				opcode: &OpcodeArray[OP_PUSHDATA1],
1853  				data:   []byte{0, 1, 2, 3, 4},
1854  			},
1855  			expectedErr: nil,
1856  		},
1857  		{
1858  			name: "OP_PUSHDATA2",
1859  			pop: &parsedOpcode{
1860  				opcode: &OpcodeArray[OP_PUSHDATA2],
1861  				data:   []byte{0, 1, 2, 3, 4},
1862  			},
1863  			expectedErr: nil,
1864  		},
1865  		{
1866  			name: "OP_PUSHDATA4",
1867  			pop: &parsedOpcode{
1868  				opcode: &OpcodeArray[OP_PUSHDATA1],
1869  				data:   []byte{0, 1, 2, 3, 4},
1870  			},
1871  			expectedErr: nil,
1872  		},
1873  		{
1874  			name: "OP_1NEGATE",
1875  			pop: &parsedOpcode{
1876  				opcode: &OpcodeArray[OP_1NEGATE],
1877  				data:   nil,
1878  			},
1879  			expectedErr: nil,
1880  		},
1881  		{
1882  			name: "OP_1NEGATE long",
1883  			pop: &parsedOpcode{
1884  				opcode: &OpcodeArray[OP_1NEGATE],
1885  				data:   make([]byte, 1),
1886  			},
1887  			expectedErr: scriptError(ErrInternal, ""),
1888  		},
1889  		{
1890  			name: "OP_RESERVED",
1891  			pop: &parsedOpcode{
1892  				opcode: &OpcodeArray[OP_RESERVED],
1893  				data:   nil,
1894  			},
1895  			expectedErr: nil,
1896  		},
1897  		{
1898  			name: "OP_RESERVED long",
1899  			pop: &parsedOpcode{
1900  				opcode: &OpcodeArray[OP_RESERVED],
1901  				data:   make([]byte, 1),
1902  			},
1903  			expectedErr: scriptError(ErrInternal, ""),
1904  		},
1905  		{
1906  			name: "OP_TRUE",
1907  			pop: &parsedOpcode{
1908  				opcode: &OpcodeArray[OP_TRUE],
1909  				data:   nil,
1910  			},
1911  			expectedErr: nil,
1912  		},
1913  		{
1914  			name: "OP_TRUE long",
1915  			pop: &parsedOpcode{
1916  				opcode: &OpcodeArray[OP_TRUE],
1917  				data:   make([]byte, 1),
1918  			},
1919  			expectedErr: scriptError(ErrInternal, ""),
1920  		},
1921  		{
1922  			name: "OP_2",
1923  			pop: &parsedOpcode{
1924  				opcode: &OpcodeArray[OP_2],
1925  				data:   nil,
1926  			},
1927  			expectedErr: nil,
1928  		},
1929  		{
1930  			name: "OP_2 long",
1931  			pop: &parsedOpcode{
1932  				opcode: &OpcodeArray[OP_2],
1933  				data:   make([]byte, 1),
1934  			},
1935  			expectedErr: scriptError(ErrInternal, ""),
1936  		},
1937  		{
1938  			name: "OP_2",
1939  			pop: &parsedOpcode{
1940  				opcode: &OpcodeArray[OP_2],
1941  				data:   nil,
1942  			},
1943  			expectedErr: nil,
1944  		},
1945  		{
1946  			name: "OP_2 long",
1947  			pop: &parsedOpcode{
1948  				opcode: &OpcodeArray[OP_2],
1949  				data:   make([]byte, 1),
1950  			},
1951  			expectedErr: scriptError(ErrInternal, ""),
1952  		},
1953  		{
1954  			name: "OP_3",
1955  			pop: &parsedOpcode{
1956  				opcode: &OpcodeArray[OP_3],
1957  				data:   nil,
1958  			},
1959  			expectedErr: nil,
1960  		},
1961  		{
1962  			name: "OP_3 long",
1963  			pop: &parsedOpcode{
1964  				opcode: &OpcodeArray[OP_3],
1965  				data:   make([]byte, 1),
1966  			},
1967  			expectedErr: scriptError(ErrInternal, ""),
1968  		},
1969  		{
1970  			name: "OP_4",
1971  			pop: &parsedOpcode{
1972  				opcode: &OpcodeArray[OP_4],
1973  				data:   nil,
1974  			},
1975  			expectedErr: nil,
1976  		},
1977  		{
1978  			name: "OP_4 long",
1979  			pop: &parsedOpcode{
1980  				opcode: &OpcodeArray[OP_4],
1981  				data:   make([]byte, 1),
1982  			},
1983  			expectedErr: scriptError(ErrInternal, ""),
1984  		},
1985  		{
1986  			name: "OP_5",
1987  			pop: &parsedOpcode{
1988  				opcode: &OpcodeArray[OP_5],
1989  				data:   nil,
1990  			},
1991  			expectedErr: nil,
1992  		},
1993  		{
1994  			name: "OP_5 long",
1995  			pop: &parsedOpcode{
1996  				opcode: &OpcodeArray[OP_5],
1997  				data:   make([]byte, 1),
1998  			},
1999  			expectedErr: scriptError(ErrInternal, ""),
2000  		},
2001  		{
2002  			name: "OP_6",
2003  			pop: &parsedOpcode{
2004  				opcode: &OpcodeArray[OP_6],
2005  				data:   nil,
2006  			},
2007  			expectedErr: nil,
2008  		},
2009  		{
2010  			name: "OP_6 long",
2011  			pop: &parsedOpcode{
2012  				opcode: &OpcodeArray[OP_6],
2013  				data:   make([]byte, 1),
2014  			},
2015  			expectedErr: scriptError(ErrInternal, ""),
2016  		},
2017  		{
2018  			name: "OP_7",
2019  			pop: &parsedOpcode{
2020  				opcode: &OpcodeArray[OP_7],
2021  				data:   nil,
2022  			},
2023  			expectedErr: nil,
2024  		},
2025  		{
2026  			name: "OP_7 long",
2027  			pop: &parsedOpcode{
2028  				opcode: &OpcodeArray[OP_7],
2029  				data:   make([]byte, 1),
2030  			},
2031  			expectedErr: scriptError(ErrInternal, ""),
2032  		},
2033  		{
2034  			name: "OP_8",
2035  			pop: &parsedOpcode{
2036  				opcode: &OpcodeArray[OP_8],
2037  				data:   nil,
2038  			},
2039  			expectedErr: nil,
2040  		},
2041  		{
2042  			name: "OP_8 long",
2043  			pop: &parsedOpcode{
2044  				opcode: &OpcodeArray[OP_8],
2045  				data:   make([]byte, 1),
2046  			},
2047  			expectedErr: scriptError(ErrInternal, ""),
2048  		},
2049  		{
2050  			name: "OP_9",
2051  			pop: &parsedOpcode{
2052  				opcode: &OpcodeArray[OP_9],
2053  				data:   nil,
2054  			},
2055  			expectedErr: nil,
2056  		},
2057  		{
2058  			name: "OP_9 long",
2059  			pop: &parsedOpcode{
2060  				opcode: &OpcodeArray[OP_9],
2061  				data:   make([]byte, 1),
2062  			},
2063  			expectedErr: scriptError(ErrInternal, ""),
2064  		},
2065  		{
2066  			name: "OP_10",
2067  			pop: &parsedOpcode{
2068  				opcode: &OpcodeArray[OP_10],
2069  				data:   nil,
2070  			},
2071  			expectedErr: nil,
2072  		},
2073  		{
2074  			name: "OP_10 long",
2075  			pop: &parsedOpcode{
2076  				opcode: &OpcodeArray[OP_10],
2077  				data:   make([]byte, 1),
2078  			},
2079  			expectedErr: scriptError(ErrInternal, ""),
2080  		},
2081  		{
2082  			name: "OP_11",
2083  			pop: &parsedOpcode{
2084  				opcode: &OpcodeArray[OP_11],
2085  				data:   nil,
2086  			},
2087  			expectedErr: nil,
2088  		},
2089  		{
2090  			name: "OP_11 long",
2091  			pop: &parsedOpcode{
2092  				opcode: &OpcodeArray[OP_11],
2093  				data:   make([]byte, 1),
2094  			},
2095  			expectedErr: scriptError(ErrInternal, ""),
2096  		},
2097  		{
2098  			name: "OP_12",
2099  			pop: &parsedOpcode{
2100  				opcode: &OpcodeArray[OP_12],
2101  				data:   nil,
2102  			},
2103  			expectedErr: nil,
2104  		},
2105  		{
2106  			name: "OP_12 long",
2107  			pop: &parsedOpcode{
2108  				opcode: &OpcodeArray[OP_12],
2109  				data:   make([]byte, 1),
2110  			},
2111  			expectedErr: scriptError(ErrInternal, ""),
2112  		},
2113  		{
2114  			name: "OP_13",
2115  			pop: &parsedOpcode{
2116  				opcode: &OpcodeArray[OP_13],
2117  				data:   nil,
2118  			},
2119  			expectedErr: nil,
2120  		},
2121  		{
2122  			name: "OP_13 long",
2123  			pop: &parsedOpcode{
2124  				opcode: &OpcodeArray[OP_13],
2125  				data:   make([]byte, 1),
2126  			},
2127  			expectedErr: scriptError(ErrInternal, ""),
2128  		},
2129  		{
2130  			name: "OP_14",
2131  			pop: &parsedOpcode{
2132  				opcode: &OpcodeArray[OP_14],
2133  				data:   nil,
2134  			},
2135  			expectedErr: nil,
2136  		},
2137  		{
2138  			name: "OP_14 long",
2139  			pop: &parsedOpcode{
2140  				opcode: &OpcodeArray[OP_14],
2141  				data:   make([]byte, 1),
2142  			},
2143  			expectedErr: scriptError(ErrInternal, ""),
2144  		},
2145  		{
2146  			name: "OP_15",
2147  			pop: &parsedOpcode{
2148  				opcode: &OpcodeArray[OP_15],
2149  				data:   nil,
2150  			},
2151  			expectedErr: nil,
2152  		},
2153  		{
2154  			name: "OP_15 long",
2155  			pop: &parsedOpcode{
2156  				opcode: &OpcodeArray[OP_15],
2157  				data:   make([]byte, 1),
2158  			},
2159  			expectedErr: scriptError(ErrInternal, ""),
2160  		},
2161  		{
2162  			name: "OP_16",
2163  			pop: &parsedOpcode{
2164  				opcode: &OpcodeArray[OP_16],
2165  				data:   nil,
2166  			},
2167  			expectedErr: nil,
2168  		},
2169  		{
2170  			name: "OP_16 long",
2171  			pop: &parsedOpcode{
2172  				opcode: &OpcodeArray[OP_16],
2173  				data:   make([]byte, 1),
2174  			},
2175  			expectedErr: scriptError(ErrInternal, ""),
2176  		},
2177  		{
2178  			name: "OP_NOP",
2179  			pop: &parsedOpcode{
2180  				opcode: &OpcodeArray[OP_NOP],
2181  				data:   nil,
2182  			},
2183  			expectedErr: nil,
2184  		},
2185  		{
2186  			name: "OP_NOP long",
2187  			pop: &parsedOpcode{
2188  				opcode: &OpcodeArray[OP_NOP],
2189  				data:   make([]byte, 1),
2190  			},
2191  			expectedErr: scriptError(ErrInternal, ""),
2192  		},
2193  		{
2194  			name: "OP_VER",
2195  			pop: &parsedOpcode{
2196  				opcode: &OpcodeArray[OP_VER],
2197  				data:   nil,
2198  			},
2199  			expectedErr: nil,
2200  		},
2201  		{
2202  			name: "OP_VER long",
2203  			pop: &parsedOpcode{
2204  				opcode: &OpcodeArray[OP_VER],
2205  				data:   make([]byte, 1),
2206  			},
2207  			expectedErr: scriptError(ErrInternal, ""),
2208  		},
2209  		{
2210  			name: "OP_IF",
2211  			pop: &parsedOpcode{
2212  				opcode: &OpcodeArray[OP_IF],
2213  				data:   nil,
2214  			},
2215  			expectedErr: nil,
2216  		},
2217  		{
2218  			name: "OP_IF long",
2219  			pop: &parsedOpcode{
2220  				opcode: &OpcodeArray[OP_IF],
2221  				data:   make([]byte, 1),
2222  			},
2223  			expectedErr: scriptError(ErrInternal, ""),
2224  		},
2225  		{
2226  			name: "OP_NOTIF",
2227  			pop: &parsedOpcode{
2228  				opcode: &OpcodeArray[OP_NOTIF],
2229  				data:   nil,
2230  			},
2231  			expectedErr: nil,
2232  		},
2233  		{
2234  			name: "OP_NOTIF long",
2235  			pop: &parsedOpcode{
2236  				opcode: &OpcodeArray[OP_NOTIF],
2237  				data:   make([]byte, 1),
2238  			},
2239  			expectedErr: scriptError(ErrInternal, ""),
2240  		},
2241  		{
2242  			name: "OP_VERIF",
2243  			pop: &parsedOpcode{
2244  				opcode: &OpcodeArray[OP_VERIF],
2245  				data:   nil,
2246  			},
2247  			expectedErr: nil,
2248  		},
2249  		{
2250  			name: "OP_VERIF long",
2251  			pop: &parsedOpcode{
2252  				opcode: &OpcodeArray[OP_VERIF],
2253  				data:   make([]byte, 1),
2254  			},
2255  			expectedErr: scriptError(ErrInternal, ""),
2256  		},
2257  		{
2258  			name: "OP_VERNOTIF",
2259  			pop: &parsedOpcode{
2260  				opcode: &OpcodeArray[OP_VERNOTIF],
2261  				data:   nil,
2262  			},
2263  			expectedErr: nil,
2264  		},
2265  		{
2266  			name: "OP_VERNOTIF long",
2267  			pop: &parsedOpcode{
2268  				opcode: &OpcodeArray[OP_VERNOTIF],
2269  				data:   make([]byte, 1),
2270  			},
2271  			expectedErr: scriptError(ErrInternal, ""),
2272  		},
2273  		{
2274  			name: "OP_ELSE",
2275  			pop: &parsedOpcode{
2276  				opcode: &OpcodeArray[OP_ELSE],
2277  				data:   nil,
2278  			},
2279  			expectedErr: nil,
2280  		},
2281  		{
2282  			name: "OP_ELSE long",
2283  			pop: &parsedOpcode{
2284  				opcode: &OpcodeArray[OP_ELSE],
2285  				data:   make([]byte, 1),
2286  			},
2287  			expectedErr: scriptError(ErrInternal, ""),
2288  		},
2289  		{
2290  			name: "OP_ENDIF",
2291  			pop: &parsedOpcode{
2292  				opcode: &OpcodeArray[OP_ENDIF],
2293  				data:   nil,
2294  			},
2295  			expectedErr: nil,
2296  		},
2297  		{
2298  			name: "OP_ENDIF long",
2299  			pop: &parsedOpcode{
2300  				opcode: &OpcodeArray[OP_ENDIF],
2301  				data:   make([]byte, 1),
2302  			},
2303  			expectedErr: scriptError(ErrInternal, ""),
2304  		},
2305  		{
2306  			name: "OP_VERIFY",
2307  			pop: &parsedOpcode{
2308  				opcode: &OpcodeArray[OP_VERIFY],
2309  				data:   nil,
2310  			},
2311  			expectedErr: nil,
2312  		},
2313  		{
2314  			name: "OP_VERIFY long",
2315  			pop: &parsedOpcode{
2316  				opcode: &OpcodeArray[OP_VERIFY],
2317  				data:   make([]byte, 1),
2318  			},
2319  			expectedErr: scriptError(ErrInternal, ""),
2320  		},
2321  		{
2322  			name: "OP_RETURN",
2323  			pop: &parsedOpcode{
2324  				opcode: &OpcodeArray[OP_RETURN],
2325  				data:   nil,
2326  			},
2327  			expectedErr: nil,
2328  		},
2329  		{
2330  			name: "OP_RETURN long",
2331  			pop: &parsedOpcode{
2332  				opcode: &OpcodeArray[OP_RETURN],
2333  				data:   make([]byte, 1),
2334  			},
2335  			expectedErr: scriptError(ErrInternal, ""),
2336  		},
2337  		{
2338  			name: "OP_TOALTSTACK",
2339  			pop: &parsedOpcode{
2340  				opcode: &OpcodeArray[OP_TOALTSTACK],
2341  				data:   nil,
2342  			},
2343  			expectedErr: nil,
2344  		},
2345  		{
2346  			name: "OP_TOALTSTACK long",
2347  			pop: &parsedOpcode{
2348  				opcode: &OpcodeArray[OP_TOALTSTACK],
2349  				data:   make([]byte, 1),
2350  			},
2351  			expectedErr: scriptError(ErrInternal, ""),
2352  		},
2353  		{
2354  			name: "OP_FROMALTSTACK",
2355  			pop: &parsedOpcode{
2356  				opcode: &OpcodeArray[OP_FROMALTSTACK],
2357  				data:   nil,
2358  			},
2359  			expectedErr: nil,
2360  		},
2361  		{
2362  			name: "OP_FROMALTSTACK long",
2363  			pop: &parsedOpcode{
2364  				opcode: &OpcodeArray[OP_FROMALTSTACK],
2365  				data:   make([]byte, 1),
2366  			},
2367  			expectedErr: scriptError(ErrInternal, ""),
2368  		},
2369  		{
2370  			name: "OP_2DROP",
2371  			pop: &parsedOpcode{
2372  				opcode: &OpcodeArray[OP_2DROP],
2373  				data:   nil,
2374  			},
2375  			expectedErr: nil,
2376  		},
2377  		{
2378  			name: "OP_2DROP long",
2379  			pop: &parsedOpcode{
2380  				opcode: &OpcodeArray[OP_2DROP],
2381  				data:   make([]byte, 1),
2382  			},
2383  			expectedErr: scriptError(ErrInternal, ""),
2384  		},
2385  		{
2386  			name: "OP_2DUP",
2387  			pop: &parsedOpcode{
2388  				opcode: &OpcodeArray[OP_2DUP],
2389  				data:   nil,
2390  			},
2391  			expectedErr: nil,
2392  		},
2393  		{
2394  			name: "OP_2DUP long",
2395  			pop: &parsedOpcode{
2396  				opcode: &OpcodeArray[OP_2DUP],
2397  				data:   make([]byte, 1),
2398  			},
2399  			expectedErr: scriptError(ErrInternal, ""),
2400  		},
2401  		{
2402  			name: "OP_3DUP",
2403  			pop: &parsedOpcode{
2404  				opcode: &OpcodeArray[OP_3DUP],
2405  				data:   nil,
2406  			},
2407  			expectedErr: nil,
2408  		},
2409  		{
2410  			name: "OP_3DUP long",
2411  			pop: &parsedOpcode{
2412  				opcode: &OpcodeArray[OP_3DUP],
2413  				data:   make([]byte, 1),
2414  			},
2415  			expectedErr: scriptError(ErrInternal, ""),
2416  		},
2417  		{
2418  			name: "OP_2OVER",
2419  			pop: &parsedOpcode{
2420  				opcode: &OpcodeArray[OP_2OVER],
2421  				data:   nil,
2422  			},
2423  			expectedErr: nil,
2424  		},
2425  		{
2426  			name: "OP_2OVER long",
2427  			pop: &parsedOpcode{
2428  				opcode: &OpcodeArray[OP_2OVER],
2429  				data:   make([]byte, 1),
2430  			},
2431  			expectedErr: scriptError(ErrInternal, ""),
2432  		},
2433  		{
2434  			name: "OP_2ROT",
2435  			pop: &parsedOpcode{
2436  				opcode: &OpcodeArray[OP_2ROT],
2437  				data:   nil,
2438  			},
2439  			expectedErr: nil,
2440  		},
2441  		{
2442  			name: "OP_2ROT long",
2443  			pop: &parsedOpcode{
2444  				opcode: &OpcodeArray[OP_2ROT],
2445  				data:   make([]byte, 1),
2446  			},
2447  			expectedErr: scriptError(ErrInternal, ""),
2448  		},
2449  		{
2450  			name: "OP_2SWAP",
2451  			pop: &parsedOpcode{
2452  				opcode: &OpcodeArray[OP_2SWAP],
2453  				data:   nil,
2454  			},
2455  			expectedErr: nil,
2456  		},
2457  		{
2458  			name: "OP_2SWAP long",
2459  			pop: &parsedOpcode{
2460  				opcode: &OpcodeArray[OP_2SWAP],
2461  				data:   make([]byte, 1),
2462  			},
2463  			expectedErr: scriptError(ErrInternal, ""),
2464  		},
2465  		{
2466  			name: "OP_IFDUP",
2467  			pop: &parsedOpcode{
2468  				opcode: &OpcodeArray[OP_IFDUP],
2469  				data:   nil,
2470  			},
2471  			expectedErr: nil,
2472  		},
2473  		{
2474  			name: "OP_IFDUP long",
2475  			pop: &parsedOpcode{
2476  				opcode: &OpcodeArray[OP_IFDUP],
2477  				data:   make([]byte, 1),
2478  			},
2479  			expectedErr: scriptError(ErrInternal, ""),
2480  		},
2481  		{
2482  			name: "OP_DEPTH",
2483  			pop: &parsedOpcode{
2484  				opcode: &OpcodeArray[OP_DEPTH],
2485  				data:   nil,
2486  			},
2487  			expectedErr: nil,
2488  		},
2489  		{
2490  			name: "OP_DEPTH long",
2491  			pop: &parsedOpcode{
2492  				opcode: &OpcodeArray[OP_DEPTH],
2493  				data:   make([]byte, 1),
2494  			},
2495  			expectedErr: scriptError(ErrInternal, ""),
2496  		},
2497  		{
2498  			name: "OP_DROP",
2499  			pop: &parsedOpcode{
2500  				opcode: &OpcodeArray[OP_DROP],
2501  				data:   nil,
2502  			},
2503  			expectedErr: nil,
2504  		},
2505  		{
2506  			name: "OP_DROP long",
2507  			pop: &parsedOpcode{
2508  				opcode: &OpcodeArray[OP_DROP],
2509  				data:   make([]byte, 1),
2510  			},
2511  			expectedErr: scriptError(ErrInternal, ""),
2512  		},
2513  		{
2514  			name: "OP_DUP",
2515  			pop: &parsedOpcode{
2516  				opcode: &OpcodeArray[OP_DUP],
2517  				data:   nil,
2518  			},
2519  			expectedErr: nil,
2520  		},
2521  		{
2522  			name: "OP_DUP long",
2523  			pop: &parsedOpcode{
2524  				opcode: &OpcodeArray[OP_DUP],
2525  				data:   make([]byte, 1),
2526  			},
2527  			expectedErr: scriptError(ErrInternal, ""),
2528  		},
2529  		{
2530  			name: "OP_NIP",
2531  			pop: &parsedOpcode{
2532  				opcode: &OpcodeArray[OP_NIP],
2533  				data:   nil,
2534  			},
2535  			expectedErr: nil,
2536  		},
2537  		{
2538  			name: "OP_NIP long",
2539  			pop: &parsedOpcode{
2540  				opcode: &OpcodeArray[OP_NIP],
2541  				data:   make([]byte, 1),
2542  			},
2543  			expectedErr: scriptError(ErrInternal, ""),
2544  		},
2545  		{
2546  			name: "OP_OVER",
2547  			pop: &parsedOpcode{
2548  				opcode: &OpcodeArray[OP_OVER],
2549  				data:   nil,
2550  			},
2551  			expectedErr: nil,
2552  		},
2553  		{
2554  			name: "OP_OVER long",
2555  			pop: &parsedOpcode{
2556  				opcode: &OpcodeArray[OP_OVER],
2557  				data:   make([]byte, 1),
2558  			},
2559  			expectedErr: scriptError(ErrInternal, ""),
2560  		},
2561  		{
2562  			name: "OP_PICK",
2563  			pop: &parsedOpcode{
2564  				opcode: &OpcodeArray[OP_PICK],
2565  				data:   nil,
2566  			},
2567  			expectedErr: nil,
2568  		},
2569  		{
2570  			name: "OP_PICK long",
2571  			pop: &parsedOpcode{
2572  				opcode: &OpcodeArray[OP_PICK],
2573  				data:   make([]byte, 1),
2574  			},
2575  			expectedErr: scriptError(ErrInternal, ""),
2576  		},
2577  		{
2578  			name: "OP_ROLL",
2579  			pop: &parsedOpcode{
2580  				opcode: &OpcodeArray[OP_ROLL],
2581  				data:   nil,
2582  			},
2583  			expectedErr: nil,
2584  		},
2585  		{
2586  			name: "OP_ROLL long",
2587  			pop: &parsedOpcode{
2588  				opcode: &OpcodeArray[OP_ROLL],
2589  				data:   make([]byte, 1),
2590  			},
2591  			expectedErr: scriptError(ErrInternal, ""),
2592  		},
2593  		{
2594  			name: "OP_ROT",
2595  			pop: &parsedOpcode{
2596  				opcode: &OpcodeArray[OP_ROT],
2597  				data:   nil,
2598  			},
2599  			expectedErr: nil,
2600  		},
2601  		{
2602  			name: "OP_ROT long",
2603  			pop: &parsedOpcode{
2604  				opcode: &OpcodeArray[OP_ROT],
2605  				data:   make([]byte, 1),
2606  			},
2607  			expectedErr: scriptError(ErrInternal, ""),
2608  		},
2609  		{
2610  			name: "OP_SWAP",
2611  			pop: &parsedOpcode{
2612  				opcode: &OpcodeArray[OP_SWAP],
2613  				data:   nil,
2614  			},
2615  			expectedErr: nil,
2616  		},
2617  		{
2618  			name: "OP_SWAP long",
2619  			pop: &parsedOpcode{
2620  				opcode: &OpcodeArray[OP_SWAP],
2621  				data:   make([]byte, 1),
2622  			},
2623  			expectedErr: scriptError(ErrInternal, ""),
2624  		},
2625  		{
2626  			name: "OP_TUCK",
2627  			pop: &parsedOpcode{
2628  				opcode: &OpcodeArray[OP_TUCK],
2629  				data:   nil,
2630  			},
2631  			expectedErr: nil,
2632  		},
2633  		{
2634  			name: "OP_TUCK long",
2635  			pop: &parsedOpcode{
2636  				opcode: &OpcodeArray[OP_TUCK],
2637  				data:   make([]byte, 1),
2638  			},
2639  			expectedErr: scriptError(ErrInternal, ""),
2640  		},
2641  		{
2642  			name: "OP_CAT",
2643  			pop: &parsedOpcode{
2644  				opcode: &OpcodeArray[OP_CAT],
2645  				data:   nil,
2646  			},
2647  			expectedErr: nil,
2648  		},
2649  		{
2650  			name: "OP_CAT long",
2651  			pop: &parsedOpcode{
2652  				opcode: &OpcodeArray[OP_CAT],
2653  				data:   make([]byte, 1),
2654  			},
2655  			expectedErr: scriptError(ErrInternal, ""),
2656  		},
2657  		{
2658  			name: "OP_SUBSTR",
2659  			pop: &parsedOpcode{
2660  				opcode: &OpcodeArray[OP_SUBSTR],
2661  				data:   nil,
2662  			},
2663  			expectedErr: nil,
2664  		},
2665  		{
2666  			name: "OP_SUBSTR long",
2667  			pop: &parsedOpcode{
2668  				opcode: &OpcodeArray[OP_SUBSTR],
2669  				data:   make([]byte, 1),
2670  			},
2671  			expectedErr: scriptError(ErrInternal, ""),
2672  		},
2673  		{
2674  			name: "OP_LEFT",
2675  			pop: &parsedOpcode{
2676  				opcode: &OpcodeArray[OP_LEFT],
2677  				data:   nil,
2678  			},
2679  			expectedErr: nil,
2680  		},
2681  		{
2682  			name: "OP_LEFT long",
2683  			pop: &parsedOpcode{
2684  				opcode: &OpcodeArray[OP_LEFT],
2685  				data:   make([]byte, 1),
2686  			},
2687  			expectedErr: scriptError(ErrInternal, ""),
2688  		},
2689  		{
2690  			name: "OP_LEFT",
2691  			pop: &parsedOpcode{
2692  				opcode: &OpcodeArray[OP_LEFT],
2693  				data:   nil,
2694  			},
2695  			expectedErr: nil,
2696  		},
2697  		{
2698  			name: "OP_LEFT long",
2699  			pop: &parsedOpcode{
2700  				opcode: &OpcodeArray[OP_LEFT],
2701  				data:   make([]byte, 1),
2702  			},
2703  			expectedErr: scriptError(ErrInternal, ""),
2704  		},
2705  		{
2706  			name: "OP_RIGHT",
2707  			pop: &parsedOpcode{
2708  				opcode: &OpcodeArray[OP_RIGHT],
2709  				data:   nil,
2710  			},
2711  			expectedErr: nil,
2712  		},
2713  		{
2714  			name: "OP_RIGHT long",
2715  			pop: &parsedOpcode{
2716  				opcode: &OpcodeArray[OP_RIGHT],
2717  				data:   make([]byte, 1),
2718  			},
2719  			expectedErr: scriptError(ErrInternal, ""),
2720  		},
2721  		{
2722  			name: "OP_SIZE",
2723  			pop: &parsedOpcode{
2724  				opcode: &OpcodeArray[OP_SIZE],
2725  				data:   nil,
2726  			},
2727  			expectedErr: nil,
2728  		},
2729  		{
2730  			name: "OP_SIZE long",
2731  			pop: &parsedOpcode{
2732  				opcode: &OpcodeArray[OP_SIZE],
2733  				data:   make([]byte, 1),
2734  			},
2735  			expectedErr: scriptError(ErrInternal, ""),
2736  		},
2737  		{
2738  			name: "OP_INVERT",
2739  			pop: &parsedOpcode{
2740  				opcode: &OpcodeArray[OP_INVERT],
2741  				data:   nil,
2742  			},
2743  			expectedErr: nil,
2744  		},
2745  		{
2746  			name: "OP_INVERT long",
2747  			pop: &parsedOpcode{
2748  				opcode: &OpcodeArray[OP_INVERT],
2749  				data:   make([]byte, 1),
2750  			},
2751  			expectedErr: scriptError(ErrInternal, ""),
2752  		},
2753  		{
2754  			name: "OP_AND",
2755  			pop: &parsedOpcode{
2756  				opcode: &OpcodeArray[OP_AND],
2757  				data:   nil,
2758  			},
2759  			expectedErr: nil,
2760  		},
2761  		{
2762  			name: "OP_AND long",
2763  			pop: &parsedOpcode{
2764  				opcode: &OpcodeArray[OP_AND],
2765  				data:   make([]byte, 1),
2766  			},
2767  			expectedErr: scriptError(ErrInternal, ""),
2768  		},
2769  		{
2770  			name: "OP_OR",
2771  			pop: &parsedOpcode{
2772  				opcode: &OpcodeArray[OP_OR],
2773  				data:   nil,
2774  			},
2775  			expectedErr: nil,
2776  		},
2777  		{
2778  			name: "OP_OR long",
2779  			pop: &parsedOpcode{
2780  				opcode: &OpcodeArray[OP_OR],
2781  				data:   make([]byte, 1),
2782  			},
2783  			expectedErr: scriptError(ErrInternal, ""),
2784  		},
2785  		{
2786  			name: "OP_XOR",
2787  			pop: &parsedOpcode{
2788  				opcode: &OpcodeArray[OP_XOR],
2789  				data:   nil,
2790  			},
2791  			expectedErr: nil,
2792  		},
2793  		{
2794  			name: "OP_XOR long",
2795  			pop: &parsedOpcode{
2796  				opcode: &OpcodeArray[OP_XOR],
2797  				data:   make([]byte, 1),
2798  			},
2799  			expectedErr: scriptError(ErrInternal, ""),
2800  		},
2801  		{
2802  			name: "OP_EQUAL",
2803  			pop: &parsedOpcode{
2804  				opcode: &OpcodeArray[OP_EQUAL],
2805  				data:   nil,
2806  			},
2807  			expectedErr: nil,
2808  		},
2809  		{
2810  			name: "OP_EQUAL long",
2811  			pop: &parsedOpcode{
2812  				opcode: &OpcodeArray[OP_EQUAL],
2813  				data:   make([]byte, 1),
2814  			},
2815  			expectedErr: scriptError(ErrInternal, ""),
2816  		},
2817  		{
2818  			name: "OP_EQUALVERIFY",
2819  			pop: &parsedOpcode{
2820  				opcode: &OpcodeArray[OP_EQUALVERIFY],
2821  				data:   nil,
2822  			},
2823  			expectedErr: nil,
2824  		},
2825  		{
2826  			name: "OP_EQUALVERIFY long",
2827  			pop: &parsedOpcode{
2828  				opcode: &OpcodeArray[OP_EQUALVERIFY],
2829  				data:   make([]byte, 1),
2830  			},
2831  			expectedErr: scriptError(ErrInternal, ""),
2832  		},
2833  		{
2834  			name: "OP_RESERVED1",
2835  			pop: &parsedOpcode{
2836  				opcode: &OpcodeArray[OP_RESERVED1],
2837  				data:   nil,
2838  			},
2839  			expectedErr: nil,
2840  		},
2841  		{
2842  			name: "OP_RESERVED1 long",
2843  			pop: &parsedOpcode{
2844  				opcode: &OpcodeArray[OP_RESERVED1],
2845  				data:   make([]byte, 1),
2846  			},
2847  			expectedErr: scriptError(ErrInternal, ""),
2848  		},
2849  		{
2850  			name: "OP_RESERVED2",
2851  			pop: &parsedOpcode{
2852  				opcode: &OpcodeArray[OP_RESERVED2],
2853  				data:   nil,
2854  			},
2855  			expectedErr: nil,
2856  		},
2857  		{
2858  			name: "OP_RESERVED2 long",
2859  			pop: &parsedOpcode{
2860  				opcode: &OpcodeArray[OP_RESERVED2],
2861  				data:   make([]byte, 1),
2862  			},
2863  			expectedErr: scriptError(ErrInternal, ""),
2864  		},
2865  		{
2866  			name: "OP_1ADD",
2867  			pop: &parsedOpcode{
2868  				opcode: &OpcodeArray[OP_1ADD],
2869  				data:   nil,
2870  			},
2871  			expectedErr: nil,
2872  		},
2873  		{
2874  			name: "OP_1ADD long",
2875  			pop: &parsedOpcode{
2876  				opcode: &OpcodeArray[OP_1ADD],
2877  				data:   make([]byte, 1),
2878  			},
2879  			expectedErr: scriptError(ErrInternal, ""),
2880  		},
2881  		{
2882  			name: "OP_1SUB",
2883  			pop: &parsedOpcode{
2884  				opcode: &OpcodeArray[OP_1SUB],
2885  				data:   nil,
2886  			},
2887  			expectedErr: nil,
2888  		},
2889  		{
2890  			name: "OP_1SUB long",
2891  			pop: &parsedOpcode{
2892  				opcode: &OpcodeArray[OP_1SUB],
2893  				data:   make([]byte, 1),
2894  			},
2895  			expectedErr: scriptError(ErrInternal, ""),
2896  		},
2897  		{
2898  			name: "OP_2MUL",
2899  			pop: &parsedOpcode{
2900  				opcode: &OpcodeArray[OP_2MUL],
2901  				data:   nil,
2902  			},
2903  			expectedErr: nil,
2904  		},
2905  		{
2906  			name: "OP_2MUL long",
2907  			pop: &parsedOpcode{
2908  				opcode: &OpcodeArray[OP_2MUL],
2909  				data:   make([]byte, 1),
2910  			},
2911  			expectedErr: scriptError(ErrInternal, ""),
2912  		},
2913  		{
2914  			name: "OP_2DIV",
2915  			pop: &parsedOpcode{
2916  				opcode: &OpcodeArray[OP_2DIV],
2917  				data:   nil,
2918  			},
2919  			expectedErr: nil,
2920  		},
2921  		{
2922  			name: "OP_2DIV long",
2923  			pop: &parsedOpcode{
2924  				opcode: &OpcodeArray[OP_2DIV],
2925  				data:   make([]byte, 1),
2926  			},
2927  			expectedErr: scriptError(ErrInternal, ""),
2928  		},
2929  		{
2930  			name: "OP_NEGATE",
2931  			pop: &parsedOpcode{
2932  				opcode: &OpcodeArray[OP_NEGATE],
2933  				data:   nil,
2934  			},
2935  			expectedErr: nil,
2936  		},
2937  		{
2938  			name: "OP_NEGATE long",
2939  			pop: &parsedOpcode{
2940  				opcode: &OpcodeArray[OP_NEGATE],
2941  				data:   make([]byte, 1),
2942  			},
2943  			expectedErr: scriptError(ErrInternal, ""),
2944  		},
2945  		{
2946  			name: "OP_ABS",
2947  			pop: &parsedOpcode{
2948  				opcode: &OpcodeArray[OP_ABS],
2949  				data:   nil,
2950  			},
2951  			expectedErr: nil,
2952  		},
2953  		{
2954  			name: "OP_ABS long",
2955  			pop: &parsedOpcode{
2956  				opcode: &OpcodeArray[OP_ABS],
2957  				data:   make([]byte, 1),
2958  			},
2959  			expectedErr: scriptError(ErrInternal, ""),
2960  		},
2961  		{
2962  			name: "OP_NOT",
2963  			pop: &parsedOpcode{
2964  				opcode: &OpcodeArray[OP_NOT],
2965  				data:   nil,
2966  			},
2967  			expectedErr: nil,
2968  		},
2969  		{
2970  			name: "OP_NOT long",
2971  			pop: &parsedOpcode{
2972  				opcode: &OpcodeArray[OP_NOT],
2973  				data:   make([]byte, 1),
2974  			},
2975  			expectedErr: scriptError(ErrInternal, ""),
2976  		},
2977  		{
2978  			name: "OP_0NOTEQUAL",
2979  			pop: &parsedOpcode{
2980  				opcode: &OpcodeArray[OP_0NOTEQUAL],
2981  				data:   nil,
2982  			},
2983  			expectedErr: nil,
2984  		},
2985  		{
2986  			name: "OP_0NOTEQUAL long",
2987  			pop: &parsedOpcode{
2988  				opcode: &OpcodeArray[OP_0NOTEQUAL],
2989  				data:   make([]byte, 1),
2990  			},
2991  			expectedErr: scriptError(ErrInternal, ""),
2992  		},
2993  		{
2994  			name: "OP_ADD",
2995  			pop: &parsedOpcode{
2996  				opcode: &OpcodeArray[OP_ADD],
2997  				data:   nil,
2998  			},
2999  			expectedErr: nil,
3000  		},
3001  		{
3002  			name: "OP_ADD long",
3003  			pop: &parsedOpcode{
3004  				opcode: &OpcodeArray[OP_ADD],
3005  				data:   make([]byte, 1),
3006  			},
3007  			expectedErr: scriptError(ErrInternal, ""),
3008  		},
3009  		{
3010  			name: "OP_SUB",
3011  			pop: &parsedOpcode{
3012  				opcode: &OpcodeArray[OP_SUB],
3013  				data:   nil,
3014  			},
3015  			expectedErr: nil,
3016  		},
3017  		{
3018  			name: "OP_SUB long",
3019  			pop: &parsedOpcode{
3020  				opcode: &OpcodeArray[OP_SUB],
3021  				data:   make([]byte, 1),
3022  			},
3023  			expectedErr: scriptError(ErrInternal, ""),
3024  		},
3025  		{
3026  			name: "OP_MUL",
3027  			pop: &parsedOpcode{
3028  				opcode: &OpcodeArray[OP_MUL],
3029  				data:   nil,
3030  			},
3031  			expectedErr: nil,
3032  		},
3033  		{
3034  			name: "OP_MUL long",
3035  			pop: &parsedOpcode{
3036  				opcode: &OpcodeArray[OP_MUL],
3037  				data:   make([]byte, 1),
3038  			},
3039  			expectedErr: scriptError(ErrInternal, ""),
3040  		},
3041  		{
3042  			name: "OP_DIV",
3043  			pop: &parsedOpcode{
3044  				opcode: &OpcodeArray[OP_DIV],
3045  				data:   nil,
3046  			},
3047  			expectedErr: nil,
3048  		},
3049  		{
3050  			name: "OP_DIV long",
3051  			pop: &parsedOpcode{
3052  				opcode: &OpcodeArray[OP_DIV],
3053  				data:   make([]byte, 1),
3054  			},
3055  			expectedErr: scriptError(ErrInternal, ""),
3056  		},
3057  		{
3058  			name: "OP_MOD",
3059  			pop: &parsedOpcode{
3060  				opcode: &OpcodeArray[OP_MOD],
3061  				data:   nil,
3062  			},
3063  			expectedErr: nil,
3064  		},
3065  		{
3066  			name: "OP_MOD long",
3067  			pop: &parsedOpcode{
3068  				opcode: &OpcodeArray[OP_MOD],
3069  				data:   make([]byte, 1),
3070  			},
3071  			expectedErr: scriptError(ErrInternal, ""),
3072  		},
3073  		{
3074  			name: "OP_LSHIFT",
3075  			pop: &parsedOpcode{
3076  				opcode: &OpcodeArray[OP_LSHIFT],
3077  				data:   nil,
3078  			},
3079  			expectedErr: nil,
3080  		},
3081  		{
3082  			name: "OP_LSHIFT long",
3083  			pop: &parsedOpcode{
3084  				opcode: &OpcodeArray[OP_LSHIFT],
3085  				data:   make([]byte, 1),
3086  			},
3087  			expectedErr: scriptError(ErrInternal, ""),
3088  		},
3089  		{
3090  			name: "OP_RSHIFT",
3091  			pop: &parsedOpcode{
3092  				opcode: &OpcodeArray[OP_RSHIFT],
3093  				data:   nil,
3094  			},
3095  			expectedErr: nil,
3096  		},
3097  		{
3098  			name: "OP_RSHIFT long",
3099  			pop: &parsedOpcode{
3100  				opcode: &OpcodeArray[OP_RSHIFT],
3101  				data:   make([]byte, 1),
3102  			},
3103  			expectedErr: scriptError(ErrInternal, ""),
3104  		},
3105  		{
3106  			name: "OP_BOOLAND",
3107  			pop: &parsedOpcode{
3108  				opcode: &OpcodeArray[OP_BOOLAND],
3109  				data:   nil,
3110  			},
3111  			expectedErr: nil,
3112  		},
3113  		{
3114  			name: "OP_BOOLAND long",
3115  			pop: &parsedOpcode{
3116  				opcode: &OpcodeArray[OP_BOOLAND],
3117  				data:   make([]byte, 1),
3118  			},
3119  			expectedErr: scriptError(ErrInternal, ""),
3120  		},
3121  		{
3122  			name: "OP_BOOLOR",
3123  			pop: &parsedOpcode{
3124  				opcode: &OpcodeArray[OP_BOOLOR],
3125  				data:   nil,
3126  			},
3127  			expectedErr: nil,
3128  		},
3129  		{
3130  			name: "OP_BOOLOR long",
3131  			pop: &parsedOpcode{
3132  				opcode: &OpcodeArray[OP_BOOLOR],
3133  				data:   make([]byte, 1),
3134  			},
3135  			expectedErr: scriptError(ErrInternal, ""),
3136  		},
3137  		{
3138  			name: "OP_NUMEQUAL",
3139  			pop: &parsedOpcode{
3140  				opcode: &OpcodeArray[OP_NUMEQUAL],
3141  				data:   nil,
3142  			},
3143  			expectedErr: nil,
3144  		},
3145  		{
3146  			name: "OP_NUMEQUAL long",
3147  			pop: &parsedOpcode{
3148  				opcode: &OpcodeArray[OP_NUMEQUAL],
3149  				data:   make([]byte, 1),
3150  			},
3151  			expectedErr: scriptError(ErrInternal, ""),
3152  		},
3153  		{
3154  			name: "OP_NUMEQUALVERIFY",
3155  			pop: &parsedOpcode{
3156  				opcode: &OpcodeArray[OP_NUMEQUALVERIFY],
3157  				data:   nil,
3158  			},
3159  			expectedErr: nil,
3160  		},
3161  		{
3162  			name: "OP_NUMEQUALVERIFY long",
3163  			pop: &parsedOpcode{
3164  				opcode: &OpcodeArray[OP_NUMEQUALVERIFY],
3165  				data:   make([]byte, 1),
3166  			},
3167  			expectedErr: scriptError(ErrInternal, ""),
3168  		},
3169  		{
3170  			name: "OP_NUMNOTEQUAL",
3171  			pop: &parsedOpcode{
3172  				opcode: &OpcodeArray[OP_NUMNOTEQUAL],
3173  				data:   nil,
3174  			},
3175  			expectedErr: nil,
3176  		},
3177  		{
3178  			name: "OP_NUMNOTEQUAL long",
3179  			pop: &parsedOpcode{
3180  				opcode: &OpcodeArray[OP_NUMNOTEQUAL],
3181  				data:   make([]byte, 1),
3182  			},
3183  			expectedErr: scriptError(ErrInternal, ""),
3184  		},
3185  		{
3186  			name: "OP_LESSTHAN",
3187  			pop: &parsedOpcode{
3188  				opcode: &OpcodeArray[OP_LESSTHAN],
3189  				data:   nil,
3190  			},
3191  			expectedErr: nil,
3192  		},
3193  		{
3194  			name: "OP_LESSTHAN long",
3195  			pop: &parsedOpcode{
3196  				opcode: &OpcodeArray[OP_LESSTHAN],
3197  				data:   make([]byte, 1),
3198  			},
3199  			expectedErr: scriptError(ErrInternal, ""),
3200  		},
3201  		{
3202  			name: "OP_GREATERTHAN",
3203  			pop: &parsedOpcode{
3204  				opcode: &OpcodeArray[OP_GREATERTHAN],
3205  				data:   nil,
3206  			},
3207  			expectedErr: nil,
3208  		},
3209  		{
3210  			name: "OP_GREATERTHAN long",
3211  			pop: &parsedOpcode{
3212  				opcode: &OpcodeArray[OP_GREATERTHAN],
3213  				data:   make([]byte, 1),
3214  			},
3215  			expectedErr: scriptError(ErrInternal, ""),
3216  		},
3217  		{
3218  			name: "OP_LESSTHANOREQUAL",
3219  			pop: &parsedOpcode{
3220  				opcode: &OpcodeArray[OP_LESSTHANOREQUAL],
3221  				data:   nil,
3222  			},
3223  			expectedErr: nil,
3224  		},
3225  		{
3226  			name: "OP_LESSTHANOREQUAL long",
3227  			pop: &parsedOpcode{
3228  				opcode: &OpcodeArray[OP_LESSTHANOREQUAL],
3229  				data:   make([]byte, 1),
3230  			},
3231  			expectedErr: scriptError(ErrInternal, ""),
3232  		},
3233  		{
3234  			name: "OP_GREATERTHANOREQUAL",
3235  			pop: &parsedOpcode{
3236  				opcode: &OpcodeArray[OP_GREATERTHANOREQUAL],
3237  				data:   nil,
3238  			},
3239  			expectedErr: nil,
3240  		},
3241  		{
3242  			name: "OP_GREATERTHANOREQUAL long",
3243  			pop: &parsedOpcode{
3244  				opcode: &OpcodeArray[OP_GREATERTHANOREQUAL],
3245  				data:   make([]byte, 1),
3246  			},
3247  			expectedErr: scriptError(ErrInternal, ""),
3248  		},
3249  		{
3250  			name: "OP_MIN",
3251  			pop: &parsedOpcode{
3252  				opcode: &OpcodeArray[OP_MIN],
3253  				data:   nil,
3254  			},
3255  			expectedErr: nil,
3256  		},
3257  		{
3258  			name: "OP_MIN long",
3259  			pop: &parsedOpcode{
3260  				opcode: &OpcodeArray[OP_MIN],
3261  				data:   make([]byte, 1),
3262  			},
3263  			expectedErr: scriptError(ErrInternal, ""),
3264  		},
3265  		{
3266  			name: "OP_MAX",
3267  			pop: &parsedOpcode{
3268  				opcode: &OpcodeArray[OP_MAX],
3269  				data:   nil,
3270  			},
3271  			expectedErr: nil,
3272  		},
3273  		{
3274  			name: "OP_MAX long",
3275  			pop: &parsedOpcode{
3276  				opcode: &OpcodeArray[OP_MAX],
3277  				data:   make([]byte, 1),
3278  			},
3279  			expectedErr: scriptError(ErrInternal, ""),
3280  		},
3281  		{
3282  			name: "OP_WITHIN",
3283  			pop: &parsedOpcode{
3284  				opcode: &OpcodeArray[OP_WITHIN],
3285  				data:   nil,
3286  			},
3287  			expectedErr: nil,
3288  		},
3289  		{
3290  			name: "OP_WITHIN long",
3291  			pop: &parsedOpcode{
3292  				opcode: &OpcodeArray[OP_WITHIN],
3293  				data:   make([]byte, 1),
3294  			},
3295  			expectedErr: scriptError(ErrInternal, ""),
3296  		},
3297  		{
3298  			name: "OP_RIPEMD160",
3299  			pop: &parsedOpcode{
3300  				opcode: &OpcodeArray[OP_RIPEMD160],
3301  				data:   nil,
3302  			},
3303  			expectedErr: nil,
3304  		},
3305  		{
3306  			name: "OP_RIPEMD160 long",
3307  			pop: &parsedOpcode{
3308  				opcode: &OpcodeArray[OP_RIPEMD160],
3309  				data:   make([]byte, 1),
3310  			},
3311  			expectedErr: scriptError(ErrInternal, ""),
3312  		},
3313  		{
3314  			name: "OP_SHA1",
3315  			pop: &parsedOpcode{
3316  				opcode: &OpcodeArray[OP_SHA1],
3317  				data:   nil,
3318  			},
3319  			expectedErr: nil,
3320  		},
3321  		{
3322  			name: "OP_SHA1 long",
3323  			pop: &parsedOpcode{
3324  				opcode: &OpcodeArray[OP_SHA1],
3325  				data:   make([]byte, 1),
3326  			},
3327  			expectedErr: scriptError(ErrInternal, ""),
3328  		},
3329  		{
3330  			name: "OP_SHA256",
3331  			pop: &parsedOpcode{
3332  				opcode: &OpcodeArray[OP_SHA256],
3333  				data:   nil,
3334  			},
3335  			expectedErr: nil,
3336  		},
3337  		{
3338  			name: "OP_SHA256 long",
3339  			pop: &parsedOpcode{
3340  				opcode: &OpcodeArray[OP_SHA256],
3341  				data:   make([]byte, 1),
3342  			},
3343  			expectedErr: scriptError(ErrInternal, ""),
3344  		},
3345  		{
3346  			name: "OP_HASH160",
3347  			pop: &parsedOpcode{
3348  				opcode: &OpcodeArray[OP_HASH160],
3349  				data:   nil,
3350  			},
3351  			expectedErr: nil,
3352  		},
3353  		{
3354  			name: "OP_HASH160 long",
3355  			pop: &parsedOpcode{
3356  				opcode: &OpcodeArray[OP_HASH160],
3357  				data:   make([]byte, 1),
3358  			},
3359  			expectedErr: scriptError(ErrInternal, ""),
3360  		},
3361  		{
3362  			name: "OP_HASH256",
3363  			pop: &parsedOpcode{
3364  				opcode: &OpcodeArray[OP_HASH256],
3365  				data:   nil,
3366  			},
3367  			expectedErr: nil,
3368  		},
3369  		{
3370  			name: "OP_HASH256 long",
3371  			pop: &parsedOpcode{
3372  				opcode: &OpcodeArray[OP_HASH256],
3373  				data:   make([]byte, 1),
3374  			},
3375  			expectedErr: scriptError(ErrInternal, ""),
3376  		},
3377  		{
3378  			name: "OP_CODESAPERATOR",
3379  			pop: &parsedOpcode{
3380  				opcode: &OpcodeArray[OP_CODESEPARATOR],
3381  				data:   nil,
3382  			},
3383  			expectedErr: nil,
3384  		},
3385  		{
3386  			name: "OP_CODESEPARATOR long",
3387  			pop: &parsedOpcode{
3388  				opcode: &OpcodeArray[OP_CODESEPARATOR],
3389  				data:   make([]byte, 1),
3390  			},
3391  			expectedErr: scriptError(ErrInternal, ""),
3392  		},
3393  		{
3394  			name: "OP_CHECKSIG",
3395  			pop: &parsedOpcode{
3396  				opcode: &OpcodeArray[OP_CHECKSIG],
3397  				data:   nil,
3398  			},
3399  			expectedErr: nil,
3400  		},
3401  		{
3402  			name: "OP_CHECKSIG long",
3403  			pop: &parsedOpcode{
3404  				opcode: &OpcodeArray[OP_CHECKSIG],
3405  				data:   make([]byte, 1),
3406  			},
3407  			expectedErr: scriptError(ErrInternal, ""),
3408  		},
3409  		{
3410  			name: "OP_CHECKSIGVERIFY",
3411  			pop: &parsedOpcode{
3412  				opcode: &OpcodeArray[OP_CHECKSIGVERIFY],
3413  				data:   nil,
3414  			},
3415  			expectedErr: nil,
3416  		},
3417  		{
3418  			name: "OP_CHECKSIGVERIFY long",
3419  			pop: &parsedOpcode{
3420  				opcode: &OpcodeArray[OP_CHECKSIGVERIFY],
3421  				data:   make([]byte, 1),
3422  			},
3423  			expectedErr: scriptError(ErrInternal, ""),
3424  		},
3425  		{
3426  			name: "OP_CHECKMULTISIG",
3427  			pop: &parsedOpcode{
3428  				opcode: &OpcodeArray[OP_CHECKMULTISIG],
3429  				data:   nil,
3430  			},
3431  			expectedErr: nil,
3432  		},
3433  		{
3434  			name: "OP_CHECKMULTISIG long",
3435  			pop: &parsedOpcode{
3436  				opcode: &OpcodeArray[OP_CHECKMULTISIG],
3437  				data:   make([]byte, 1),
3438  			},
3439  			expectedErr: scriptError(ErrInternal, ""),
3440  		},
3441  		{
3442  			name: "OP_CHECKMULTISIGVERIFY",
3443  			pop: &parsedOpcode{
3444  				opcode: &OpcodeArray[OP_CHECKMULTISIGVERIFY],
3445  				data:   nil,
3446  			},
3447  			expectedErr: nil,
3448  		},
3449  		{
3450  			name: "OP_CHECKMULTISIGVERIFY long",
3451  			pop: &parsedOpcode{
3452  				opcode: &OpcodeArray[OP_CHECKMULTISIGVERIFY],
3453  				data:   make([]byte, 1),
3454  			},
3455  			expectedErr: scriptError(ErrInternal, ""),
3456  		},
3457  		{
3458  			name: "OP_NOP1",
3459  			pop: &parsedOpcode{
3460  				opcode: &OpcodeArray[OP_NOP1],
3461  				data:   nil,
3462  			},
3463  			expectedErr: nil,
3464  		},
3465  		{
3466  			name: "OP_NOP1 long",
3467  			pop: &parsedOpcode{
3468  				opcode: &OpcodeArray[OP_NOP1],
3469  				data:   make([]byte, 1),
3470  			},
3471  			expectedErr: scriptError(ErrInternal, ""),
3472  		},
3473  		{
3474  			name: "OP_NOP2",
3475  			pop: &parsedOpcode{
3476  				opcode: &OpcodeArray[OP_NOP2],
3477  				data:   nil,
3478  			},
3479  			expectedErr: nil,
3480  		},
3481  		{
3482  			name: "OP_NOP2 long",
3483  			pop: &parsedOpcode{
3484  				opcode: &OpcodeArray[OP_NOP2],
3485  				data:   make([]byte, 1),
3486  			},
3487  			expectedErr: scriptError(ErrInternal, ""),
3488  		},
3489  		{
3490  			name: "OP_NOP3",
3491  			pop: &parsedOpcode{
3492  				opcode: &OpcodeArray[OP_NOP3],
3493  				data:   nil,
3494  			},
3495  			expectedErr: nil,
3496  		},
3497  		{
3498  			name: "OP_NOP3 long",
3499  			pop: &parsedOpcode{
3500  				opcode: &OpcodeArray[OP_NOP3],
3501  				data:   make([]byte, 1),
3502  			},
3503  			expectedErr: scriptError(ErrInternal, ""),
3504  		},
3505  		{
3506  			name: "OP_NOP4",
3507  			pop: &parsedOpcode{
3508  				opcode: &OpcodeArray[OP_NOP4],
3509  				data:   nil,
3510  			},
3511  			expectedErr: nil,
3512  		},
3513  		{
3514  			name: "OP_NOP4 long",
3515  			pop: &parsedOpcode{
3516  				opcode: &OpcodeArray[OP_NOP4],
3517  				data:   make([]byte, 1),
3518  			},
3519  			expectedErr: scriptError(ErrInternal, ""),
3520  		},
3521  		{
3522  			name: "OP_NOP5",
3523  			pop: &parsedOpcode{
3524  				opcode: &OpcodeArray[OP_NOP5],
3525  				data:   nil,
3526  			},
3527  			expectedErr: nil,
3528  		},
3529  		{
3530  			name: "OP_NOP5 long",
3531  			pop: &parsedOpcode{
3532  				opcode: &OpcodeArray[OP_NOP5],
3533  				data:   make([]byte, 1),
3534  			},
3535  			expectedErr: scriptError(ErrInternal, ""),
3536  		},
3537  		{
3538  			name: "OP_NOP6",
3539  			pop: &parsedOpcode{
3540  				opcode: &OpcodeArray[OP_NOP6],
3541  				data:   nil,
3542  			},
3543  			expectedErr: nil,
3544  		},
3545  		{
3546  			name: "OP_NOP6 long",
3547  			pop: &parsedOpcode{
3548  				opcode: &OpcodeArray[OP_NOP6],
3549  				data:   make([]byte, 1),
3550  			},
3551  			expectedErr: scriptError(ErrInternal, ""),
3552  		},
3553  		{
3554  			name: "OP_NOP7",
3555  			pop: &parsedOpcode{
3556  				opcode: &OpcodeArray[OP_NOP7],
3557  				data:   nil,
3558  			},
3559  			expectedErr: nil,
3560  		},
3561  		{
3562  			name: "OP_NOP7 long",
3563  			pop: &parsedOpcode{
3564  				opcode: &OpcodeArray[OP_NOP7],
3565  				data:   make([]byte, 1),
3566  			},
3567  			expectedErr: scriptError(ErrInternal, ""),
3568  		},
3569  		{
3570  			name: "OP_NOP8",
3571  			pop: &parsedOpcode{
3572  				opcode: &OpcodeArray[OP_NOP8],
3573  				data:   nil,
3574  			},
3575  			expectedErr: nil,
3576  		},
3577  		{
3578  			name: "OP_NOP8 long",
3579  			pop: &parsedOpcode{
3580  				opcode: &OpcodeArray[OP_NOP8],
3581  				data:   make([]byte, 1),
3582  			},
3583  			expectedErr: scriptError(ErrInternal, ""),
3584  		},
3585  		{
3586  			name: "OP_NOP9",
3587  			pop: &parsedOpcode{
3588  				opcode: &OpcodeArray[OP_NOP9],
3589  				data:   nil,
3590  			},
3591  			expectedErr: nil,
3592  		},
3593  		{
3594  			name: "OP_NOP9 long",
3595  			pop: &parsedOpcode{
3596  				opcode: &OpcodeArray[OP_NOP9],
3597  				data:   make([]byte, 1),
3598  			},
3599  			expectedErr: scriptError(ErrInternal, ""),
3600  		},
3601  		{
3602  			name: "OP_NOP10",
3603  			pop: &parsedOpcode{
3604  				opcode: &OpcodeArray[OP_NOP10],
3605  				data:   nil,
3606  			},
3607  			expectedErr: nil,
3608  		},
3609  		{
3610  			name: "OP_NOP10 long",
3611  			pop: &parsedOpcode{
3612  				opcode: &OpcodeArray[OP_NOP10],
3613  				data:   make([]byte, 1),
3614  			},
3615  			expectedErr: scriptError(ErrInternal, ""),
3616  		},
3617  		{
3618  			name: "OP_PUBKEYHASH",
3619  			pop: &parsedOpcode{
3620  				opcode: &OpcodeArray[OP_PUBKEYHASH],
3621  				data:   nil,
3622  			},
3623  			expectedErr: nil,
3624  		},
3625  		{
3626  			name: "OP_PUBKEYHASH long",
3627  			pop: &parsedOpcode{
3628  				opcode: &OpcodeArray[OP_PUBKEYHASH],
3629  				data:   make([]byte, 1),
3630  			},
3631  			expectedErr: scriptError(ErrInternal, ""),
3632  		},
3633  		{
3634  			name: "OP_PUBKEY",
3635  			pop: &parsedOpcode{
3636  				opcode: &OpcodeArray[OP_PUBKEY],
3637  				data:   nil,
3638  			},
3639  			expectedErr: nil,
3640  		},
3641  		{
3642  			name: "OP_PUBKEY long",
3643  			pop: &parsedOpcode{
3644  				opcode: &OpcodeArray[OP_PUBKEY],
3645  				data:   make([]byte, 1),
3646  			},
3647  			expectedErr: scriptError(ErrInternal, ""),
3648  		},
3649  		{
3650  			name: "OP_INVALIDOPCODE",
3651  			pop: &parsedOpcode{
3652  				opcode: &OpcodeArray[OP_INVALIDOPCODE],
3653  				data:   nil,
3654  			},
3655  			expectedErr: nil,
3656  		},
3657  		{
3658  			name: "OP_INVALIDOPCODE long",
3659  			pop: &parsedOpcode{
3660  				opcode: &OpcodeArray[OP_INVALIDOPCODE],
3661  				data:   make([]byte, 1),
3662  			},
3663  			expectedErr: scriptError(ErrInternal, ""),
3664  		},
3665  	}
3666  	var e error
3667  	for _, test := range tests {
3668  		_, e = test.pop.bytes()
3669  		if e = tstCheckScriptError(e, test.expectedErr); e != nil {
3670  			t.Errorf("Parsed opcode test '%s': %v", test.name, e)
3671  			continue
3672  		}
3673  	}
3674  }
3675  
3676  // TestPushedData ensured the PushedData function extracts the expected data out of various scripts.
3677  func TestPushedData(t *testing.T) {
3678  	t.Parallel()
3679  	var tests = []struct {
3680  		script string
3681  		out    [][]byte
3682  		valid  bool
3683  	}{
3684  		{
3685  			"0 IF 0 ELSE 2 ENDIF",
3686  			[][]byte{nil, nil},
3687  			true,
3688  		},
3689  		{
3690  			"16777216 10000000",
3691  			[][]byte{
3692  				{0x00, 0x00, 0x00, 0x01}, // 16777216
3693  				{0x80, 0x96, 0x98, 0x00}, // 10000000
3694  			},
3695  			true,
3696  		},
3697  		{
3698  			"DUP HASH160 '17VZNX1SN5NtKa8UQFxwQbFeFc3iqRYhem' EQUALVERIFY CHECKSIG",
3699  			[][]byte{
3700  				// 17VZNX1SN5NtKa8UQFxwQbFeFc3iqRYhem
3701  				{
3702  					0x31, 0x37, 0x56, 0x5a, 0x4e, 0x58, 0x31, 0x53, 0x4e, 0x35,
3703  					0x4e, 0x74, 0x4b, 0x61, 0x38, 0x55, 0x51, 0x46, 0x78, 0x77,
3704  					0x51, 0x62, 0x46, 0x65, 0x46, 0x63, 0x33, 0x69, 0x71, 0x52,
3705  					0x59, 0x68, 0x65, 0x6d,
3706  				},
3707  			},
3708  			true,
3709  		},
3710  		{
3711  			"PUSHDATA4 1000 EQUAL",
3712  			nil,
3713  			false,
3714  		},
3715  	}
3716  	for i, test := range tests {
3717  		script := mustParseShortForm(test.script)
3718  		data, e := PushedData(script)
3719  		if test.valid && e != nil {
3720  			t.Errorf("TestPushedData failed test #%d: %v\n", i, e)
3721  			continue
3722  		} else if !test.valid && e == nil {
3723  			t.Errorf("TestPushedData failed test #%d: test should "+
3724  				"be invalid\n", i,
3725  			)
3726  			continue
3727  		}
3728  		if !reflect.DeepEqual(data, test.out) {
3729  			t.Errorf("TestPushedData failed test #%d: want: %x "+
3730  				"got: %x\n", i, test.out, data,
3731  			)
3732  		}
3733  	}
3734  }
3735  
3736  // TestHasCanonicalPush ensures the canonicalPush function works as expected.
3737  func TestHasCanonicalPush(t *testing.T) {
3738  	t.Parallel()
3739  	for i := 0; i < 65535; i++ {
3740  		script, e := NewScriptBuilder().AddInt64(int64(i)).Script()
3741  		if e != nil {
3742  			t.Errorf("Script: test #%d unexpected error: %v\n", i,
3743  				e,
3744  			)
3745  			continue
3746  		}
3747  		if result := IsPushOnlyScript(script); !result {
3748  			t.Errorf("IsPushOnlyScript: test #%d failed: %x\n", i,
3749  				script,
3750  			)
3751  			continue
3752  		}
3753  		pops, e := parseScript(script)
3754  		if e != nil {
3755  			t.Errorf("parseScript: #%d failed: %v", i, e)
3756  			continue
3757  		}
3758  		for _, pop := range pops {
3759  			if result := canonicalPush(pop); !result {
3760  				t.Errorf("canonicalPush: test #%d failed: %x\n",
3761  					i, script,
3762  				)
3763  				break
3764  			}
3765  		}
3766  	}
3767  	for i := 0; i <= MaxScriptElementSize; i++ {
3768  		builder := NewScriptBuilder()
3769  		builder.AddData(bytes.Repeat([]byte{0x49}, i))
3770  		script, e := builder.Script()
3771  		if e != nil {
3772  			t.Errorf("StandardPushesTests test #%d unexpected error: %v\n", i, e)
3773  			continue
3774  		}
3775  		if result := IsPushOnlyScript(script); !result {
3776  			t.Errorf("StandardPushesTests IsPushOnlyScript test #%d failed: %x\n", i, script)
3777  			continue
3778  		}
3779  		pops, e := parseScript(script)
3780  		if e != nil {
3781  			t.Errorf("StandardPushesTests #%d failed to TstParseScript: %v", i, e)
3782  			continue
3783  		}
3784  		for _, pop := range pops {
3785  			if result := canonicalPush(pop); !result {
3786  				t.Errorf("StandardPushesTests TstHasCanonicalPushes test #%d failed: %x\n", i, script)
3787  				break
3788  			}
3789  		}
3790  	}
3791  }
3792  
3793  // TestGetPreciseSigOps ensures the more precise signature operation counting mechanism which includes signatures in P2SH scripts works as expected.
3794  func TestGetPreciseSigOps(t *testing.T) {
3795  	t.Parallel()
3796  	tests := []struct {
3797  		name      string
3798  		scriptSig []byte
3799  		nSigOps   int
3800  	}{
3801  		{
3802  			name:      "scriptSig doesn't parse",
3803  			scriptSig: mustParseShortForm("PUSHDATA1 0x02"),
3804  		},
3805  		{
3806  			name:      "scriptSig isn't push only",
3807  			scriptSig: mustParseShortForm("1 DUP"),
3808  			nSigOps:   0,
3809  		},
3810  		{
3811  			name:      "scriptSig length 0",
3812  			scriptSig: nil,
3813  			nSigOps:   0,
3814  		},
3815  		{
3816  			name: "No script at the end",
3817  			// No script at end but still push only.
3818  			scriptSig: mustParseShortForm("1 1"),
3819  			nSigOps:   0,
3820  		},
3821  		{
3822  			name:      "pushed script doesn't parse",
3823  			scriptSig: mustParseShortForm("DATA_2 PUSHDATA1 0x02"),
3824  		},
3825  	}
3826  	// The signature in the p2sh script is nonsensical for the tests since this script will never be executed. What
3827  	// matters is that it matches the right pattern.
3828  	pkScript := mustParseShortForm("HASH160 DATA_20 0x433ec2ac1ffa1b7b7d0" +
3829  		"27f564529c57197f9ae88 EQUAL",
3830  	)
3831  	for _, test := range tests {
3832  		count := GetPreciseSigOpCount(test.scriptSig, pkScript, true)
3833  		if count != test.nSigOps {
3834  			t.Errorf("%s: expected count of %d, got %d", test.name,
3835  				test.nSigOps, count,
3836  			)
3837  		}
3838  	}
3839  }
3840  
3841  // TestRemoveOpcodes ensures that removing opcodes from scripts behaves as expected.
3842  func TestRemoveOpcodes(t *testing.T) {
3843  	t.Parallel()
3844  	tests := []struct {
3845  		name   string
3846  		before string
3847  		remove byte
3848  		e      error
3849  		after  string
3850  	}{
3851  		{
3852  			// Nothing to remove.
3853  			name:   "nothing to remove",
3854  			before: "NOP",
3855  			remove: OP_CODESEPARATOR,
3856  			after:  "NOP",
3857  		},
3858  		{
3859  			// Test basic opcode removal.
3860  			name:   "codeseparator 1",
3861  			before: "NOP CODESEPARATOR TRUE",
3862  			remove: OP_CODESEPARATOR,
3863  			after:  "NOP TRUE",
3864  		},
3865  		{
3866  			// The opcode in question is actually part of the data in a previous opcode.
3867  			name:   "codeseparator by coincidence",
3868  			before: "NOP DATA_1 CODESEPARATOR TRUE",
3869  			remove: OP_CODESEPARATOR,
3870  			after:  "NOP DATA_1 CODESEPARATOR TRUE",
3871  		},
3872  		{
3873  			name:   "invalid opcode",
3874  			before: "CAT",
3875  			remove: OP_CODESEPARATOR,
3876  			after:  "CAT",
3877  		},
3878  		{
3879  			name:   "invalid length (instruction)",
3880  			before: "PUSHDATA1",
3881  			remove: OP_CODESEPARATOR,
3882  			e:      scriptError(ErrMalformedPush, ""),
3883  		},
3884  		{
3885  			name:   "invalid length (data)",
3886  			before: "PUSHDATA1 0xff 0xfe",
3887  			remove: OP_CODESEPARATOR,
3888  			e:      scriptError(ErrMalformedPush, ""),
3889  		},
3890  	}
3891  	// tstRemoveOpcode is a convenience function to parse the provided raw script, remove the passed opcode, then
3892  	// unparse the result back into a raw script.
3893  	tstRemoveOpcode := func(script []byte, opcode byte) ([]byte, error) {
3894  		pops, e := parseScript(script)
3895  		if e != nil {
3896  			return nil, e
3897  		}
3898  		pops = removeOpcode(pops, opcode)
3899  		return unparseScript(pops)
3900  	}
3901  	for _, test := range tests {
3902  		before := mustParseShortForm(test.before)
3903  		after := mustParseShortForm(test.after)
3904  		result, e := tstRemoveOpcode(before, test.remove)
3905  		if e = tstCheckScriptError(e, test.e); e != nil {
3906  			t.Errorf("%s: %v", test.name, e)
3907  			continue
3908  		}
3909  		if !bytes.Equal(after, result) {
3910  			t.Errorf("%s: value does not equal expected: exp: %q"+
3911  				" got: %q", test.name, after, result,
3912  			)
3913  		}
3914  	}
3915  }
3916  
3917  // TestRemoveOpcodeByData ensures that removing data carrying opcodes based on the data they contain works as expected.
3918  func TestRemoveOpcodeByData(t *testing.T) {
3919  	t.Parallel()
3920  	tests := []struct {
3921  		name   string
3922  		before []byte
3923  		remove []byte
3924  		e      error
3925  		after  []byte
3926  	}{
3927  		{
3928  			name:   "nothing to do",
3929  			before: []byte{OP_NOP},
3930  			remove: []byte{1, 2, 3, 4},
3931  			after:  []byte{OP_NOP},
3932  		},
3933  		{
3934  			name:   "simple case",
3935  			before: []byte{OP_DATA_4, 1, 2, 3, 4},
3936  			remove: []byte{1, 2, 3, 4},
3937  			after:  nil,
3938  		},
3939  		{
3940  			name:   "simple case (miss)",
3941  			before: []byte{OP_DATA_4, 1, 2, 3, 4},
3942  			remove: []byte{1, 2, 3, 5},
3943  			after:  []byte{OP_DATA_4, 1, 2, 3, 4},
3944  		},
3945  		{
3946  			// padded to keep it canonical.
3947  			name: "simple case (pushdata1)",
3948  			before: append(append([]byte{OP_PUSHDATA1, 76},
3949  				bytes.Repeat([]byte{0}, 72)...,
3950  			),
3951  				[]byte{1, 2, 3, 4}...,
3952  			),
3953  			remove: []byte{1, 2, 3, 4},
3954  			after:  nil,
3955  		},
3956  		{
3957  			name: "simple case (pushdata1 miss)",
3958  			before: append(append([]byte{OP_PUSHDATA1, 76},
3959  				bytes.Repeat([]byte{0}, 72)...,
3960  			),
3961  				[]byte{1, 2, 3, 4}...,
3962  			),
3963  			remove: []byte{1, 2, 3, 5},
3964  			after: append(append([]byte{OP_PUSHDATA1, 76},
3965  				bytes.Repeat([]byte{0}, 72)...,
3966  			),
3967  				[]byte{1, 2, 3, 4}...,
3968  			),
3969  		},
3970  		{
3971  			name:   "simple case (pushdata1 miss noncanonical)",
3972  			before: []byte{OP_PUSHDATA1, 4, 1, 2, 3, 4},
3973  			remove: []byte{1, 2, 3, 4},
3974  			after:  []byte{OP_PUSHDATA1, 4, 1, 2, 3, 4},
3975  		},
3976  		{
3977  			name: "simple case (pushdata2)",
3978  			before: append(append([]byte{OP_PUSHDATA2, 0, 1},
3979  				bytes.Repeat([]byte{0}, 252)...,
3980  			),
3981  				[]byte{1, 2, 3, 4}...,
3982  			),
3983  			remove: []byte{1, 2, 3, 4},
3984  			after:  nil,
3985  		},
3986  		{
3987  			name: "simple case (pushdata2 miss)",
3988  			before: append(append([]byte{OP_PUSHDATA2, 0, 1},
3989  				bytes.Repeat([]byte{0}, 252)...,
3990  			),
3991  				[]byte{1, 2, 3, 4}...,
3992  			),
3993  			remove: []byte{1, 2, 3, 4, 5},
3994  			after: append(append([]byte{OP_PUSHDATA2, 0, 1},
3995  				bytes.Repeat([]byte{0}, 252)...,
3996  			),
3997  				[]byte{1, 2, 3, 4}...,
3998  			),
3999  		},
4000  		{
4001  			name:   "simple case (pushdata2 miss noncanonical)",
4002  			before: []byte{OP_PUSHDATA2, 4, 0, 1, 2, 3, 4},
4003  			remove: []byte{1, 2, 3, 4},
4004  			after:  []byte{OP_PUSHDATA2, 4, 0, 1, 2, 3, 4},
4005  		},
4006  		{
4007  			// This is padded to make the push canonical.
4008  			name: "simple case (pushdata4)",
4009  			before: append(append([]byte{OP_PUSHDATA4, 0, 0, 1, 0},
4010  				bytes.Repeat([]byte{0}, 65532)...,
4011  			),
4012  				[]byte{1, 2, 3, 4}...,
4013  			),
4014  			remove: []byte{1, 2, 3, 4},
4015  			after:  nil,
4016  		},
4017  		{
4018  			name:   "simple case (pushdata4 miss noncanonical)",
4019  			before: []byte{OP_PUSHDATA4, 4, 0, 0, 0, 1, 2, 3, 4},
4020  			remove: []byte{1, 2, 3, 4},
4021  			after:  []byte{OP_PUSHDATA4, 4, 0, 0, 0, 1, 2, 3, 4},
4022  		},
4023  		{
4024  			// This is padded to make the push canonical.
4025  			name: "simple case (pushdata4 miss)",
4026  			before: append(append([]byte{OP_PUSHDATA4, 0, 0, 1, 0},
4027  				bytes.Repeat([]byte{0}, 65532)...,
4028  			), []byte{1, 2, 3, 4}...,
4029  			),
4030  			remove: []byte{1, 2, 3, 4, 5},
4031  			after: append(append([]byte{OP_PUSHDATA4, 0, 0, 1, 0},
4032  				bytes.Repeat([]byte{0}, 65532)...,
4033  			), []byte{1, 2, 3, 4}...,
4034  			),
4035  		},
4036  		{
4037  			name:   "invalid opcode ",
4038  			before: []byte{OP_UNKNOWN187},
4039  			remove: []byte{1, 2, 3, 4},
4040  			after:  []byte{OP_UNKNOWN187},
4041  		},
4042  		{
4043  			name:   "invalid length (instruction)",
4044  			before: []byte{OP_PUSHDATA1},
4045  			remove: []byte{1, 2, 3, 4},
4046  			e:      scriptError(ErrMalformedPush, ""),
4047  		},
4048  		{
4049  			name:   "invalid length (data)",
4050  			before: []byte{OP_PUSHDATA1, 255, 254},
4051  			remove: []byte{1, 2, 3, 4},
4052  			e:      scriptError(ErrMalformedPush, ""),
4053  		},
4054  	}
4055  	// tstRemoveOpcodeByData is a convenience function to parse the provided raw script, remove the passed data, then
4056  	// unparse the result back into a raw script.
4057  	tstRemoveOpcodeByData := func(script []byte, data []byte) ([]byte, error) {
4058  		pops, e := parseScript(script)
4059  		if e != nil {
4060  			return nil, e
4061  		}
4062  		pops = removeOpcodeByData(pops, data)
4063  		return unparseScript(pops)
4064  	}
4065  	for _, test := range tests {
4066  		result, e := tstRemoveOpcodeByData(test.before, test.remove)
4067  		if e = tstCheckScriptError(e, test.e); e != nil {
4068  			t.Errorf("%s: %v", test.name, e)
4069  			continue
4070  		}
4071  		if !bytes.Equal(test.after, result) {
4072  			t.Errorf("%s: value does not equal expected: exp: %q"+
4073  				" got: %q", test.name, test.after, result,
4074  			)
4075  		}
4076  	}
4077  }
4078  
4079  // TestIsPayToScriptHash ensures the IsPayToScriptHash function returns the expected results for all the scripts in
4080  // scriptClassTests.
4081  func TestIsPayToScriptHash(t *testing.T) {
4082  	t.Parallel()
4083  	for _, test := range scriptClassTests {
4084  		script := mustParseShortForm(test.script)
4085  		shouldBe := test.class == ScriptHashTy
4086  		p2sh := IsPayToScriptHash(script)
4087  		if p2sh != shouldBe {
4088  			t.Errorf("%s: expected p2sh %v, got %v", test.name,
4089  				shouldBe, p2sh,
4090  			)
4091  		}
4092  	}
4093  }
4094  
4095  // TestHasCanonicalPushes ensures the canonicalPush function properly determines what is considered a canonical push for
4096  // the purposes of removeOpcodeByData.
4097  func TestHasCanonicalPushes(t *testing.T) {
4098  	t.Parallel()
4099  	tests := []struct {
4100  		name     string
4101  		script   string
4102  		expected bool
4103  	}{
4104  		{
4105  			name: "does not parse",
4106  			script: "0x046708afdb0fe5548271967f1a67130b7105cd6a82" +
4107  				"8e03909a67962e0ea1f61d",
4108  			expected: false,
4109  		},
4110  		{
4111  			name:     "non-canonical push",
4112  			script:   "PUSHDATA1 0x04 0x01020304",
4113  			expected: false,
4114  		},
4115  	}
4116  	for i, test := range tests {
4117  		script := mustParseShortForm(test.script)
4118  		pops, e := parseScript(script)
4119  		if e != nil {
4120  			if test.expected {
4121  				t.Errorf("TstParseScript #%d failed: %v", i, e)
4122  			}
4123  			continue
4124  		}
4125  		for _, pop := range pops {
4126  			if canonicalPush(pop) != test.expected {
4127  				t.Errorf("canonicalPush: #%d (%s) wrong result"+
4128  					"\ngot: %v\nwant: %v", i, test.name,
4129  					true, test.expected,
4130  				)
4131  				break
4132  			}
4133  		}
4134  	}
4135  }
4136  
4137  // TestIsPushOnlyScript ensures the IsPushOnlyScript function returns the expected results.
4138  func TestIsPushOnlyScript(t *testing.T) {
4139  	t.Parallel()
4140  	test := struct {
4141  		name     string
4142  		script   []byte
4143  		expected bool
4144  	}{
4145  		name: "does not parse",
4146  		script: mustParseShortForm("0x046708afdb0fe5548271967f1a67130" +
4147  			"b7105cd6a828e03909a67962e0ea1f61d",
4148  		),
4149  		expected: false,
4150  	}
4151  	if IsPushOnlyScript(test.script) != test.expected {
4152  		t.Errorf("IsPushOnlyScript (%s) wrong result\ngot: %v\nwant: "+
4153  			"%v", test.name, true, test.expected,
4154  		)
4155  	}
4156  }
4157  
4158  // TestIsUnspendable ensures the IsUnspendable function returns the expected results.
4159  func TestIsUnspendable(t *testing.T) {
4160  	t.Parallel()
4161  	tests := []struct {
4162  		// name     string
4163  		pkScript []byte
4164  		expected bool
4165  	}{
4166  		{
4167  			// Unspendable
4168  			pkScript: []byte{0x6a, 0x04, 0x74, 0x65, 0x73, 0x74},
4169  			expected: true,
4170  		},
4171  		{
4172  			// Spendable
4173  			pkScript: []byte{0x76, 0xa9, 0x14, 0x29, 0x95, 0xa0,
4174  				0xfe, 0x68, 0x43, 0xfa, 0x9b, 0x95, 0x45,
4175  				0x97, 0xf0, 0xdc, 0xa7, 0xa4, 0x4d, 0xf6,
4176  				0xfa, 0x0b, 0x5c, 0x88, 0xac,
4177  			},
4178  			expected: false,
4179  		},
4180  	}
4181  	for i, test := range tests {
4182  		res := IsUnspendable(test.pkScript)
4183  		if res != test.expected {
4184  			t.Errorf("TestIsUnspendable #%d failed: got %v want %v",
4185  				i, res, test.expected,
4186  			)
4187  			continue
4188  		}
4189  	}
4190  }
4191