forked from hush/lightwalletd
Larry Ruane
5 years ago
committed by
Aditya Kulkarni
2 changed files with 550 additions and 39 deletions
@ -1,39 +0,0 @@ |
|||||
package frontend |
|
||||
|
|
||||
import ( |
|
||||
"encoding/json" |
|
||||
"strconv" |
|
||||
"strings" |
|
||||
"testing" |
|
||||
) |
|
||||
|
|
||||
// a well-formed raw transaction
|
|
||||
const coinbaseTxHex = "0400008085202f89010000000000000000000000000000000000000" + |
|
||||
"000000000000000000000000000ffffffff03580101ffffffff0200ca9a3b000000001976a9146b" + |
|
||||
"9ae8c14e917966b0afdf422d32dbac40486d3988ac80b2e60e0000000017a9146708e6670db0b95" + |
|
||||
"0dac68031025cc5b63213a4918700000000000000000000000000000000000000" |
|
||||
|
|
||||
func TestSendTransaction(t *testing.T) { |
|
||||
client, err := NewZRPCFromCreds("127.0.0.1:8232", "user", "password") |
|
||||
if err != nil { |
|
||||
t.Fatalf("Couldn't init JSON-RPC client: %v", err) |
|
||||
} |
|
||||
|
|
||||
params := make([]json.RawMessage, 1) |
|
||||
params[0] = json.RawMessage("\"" + coinbaseTxHex + "\"") |
|
||||
_, err = client.RawRequest("sendrawtransaction", params) |
|
||||
if err == nil { |
|
||||
t.Fatal("somehow succeeded at sending a coinbase tx") |
|
||||
} |
|
||||
|
|
||||
errParts := strings.SplitN(err.Error(), ":", 2) |
|
||||
errCode, err := strconv.ParseInt(errParts[0], 10, 64) |
|
||||
if err != nil { |
|
||||
t.Errorf("couldn't parse error code: %v", err) |
|
||||
} |
|
||||
errMsg := strings.TrimSpace(errParts[1]) |
|
||||
|
|
||||
if errCode != -26 || errMsg != "16: coinbase" { |
|
||||
t.Error("got the wrong errors") |
|
||||
} |
|
||||
} |
|
@ -0,0 +1,550 @@ |
|||||
|
package bytestring |
||||
|
|
||||
|
import ( |
||||
|
"bytes" |
||||
|
"testing" |
||||
|
) |
||||
|
|
||||
|
func TestString_read(t *testing.T) { |
||||
|
s := String{} |
||||
|
if !(s).Empty() { |
||||
|
t.Fatal("initial string not empty") |
||||
|
} |
||||
|
s = String{22, 33, 44} |
||||
|
if s.Empty() { |
||||
|
t.Fatal("string unexpectedly empty") |
||||
|
} |
||||
|
r := s.read(2) |
||||
|
if len(r) != 2 { |
||||
|
t.Fatal("unexpected string length after read()") |
||||
|
} |
||||
|
if !bytes.Equal(r, []byte{22, 33}) { |
||||
|
t.Fatal("miscompare mismatch after read()") |
||||
|
} |
||||
|
r = s.read(0) |
||||
|
if !bytes.Equal(r, []byte{}) { |
||||
|
t.Fatal("miscompare mismatch after read()") |
||||
|
} |
||||
|
if s.read(2) != nil { |
||||
|
t.Fatal("unexpected successful too-large read()") |
||||
|
} |
||||
|
r = s.read(1) |
||||
|
if !bytes.Equal(r, []byte{44}) { |
||||
|
t.Fatal("miscompare after read()") |
||||
|
} |
||||
|
r = s.read(0) |
||||
|
if !bytes.Equal(r, []byte{}) { |
||||
|
t.Fatal("miscompare after read()") |
||||
|
} |
||||
|
if s.read(1) != nil { |
||||
|
t.Fatal("unexpected successful too-large read()") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func TestString_Read(t *testing.T) { |
||||
|
s := String{22, 33, 44} |
||||
|
b := make([]byte, 10) |
||||
|
n, err := s.Read(b) |
||||
|
if err != nil { |
||||
|
t.Fatal("Read() failed") |
||||
|
} |
||||
|
if n != 3 { |
||||
|
t.Fatal("Read() returned incorrect length") |
||||
|
} |
||||
|
if !bytes.Equal(b[:3], []byte{22, 33, 44}) { |
||||
|
t.Fatal("miscompare after Read()") |
||||
|
} |
||||
|
|
||||
|
// s should now be empty
|
||||
|
n, err = s.Read(b) |
||||
|
if err == nil { |
||||
|
t.Fatal("Read() unexpectedly succeeded") |
||||
|
} |
||||
|
if n != 0 { |
||||
|
t.Fatal("Read() failed as expected but returned incorrect length") |
||||
|
} |
||||
|
// s empty, the passed-in slice has zero length is not an error
|
||||
|
n, err = s.Read([]byte{}) |
||||
|
if err != nil { |
||||
|
t.Fatal("Read() failed") |
||||
|
} |
||||
|
if n != 0 { |
||||
|
t.Fatal("Read() returned non-zero length") |
||||
|
} |
||||
|
|
||||
|
// make sure we can advance through string s (this time buffer smaller than s)
|
||||
|
s = String{55, 66, 77} |
||||
|
b = make([]byte, 2) |
||||
|
n, err = s.Read(b) |
||||
|
if err != nil { |
||||
|
t.Fatal("Read() failed") |
||||
|
} |
||||
|
if n != 2 { |
||||
|
t.Fatal("Read() returned incorrect length") |
||||
|
} |
||||
|
if !bytes.Equal(b[:2], []byte{55, 66}) { |
||||
|
t.Fatal("miscompare after Read()") |
||||
|
} |
||||
|
|
||||
|
// keep reading s, one byte remaining
|
||||
|
n, err = s.Read(b) |
||||
|
if err != nil { |
||||
|
t.Fatal("Read() failed") |
||||
|
} |
||||
|
if n != 1 { |
||||
|
t.Fatal("Read() returned incorrect length") |
||||
|
} |
||||
|
if !bytes.Equal(b[:1], []byte{77}) { |
||||
|
t.Fatal("miscompare after Read()") |
||||
|
} |
||||
|
|
||||
|
// If the buffer to read into is zero-length...
|
||||
|
s = String{88} |
||||
|
n, err = s.Read([]byte{}) |
||||
|
if err != nil { |
||||
|
t.Fatal("Read() into zero-length buffer failed") |
||||
|
} |
||||
|
if n != 0 { |
||||
|
t.Fatal("Read() failed as expected but returned incorrect length") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func TestString_Skip(t *testing.T) { |
||||
|
s := String{22, 33, 44} |
||||
|
b := make([]byte, 10) |
||||
|
if !s.Skip(1) { |
||||
|
t.Fatal("Skip() failed") |
||||
|
} |
||||
|
n, err := s.Read(b) |
||||
|
if err != nil { |
||||
|
t.Fatal("Read() failed") |
||||
|
} |
||||
|
if n != 2 { |
||||
|
t.Fatal("Read() returned incorrect length") |
||||
|
} |
||||
|
if !bytes.Equal(b[:2], []byte{33, 44}) { |
||||
|
t.Fatal("miscompare after Read()") |
||||
|
} |
||||
|
|
||||
|
// we're at the end of the string
|
||||
|
if s.Skip(1) { |
||||
|
t.Fatal("Skip() unexpectedly succeeded") |
||||
|
} |
||||
|
if !s.Skip(0) { |
||||
|
t.Fatal("Skip(0) failed") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func TestString_ReadByte(t *testing.T) { |
||||
|
s := String{22, 33} |
||||
|
var b byte |
||||
|
if !s.ReadByte(&b) { |
||||
|
t.Fatal("ReadByte() failed") |
||||
|
} |
||||
|
if b != 22 { |
||||
|
t.Fatal("ReadByte() unexpected value") |
||||
|
} |
||||
|
if !s.ReadByte(&b) { |
||||
|
t.Fatal("ReadByte() failed") |
||||
|
} |
||||
|
if b != 33 { |
||||
|
t.Fatal("ReadByte() unexpected value") |
||||
|
} |
||||
|
|
||||
|
// we're at the end of the string
|
||||
|
if s.ReadByte(&b) { |
||||
|
t.Fatal("ReadByte() unexpectedly succeeded") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func TestString_ReadBytes(t *testing.T) { |
||||
|
s := String{22, 33, 44} |
||||
|
var b []byte |
||||
|
if !s.ReadBytes(&b, 2) { |
||||
|
t.Fatal("ReadBytes() failed") |
||||
|
} |
||||
|
if !bytes.Equal(b, []byte{22, 33}) { |
||||
|
t.Fatal("miscompare after ReadBytes()") |
||||
|
} |
||||
|
|
||||
|
// s is now [44]
|
||||
|
if len(s) != 1 { |
||||
|
t.Fatal("unexpected updated s following ReadBytes()") |
||||
|
} |
||||
|
if s.ReadBytes(&b, 2) { |
||||
|
t.Fatal("ReadBytes() unexpected success") |
||||
|
} |
||||
|
if !s.ReadBytes(&b, 1) { |
||||
|
t.Fatal("ReadBytes() failed") |
||||
|
} |
||||
|
if !bytes.Equal(b, []byte{44}) { |
||||
|
t.Fatal("miscompare after ReadBytes()") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
var readCompactSizeTests = []struct { |
||||
|
s String |
||||
|
ok bool |
||||
|
expected int |
||||
|
}{ |
||||
|
/* 00 */ {String{}, false, 0}, |
||||
|
/* 01 */ {String{43}, true, 43}, |
||||
|
/* 02 */ {String{252}, true, 252}, |
||||
|
/* 03 */ {String{253, 1, 0}, false, 0}, // 1 < minSize (253)
|
||||
|
/* 04 */ {String{253, 252, 0}, false, 0}, // 252 < minSize (253)
|
||||
|
/* 05 */ {String{253, 253, 0}, true, 253}, |
||||
|
/* 06 */ {String{253, 255, 255}, true, 0xffff}, |
||||
|
/* 07 */ {String{254, 0xff, 0xff, 0, 0}, false, 0}, // 0xffff < minSize
|
||||
|
/* 08 */ {String{254, 0, 0, 1, 0}, true, 0x00010000}, |
||||
|
/* 09 */ {String{254, 7, 0, 1, 0}, true, 0x00010007}, |
||||
|
/* 10 */ {String{254, 0, 0, 0, 2}, true, 0x02000000}, |
||||
|
/* 11 */ {String{254, 1, 0, 0, 2}, false, 0}, // > maxCompactSize
|
||||
|
/* 12 */ {String{255, 0, 0, 0, 2, 0, 0, 0, 0}, false, 0}, |
||||
|
} |
||||
|
|
||||
|
func TestString_ReadCompactSize(t *testing.T) { |
||||
|
for i, tt := range readCompactSizeTests { |
||||
|
var expected int |
||||
|
ok := tt.s.ReadCompactSize(&expected) |
||||
|
if ok != tt.ok { |
||||
|
t.Fatalf("ReadCompactSize case %d: want: %v, have: %v", i, tt.ok, ok) |
||||
|
} |
||||
|
if expected != tt.expected { |
||||
|
t.Fatalf("ReadCompactSize case %d: want: %v, have: %v", i, tt.expected, expected) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func TestString_ReadCompactLengthPrefixed(t *testing.T) { |
||||
|
// a stream of 3 bytes followed by 2 bytes into the value variable, v
|
||||
|
s := String{3, 55, 66, 77, 2, 88, 99} |
||||
|
v := String{} |
||||
|
|
||||
|
// read the 3 and thus the following 3 bytes
|
||||
|
if !s.ReadCompactLengthPrefixed(&v) { |
||||
|
t.Fatalf("ReadCompactLengthPrefix failed") |
||||
|
} |
||||
|
if len(v) != 3 { |
||||
|
t.Fatalf("ReadCompactLengthPrefix incorrect length") |
||||
|
} |
||||
|
if !bytes.Equal(v, String{55, 66, 77}) { |
||||
|
t.Fatalf("ReadCompactLengthPrefix unexpected return") |
||||
|
} |
||||
|
|
||||
|
// read the 2 and then two bytes
|
||||
|
if !s.ReadCompactLengthPrefixed(&v) { |
||||
|
t.Fatalf("ReadCompactLengthPrefix failed") |
||||
|
} |
||||
|
if len(v) != 2 { |
||||
|
t.Fatalf("ReadCompactLengthPrefix incorrect length") |
||||
|
} |
||||
|
if !bytes.Equal(v, String{88, 99}) { |
||||
|
t.Fatalf("ReadCompactLengthPrefix unexpected return") |
||||
|
} |
||||
|
|
||||
|
// at the end of the String, another read should return false
|
||||
|
if s.ReadCompactLengthPrefixed(&v) { |
||||
|
t.Fatalf("ReadCompactLengthPrefix unexpected success") |
||||
|
} |
||||
|
|
||||
|
// this string is too short (less than 2 bytes of data)
|
||||
|
s = String{3, 55, 66} |
||||
|
if s.ReadCompactLengthPrefixed(&v) { |
||||
|
t.Fatalf("ReadCompactLengthPrefix unexpected success") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
var readInt32Tests = []struct { |
||||
|
s String |
||||
|
expected int32 |
||||
|
}{ |
||||
|
// Little-endian (least-significant byte first)
|
||||
|
/* 00 */ {String{0, 0, 0, 0}, 0}, |
||||
|
/* 01 */ {String{17, 0, 0, 0}, 17}, |
||||
|
/* 02 */ {String{0xde, 0x8a, 0x7b, 0x72}, 0x727b8ade}, |
||||
|
/* 03 */ {String{0xde, 0x8a, 0x7b, 0x92}, -1837397282}, // signed overflow
|
||||
|
/* 04 */ {String{0xff, 0xff, 0xff, 0xff}, -1}, |
||||
|
} |
||||
|
|
||||
|
var readInt32FailTests = []struct { |
||||
|
s String |
||||
|
}{ |
||||
|
/* 00 */ {String{}}, |
||||
|
/* 01 */ {String{1, 2, 3}}, // too few bytes (must be >= 4)
|
||||
|
} |
||||
|
|
||||
|
func TestString_ReadInt32(t *testing.T) { |
||||
|
// create one large string to ensure a sequences of values can be read
|
||||
|
var s String |
||||
|
for _, tt := range readInt32Tests { |
||||
|
s = append(s, tt.s...) |
||||
|
} |
||||
|
for i, tt := range readInt32Tests { |
||||
|
var v int32 |
||||
|
if !s.ReadInt32(&v) { |
||||
|
t.Fatalf("ReadInt32 case %d: failed", i) |
||||
|
} |
||||
|
if v != tt.expected { |
||||
|
t.Fatalf("ReadInt32 case %d: want: %v, have: %v", i, tt.expected, v) |
||||
|
} |
||||
|
} |
||||
|
if len(s) > 0 { |
||||
|
t.Fatalf("ReadInt32 bytes remaining: %d", len(s)) |
||||
|
} |
||||
|
for i, tt := range readInt32FailTests { |
||||
|
var v int32 |
||||
|
prevlen := len(tt.s) |
||||
|
if tt.s.ReadInt32(&v) { |
||||
|
t.Fatalf("ReadInt32 fail case %d: unexpected success", i) |
||||
|
} |
||||
|
if v != 0 { |
||||
|
t.Fatalf("ReadInt32 fail case %d: value should be zero", i) |
||||
|
} |
||||
|
if len(tt.s) != prevlen { |
||||
|
t.Fatalf("ReadInt32 fail case %d: some bytes consumed", i) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
var readInt64Tests = []struct { |
||||
|
s String |
||||
|
expected int64 |
||||
|
}{ |
||||
|
// Little-endian (least-significant byte first)
|
||||
|
/* 00 */ {String{0, 0, 0, 0, 0, 0, 0, 0}, 0}, |
||||
|
/* 01 */ {String{17, 0, 0, 0, 0, 0, 0, 0}, 17}, |
||||
|
/* 02 */ {String{0xde, 0x8a, 0x7b, 0x72, 0x27, 0xa3, 0x94, 0x55}, 0x5594a327727b8ade}, |
||||
|
/* 03 */ {String{0xde, 0x8a, 0x7b, 0x72, 0x27, 0xa3, 0x94, 0x85}, -8821246380292207906}, // signed overflow
|
||||
|
/* 04 */ {String{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, -1}, |
||||
|
} |
||||
|
|
||||
|
var readInt64FailTests = []struct { |
||||
|
s String |
||||
|
}{ |
||||
|
/* 00 */ {String{}}, |
||||
|
/* 01 */ {String{1, 2, 3, 4, 5, 6, 7}}, // too few bytes (must be >= 8)
|
||||
|
} |
||||
|
|
||||
|
func TestString_ReadInt64(t *testing.T) { |
||||
|
// create one large string to ensure a sequences of values can be read
|
||||
|
var s String |
||||
|
for _, tt := range readInt64Tests { |
||||
|
s = append(s, tt.s...) |
||||
|
} |
||||
|
for i, tt := range readInt64Tests { |
||||
|
var v int64 |
||||
|
if !s.ReadInt64(&v) { |
||||
|
t.Fatalf("ReadInt64 case %d: failed", i) |
||||
|
} |
||||
|
if v != tt.expected { |
||||
|
t.Fatalf("ReadInt64 case %d: want: %v, have: %v", i, tt.expected, v) |
||||
|
} |
||||
|
} |
||||
|
if len(s) > 0 { |
||||
|
t.Fatalf("ReadInt64 bytes remaining: %d", len(s)) |
||||
|
} |
||||
|
for i, tt := range readInt64FailTests { |
||||
|
var v int64 |
||||
|
prevlen := len(tt.s) |
||||
|
if tt.s.ReadInt64(&v) { |
||||
|
t.Fatalf("ReadInt64 fail case %d: unexpected success", i) |
||||
|
} |
||||
|
if v != 0 { |
||||
|
t.Fatalf("ReadInt32 fail case %d: value should be zero", i) |
||||
|
} |
||||
|
if len(tt.s) != prevlen { |
||||
|
t.Fatalf("ReadInt64 fail case %d: some bytes consumed", i) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
var readUint16Tests = []struct { |
||||
|
s String |
||||
|
expected uint16 |
||||
|
}{ |
||||
|
// Little-endian (least-significant byte first)
|
||||
|
/* 00 */ {String{0, 0}, 0}, |
||||
|
/* 01 */ {String{23, 0}, 23}, |
||||
|
/* 02 */ {String{0xde, 0x8a}, 0x8ade}, |
||||
|
/* 03 */ {String{0xff, 0xff}, 0xffff}, |
||||
|
} |
||||
|
|
||||
|
var readUint16FailTests = []struct { |
||||
|
s String |
||||
|
}{ |
||||
|
/* 00 */ {String{}}, |
||||
|
/* 01 */ {String{1}}, // too few bytes (must be >= 2)
|
||||
|
} |
||||
|
|
||||
|
func TestString_ReadUint16(t *testing.T) { |
||||
|
// create one large string to ensure a sequences of values can be read
|
||||
|
var s String |
||||
|
for _, tt := range readUint16Tests { |
||||
|
s = append(s, tt.s...) |
||||
|
} |
||||
|
for i, tt := range readUint16Tests { |
||||
|
var v uint16 |
||||
|
if !s.ReadUint16(&v) { |
||||
|
t.Fatalf("ReadUint16 case %d: failed", i) |
||||
|
} |
||||
|
if v != tt.expected { |
||||
|
t.Fatalf("ReadUint16 case %d: want: %v, have: %v", i, tt.expected, v) |
||||
|
} |
||||
|
} |
||||
|
if len(s) > 0 { |
||||
|
t.Fatalf("ReadUint16 bytes remaining: %d", len(s)) |
||||
|
} |
||||
|
for i, tt := range readUint16FailTests { |
||||
|
var v uint16 |
||||
|
prevlen := len(tt.s) |
||||
|
if tt.s.ReadUint16(&v) { |
||||
|
t.Fatalf("ReadUint16 fail case %d: unexpected success", i) |
||||
|
} |
||||
|
if v != 0 { |
||||
|
t.Fatalf("ReadInt32 fail case %d: value should be zero", i) |
||||
|
} |
||||
|
if len(tt.s) != prevlen { |
||||
|
t.Fatalf("ReadUint16 fail case %d: some bytes consumed", i) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
var readUint32Tests = []struct { |
||||
|
s String |
||||
|
expected uint32 |
||||
|
}{ |
||||
|
// Little-endian (least-significant byte first)
|
||||
|
/* 00 */ {String{0, 0, 0, 0}, 0}, |
||||
|
/* 01 */ {String{23, 0, 0, 0}, 23}, |
||||
|
/* 02 */ {String{0xde, 0x8a, 0x7b, 0x92}, 0x927b8ade}, |
||||
|
/* 03 */ {String{0xff, 0xff, 0xff, 0xff}, 0xffffffff}, |
||||
|
} |
||||
|
|
||||
|
var readUint32FailTests = []struct { |
||||
|
s String |
||||
|
}{ |
||||
|
/* 00 */ {String{}}, |
||||
|
/* 01 */ {String{1, 2, 3}}, // too few bytes (must be >= 4)
|
||||
|
} |
||||
|
|
||||
|
func TestString_ReadUint32(t *testing.T) { |
||||
|
// create one large string to ensure a sequences of values can be read
|
||||
|
var s String |
||||
|
for _, tt := range readUint32Tests { |
||||
|
s = append(s, tt.s...) |
||||
|
} |
||||
|
for i, tt := range readUint32Tests { |
||||
|
var v uint32 |
||||
|
if !s.ReadUint32(&v) { |
||||
|
t.Fatalf("ReadUint32 case %d: failed", i) |
||||
|
} |
||||
|
if v != tt.expected { |
||||
|
t.Fatalf("ReadUint32 case %d: want: %v, have: %v", i, tt.expected, v) |
||||
|
} |
||||
|
} |
||||
|
if len(s) > 0 { |
||||
|
t.Fatalf("ReadUint32 bytes remaining: %d", len(s)) |
||||
|
} |
||||
|
for i, tt := range readUint32FailTests { |
||||
|
var v uint32 |
||||
|
prevlen := len(tt.s) |
||||
|
if tt.s.ReadUint32(&v) { |
||||
|
t.Fatalf("ReadUint32 fail case %d: unexpected success", i) |
||||
|
} |
||||
|
if v != 0 { |
||||
|
t.Fatalf("ReadInt32 fail case %d: value should be zero", i) |
||||
|
} |
||||
|
if len(tt.s) != prevlen { |
||||
|
t.Fatalf("ReadUint32 fail case %d: some bytes consumed", i) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
var readUint64Tests = []struct { |
||||
|
s String |
||||
|
expected uint64 |
||||
|
}{ |
||||
|
// Little-endian (least-significant byte first)
|
||||
|
/* 00 */ {String{0, 0, 0, 0, 0, 0, 0, 0}, 0}, |
||||
|
/* 01 */ {String{17, 0, 0, 0, 0, 0, 0, 0}, 17}, |
||||
|
/* 03 */ {String{0xde, 0x8a, 0x7b, 0x72, 0x27, 0xa3, 0x94, 0x55}, 0x5594a327727b8ade}, |
||||
|
/* 04 */ {String{0xde, 0x8a, 0x7b, 0x72, 0x27, 0xa3, 0x94, 0x85}, 0x8594a327727b8ade}, |
||||
|
/* 05 */ {String{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, 0xffffffffffffffff}, |
||||
|
} |
||||
|
|
||||
|
var readUint64FailTests = []struct { |
||||
|
s String |
||||
|
}{ |
||||
|
/* 00 */ {String{}}, |
||||
|
/* 01 */ {String{1, 2, 3, 4, 5, 6, 7}}, // too few bytes (must be >= 8)
|
||||
|
} |
||||
|
|
||||
|
func TestString_ReadUint64(t *testing.T) { |
||||
|
// create one large string to ensure a sequences of values can be read
|
||||
|
var s String |
||||
|
for _, tt := range readUint64Tests { |
||||
|
s = append(s, tt.s...) |
||||
|
} |
||||
|
for i, tt := range readUint64Tests { |
||||
|
var v uint64 |
||||
|
if !s.ReadUint64(&v) { |
||||
|
t.Fatalf("ReadUint64 case %d: failed", i) |
||||
|
} |
||||
|
if v != tt.expected { |
||||
|
t.Fatalf("ReadUint64 case %d: want: %v, have: %v", i, tt.expected, v) |
||||
|
} |
||||
|
} |
||||
|
if len(s) > 0 { |
||||
|
t.Fatalf("ReadUint64 bytes remaining: %d", len(s)) |
||||
|
} |
||||
|
for i, tt := range readUint64FailTests { |
||||
|
var v uint64 |
||||
|
prevlen := len(tt.s) |
||||
|
if tt.s.ReadUint64(&v) { |
||||
|
t.Fatalf("ReadUint64 fail case %d: unexpected success", i) |
||||
|
} |
||||
|
if v != 0 { |
||||
|
t.Fatalf("ReadInt64 fail case %d: value should be zero", i) |
||||
|
} |
||||
|
if len(tt.s) != prevlen { |
||||
|
t.Fatalf("ReadUint64 fail case %d: some bytes consumed", i) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
var readScriptInt64Tests = []struct { |
||||
|
s String |
||||
|
ok bool |
||||
|
expected int64 |
||||
|
}{ |
||||
|
// Little-endian (least-significant byte first).
|
||||
|
/* 00 */ {String{}, false, 0}, |
||||
|
/* 01 */ {String{0x4f}, true, -1}, |
||||
|
/* 02 */ {String{0x00}, true, 0x00}, |
||||
|
/* 03 */ {String{0x51}, true, 0x01}, |
||||
|
/* 04 */ {String{0x52}, true, 0x02}, |
||||
|
/* 05 */ {String{0x5f}, true, 0x0f}, |
||||
|
/* 06 */ {String{0x60}, true, 0x10}, |
||||
|
/* 07 */ {String{0x01}, false, 0}, // should be one byte following count 0x01
|
||||
|
/* 07 */ {String{0x01, 0xbd}, true, 0xbd}, |
||||
|
/* 07 */ {String{0x02, 0xbd, 0xac}, true, 0xacbd}, |
||||
|
/* 07 */ {String{0x08, 0xbd, 0xac, 0x12, 0x34, 0x56, 0x78, 0x9a, 0x44}, true, 0x449a78563412acbd}, |
||||
|
/* 07 */ {String{0x08, 0xbd, 0xac, 0x12, 0x34, 0x56, 0x78, 0x9a, 0x94}, true, -7738740698046616387}, |
||||
|
} |
||||
|
|
||||
|
func TestString_ReadScriptInt64(t *testing.T) { |
||||
|
for i, tt := range readScriptInt64Tests { |
||||
|
var v int64 |
||||
|
ok := tt.s.ReadScriptInt64(&v) |
||||
|
if ok != tt.ok { |
||||
|
t.Fatalf("ReadScriptInt64 case %d: want: %v, have: %v", i, tt.ok, ok) |
||||
|
} |
||||
|
if v != tt.expected { |
||||
|
t.Fatalf("ReadScriptInt64 case %d: want: %v, have: %v", i, tt.expected, v) |
||||
|
} |
||||
|
// there should be no bytes remaining
|
||||
|
if ok && len(tt.s) != 0 { |
||||
|
t.Fatalf("ReadScriptInt64 case %d: stream mispositioned", i) |
||||
|
} |
||||
|
} |
||||
|
} |
Loading…
Reference in new issue