mirror of git://gcc.gnu.org/git/gcc.git
652 lines
16 KiB
Go
652 lines
16 KiB
Go
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package big
|
|
|
|
import (
|
|
"fmt"
|
|
"runtime"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
var cmpTests = []struct {
|
|
x, y nat
|
|
r int
|
|
}{
|
|
{nil, nil, 0},
|
|
{nil, nat(nil), 0},
|
|
{nat(nil), nil, 0},
|
|
{nat(nil), nat(nil), 0},
|
|
{nat{0}, nat{0}, 0},
|
|
{nat{0}, nat{1}, -1},
|
|
{nat{1}, nat{0}, 1},
|
|
{nat{1}, nat{1}, 0},
|
|
{nat{0, _M}, nat{1}, 1},
|
|
{nat{1}, nat{0, _M}, -1},
|
|
{nat{1, _M}, nat{0, _M}, 1},
|
|
{nat{0, _M}, nat{1, _M}, -1},
|
|
{nat{16, 571956, 8794, 68}, nat{837, 9146, 1, 754489}, -1},
|
|
{nat{34986, 41, 105, 1957}, nat{56, 7458, 104, 1957}, 1},
|
|
}
|
|
|
|
func TestCmp(t *testing.T) {
|
|
for i, a := range cmpTests {
|
|
r := a.x.cmp(a.y)
|
|
if r != a.r {
|
|
t.Errorf("#%d got r = %v; want %v", i, r, a.r)
|
|
}
|
|
}
|
|
}
|
|
|
|
type funNN func(z, x, y nat) nat
|
|
type argNN struct {
|
|
z, x, y nat
|
|
}
|
|
|
|
var sumNN = []argNN{
|
|
{},
|
|
{nat{1}, nil, nat{1}},
|
|
{nat{1111111110}, nat{123456789}, nat{987654321}},
|
|
{nat{0, 0, 0, 1}, nil, nat{0, 0, 0, 1}},
|
|
{nat{0, 0, 0, 1111111110}, nat{0, 0, 0, 123456789}, nat{0, 0, 0, 987654321}},
|
|
{nat{0, 0, 0, 1}, nat{0, 0, _M}, nat{0, 0, 1}},
|
|
}
|
|
|
|
var prodNN = []argNN{
|
|
{},
|
|
{nil, nil, nil},
|
|
{nil, nat{991}, nil},
|
|
{nat{991}, nat{991}, nat{1}},
|
|
{nat{991 * 991}, nat{991}, nat{991}},
|
|
{nat{0, 0, 991 * 991}, nat{0, 991}, nat{0, 991}},
|
|
{nat{1 * 991, 2 * 991, 3 * 991, 4 * 991}, nat{1, 2, 3, 4}, nat{991}},
|
|
{nat{4, 11, 20, 30, 20, 11, 4}, nat{1, 2, 3, 4}, nat{4, 3, 2, 1}},
|
|
// 3^100 * 3^28 = 3^128
|
|
{
|
|
natFromString("11790184577738583171520872861412518665678211592275841109096961"),
|
|
natFromString("515377520732011331036461129765621272702107522001"),
|
|
natFromString("22876792454961"),
|
|
},
|
|
// z = 111....1 (70000 digits)
|
|
// x = 10^(99*700) + ... + 10^1400 + 10^700 + 1
|
|
// y = 111....1 (700 digits, larger than Karatsuba threshold on 32-bit and 64-bit)
|
|
{
|
|
natFromString(strings.Repeat("1", 70000)),
|
|
natFromString("1" + strings.Repeat(strings.Repeat("0", 699)+"1", 99)),
|
|
natFromString(strings.Repeat("1", 700)),
|
|
},
|
|
// z = 111....1 (20000 digits)
|
|
// x = 10^10000 + 1
|
|
// y = 111....1 (10000 digits)
|
|
{
|
|
natFromString(strings.Repeat("1", 20000)),
|
|
natFromString("1" + strings.Repeat("0", 9999) + "1"),
|
|
natFromString(strings.Repeat("1", 10000)),
|
|
},
|
|
}
|
|
|
|
func natFromString(s string) nat {
|
|
x, _, _, err := nat(nil).scan(strings.NewReader(s), 0, false)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return x
|
|
}
|
|
|
|
func TestSet(t *testing.T) {
|
|
for _, a := range sumNN {
|
|
z := nat(nil).set(a.z)
|
|
if z.cmp(a.z) != 0 {
|
|
t.Errorf("got z = %v; want %v", z, a.z)
|
|
}
|
|
}
|
|
}
|
|
|
|
func testFunNN(t *testing.T, msg string, f funNN, a argNN) {
|
|
z := f(nil, a.x, a.y)
|
|
if z.cmp(a.z) != 0 {
|
|
t.Errorf("%s%+v\n\tgot z = %v; want %v", msg, a, z, a.z)
|
|
}
|
|
}
|
|
|
|
func TestFunNN(t *testing.T) {
|
|
for _, a := range sumNN {
|
|
arg := a
|
|
testFunNN(t, "add", nat.add, arg)
|
|
|
|
arg = argNN{a.z, a.y, a.x}
|
|
testFunNN(t, "add symmetric", nat.add, arg)
|
|
|
|
arg = argNN{a.x, a.z, a.y}
|
|
testFunNN(t, "sub", nat.sub, arg)
|
|
|
|
arg = argNN{a.y, a.z, a.x}
|
|
testFunNN(t, "sub symmetric", nat.sub, arg)
|
|
}
|
|
|
|
for _, a := range prodNN {
|
|
arg := a
|
|
testFunNN(t, "mul", nat.mul, arg)
|
|
|
|
arg = argNN{a.z, a.y, a.x}
|
|
testFunNN(t, "mul symmetric", nat.mul, arg)
|
|
}
|
|
}
|
|
|
|
var mulRangesN = []struct {
|
|
a, b uint64
|
|
prod string
|
|
}{
|
|
{0, 0, "0"},
|
|
{1, 1, "1"},
|
|
{1, 2, "2"},
|
|
{1, 3, "6"},
|
|
{10, 10, "10"},
|
|
{0, 100, "0"},
|
|
{0, 1e9, "0"},
|
|
{1, 0, "1"}, // empty range
|
|
{100, 1, "1"}, // empty range
|
|
{1, 10, "3628800"}, // 10!
|
|
{1, 20, "2432902008176640000"}, // 20!
|
|
{1, 100,
|
|
"933262154439441526816992388562667004907159682643816214685929" +
|
|
"638952175999932299156089414639761565182862536979208272237582" +
|
|
"51185210916864000000000000000000000000", // 100!
|
|
},
|
|
}
|
|
|
|
func TestMulRangeN(t *testing.T) {
|
|
for i, r := range mulRangesN {
|
|
prod := string(nat(nil).mulRange(r.a, r.b).utoa(10))
|
|
if prod != r.prod {
|
|
t.Errorf("#%d: got %s; want %s", i, prod, r.prod)
|
|
}
|
|
}
|
|
}
|
|
|
|
// allocBytes returns the number of bytes allocated by invoking f.
|
|
func allocBytes(f func()) uint64 {
|
|
var stats runtime.MemStats
|
|
runtime.ReadMemStats(&stats)
|
|
t := stats.TotalAlloc
|
|
f()
|
|
runtime.ReadMemStats(&stats)
|
|
return stats.TotalAlloc - t
|
|
}
|
|
|
|
// TestMulUnbalanced tests that multiplying numbers of different lengths
|
|
// does not cause deep recursion and in turn allocate too much memory.
|
|
// Test case for issue 3807.
|
|
func TestMulUnbalanced(t *testing.T) {
|
|
defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1))
|
|
x := rndNat(50000)
|
|
y := rndNat(40)
|
|
allocSize := allocBytes(func() {
|
|
nat(nil).mul(x, y)
|
|
})
|
|
inputSize := uint64(len(x)+len(y)) * _S
|
|
if ratio := allocSize / uint64(inputSize); ratio > 10 {
|
|
t.Errorf("multiplication uses too much memory (%d > %d times the size of inputs)", allocSize, ratio)
|
|
}
|
|
}
|
|
|
|
func rndNat(n int) nat {
|
|
return nat(rndV(n)).norm()
|
|
}
|
|
|
|
func BenchmarkMul(b *testing.B) {
|
|
mulx := rndNat(1e4)
|
|
muly := rndNat(1e4)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
var z nat
|
|
z.mul(mulx, muly)
|
|
}
|
|
}
|
|
|
|
func TestNLZ(t *testing.T) {
|
|
var x Word = _B >> 1
|
|
for i := 0; i <= _W; i++ {
|
|
if int(nlz(x)) != i {
|
|
t.Errorf("failed at %x: got %d want %d", x, nlz(x), i)
|
|
}
|
|
x >>= 1
|
|
}
|
|
}
|
|
|
|
type shiftTest struct {
|
|
in nat
|
|
shift uint
|
|
out nat
|
|
}
|
|
|
|
var leftShiftTests = []shiftTest{
|
|
{nil, 0, nil},
|
|
{nil, 1, nil},
|
|
{natOne, 0, natOne},
|
|
{natOne, 1, natTwo},
|
|
{nat{1 << (_W - 1)}, 1, nat{0}},
|
|
{nat{1 << (_W - 1), 0}, 1, nat{0, 1}},
|
|
}
|
|
|
|
func TestShiftLeft(t *testing.T) {
|
|
for i, test := range leftShiftTests {
|
|
var z nat
|
|
z = z.shl(test.in, test.shift)
|
|
for j, d := range test.out {
|
|
if j >= len(z) || z[j] != d {
|
|
t.Errorf("#%d: got: %v want: %v", i, z, test.out)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var rightShiftTests = []shiftTest{
|
|
{nil, 0, nil},
|
|
{nil, 1, nil},
|
|
{natOne, 0, natOne},
|
|
{natOne, 1, nil},
|
|
{natTwo, 1, natOne},
|
|
{nat{0, 1}, 1, nat{1 << (_W - 1)}},
|
|
{nat{2, 1, 1}, 1, nat{1<<(_W-1) + 1, 1 << (_W - 1)}},
|
|
}
|
|
|
|
func TestShiftRight(t *testing.T) {
|
|
for i, test := range rightShiftTests {
|
|
var z nat
|
|
z = z.shr(test.in, test.shift)
|
|
for j, d := range test.out {
|
|
if j >= len(z) || z[j] != d {
|
|
t.Errorf("#%d: got: %v want: %v", i, z, test.out)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
type modWTest struct {
|
|
in string
|
|
dividend string
|
|
out string
|
|
}
|
|
|
|
var modWTests32 = []modWTest{
|
|
{"23492635982634928349238759823742", "252341", "220170"},
|
|
}
|
|
|
|
var modWTests64 = []modWTest{
|
|
{"6527895462947293856291561095690465243862946", "524326975699234", "375066989628668"},
|
|
}
|
|
|
|
func runModWTests(t *testing.T, tests []modWTest) {
|
|
for i, test := range tests {
|
|
in, _ := new(Int).SetString(test.in, 10)
|
|
d, _ := new(Int).SetString(test.dividend, 10)
|
|
out, _ := new(Int).SetString(test.out, 10)
|
|
|
|
r := in.abs.modW(d.abs[0])
|
|
if r != out.abs[0] {
|
|
t.Errorf("#%d failed: got %d want %s", i, r, out)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestModW(t *testing.T) {
|
|
if _W >= 32 {
|
|
runModWTests(t, modWTests32)
|
|
}
|
|
if _W >= 64 {
|
|
runModWTests(t, modWTests64)
|
|
}
|
|
}
|
|
|
|
func TestTrailingZeroBits(t *testing.T) {
|
|
// test 0 case explicitly
|
|
if n := trailingZeroBits(0); n != 0 {
|
|
t.Errorf("got trailingZeroBits(0) = %d; want 0", n)
|
|
}
|
|
|
|
x := Word(1)
|
|
for i := uint(0); i < _W; i++ {
|
|
n := trailingZeroBits(x)
|
|
if n != i {
|
|
t.Errorf("got trailingZeroBits(%#x) = %d; want %d", x, n, i%_W)
|
|
}
|
|
x <<= 1
|
|
}
|
|
|
|
// test 0 case explicitly
|
|
if n := nat(nil).trailingZeroBits(); n != 0 {
|
|
t.Errorf("got nat(nil).trailingZeroBits() = %d; want 0", n)
|
|
}
|
|
|
|
y := nat(nil).set(natOne)
|
|
for i := uint(0); i <= 3*_W; i++ {
|
|
n := y.trailingZeroBits()
|
|
if n != i {
|
|
t.Errorf("got 0x%s.trailingZeroBits() = %d; want %d", y.utoa(16), n, i)
|
|
}
|
|
y = y.shl(y, 1)
|
|
}
|
|
}
|
|
|
|
var montgomeryTests = []struct {
|
|
x, y, m string
|
|
k0 uint64
|
|
out32, out64 string
|
|
}{
|
|
{
|
|
"0xffffffffffffffffffffffffffffffffffffffffffffffffe",
|
|
"0xffffffffffffffffffffffffffffffffffffffffffffffffe",
|
|
"0xfffffffffffffffffffffffffffffffffffffffffffffffff",
|
|
1,
|
|
"0x1000000000000000000000000000000000000000000",
|
|
"0x10000000000000000000000000000000000",
|
|
},
|
|
{
|
|
"0x000000000ffffff5",
|
|
"0x000000000ffffff0",
|
|
"0x0000000010000001",
|
|
0xff0000000fffffff,
|
|
"0x000000000bfffff4",
|
|
"0x0000000003400001",
|
|
},
|
|
{
|
|
"0x0000000080000000",
|
|
"0x00000000ffffffff",
|
|
"0x1000000000000001",
|
|
0xfffffffffffffff,
|
|
"0x0800000008000001",
|
|
"0x0800000008000001",
|
|
},
|
|
{
|
|
"0x0000000080000000",
|
|
"0x0000000080000000",
|
|
"0xffffffff00000001",
|
|
0xfffffffeffffffff,
|
|
"0xbfffffff40000001",
|
|
"0xbfffffff40000001",
|
|
},
|
|
{
|
|
"0x0000000080000000",
|
|
"0x0000000080000000",
|
|
"0x00ffffff00000001",
|
|
0xfffffeffffffff,
|
|
"0xbfffff40000001",
|
|
"0xbfffff40000001",
|
|
},
|
|
{
|
|
"0x0000000080000000",
|
|
"0x0000000080000000",
|
|
"0x0000ffff00000001",
|
|
0xfffeffffffff,
|
|
"0xbfff40000001",
|
|
"0xbfff40000001",
|
|
},
|
|
{
|
|
"0x3321ffffffffffffffffffffffffffff00000000000022222623333333332bbbb888c0",
|
|
"0x3321ffffffffffffffffffffffffffff00000000000022222623333333332bbbb888c0",
|
|
"0x33377fffffffffffffffffffffffffffffffffffffffffffff0000000000022222eee1",
|
|
0xdecc8f1249812adf,
|
|
"0x04eb0e11d72329dc0915f86784820fc403275bf2f6620a20e0dd344c5cd0875e50deb5",
|
|
"0x0d7144739a7d8e11d72329dc0915f86784820fc403275bf2f61ed96f35dd34dbb3d6a0",
|
|
},
|
|
{
|
|
"0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffff00000000000022222223333333333444444444",
|
|
"0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffff999999999999999aaabbbbbbbbcccccccccccc",
|
|
"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff33377fffffffffffffffffffffffffffffffffffffffffffff0000000000022222eee1",
|
|
0xdecc8f1249812adf,
|
|
"0x5c0d52f451aec609b15da8e5e5626c4eaa88723bdeac9d25ca9b961269400410ca208a16af9c2fb07d7a11c7772cba02c22f9711078d51a3797eb18e691295293284d988e349fa6deba46b25a4ecd9f715",
|
|
"0x92fcad4b5c0d52f451aec609b15da8e5e5626c4eaa88723bdeac9d25ca9b961269400410ca208a16af9c2fb07d799c32fe2f3cc5422f9711078d51a3797eb18e691295293284d8f5e69caf6decddfe1df6",
|
|
},
|
|
}
|
|
|
|
func TestMontgomery(t *testing.T) {
|
|
one := NewInt(1)
|
|
_B := new(Int).Lsh(one, _W)
|
|
for i, test := range montgomeryTests {
|
|
x := natFromString(test.x)
|
|
y := natFromString(test.y)
|
|
m := natFromString(test.m)
|
|
for len(x) < len(m) {
|
|
x = append(x, 0)
|
|
}
|
|
for len(y) < len(m) {
|
|
y = append(y, 0)
|
|
}
|
|
|
|
if x.cmp(m) > 0 {
|
|
_, r := nat(nil).div(nil, x, m)
|
|
t.Errorf("#%d: x > m (0x%s > 0x%s; use 0x%s)", i, x.utoa(16), m.utoa(16), r.utoa(16))
|
|
}
|
|
if y.cmp(m) > 0 {
|
|
_, r := nat(nil).div(nil, x, m)
|
|
t.Errorf("#%d: y > m (0x%s > 0x%s; use 0x%s)", i, y.utoa(16), m.utoa(16), r.utoa(16))
|
|
}
|
|
|
|
var out nat
|
|
if _W == 32 {
|
|
out = natFromString(test.out32)
|
|
} else {
|
|
out = natFromString(test.out64)
|
|
}
|
|
|
|
// t.Logf("#%d: len=%d\n", i, len(m))
|
|
|
|
// check output in table
|
|
xi := &Int{abs: x}
|
|
yi := &Int{abs: y}
|
|
mi := &Int{abs: m}
|
|
p := new(Int).Mod(new(Int).Mul(xi, new(Int).Mul(yi, new(Int).ModInverse(new(Int).Lsh(one, uint(len(m))*_W), mi))), mi)
|
|
if out.cmp(p.abs.norm()) != 0 {
|
|
t.Errorf("#%d: out in table=0x%s, computed=0x%s", i, out.utoa(16), p.abs.norm().utoa(16))
|
|
}
|
|
|
|
// check k0 in table
|
|
k := new(Int).Mod(&Int{abs: m}, _B)
|
|
k = new(Int).Sub(_B, k)
|
|
k = new(Int).Mod(k, _B)
|
|
k0 := Word(new(Int).ModInverse(k, _B).Uint64())
|
|
if k0 != Word(test.k0) {
|
|
t.Errorf("#%d: k0 in table=%#x, computed=%#x\n", i, test.k0, k0)
|
|
}
|
|
|
|
// check montgomery with correct k0 produces correct output
|
|
z := nat(nil).montgomery(x, y, m, k0, len(m))
|
|
z = z.norm()
|
|
if z.cmp(out) != 0 {
|
|
t.Errorf("#%d: got 0x%s want 0x%s", i, z.utoa(16), out.utoa(16))
|
|
}
|
|
}
|
|
}
|
|
|
|
var expNNTests = []struct {
|
|
x, y, m string
|
|
out string
|
|
}{
|
|
{"0", "0", "0", "1"},
|
|
{"0", "0", "1", "0"},
|
|
{"1", "1", "1", "0"},
|
|
{"2", "1", "1", "0"},
|
|
{"2", "2", "1", "0"},
|
|
{"10", "100000000000", "1", "0"},
|
|
{"0x8000000000000000", "2", "", "0x40000000000000000000000000000000"},
|
|
{"0x8000000000000000", "2", "6719", "4944"},
|
|
{"0x8000000000000000", "3", "6719", "5447"},
|
|
{"0x8000000000000000", "1000", "6719", "1603"},
|
|
{"0x8000000000000000", "1000000", "6719", "3199"},
|
|
{
|
|
"2938462938472983472983659726349017249287491026512746239764525612965293865296239471239874193284792387498274256129746192347",
|
|
"298472983472983471903246121093472394872319615612417471234712061",
|
|
"29834729834729834729347290846729561262544958723956495615629569234729836259263598127342374289365912465901365498236492183464",
|
|
"23537740700184054162508175125554701713153216681790245129157191391322321508055833908509185839069455749219131480588829346291",
|
|
},
|
|
{
|
|
"11521922904531591643048817447554701904414021819823889996244743037378330903763518501116638828335352811871131385129455853417360623007349090150042001944696604737499160174391019030572483602867266711107136838523916077674888297896995042968746762200926853379",
|
|
"426343618817810911523",
|
|
"444747819283133684179",
|
|
"42",
|
|
},
|
|
}
|
|
|
|
func TestExpNN(t *testing.T) {
|
|
for i, test := range expNNTests {
|
|
x := natFromString(test.x)
|
|
y := natFromString(test.y)
|
|
out := natFromString(test.out)
|
|
|
|
var m nat
|
|
if len(test.m) > 0 {
|
|
m = natFromString(test.m)
|
|
}
|
|
|
|
z := nat(nil).expNN(x, y, m)
|
|
if z.cmp(out) != 0 {
|
|
t.Errorf("#%d got %s want %s", i, z.utoa(10), out.utoa(10))
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkExp3Power(b *testing.B) {
|
|
const x = 3
|
|
for _, y := range []Word{
|
|
0x10, 0x40, 0x100, 0x400, 0x1000, 0x4000, 0x10000, 0x40000, 0x100000, 0x400000,
|
|
} {
|
|
b.Run(fmt.Sprintf("%#x", y), func(b *testing.B) {
|
|
var z nat
|
|
for i := 0; i < b.N; i++ {
|
|
z.expWW(x, y)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func fibo(n int) nat {
|
|
switch n {
|
|
case 0:
|
|
return nil
|
|
case 1:
|
|
return nat{1}
|
|
}
|
|
f0 := fibo(0)
|
|
f1 := fibo(1)
|
|
var f2 nat
|
|
for i := 1; i < n; i++ {
|
|
f2 = f2.add(f0, f1)
|
|
f0, f1, f2 = f1, f2, f0
|
|
}
|
|
return f1
|
|
}
|
|
|
|
var fiboNums = []string{
|
|
"0",
|
|
"55",
|
|
"6765",
|
|
"832040",
|
|
"102334155",
|
|
"12586269025",
|
|
"1548008755920",
|
|
"190392490709135",
|
|
"23416728348467685",
|
|
"2880067194370816120",
|
|
"354224848179261915075",
|
|
}
|
|
|
|
func TestFibo(t *testing.T) {
|
|
for i, want := range fiboNums {
|
|
n := i * 10
|
|
got := string(fibo(n).utoa(10))
|
|
if got != want {
|
|
t.Errorf("fibo(%d) failed: got %s want %s", n, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkFibo(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
fibo(1e0)
|
|
fibo(1e1)
|
|
fibo(1e2)
|
|
fibo(1e3)
|
|
fibo(1e4)
|
|
fibo(1e5)
|
|
}
|
|
}
|
|
|
|
var bitTests = []struct {
|
|
x string
|
|
i uint
|
|
want uint
|
|
}{
|
|
{"0", 0, 0},
|
|
{"0", 1, 0},
|
|
{"0", 1000, 0},
|
|
|
|
{"0x1", 0, 1},
|
|
{"0x10", 0, 0},
|
|
{"0x10", 3, 0},
|
|
{"0x10", 4, 1},
|
|
{"0x10", 5, 0},
|
|
|
|
{"0x8000000000000000", 62, 0},
|
|
{"0x8000000000000000", 63, 1},
|
|
{"0x8000000000000000", 64, 0},
|
|
|
|
{"0x3" + strings.Repeat("0", 32), 127, 0},
|
|
{"0x3" + strings.Repeat("0", 32), 128, 1},
|
|
{"0x3" + strings.Repeat("0", 32), 129, 1},
|
|
{"0x3" + strings.Repeat("0", 32), 130, 0},
|
|
}
|
|
|
|
func TestBit(t *testing.T) {
|
|
for i, test := range bitTests {
|
|
x := natFromString(test.x)
|
|
if got := x.bit(test.i); got != test.want {
|
|
t.Errorf("#%d: %s.bit(%d) = %v; want %v", i, test.x, test.i, got, test.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
var stickyTests = []struct {
|
|
x string
|
|
i uint
|
|
want uint
|
|
}{
|
|
{"0", 0, 0},
|
|
{"0", 1, 0},
|
|
{"0", 1000, 0},
|
|
|
|
{"0x1", 0, 0},
|
|
{"0x1", 1, 1},
|
|
|
|
{"0x1350", 0, 0},
|
|
{"0x1350", 4, 0},
|
|
{"0x1350", 5, 1},
|
|
|
|
{"0x8000000000000000", 63, 0},
|
|
{"0x8000000000000000", 64, 1},
|
|
|
|
{"0x1" + strings.Repeat("0", 100), 400, 0},
|
|
{"0x1" + strings.Repeat("0", 100), 401, 1},
|
|
}
|
|
|
|
func TestSticky(t *testing.T) {
|
|
for i, test := range stickyTests {
|
|
x := natFromString(test.x)
|
|
if got := x.sticky(test.i); got != test.want {
|
|
t.Errorf("#%d: %s.sticky(%d) = %v; want %v", i, test.x, test.i, got, test.want)
|
|
}
|
|
if test.want == 1 {
|
|
// all subsequent i's should also return 1
|
|
for d := uint(1); d <= 3; d++ {
|
|
if got := x.sticky(test.i + d); got != 1 {
|
|
t.Errorf("#%d: %s.sticky(%d) = %v; want %v", i, test.x, test.i+d, got, 1)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|