go/src/math/big/nat_test.go

var cmpTests …

func TestCmp(t *testing.T) { … }

type funNN …

type argNN …

var sumNN …

var prodNN …

func natFromString(s string) nat { … }

func TestSet(t *testing.T) { … }

func testFunNN(t *testing.T, msg string, f funNN, a argNN) { … }

func TestFunNN(t *testing.T) { … }

var mulRangesN …

func TestMulRangeN(t *testing.T) { … }

// allocBytes returns the number of bytes allocated by invoking f.
func allocBytes(f func()) uint64 { … }

// 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) { … }

// rndNat returns a random nat value >= 0 of (usually) n words in length.
// In extremely unlikely cases it may be smaller than n words if the top-
// most words are 0.
func rndNat(n int) nat { … }

// rndNat1 is like rndNat but the result is guaranteed to be > 0.
func rndNat1(n int) nat { … }

func BenchmarkMul(b *testing.B) { … }

func benchmarkNatMul(b *testing.B, nwords int) { … }

var mulBenchSizes …

func BenchmarkNatMul(b *testing.B) { … }

func TestNLZ(t *testing.T) { … }

type shiftTest …

var leftShiftTests …

func TestShiftLeft(t *testing.T) { … }

var rightShiftTests …

func TestShiftRight(t *testing.T) { … }

func BenchmarkZeroShifts(b *testing.B) { … }

type modWTest …

var modWTests32 …

var modWTests64 …

func runModWTests(t *testing.T, tests []modWTest) { … }

func TestModW(t *testing.T) { … }

var montgomeryTests …

func TestMontgomery(t *testing.T) { … }

var expNNTests …

func TestExpNN(t *testing.T) { … }

func FuzzExpMont(f *testing.F) { … }

func BenchmarkExp3Power(b *testing.B) { … }

func fibo(n int) nat { … }

var fiboNums …

func TestFibo(t *testing.T) { … }

func BenchmarkFibo(b *testing.B) { … }

var bitTests …

func TestBit(t *testing.T) { … }

var stickyTests …

func TestSticky(t *testing.T) { … }

func testSqr(t *testing.T, x nat) { … }

func TestSqr(t *testing.T) { … }

func benchmarkNatSqr(b *testing.B, nwords int) { … }

var sqrBenchSizes …

func BenchmarkNatSqr(b *testing.B) { … }

var subMod2NTests …

func TestNatSubMod2N(t *testing.T) { … }

func BenchmarkNatSetBytes(b *testing.B) { … }

func TestNatDiv(t *testing.T) { … }

// TestIssue37499 triggers the edge case of divBasic where
// the inaccurate estimate of the first word's quotient
// happens at the very beginning of the loop.
func TestIssue37499(t *testing.T) { … }

// TestIssue42552 triggers an edge case of recursive division
// where the first division loop is never entered, and correcting
// the remainder takes exactly two iterations in the final loop.
func TestIssue42552(t *testing.T) { … }