sharding: Fix tests and clean up(ethereum#92)

Author: nisdas

sharding/collation.go

@@ -118,7 +118,10 @@ func (c *Collation) CalculateChunkRoot() {
 // Serialize method  serializes the collation body
 func (c *Collation) Serialize() ([]byte, error) {
 
-	blob := utils.ConvertToInterface(c.transactions)
+	blob, err := utils.ConvertToRawBlob(c.transactions)
+	if err != nil {
+		return nil, fmt.Errorf("%v", err)
+	}
 
 	serializedtx, err := utils.Serialize(blob)
 

sharding/collation_test.go

@@ -27,6 +27,9 @@ func TestCollation_Transactions(t *testing.T) {
 	}
 }
 
+//TODO: Add test for converting *types.Transaction into raw blobs
+
+//Tests thta Transactions can be serialised
 func TestSerialize(t *testing.T) {
 	tests := []struct {
 		transactions []*types.Transaction
@@ -51,7 +54,7 @@ func TestSerialize(t *testing.T) {
 
 		results, err := c.Serialize()
 		if err != nil {
-			t.Fatalf("%v ----%v---%v", err, results, c.transactions)
+			t.Fatalf("%v\n %v\n %v", err, results, c.transactions)
 		}
 
 	}

sharding/utils/marshal.go

@@ -1,9 +1,7 @@
 package utils
 
 import (
-	"errors"
 	"fmt"
-	"reflect"
 )
 
 var (
@@ -12,16 +10,20 @@ var (
 	chunkDataSize = chunkSize - indicatorSize
 )
 
+// Flags to add to chunk delimiter.
 type Flags struct {
 	skipEvmExecution bool
 }
 
+// RawBlob type which will contain flags and data for serialization.
 type RawBlob struct {
 	flags Flags
 	data  []byte
 }
 
-// ConvertInterface converts inputted interface to the required type of interface, ex: slice.
+/*
+* Might be needed in part 2 of serialisation
+* ConvertInterface converts inputted interface to the required type of interface, ex: slice.
 func ConvertInterfacetoBytes(arg interface{}) ([]byte, error) {
 	val := reflect.ValueOf(arg)
 	if val.Kind() == reflect.Slice {
@@ -39,26 +41,12 @@ func ConvertInterfacetoBytes(arg interface{}) ([]byte, error) {
 	return nil, err
 
 }
+*/
 
-func convertbyteToInterface(arg []byte) []interface{} {
-	length := int64(len(arg))
-	newtype := make([]interface{}, length)
-	for i, v := range arg {
-		newtype[i] = v
-	}
-
-	return newtype
-}
-
-func ConvertToInterface(arg interface{}) []interface{} {
-	val := reflect.ValueOf(arg)
-	length := val.Len()
-	newtype := make([]interface{}, length)
-	for i := 0; i < length; i++ {
-		newtype[i] = val.Index(i)
-	}
-
-	return newtype
+// ConvertToRawBlob will convert any supported type into a the RawBlob type.
+func ConvertToRawBlob(arg interface{}) ([]RawBlob, error) {
+	//TODO: will be done in part 2 to convert any type to a rawBlob
+	return nil, nil
 }
 
 // serializeBlob parses the blob and serializes it appropriately.
@@ -148,9 +136,6 @@ func serializeBlob(cb RawBlob) ([]byte, error) {
 func Serialize(rawblobs []RawBlob) ([]byte, error) {
 	length := int64(len(rawblobs))
 
-	if length == 0 {
-		return nil, fmt.Errorf("Validation failed: Collation Body has to be a non-zero value")
-	}
 	serialisedData := []byte{}
 
 	//Loops through all the blobs and serializes them into chunks
@@ -168,9 +153,9 @@ func Serialize(rawblobs []RawBlob) ([]byte, error) {
 }
 
 // Deserialize results in the byte array being deserialised and separated into its respective interfaces.
-func Deserialize(collationbody []byte) ([]RawBlob, error) {
+func Deserialize(data []byte) ([]RawBlob, error) {
 
-	length := int64(len(collationbody))
+	length := int64(len(data))
 	chunksNumber := length / chunkSize
 	indicatorByte := byte(0)
 	tempbody := RawBlob{}
@@ -182,28 +167,28 @@ func Deserialize(collationbody []byte) ([]RawBlob, error) {
 
 		// Tests if the chunk delimiter is zero, if it is it will append the data chunk
 		// to tempbody
-		if collationbody[indicatorIndex] == indicatorByte || collationbody[indicatorIndex] == byte(128) {
-			tempbody.data = append(tempbody.data, collationbody[(indicatorIndex+1):(i)*chunkSize]...)
+		if data[indicatorIndex] == indicatorByte || data[indicatorIndex] == byte(128) {
+			tempbody.data = append(tempbody.data, data[(indicatorIndex+1):(i)*chunkSize]...)
 
-		} else if collationbody[indicatorIndex] == byte(31) || collationbody[indicatorIndex] == byte(159) {
-			if collationbody[indicatorIndex] == byte(159) {
+		} else if data[indicatorIndex] == byte(31) || data[indicatorIndex] == byte(159) {
+			if data[indicatorIndex] == byte(159) {
 				tempbody.flags.skipEvmExecution = true
 			}
-			tempbody.data = append(tempbody.data, collationbody[(indicatorIndex+1)])
+			tempbody.data = append(tempbody.data, data[(indicatorIndex+1):indicatorIndex+1+chunkDataSize]...)
 			deserializedblob = append(deserializedblob, tempbody)
 			tempbody = RawBlob{}
 
 		} else {
 			// Since the chunk delimiter in non-zero now we can infer that it is a terminal chunk and
 			// add it and append to the deserializedblob slice. The tempbody signifies a single deserialized blob
-			terminalIndex := int64(collationbody[indicatorIndex])
+			terminalIndex := int64(data[indicatorIndex])
 			//Check if EVM flag is equal to 1
-			flagindex := collationbody[indicatorIndex] >> 7
+			flagindex := data[indicatorIndex] >> 7
 			if flagindex == byte(1) {
-				terminalIndex = int64(collationbody[indicatorIndex]) - 128
+				terminalIndex = int64(data[indicatorIndex]) - 128
 				tempbody.flags.skipEvmExecution = true
 			}
-			tempbody.data = append(tempbody.data, collationbody[(indicatorIndex+1):(indicatorIndex+1+terminalIndex)]...)
+			tempbody.data = append(tempbody.data, data[(indicatorIndex+1):(indicatorIndex+1+terminalIndex)]...)
 			deserializedblob = append(deserializedblob, tempbody)
 			tempbody = RawBlob{}
 

sharding/utils/marshal_test.go

@@ -48,44 +48,49 @@ func TestConvertInterface(t *testing.T) {
 
 } */
 func TestSize(t *testing.T) {
-	size := int64(8)
-	blob := buildrawblob(size)
-	chunksafterSerialize := size / chunkDataSize
-	terminalchunk := size % chunkDataSize
-	if terminalchunk != 0 {
-		chunksafterSerialize = chunksafterSerialize + 1
-	}
-	chunksafterSerialize = chunksafterSerialize * size
-	sizeafterSerialize := chunksafterSerialize * chunkSize
-	serializedblob, err := Serialize(blob)
-	if err != nil {
-		t.Fatalf("Error Serializing blob:%v %v", err, serializedblob)
-	}
+	for i := 0; i < 300; i++ {
+		size := int64(i)
+		blob := buildrawblob(size)
+		chunksafterSerialize := size / chunkDataSize
+		terminalchunk := size % chunkDataSize
+		if terminalchunk != 0 {
+			chunksafterSerialize = chunksafterSerialize + 1
+		}
+		chunksafterSerialize = chunksafterSerialize * size
+		sizeafterSerialize := chunksafterSerialize * chunkSize
+		serializedblob, err := Serialize(blob)
+		if err != nil {
+			t.Errorf("Error Serializing blob:%v\n %v", err, serializedblob)
+		}
 
-	if int64(len(serializedblob)) != sizeafterSerialize {
+		if int64(len(serializedblob)) != sizeafterSerialize {
 
-		t.Fatalf("Error Serializing blobs the lengths are not the same: %v , %v", int64(len(serializedblob)), sizeafterSerialize)
+			t.Errorf("Error Serializing blobs the lengths are not the same:\n %d \n %d", int64(len(serializedblob)), sizeafterSerialize)
 
+		}
 	}
 
 }
 func TestSerializeAndDeserializeblob(t *testing.T) {
 
-	blob := buildrawblob(330)
+	for i := 1; i < 300; i++ {
 
-	serializedblob, err := Serialize(blob)
+		blob := buildrawblob(int64(i))
 
-	if err != nil {
-		t.Fatalf("Error Serializing blob:%v %v", err, serializedblob)
-	}
-	raw, err2 := Deserialize(serializedblob)
-	if err2 != nil {
-		t.Fatalf("Error Serializing blob:%v due to %v", raw, err2)
-	}
+		serializedblob, err := Serialize(blob)
+
+		if err != nil {
+			t.Errorf("Error Serializing blob at index %d:\n%v\n%v", i, err, serializedblob)
+		}
+		raw, err2 := Deserialize(serializedblob)
+		if err2 != nil {
+			t.Errorf("Error Serializing blob at index %d:\n%v due to \n%v", i, raw, err2)
+		}
 
-	if !reflect.DeepEqual(blob, raw) {
+		if !reflect.DeepEqual(blob, raw) {
 
-		t.Fatalf("Error Serializing blobs, the serialized and deserialized versions are not the same:\n\n %v \n\n %v \n\n %v", blob, serializedblob, raw)
+			t.Errorf("Error Serializing blobs at index %d, the serialized and deserialized versions are not the same:\n\n %v \n\n %v \n\n %v", i, blob, serializedblob, raw)
+		}
 	}
 
 }