arnaucube/arbo
1
1
Fork 0
mirror of https://github.com/arnaucube/arbo.git synced 2026-01-15 01:41:28 +01:00
Code Issues Projects Releases Wiki Activity

Tests migrate from stretchr/testify to frankban/quicktest

Browse Source
This commit is contained in:
arnaucube
2021-04-03 19:40:12 +02:00
parent f1665b1a15
commit f8ac4be02b
5 changed files with 85 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
tree_test.go
View File

@@ -2,16 +2,16 @@ package arbo
import (
"encoding/hex"
"fmt"
"math/big"
"testing"
qt "github.com/frankban/quicktest"
"github.com/iden3/go-merkletree/db/memory"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestAddTestVectors(t *testing.T) {
c := qt.New(t)
// Poseidon test vectors generated using https://github.com/iden3/circomlib smt.js
testVectorsPoseidon := []string{
"0000000000000000000000000000000000000000000000000000000000000000",
@@ -19,7 +19,7 @@ func TestAddTestVectors(t *testing.T) {
"5412393676474193513566895793055462193090331607895808993925969873307089394741",
"14204494359367183802864593755198662203838502594566452929175967972147978322084",
}
testAdd(t, HashFunctionPoseidon, testVectorsPoseidon)
testAdd(c, HashFunctionPoseidon, testVectorsPoseidon)
testVectorsSha256 := []string{
"0000000000000000000000000000000000000000000000000000000000000000",
@@ -27,41 +27,42 @@ func TestAddTestVectors(t *testing.T) {
"59481735341404520835410489183267411392292882901306595567679529387376287440550",
"20573794434149960984975763118181266662429997821552560184909083010514790081771",
}
testAdd(t, HashFunctionSha256, testVectorsSha256)
testAdd(c, HashFunctionSha256, testVectorsSha256)
}
func testAdd(t *testing.T, hashFunc HashFunction, testVectors []string) {
func testAdd(c *qt.C, hashFunc HashFunction, testVectors []string) {
tree, err := NewTree(memory.NewMemoryStorage(), 10, hashFunc)
assert.Nil(t, err)
c.Assert(err, qt.IsNil)
defer tree.db.Close()
assert.Equal(t, testVectors[0], hex.EncodeToString(tree.Root()))
c.Check(hex.EncodeToString(tree.Root()), qt.Equals, testVectors[0])
err = tree.Add(
BigIntToBytes(big.NewInt(1)),
BigIntToBytes(big.NewInt(2)))
assert.Nil(t, err)
c.Assert(err, qt.IsNil)
rootBI := BytesToBigInt(tree.Root())
assert.Equal(t, testVectors[1], rootBI.String())
c.Check(rootBI.String(), qt.Equals, testVectors[1])
err = tree.Add(
BigIntToBytes(big.NewInt(33)),
BigIntToBytes(big.NewInt(44)))
assert.Nil(t, err)
c.Assert(err, qt.IsNil)
rootBI = BytesToBigInt(tree.Root())
assert.Equal(t, testVectors[2], rootBI.String())
c.Check(rootBI.String(), qt.Equals, testVectors[2])
err = tree.Add(
BigIntToBytes(big.NewInt(1234)),
BigIntToBytes(big.NewInt(9876)))
assert.Nil(t, err)
c.Assert(err, qt.IsNil)
rootBI = BytesToBigInt(tree.Root())
assert.Equal(t, testVectors[3], rootBI.String())
c.Check(rootBI.String(), qt.Equals, testVectors[3])
}
func TestAddBatch(t *testing.T) {
c := qt.New(t)
tree, err := NewTree(memory.NewMemoryStorage(), 100, HashFunctionPoseidon)
require.Nil(t, err)
c.Assert(err, qt.IsNil)
defer tree.db.Close()
for i := 0; i < 1000; i++ {
@@ -73,12 +74,11 @@ func TestAddBatch(t *testing.T) {
}
rootBI := BytesToBigInt(tree.Root())
assert.Equal(t,
"296519252211642170490407814696803112091039265640052570497930797516015811235",
rootBI.String())
c.Check(rootBI.String(), qt.Equals,
"296519252211642170490407814696803112091039265640052570497930797516015811235")
tree2, err := NewTree(memory.NewMemoryStorage(), 100, HashFunctionPoseidon)
require.Nil(t, err)
c.Assert(err, qt.IsNil)
defer tree2.db.Close()
var keys, values [][]byte
@@ -89,18 +89,18 @@ func TestAddBatch(t *testing.T) {
values = append(values, v)
}
indexes, err := tree2.AddBatch(keys, values)
assert.Nil(t, err)
assert.Equal(t, 0, len(indexes))
c.Assert(err, qt.IsNil)
c.Check(len(indexes), qt.Equals, 0)
rootBI = BytesToBigInt(tree2.Root())
assert.Equal(t,
"296519252211642170490407814696803112091039265640052570497930797516015811235",
rootBI.String())
c.Check(rootBI.String(), qt.Equals,
"296519252211642170490407814696803112091039265640052570497930797516015811235")
}
func TestAddDifferentOrder(t *testing.T) {
c := qt.New(t)
tree1, err := NewTree(memory.NewMemoryStorage(), 100, HashFunctionPoseidon)
require.Nil(t, err)
c.Assert(err, qt.IsNil)
defer tree1.db.Close()
for i := 0; i < 16; i++ {
@@ -112,7 +112,7 @@ func TestAddDifferentOrder(t *testing.T) {
}
tree2, err := NewTree(memory.NewMemoryStorage(), 100, HashFunctionPoseidon)
require.Nil(t, err)
c.Assert(err, qt.IsNil)
defer tree2.db.Close()
for i := 16 - 1; i >= 0; i-- {
@@ -123,15 +123,15 @@ func TestAddDifferentOrder(t *testing.T) {
}
}
assert.Equal(t, hex.EncodeToString(tree1.Root()), hex.EncodeToString(tree2.Root()))
assert.Equal(t,
"3b89100bec24da9275c87bc188740389e1d5accfc7d88ba5688d7fa96a00d82f",
hex.EncodeToString(tree1.Root()))
c.Check(hex.EncodeToString(tree2.Root()), qt.Equals, hex.EncodeToString(tree1.Root()))
c.Check(hex.EncodeToString(tree1.Root()), qt.Equals,
"3b89100bec24da9275c87bc188740389e1d5accfc7d88ba5688d7fa96a00d82f")
}
func TestAddRepeatedIndex(t *testing.T) {
c := qt.New(t)
tree, err := NewTree(memory.NewMemoryStorage(), 100, HashFunctionPoseidon)
require.Nil(t, err)
c.Assert(err, qt.IsNil)
defer tree.db.Close()
k := big.NewInt(int64(3)).Bytes()
@@ -140,38 +140,40 @@ func TestAddRepeatedIndex(t *testing.T) {
t.Fatal(err)
}
err = tree.Add(k, v)
assert.NotNil(t, err)
assert.Equal(t, fmt.Errorf("max virtual level 100"), err)
c.Assert(err, qt.Not(qt.IsNil))
c.Check(err, qt.ErrorMatches, "max virtual level 100")
}
func TestAux(t *testing.T) {
c := qt.New(t)
tree, err := NewTree(memory.NewMemoryStorage(), 100, HashFunctionPoseidon)
require.Nil(t, err)
c.Assert(err, qt.IsNil)
defer tree.db.Close()
k := BigIntToBytes(big.NewInt(int64(1)))
v := BigIntToBytes(big.NewInt(int64(0)))
err = tree.Add(k, v)
assert.Nil(t, err)
c.Assert(err, qt.IsNil)
k = BigIntToBytes(big.NewInt(int64(256)))
err = tree.Add(k, v)
assert.Nil(t, err)
c.Assert(err, qt.IsNil)
k = BigIntToBytes(big.NewInt(int64(257)))
err = tree.Add(k, v)
assert.Nil(t, err)
c.Assert(err, qt.IsNil)
k = BigIntToBytes(big.NewInt(int64(515)))
err = tree.Add(k, v)
assert.Nil(t, err)
c.Assert(err, qt.IsNil)
k = BigIntToBytes(big.NewInt(int64(770)))
err = tree.Add(k, v)
assert.Nil(t, err)
c.Assert(err, qt.IsNil)
}
func TestGet(t *testing.T) {
c := qt.New(t)
tree, err := NewTree(memory.NewMemoryStorage(), 100, HashFunctionPoseidon)
require.Nil(t, err)
c.Assert(err, qt.IsNil)
defer tree.db.Close()
for i := 0; i < 10; i++ {
@@ -184,14 +186,15 @@ func TestGet(t *testing.T) {
k := BigIntToBytes(big.NewInt(int64(7)))
gettedKey, gettedValue, err := tree.Get(k)
assert.Nil(t, err)
assert.Equal(t, k, gettedKey)
assert.Equal(t, BigIntToBytes(big.NewInt(int64(7*2))), gettedValue)
c.Assert(err, qt.IsNil)
c.Check(gettedKey, qt.DeepEquals, k)
c.Check(gettedValue, qt.DeepEquals, BigIntToBytes(big.NewInt(int64(7*2))))
}
func TestGenProofAndVerify(t *testing.T) {
c := qt.New(t)
tree, err := NewTree(memory.NewMemoryStorage(), 100, HashFunctionPoseidon)
require.Nil(t, err)
c.Assert(err, qt.IsNil)
defer tree.db.Close()
for i := 0; i < 10; i++ {
@@ -204,18 +207,19 @@ func TestGenProofAndVerify(t *testing.T) {
k := BigIntToBytes(big.NewInt(int64(7)))
siblings, err := tree.GenProof(k)
assert.Nil(t, err)
c.Assert(err, qt.IsNil)
k = BigIntToBytes(big.NewInt(int64(7)))
v := BigIntToBytes(big.NewInt(int64(14)))
verif, err := CheckProof(tree.hashFunction, k, v, tree.Root(), siblings)
require.Nil(t, err)
assert.True(t, verif)
c.Assert(err, qt.IsNil)
c.Check(verif, qt.IsTrue)
}
func TestDumpAndImportDump(t *testing.T) {
c := qt.New(t)
tree1, err := NewTree(memory.NewMemoryStorage(), 100, HashFunctionPoseidon)
require.Nil(t, err)
c.Assert(err, qt.IsNil)
defer tree1.db.Close()
for i := 0; i < 16; i++ {
@@ -227,17 +231,16 @@ func TestDumpAndImportDump(t *testing.T) {
}
e, err := tree1.Dump()
require.Nil(t, err)
c.Assert(err, qt.IsNil)
tree2, err := NewTree(memory.NewMemoryStorage(), 100, HashFunctionPoseidon)
require.Nil(t, err)
c.Assert(err, qt.IsNil)
defer tree2.db.Close()
err = tree2.ImportDump(e)
require.Nil(t, err)
assert.Equal(t, tree1.Root(), tree2.Root())
assert.Equal(t,
"0d93aaa3362b2f999f15e15728f123087c2eee716f01c01f56e23aae07f09f08",
hex.EncodeToString(tree2.Root()))
c.Assert(err, qt.IsNil)
c.Check(tree2.Root(), qt.DeepEquals, tree1.Root())
c.Check(hex.EncodeToString(tree2.Root()), qt.Equals,
"0d93aaa3362b2f999f15e15728f123087c2eee716f01c01f56e23aae07f09f08")
}
func BenchmarkAdd(b *testing.B) {
@@ -259,8 +262,9 @@ func BenchmarkAdd(b *testing.B) {
}
func benchmarkAdd(b *testing.B, hashFunc HashFunction, ks, vs [][]byte) {
c := qt.New(b)
tree, err := NewTree(memory.NewMemoryStorage(), 140, hashFunc)
require.Nil(b, err)
c.Assert(err, qt.IsNil)
defer tree.db.Close()
for i := 0; i < len(ks); i++ {