func TestPersistence(t *testing.T) { db := db.NewMemDB() // Create some random key value pairs records := make(map[string]string) for i := 0; i < 10000; i++ { records[randstr(20)] = randstr(20) } // Construct some tree and save it t1 := NewIAVLTree(wire.BasicCodec, wire.BasicCodec, 0, db) for key, value := range records { t1.Set(key, value) } t1.Save() hash, _ := t1.HashWithCount() // Load a tree t2 := NewIAVLTree(wire.BasicCodec, wire.BasicCodec, 0, db) t2.Load(hash) for key, value := range records { _, t2value := t2.Get(key) if t2value != value { t.Fatalf("Invalid value. Expected %v, got %v", value, t2value) } } }
func RandGenesisState(numAccounts int, randBalance bool, minBalance int64, numValidators int, randBonded bool, minBonded int64) (*State, []*acm.PrivAccount, []*types.PrivValidator) { db := dbm.NewMemDB() genDoc, privAccounts, privValidators := RandGenesisDoc(numAccounts, randBalance, minBalance, numValidators, randBonded, minBonded) s0 := MakeGenesisState(db, genDoc) s0.Save() return s0, privAccounts, privValidators }
func TestGenesisMakeState(t *testing.T) { genDoc := GenesisDocFromJSON([]byte(g1)) db := tdb.NewMemDB() st := MakeGenesisState(db, genDoc) acc := st.GetAccount(addr1) v, _ := acc.Permissions.Base.Get(ptypes.Send) if v != (send1 > 0) { t.Fatalf("Incorrect permission for send. Got %v, expected %v\n", v, send1 > 0) } }
func testCoreRandom(N int) error { chainID := "test_chainID" genBytes, privVals, err := coreRandom(N, chainID) if err != nil { return err } if len(privVals) != N { return fmt.Errorf("len(privVals) != N") } // make sure each validator is in the genesis and all genesi are the same for i, v := range privVals { dirFlag := DirFlag if N > 1 { dirFlag = path.Join(DirFlag, fmt.Sprintf("%s_%d", chainID, i)) } b, err := ioutil.ReadFile(path.Join(dirFlag, "genesis.json")) if err != nil { return err } if !bytes.Equal(b, genBytes) { return fmt.Errorf("written genesis.json different from returned by coreRandom") } db := dbm.NewMemDB() gDoc, _ := sm.MakeGenesisStateFromFile(db, path.Join(dirFlag, "genesis.json")) if len(gDoc.Validators) != N { return fmt.Errorf("Expected %d validators. Got %d", N, len(gDoc.Validators)) } privVal := types.LoadPrivValidator(path.Join(dirFlag, "priv_validator.json")) if !bytes.Equal(privVal.Address, v.Address) { return fmt.Errorf("priv_validator file contents different than result of coreRandom") } var found bool for _, val := range gDoc.Validators { if bytes.Equal(val.UnbondTo[0].Address, privVal.Address) { found = true } } if !found { return fmt.Errorf("failed to find validator %d:%X in genesis.json", i, v.Address) } } return nil }
func testKnownCSV(csvFile string, csv GenDoc) error { chainID := "test_chainID" if err := ioutil.WriteFile(path.Join(DirFlag, "accounts.csv"), []byte(csvFile), 0600); err != nil { return err } genBytes, err := coreKnown(chainID, path.Join(DirFlag, "accounts.csv")) if err != nil { return err } if err := ioutil.WriteFile(path.Join(DirFlag, "genesis.json"), genBytes, 0600); err != nil { return err } db := dbm.NewMemDB() gDoc, _ := sm.MakeGenesisStateFromFile(db, path.Join(DirFlag, "genesis.json")) N := len(csv.pubkeys) if len(gDoc.Validators) != N { return fmt.Errorf("Expected %d validators. Got %d", N, len(gDoc.Validators)) } for i, pub := range csv.pubkeys { pubBytes, _ := hex.DecodeString(pub) if !bytes.Equal(gDoc.Validators[i].PubKey[:], pubBytes) { return fmt.Errorf("failed to find validator %d:%X in genesis.json", i, pub) } if len(csv.amts) > 0 && gDoc.Accounts[i].Amount != int64(csv.amts[i]) { return fmt.Errorf("amts dont match. got %d, expected %d", gDoc.Accounts[i].Amount, csv.amts[i]) } if len(csv.perms) > 0 && gDoc.Accounts[i].Permissions.Base.Perms != ptypes.PermFlag(csv.perms[i]) { return fmt.Errorf("perms dont match. got %d, expected %d", gDoc.Accounts[i].Permissions.Base.Perms, csv.perms[i]) } if len(csv.setbits) > 0 && gDoc.Accounts[i].Permissions.Base.SetBit != ptypes.PermFlag(csv.setbits[i]) { return fmt.Errorf("setbits dont match. got %d, expected %d", gDoc.Accounts[i].Permissions.Base.SetBit, csv.setbits[i]) } } return nil }
func TestIAVLProof(t *testing.T) { // Convenient wrapper around wire.BasicCodec. toBytes := func(o interface{}) []byte { buf, n, err := new(bytes.Buffer), int64(0), error(nil) wire.BasicCodec.Encode(o, buf, &n, &err) if err != nil { panic(Fmt("Failed to encode thing: %v", err)) } return buf.Bytes() } // Construct some random tree db := db.NewMemDB() var tree *IAVLTree = NewIAVLTree(wire.BasicCodec, wire.BasicCodec, 100, db) for i := 0; i < 1000; i++ { key, value := randstr(20), randstr(20) tree.Set(key, value) } // Persist the items so far tree.Save() // Add more items so it's not all persisted for i := 0; i < 100; i++ { key, value := randstr(20), randstr(20) tree.Set(key, value) } // Now for each item, construct a proof and verify tree.Iterate(func(key interface{}, value interface{}) bool { proof := tree.ConstructProof(key) if !bytes.Equal(proof.RootHash, tree.Hash()) { t.Errorf("Invalid proof. Expected root %X, got %X", tree.Hash(), proof.RootHash) } testProof(t, proof, toBytes(key), toBytes(value), tree.Hash()) return false }) }