lbcwallet/internal/zero/zero_test.go

158 lines
3.3 KiB
Go
Raw Normal View History

2015-04-13 20:58:03 +02:00
// 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)
}
}