Improve test coverage

.github/workflows/go.yml

@@ -43,4 +43,4 @@ jobs:
       with:
         go-version: 1.18
     - name: Test
-      run: go test -v ./...
+      run: go test -v -race ./...

config_ipa.go

@@ -59,7 +59,7 @@ func (ipac *IPAConfig) CommitToPoly(poly []Fr, _ int) *Point {
 
 var cfg *Config
 
-const precompFileName = "precomp"
+var precompFileName = "precomp"
 
 func GetConfig() *Config {
 	if cfg == nil {

config_ipa_test.go

@@ -0,0 +1,31 @@
+package verkle
+
+import (
+	"os"
+	"testing"
+)
+
+func TestGeneratePrecompFile(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode")
+	}
+	cfg = nil // Side-effects of the package having globals, yuck.
+
+	// Restore the default after this test.
+	defer func(originalPath string) {
+		precompFileName = originalPath
+		cfg = nil
+	}(precompFileName)
+
+	precompFileName = t.TempDir() + "/precomp"
+	if conf := GetConfig(); conf == nil {
+		t.Fatal("GetConfig() returned nil")
+	}
+	stat, err := os.Stat(precompFileName)
+	if err != nil {
+		t.Fatalf("file stat failed: %s", err)
+	}
+	if stat.Size() == 0 {
+		t.Fatal("precomp file is empty")
+	}
+}

debug_test.go

@@ -33,6 +33,7 @@ func TestJSON(t *testing.T) {
 	root := New()
 	root.Insert(zeroKeyTest, fourtyKeyTest, nil)
 	root.Insert(oneKeyTest, zeroKeyTest, nil)
+	root.Insert(forkOneKeyTest, zeroKeyTest, nil) // Force an internal node in the first layer.
 	root.Insert(fourtyKeyTest, oneKeyTest, nil)
 	root.(*InternalNode).children[152] = &HashedNode{commitment: []byte{1, 2, 3, 4}}
 	root.Commit()

doc.go

@@ -28,13 +28,13 @@ package verkle
 import "errors"
 
 var (
-	errInsertIntoHash          = errors.New("trying to insert into hashed node")
-	errDeleteHash              = errors.New("trying to delete from a hashed subtree")
-	errReadFromInvalid         = errors.New("trying to read from an invalid child")
-	errSerializeHashedNode     = errors.New("trying to serialize a hashed internal node")
-	errInsertIntoOtherStem     = errors.New("insert splits a stem where it should not happen")
-	errStatelessAndStatefulMix = errors.New("a stateless node should not be found in a stateful tree")
-	errMissingNodeInStateless  = errors.New("trying to access a node that is missing from the stateless view")
+	errInsertIntoHash         = errors.New("trying to insert into hashed node")
+	errDeleteHash             = errors.New("trying to delete from a hashed subtree")
+	errReadFromInvalid        = errors.New("trying to read from an invalid child")
+	errSerializeHashedNode    = errors.New("trying to serialize a hashed internal node")
+	errInsertIntoOtherStem    = errors.New("insert splits a stem where it should not happen")
+	errUnknownNodeType        = errors.New("unknown node type detected")
+	errMissingNodeInStateless = errors.New("trying to access a node that is missing from the stateless view")
 )
 
 const (

empty_test.go

@@ -44,4 +44,20 @@ func TestEmptyFuncs(t *testing.T) {
 	if v != nil {
 		t.Fatal("non-nil get from empty")
 	}
+
+	if !e.Commitment().Equal(e.Commit()) {
+		t.Fatal("commitment and commit mismatch")
+	}
+
+	if _, _, _, err := e.GetProofItems(nil); err == nil {
+		t.Fatal("get proof items should error")
+	}
+
+	if _, err := e.Serialize(); err == nil {
+		t.Fatal("serialize should error")
+	}
+
+	if !e.Hash().Equal(&FrZero) {
+		t.Fatal("hash should be the zero element")
+	}
 }

encoding_test.go

@@ -22,3 +22,23 @@ func TestLeafStemLength(t *testing.T) {
 		t.Fatalf("invalid serialization when the stem is longer than 31 bytes: %x (%d bytes)", ser, len(ser))
 	}
 }
+
+func TestInvalidNodeEncoding(t *testing.T) {
+	// Test a short payload.
+	if _, err := ParseNode([]byte{leafRLPType}, 0, SerializedPointCompressed{}); err != errSerializedPayloadTooShort {
+		t.Fatalf("invalid error, got %v, expected %v", err, errSerializedPayloadTooShort)
+	}
+
+	// Test an invalid node type.
+	values := make([][]byte, NodeWidth)
+	values[42] = testValue
+	ln := NewLeafNode(ffx32KeyTest, values)
+	lnbytes, err := ln.Serialize()
+	if err != nil {
+		t.Fatalf("serializing leaf node: %v", err)
+	}
+	lnbytes[0] = leafRLPType + internalRLPType // Change the type of the node to something invalid.
+	if _, err := ParseNode(lnbytes, 0, SerializedPointCompressed{}); err != ErrInvalidNodeEncoding {
+		t.Fatalf("invalid error, got %v, expected %v", err, ErrInvalidNodeEncoding)
+	}
+}

hashednode_test.go

@@ -28,9 +28,10 @@ package verkle
 import "testing"
 
 func TestHashedNodeFuncs(t *testing.T) {
-	e := HashedNode{}
+	fakeCommitment := EmptyCodeHashPoint.Bytes()
+	e := HashedNode{commitment: fakeCommitment[:]}
 	err := e.Insert(zeroKeyTest, zeroKeyTest, nil)
-	if err == nil {
+	if err != errInsertIntoHash {
 		t.Fatal("got nil error when inserting into a hashed node")
 	}
 	err = e.Delete(zeroKeyTest, nil)
@@ -44,4 +45,13 @@ func TestHashedNodeFuncs(t *testing.T) {
 	if v != nil {
 		t.Fatal("non-nil get from a hashed node")
 	}
+	if _, _, _, err := e.GetProofItems(nil); err == nil {
+		t.Fatal("got nil error when getting proof items from a hashed node")
+	}
+	if _, err := e.Serialize(); err != errSerializeHashedNode {
+		t.Fatal("got nil error when serializing a hashed node")
+	}
+	if hash := e.Hash(); hash == nil {
+		t.Fatal("got nil hash when hashing a hashed node")
+	}
 }

ipa.go

@@ -58,27 +58,27 @@ func toFrMultiple(res []*Fr, ps []*Point) {
 }
 
 func FromLEBytes(fr *Fr, data []byte) {
+	if len(data) > 32 {
+		panic("data is too long")
+	}
 	var aligned [32]byte
-	copy(aligned[:len(data)], data)
+	copy(aligned[:], data)
 	fr.SetBytesLE(aligned[:])
 }
 
+func StemFromBytes(fr *Fr, data []byte) {
+	if len(data) != StemSize {
+		panic("data length must be StemSize")
+	}
+	FromLEBytes(fr, data)
+}
+
 func FromBytes(fr *Fr, data []byte) {
 	var aligned [32]byte
 	copy(aligned[32-len(data):], data)
 	fr.SetBytes(aligned[:])
 }
 
-func StemFromBytes(fr *Fr, data []byte) {
-	bytes := make([]byte, len(data))
-	copy(bytes, data)
-	fr.SetBytesLE(bytes)
-}
-
 func Equal(self *Point, other *Point) bool {
 	return other.Equal(self)
 }
-
-func Generator() *Point {
-	return new(Point).Identity()
-}

ipa_test.go

@@ -0,0 +1,22 @@
+package verkle
+
+import (
+	"encoding/binary"
+	"math/big"
+	"testing"
+)
+
+func TestFromBytes(t *testing.T) {
+	var fr Fr
+
+	var beFortyTwo [8]byte
+	binary.BigEndian.PutUint64(beFortyTwo[:], 42)
+
+	FromBytes(&fr, beFortyTwo[:])
+
+	bi := big.NewInt(0)
+	if fr.ToBigIntRegular(bi).Int64() != 42 {
+		t.Fatalf("got %v, want 42", bi)
+	}
+
+}