// https://camlistore.org/issue/216 func TestBug216(t *testing.T) { const S = 2*kKV + 2 // 2*kKV+1 ok const N = 300000 rng, err := mathutil.NewFC32(math.MinInt32, math.MaxInt32, true) if err != nil { t.Fatal(err) } k := make([]byte, S/2) v := make([]byte, S-S/2) tr := NewBTree(nil) for i := 0; i < N; i++ { for i := range k { k[i] = byte(rng.Next()) } for i := range v { v[i] = byte(rng.Next()) } if err := tr.Set(h2b(k, int64(i)), h2b(v, int64(i))); err != nil { t.Fatal(i, err) } if (i+1)%10000 == 0 { //dbg("%v", i+1) } } }
func fc() *mathutil.FC32 { r, err := mathutil.NewFC32(0, math.MaxInt32, false) if err != nil { panic(err) } return r }
func r32() *mathutil.FC32 { r, err := mathutil.NewFC32(math.MinInt32, math.MaxInt32, true) if err != nil { panic(err) } return r }
func TestModPow2(t *testing.T) { const N = 1e3 data := []struct{ e, m uint32 }{ // e == 0 -> x == 0 {0, 2}, {0, 3}, {0, 4}, {1, 2}, {1, 3}, {1, 4}, {1, 5}, {2, 2}, {2, 3}, {2, 4}, {2, 5}, {3, 2}, {3, 3}, {3, 4}, {3, 5}, {3, 6}, {3, 7}, {3, 8}, {3, 9}, {4, 2}, {4, 3}, {4, 4}, {4, 5}, {4, 6}, {4, 7}, {4, 8}, {4, 9}, } var got big.Int f := func(e, m uint32) { x := ModPow2(e, m) exp := ModPow(2, e, m) got.SetInt64(0) got.SetBit(&got, int(x), 1) if got.Cmp(exp) != 0 { t.Fatalf("\ne %d, m %d\ng: %s\ne: %s", e, m, &got, exp) } } for _, v := range data { f(v.e, v.m) } rg, _ := mathutil.NewFC32(2, 1<<10, true) for i := 0; i < N; i++ { f(uint32(rg.Next()), uint32(rg.Next())) } }
func TestMod(t *testing.T) { const N = 1e4 data := []struct { mod, n int64 exp uint32 }{ {0, 0x00, 3}, {1, 0x01, 3}, {3, 0x03, 3}, {0, 0x07, 3}, {1, 0x0f, 3}, {3, 0x1f, 3}, {0, 0x3f, 3}, {1, 0x7f, 3}, {3, 0xff, 3}, {0, 0x1ff, 3}, } var mod, n big.Int for _, v := range data { n.SetInt64(v.n) p := Mod(&mod, &n, v.exp) if p != &mod { t.Fatal() } if g, e := mod.Int64(), v.mod; g != e { t.Fatal(v.n, v.exp, g, e) } } f := func(in int64, exp uint32) { n.SetInt64(in) mod.Mod(&n, New(exp)) e := mod.Int64() Mod(&mod, &n, exp) g := mod.Int64() if g != e { t.Fatal(in, exp, g, e) } } r32, _ := mathutil.NewFC32(1, 1e6, true) r64, _ := mathutil.NewFCBig(_0, mathutil.Uint64ToBigInt(math.MaxInt64), true) for i := 0; i < N; i++ { f(r64.Next().Int64(), uint32(r32.Next())) } }
func TestModPow(t *testing.T) { const N = 2e2 data := []struct{ b, e, m, r uint32 }{ {0, 1, 1, 0}, {0, 2, 1, 0}, {0, 3, 1, 0}, {1, 0, 1, 0}, {1, 1, 1, 0}, {1, 2, 1, 0}, {1, 3, 1, 0}, {2, 0, 1, 0}, {2, 1, 1, 0}, {2, 2, 1, 0}, {2, 3, 1, 0}, {2, 3, 4, 8}, {2, 3, 5, 4}, {2, 4, 3, 1}, {3, 3, 3, 3}, {3, 4, 5, 30}, } f := func(b, e, m uint32, expect *big.Int) { got := ModPow(b, e, m) if got.Cmp(expect) != 0 { t.Fatal(b, e, m, got, expect) } } var r big.Int for _, v := range data { r.SetInt64(int64(v.r)) f(v.b, v.e, v.m, &r) } rg, _ := mathutil.NewFC32(2, 1<<10, true) var bb big.Int for i := 0; i < N; i++ { b, e, m := uint32(rg.Next()), uint32(rg.Next()), uint32(rg.Next()) bb.SetInt64(int64(b)) f(b, e, m, mathutil.ModPowBigInt(&bb, New(e), New(m))) } }
func testBTreePut2(t *testing.T, nf func() btreeStore, grow, n int) (tree btree) { if *noGrow { grow = 0 } rng, err := mathutil.NewFC32(math.MinInt32, math.MaxInt32, true) if err != nil { t.Fatal(err) } a := nf() if a == nil { t.Fatal(a) } tree, err = newBTree(a) if err != nil { t.Fatal(err) } var k, v [7]byte for i := 0; i < n; i++ { ik, iv := int64(rng.Next()), int64(rng.Next()) h2b(k[:], ik) h2b(v[:], iv) kk := append(make([]byte, grow*i), k[:]...) vv := append(make([]byte, grow*i), v[:]...) prev, err := tree.put(nil, a, nil, kk, vv, true) if err != nil || len(prev) != 0 { t.Fatal(i, prev, err) } var buf []byte if buf, err = tree.get(a, nil, nil, kk); err != nil { t.Fatal(err) } if !bytes.Equal(buf, vv) { t.Fatalf("\n%s%s%s%s", hex.Dump(kk), hex.Dump(buf), hex.Dump(vv), tree.String(a)) } } if err := verifyPageLinks(a, tree, n); err != nil { t.Fatalf("%s\n%s\n", err, tree.String(a)) } rng.Seek(0) for i := 0; i < n; i++ { ik, iv := int64(rng.Next()), int64(rng.Next()) h2b(k[:], ik) h2b(v[:], iv) kk := append(make([]byte, grow*i), k[:]...) vv := append(make([]byte, grow*i), v[:]...) var buf []byte buf, err := tree.extract(a, nil, nil, kk) if err != nil { t.Fatal(i, err) } if !bytes.Equal(buf, vv) { t.Fatalf("\n%s\n%s\n%s\n%s", hex.Dump(kk), hex.Dump(buf), hex.Dump(vv), tree.String(a)) } if err := verifyPageLinks(a, tree, n-i-1); err != nil { t.Fatalf("%s\n%s", err, tree.String(a)) } } return }
func testBenchReadRnd(t *testing.T, n, block int) (dt int64) { println(252, n, block) //TODO- f, err := fcreate(*fnFlag) println(254) //TODO- if err != nil { println(254) //TODO- t.Fatal(err) } println(259) //TODO- defer func() { f.Accessor().Sync() probed(t, f) ec := f.Close() er := os.Remove(*fnFlag) if ec != nil { t.Fatal(ec) } if er != nil { t.Fatal(er) } }() h := make([]Handle, n) b := make([]byte, block) perc := 1 if n >= 1000 { perc = n / 1000 } println(281) //TODO- t0 := time.Now().UnixNano() for i := 0; i < n; i++ { if h[i], err = f.Alloc(b); err != nil { println(285) //TODO- t.Fatal(err) } if i != 0 && i%perc == 0 { dt := float64((time.Now().UnixNano() - t0) / 1e9) q := float64(i) / float64(n) rt := dt/q - dt print("w ", (1000*uint64(i))/uint64(n), " eta ", int(rt/60), ":", int(rt)%60, " \r") } } rng, err := mathutil.NewFC32(0, n-1, true) if err != nil { println(297) //TODO- t.Fatal(err) } println("\nsync") f.Accessor().Sync() println("synced") t0 = time.Now().UnixNano() for i := 0; i < n; i++ { if _, err := f.Read(h[rng.Next()]); err != nil { println(306) //TODO- t.Fatal(err) } if i != 0 && i%perc == 0 { dt := float64((time.Now().UnixNano() - t0) / 1e9) q := float64(i) / float64(n) rt := dt/q - dt print("r ", (1000*uint64(i))/uint64(n), " eta ", int(rt/60), ":", int(rt)%60, " \r") } } println() println(314) //TODO- dt = time.Now().UnixNano() - t0 if c, ok := f.Accessor().(*storage.Cache); ok { x, _ := c.Stat() t.Logf("Cache rq %10d, load %10d, purge %10d, top %10d, fs %10d", c.Rq, c.Load, c.Purge, c.Top, x.Size()) } println(323) //TODO- return }