"testing"
"github.com/holiman/uint256"
+
+ "github.com/bytom/bytom/testutil"
)
func TestBoolBytes(t *testing.T) {
}
}
}
+
+func TestInt64BigIntConvert(t *testing.T) {
+ cases := []int64{0, 1, 2, 1024, 65536, 9223372036854775807}
+ for i, c := range cases {
+ x := Int64Bytes(c)
+ y := BigIntBytes(uint256.NewInt().SetUint64(uint64(c)))
+ if !testutil.DeepEqual(x, y) {
+ t.Errorf("case %d fail on compare %d bytes", i, c)
+ }
+ }
+}
runLimit: gasLimit,
context: context,
}
- stateData := context.StateData
- for i, state := range stateData {
+
+ for i, state := range context.StateData {
if err = vm.pushAlt(state, false); err != nil {
return vm.runLimit, errors.Wrapf(err, "pushing initial statedata %d", i)
}
}
- args := context.Arguments
- for i, arg := range args {
- err = vm.push(arg, false)
- if err != nil {
+ for i, arg := range context.Arguments {
+ if err = vm.push(arg, false); err != nil {
return vm.runLimit, errors.Wrapf(err, "pushing initial argument %d", i)
}
}
err = ErrFalseVMResult
}
- return vm.runLimit, wrapErr(err, vm, args)
+ return vm.runLimit, wrapErr(err, vm, context.Arguments)
}
// falseResult returns true iff the stack is empty or the top
func (vm *virtualMachine) run() error {
for vm.pc = 0; vm.pc < uint32(len(vm.program)); { // handle vm.pc updates in step
- err := vm.step()
- if err != nil {
+ if err := vm.step(); err != nil {
return err
}
}
vm.deferredCost = 0
vm.data = inst.Data
- err = ops[inst.Op].fn(vm)
- if err != nil {
+ if err = ops[inst.Op].fn(vm); err != nil {
return err
}
- err = vm.applyCost(vm.deferredCost)
- if err != nil {
+
+ if err = vm.applyCost(vm.deferredCost); err != nil {
return err
}
- vm.pc = vm.nextPC
+ vm.pc = vm.nextPC
if TraceOut != nil {
for i := len(vm.dataStack) - 1; i >= 0; i-- {
fmt.Fprintf(TraceOut, " stack %d: %x\n", len(vm.dataStack)-1-i, vm.dataStack[i])
cost := 8 + int64(len(data))
if deferred {
vm.deferCost(cost)
- } else {
- err := vm.applyCost(cost)
- if err != nil {
- return err
- }
+ } else if err := vm.applyCost(cost); err != nil {
+ return err
}
+
vm.dataStack = append(vm.dataStack, data)
return nil
}
cost := 8 + int64(len(data))
if deferred {
vm.deferCost(cost)
- } else {
- err := vm.applyCost(cost)
- if err != nil {
- return err
- }
+ } else if err := vm.applyCost(cost); err != nil {
+ return err
}
- vm.altStack = append(vm.altStack, data)
+ vm.altStack = append(vm.altStack, data)
return nil
}
if err != nil {
return 0, err
}
- n, err := AsInt64(bytes)
- return n, err
+
+ return AsInt64(bytes)
}
func (vm *virtualMachine) popBigInt(deferred bool) (*uint256.Int, error) {
if len(vm.dataStack) == 0 {
return nil, ErrDataStackUnderflow
}
+
return vm.dataStack[len(vm.dataStack)-1], nil
}
vm.runLimit = 0
return ErrRunLimitExceeded
}
+
vm.runLimit -= n
return nil
}