158 lines
3.3 KiB
Go
158 lines
3.3 KiB
Go
// Copyright (c) 2015 Conformal Systems LLC <info@conformal.com>
|
|
//
|
|
// Permission to use, copy, modify, and distribute this software for any
|
|
// purpose with or without fee is hereby granted, provided that the above
|
|
// copyright notice and this permission notice appear in all copies.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
package zero_test
|
|
|
|
import (
|
|
"fmt"
|
|
"math/big"
|
|
"strings"
|
|
"testing"
|
|
|
|
. "github.com/btcsuite/btcwallet/internal/zero"
|
|
)
|
|
|
|
func makeOneBytes(n int) []byte {
|
|
b := make([]byte, n)
|
|
for i := range b {
|
|
b[i] = 1
|
|
}
|
|
return b
|
|
}
|
|
|
|
func checkZeroBytes(b []byte) error {
|
|
for i, v := range b {
|
|
if v != 0 {
|
|
return fmt.Errorf("b[%d] = %d", i, v)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func TestBytes(t *testing.T) {
|
|
tests := []int{
|
|
0,
|
|
31,
|
|
32,
|
|
33,
|
|
127,
|
|
128,
|
|
129,
|
|
255,
|
|
256,
|
|
256,
|
|
257,
|
|
383,
|
|
384,
|
|
385,
|
|
511,
|
|
512,
|
|
513,
|
|
}
|
|
|
|
for i, n := range tests {
|
|
b := makeOneBytes(n)
|
|
Bytes(b)
|
|
err := checkZeroBytes(b)
|
|
if err != nil {
|
|
t.Errorf("Test %d (n=%d) failed: %v", i, n, err)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func checkZeroWords(b []big.Word) error {
|
|
for i, v := range b {
|
|
if v != 0 {
|
|
return fmt.Errorf("b[%d] = %d", i, v)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
var bigZero = new(big.Int)
|
|
|
|
func TestBigInt(t *testing.T) {
|
|
tests := []string{
|
|
// 16 0xFFFFFFFF 32-bit uintptrs
|
|
strings.Repeat("FFFFFFFF", 16),
|
|
|
|
// 17 32-bit uintptrs, minimum value which enters loop on 32-bit
|
|
"01" + strings.Repeat("00000000", 16),
|
|
|
|
// 32 0xFFFFFFFF 32-bit uintptrs, maximum value which enters loop exactly once on 32-bit
|
|
strings.Repeat("FFFFFFFF", 32),
|
|
|
|
// 33 32-bit uintptrs, minimum value which enters loop twice on 32-bit
|
|
"01" + strings.Repeat("00000000", 32),
|
|
|
|
// 16 0xFFFFFFFFFFFFFFFF 64-bit uintptrs
|
|
strings.Repeat("FFFFFFFFFFFFFFFF", 16),
|
|
|
|
// 17 64-bit uintptrs, minimum value which enters loop on 64-bit
|
|
"01" + strings.Repeat("0000000000000000", 16),
|
|
|
|
// 32 0xFFFFFFFFFFFFFFFF 64-bit uintptrs, maximum value which enters loop exactly once on 64-bit
|
|
strings.Repeat("FFFFFFFFFFFFFFFF", 32),
|
|
|
|
// 33 64-bit uintptrs, minimum value which enters loop twice on 64-bit
|
|
"01" + strings.Repeat("0000000000000000", 32),
|
|
}
|
|
|
|
for i, s := range tests {
|
|
v, ok := new(big.Int).SetString(s, 16)
|
|
if !ok {
|
|
t.Errorf("Test %d includes invalid hex number %s", i, s)
|
|
continue
|
|
}
|
|
|
|
BigInt(v)
|
|
err := checkZeroWords(v.Bits())
|
|
if err != nil {
|
|
t.Errorf("Test %d (s=%s) failed: %v", i, s, err)
|
|
continue
|
|
}
|
|
if v.Cmp(bigZero) != 0 {
|
|
t.Errorf("Test %d (s=%s) zeroed big.Int represents non-zero number %v", i, s, v)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBytea32(t *testing.T) {
|
|
const sz = 32
|
|
var b [sz]byte
|
|
copy(b[:], makeOneBytes(sz))
|
|
|
|
Bytea32(&b)
|
|
|
|
err := checkZeroBytes(b[:])
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func TestBytea64(t *testing.T) {
|
|
const sz = 64
|
|
var b [sz]byte
|
|
copy(b[:], makeOneBytes(sz))
|
|
|
|
Bytea64(&b)
|
|
|
|
err := checkZeroBytes(b[:])
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|