status-im
/
op-geth
mirror of https://github.com/status-im/op-geth.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

core/vm, common/math: Add doc about Byte, fix format

This commit is contained in:
Martin Holst Swende 2017-06-08 23:16:05 +02:00
parent 1496b3aff6
commit ac9865791a
3 changed files with 20 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
common/math/big.go
View File

@ -131,7 +131,7 @@ func PaddedBigBytes(bigint *big.Int, n int) []byte {
} }
// bigEndianByteAt returns the byte at position n, // bigEndianByteAt returns the byte at position n,
// if bigint is considered big-endian. // in Big-Endian encoding
// So n==0 returns the least significant byte // So n==0 returns the least significant byte
func bigEndianByteAt(bigint *big.Int, n int) byte { func bigEndianByteAt(bigint *big.Int, n int) byte {
words := bigint.Bits() words := bigint.Bits()
@ -148,9 +148,9 @@ func bigEndianByteAt(bigint *big.Int, n int) byte {
} }
// Byte returns the byte at position n, // Byte returns the byte at position n,
// if bigint is considered little-endian with the supplied padlength. // with the supplied padlength in Little-Endian encoding.
// n==0 returns the most significant byte // n==0 returns the MSB
// bigint '5', padlength 32, n=31 => 5 // Example: bigint '5', padlength 32, n=31 => 5
func Byte(bigint *big.Int, padlength, n int) byte { func Byte(bigint *big.Int, padlength, n int) byte {
if n >= padlength { if n >= padlength {
return byte(0) return byte(0)

27
common/math/big_test.go
View File

@ -141,6 +141,7 @@ func BenchmarkPaddedBigBytesLargePadding(b *testing.B) {
PaddedBigBytes(bigint, 200) PaddedBigBytes(bigint, 200)
} }
} }
func BenchmarkPaddedBigBytesSmallPadding(b *testing.B) { func BenchmarkPaddedBigBytesSmallPadding(b *testing.B) {
bigint := MustParseBig256("0x18F8F8F1000111000110011100222004330052300000000000000000FEFCF3CC") bigint := MustParseBig256("0x18F8F8F1000111000110011100222004330052300000000000000000FEFCF3CC")
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
@ -154,18 +155,21 @@ func BenchmarkPaddedBigBytesSmallOnePadding(b *testing.B) {
PaddedBigBytes(bigint, 32) PaddedBigBytes(bigint, 32)
} }
} }
func BenchmarkByteAtBrandNew(b *testing.B) { func BenchmarkByteAtBrandNew(b *testing.B) {
bigint := MustParseBig256("0x18F8F8F1000111000110011100222004330052300000000000000000FEFCF3CC") bigint := MustParseBig256("0x18F8F8F1000111000110011100222004330052300000000000000000FEFCF3CC")
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
bigEndianByteAt(bigint, 15) bigEndianByteAt(bigint, 15)
} }
} }
func BenchmarkByteAt(b *testing.B) { func BenchmarkByteAt(b *testing.B) {
bigint := MustParseBig256("0x18F8F8F1000111000110011100222004330052300000000000000000FEFCF3CC") bigint := MustParseBig256("0x18F8F8F1000111000110011100222004330052300000000000000000FEFCF3CC")
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
bigEndianByteAt(bigint, 15) bigEndianByteAt(bigint, 15)
} }
} }
func BenchmarkByteAtOld(b *testing.B) { func BenchmarkByteAtOld(b *testing.B) {
bigint := MustParseBig256("0x18F8F8F1000111000110011100222004330052300000000000000000FEFCF3CC") bigint := MustParseBig256("0x18F8F8F1000111000110011100222004330052300000000000000000FEFCF3CC")
@ -207,21 +211,22 @@ func TestU256(t *testing.T) {
} }
} }
} }
func TestLittleEndianByteAt(t *testing.T) {
func TestBigEndianByteAt(t *testing.T) {
tests := []struct { tests := []struct {
x string x string
y int y int
exp byte exp byte
}{ }{
{"0", 0, 0x00}, {"00", 0, 0x00},
{"1", 1, 0x00}, {"01", 1, 0x00},
{"0", 1, 0x00}, {"00", 1, 0x00},
//{"1", 0, 0x01}, {"01", 0, 0x01},
{"0000000000000000000000000000000000000000000000000000000000102030", 0, 0x30}, {"0000000000000000000000000000000000000000000000000000000000102030", 0, 0x30},
{"0000000000000000000000000000000000000000000000000000000000102030", 1, 0x20}, {"0000000000000000000000000000000000000000000000000000000000102030", 1, 0x20},
{"ABCDEF0908070605040302010000000000000000000000000000000000000000", 31, 0xAB}, {"ABCDEF0908070605040302010000000000000000000000000000000000000000", 31, 0xAB},
{"ABCDEF0908070605040302010000000000000000000000000000000000000000", 32, 0x00}, {"ABCDEF0908070605040302010000000000000000000000000000000000000000", 32, 0x00},
{"ABCDEF0908070605040302010000000000000000000000000000000000000000", 500, 0x00},
} }
for _, test := range tests { for _, test := range tests {
v := new(big.Int).SetBytes(common.Hex2Bytes(test.x)) v := new(big.Int).SetBytes(common.Hex2Bytes(test.x))
@ -232,17 +237,16 @@ func TestLittleEndianByteAt(t *testing.T) {
} }
} }
func TestBigEndianByteAt(t *testing.T) { func TestLittleEndianByteAt(t *testing.T) {
tests := []struct { tests := []struct {
x string x string
y int y int
exp byte exp byte
}{ }{
{"0", 0, 0x00}, {"00", 0, 0x00},
{"1", 1, 0x00}, {"01", 1, 0x00},
{"0", 1, 0x00}, {"00", 1, 0x00},
{"1", 0, 0x00}, {"01", 0, 0x00},
{"0000000000000000000000000000000000000000000000000000000000102030", 0, 0x00}, {"0000000000000000000000000000000000000000000000000000000000102030", 0, 0x00},
{"0000000000000000000000000000000000000000000000000000000000102030", 1, 0x00}, {"0000000000000000000000000000000000000000000000000000000000102030", 1, 0x00},
{"ABCDEF0908070605040302010000000000000000000000000000000000000000", 31, 0x00}, {"ABCDEF0908070605040302010000000000000000000000000000000000000000", 31, 0x00},
@ -266,6 +270,7 @@ func TestBigEndianByteAt(t *testing.T) {
} }
} }
func TestS256(t *testing.T) { func TestS256(t *testing.T) {
tests := []struct{ x, y *big.Int }{ tests := []struct{ x, y *big.Int }{
{x: big.NewInt(0), y: big.NewInt(0)}, {x: big.NewInt(0), y: big.NewInt(0)},

1
core/vm/instructions_test.go
View File

@ -9,7 +9,6 @@ import (
) )
func TestByteOp(t *testing.T) { func TestByteOp(t *testing.T) {
var ( var (
env = NewEVM(Context{}, nil, params.TestChainConfig, Config{EnableJit: false, ForceJit: false}) env = NewEVM(Context{}, nil, params.TestChainConfig, Config{EnableJit: false, ForceJit: false})
stack = newstack() stack = newstack()