From b7e688b7fb24d21fdff868fb2aef663b4607e87d Mon Sep 17 00:00:00 2001 From: jovijovi Date: Thu, 16 Dec 2021 16:29:59 +0800 Subject: [PATCH] test: add more uat --- merkle_test.go | 236 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 236 insertions(+) diff --git a/merkle_test.go b/merkle_test.go index f9bc316..df241d5 100644 --- a/merkle_test.go +++ b/merkle_test.go @@ -87,6 +87,20 @@ func TestLeaves_BuildTree_Simple(t *testing.T) { } t.Log("Tree=", tree) t.Log("Root=", root) + + var invalidLeaves1 *merkletree.Leaves + _, _, err = invalidLeaves1.BuildTree() + if err != nil { + t.Log("leaves1 is nil, build tree failed as expected") + } + assert.NotNil(t, err) + + var invalidLeaves2 merkletree.Leaves + _, _, err = invalidLeaves2.BuildTree() + if err != nil { + t.Log("leaves2 is empty, build tree failed as expected") + } + assert.NotNil(t, err) } // Build tree with sorted leaves @@ -226,6 +240,14 @@ func TestTree_Marshal(t *testing.T) { t.Log("TreeMarshalString_2=", string(bytes2)) assert.Equal(t, bytes1, bytes2) + + // Test invalid tree + var invalidTree1 *merkletree.Tree + _, err = invalidTree1.Marshal() + if err != nil { + t.Log("tree is nil, marshal tree failed as expected") + } + assert.NotNil(t, err) } // Get hash from tree by coordinate(y, x) @@ -289,3 +311,217 @@ func TestTree_Prove(t *testing.T) { t.Log("Result=", resultBad) assert.Equal(t, false, resultBad) } + +// Clone leaf +func TestLeaf_Clone(t *testing.T) { + clone1 := MockLeaves[0].Clone() + if clone1 == nil { + t.Fatal("clone leaf failed") + } + assert.Equal(t, *clone1, MockLeaves[0]) + + var invalidLeaf *merkletree.Leaf = nil + clone2 := invalidLeaf.Clone() + if clone2 == nil { + t.Log("leaf is nil, clone failed as expected.") + } + assert.Nil(t, clone2) +} + +// Get length of leaves +func TestLeaves_Length(t *testing.T) { + len1 := MockLeaves.Length() + if len1 == 0 { + t.Fatal("get length of leaves failed") + } + assert.NotZero(t, len1) + + var invalidLeaves *merkletree.Leaves + len2 := invalidLeaves.Length() + if len2 == 0 { + t.Log("leaves is nil, get length failed as expected.") + } + assert.Zero(t, len2) +} + +// Get last leaf +func TestLeaves_LastLeaf(t *testing.T) { + leaf1 := MockLeaves.LastLeaf() + if leaf1 == nil { + t.Fatal("get last leaf failed") + } + assert.NotNil(t, leaf1) + + var invalidLeaves *merkletree.Leaves + leaf2 := invalidLeaves.LastLeaf() + if leaf2 == nil { + t.Log("leaves is nil, get last leaf failed as expected") + } + assert.Nil(t, leaf2) +} + +// Add leaf to leaves +func TestLeaves_Add(t *testing.T) { + // Test add leaf + var leaves merkletree.Leaves + leaves.Add(&merkletree.Leaf{}) + leavesLen := leaves.Length() + assert.NotZero(t, leaves.Length()) + + // Test add nil leaf + var nilLeaf *merkletree.Leaf = nil + leaves.Add(nilLeaf) + assert.Equal(t, leavesLen, leaves.Length()) + + var invalidLeaves *merkletree.Leaves + invalidLeaves.Add(&merkletree.Leaf{}) + assert.Zero(t, invalidLeaves.Length()) +} + +// Clone leaves +func TestLeaves_Clone(t *testing.T) { + clone1 := MockLeaves.Clone() + if clone1 == nil { + t.Fatal("clone leaves failed") + } + assert.Equal(t, *clone1, MockLeaves) + + var invalidLeaves *merkletree.Leaves + clone2 := invalidLeaves.Clone() + if clone2 == nil { + t.Log("leaves is nil, clone failed as expected") + } + assert.Nil(t, clone2) +} + +// Get tree height +func TestTree_Height(t *testing.T) { + leaves := MockLeaves + + // Build tree + tree1, _, err := leaves.BuildTree(merkletree.WithHashFunc(GetCustomHashFunc())) + if err != nil { + t.Fatal(err) + } + t.Log("Tree1=", tree1) + + // Test get tree height + height1 := tree1.Height() + if height1 == 0 { + t.Fatal("invalid tree, get tree height failed") + } + assert.NotZero(t, height1) + + // Test invalid tree + var invalidTree1 *merkletree.Tree + height2 := invalidTree1.Height() + if height2 == 0 { + t.Log("tree is nil, get tree height failed as expected") + } + assert.Zero(t, height2) +} + +// Get tree width +func TestTree_Width(t *testing.T) { + leaves := MockLeaves + + // Build tree + tree1, _, err := leaves.BuildTree(merkletree.WithHashFunc(GetCustomHashFunc())) + if err != nil { + t.Fatal(err) + } + t.Log("Tree1=", tree1) + + // Test get tree width + width1 := tree1.Width(0) + if width1 == 0 { + t.Fatal("invalid tree, get tree width failed") + } + assert.NotZero(t, width1) + + // Test invalid tree + var invalidTree1 *merkletree.Tree + width2 := invalidTree1.Width(0) + if width2 == 0 { + t.Log("tree is nil, get tree width failed as expected") + } + assert.Zero(t, width2) + + // Test empty tree + var invalidTree2 merkletree.Tree + width3 := invalidTree2.Width(0) + if width3 == 0 { + t.Log("tree is empty, get tree width failed as expected") + } + assert.Zero(t, width3) +} + +// Get tree Y +func TestTree_Y(t *testing.T) { + leaves := MockLeaves + + // Build tree + tree1, _, err := leaves.BuildTree(merkletree.WithHashFunc(GetCustomHashFunc())) + if err != nil { + t.Fatal(err) + } + t.Log("Tree1=", tree1) + + // Test get Y + y1 := tree1.Y() + if y1 == 0 { + t.Fatal("invalid tree, get Y failed") + } + assert.NotZero(t, y1) + + // Test invalid tree + var invalidTree1 *merkletree.Tree + y2 := invalidTree1.Y() + if y2 == 0 { + t.Log("tree is nil, get Y failed as expected") + } + assert.Zero(t, y2) + + // Test empty tree + var invalidTree2 merkletree.Tree + y3 := invalidTree2.Y() + if y3 == 0 { + t.Log("tree is empty, get Y failed as expected") + } + assert.Zero(t, y3) +} + +// Get tree X +func TestTree_X(t *testing.T) { + leaves := MockLeaves + + // Build tree + tree1, _, err := leaves.BuildTree(merkletree.WithHashFunc(GetCustomHashFunc())) + if err != nil { + t.Fatal(err) + } + t.Log("Tree1=", tree1) + + // Test get X + x1 := tree1.X(0) + if x1 == 0 { + t.Fatal("invalid tree, get X failed") + } + assert.NotZero(t, x1) + + // Test invalid tree + var invalidTree1 *merkletree.Tree + x2 := invalidTree1.X(0) + if x2 == 0 { + t.Log("tree is nil, get X failed as expected") + } + assert.Zero(t, x2) + + // Test empty tree + var invalidTree2 merkletree.Tree + x3 := invalidTree2.X(0) + if x3 == 0 { + t.Log("tree is empty, get X failed as expected") + } + assert.Zero(t, x3) +}