linkedlist implementation (#7)

* adding gitignore

* initial structure

* added test and src dirs

* Implemented CRUD methods linkedList
Closing #3

* increasing coverage

* update gitignore

Author: neelkshah

.gitignore

@@ -12,4 +12,7 @@
 *.out
 
 # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
-.glide/
+.glide/
+
+# Dev runner files
+cmd/runner/*

cmd/runner/main.go

@@ -0,0 +1,8 @@
+// Author: Neel Shah, 2020
+// linkedlist_config.go contains the config variables for the linked-list ADT
+// to be used as part of the hash table ADT.
+
+package config
+
+// NODEFATNESS determines the number of valueNode instances contained in a single linkedListNode instance.
+var NODEFATNESS = 512

config/linkedlist_config.go

@@ -0,0 +1,19 @@
+### Little pointers
+
+* Create a subdirectory under `pkg` for each new package.
+* Visibility and scope are based on packages as a unit, so organize code accordingly.
+* Split a package into files for readability and maintainability.
+* Identifiers having capitalized names are visible outside the package. This can be as low-grained as individual fields in a `struct`. 
+* All global variables and configurations will go into their respective files in the `config` package.
+* In Go, tests are not different from regular code. Rules of visibility apply to test code too. So low-level unit tests are present in a separate file within the package itself.
+* End-to-end test cases can be placed in a separate `test` package. This will help organize test code better, and make profiling and benchmarking easier; whatever profiling has to be done can be done within the `test` package.
+
+### A primer for writing unit tests
+
+(Check the `pkg\linkedlist\linkedlist_test.go` file for reference)
+* Name the file ending in `_test.go`
+* Import the `testing` package.
+* Write a separate function for each test.
+* Unit tests follow the arrange, act, assert layout. First, arrange all the local variables needed (parameters, connectors, configs, etc). Then execute the action that is being tested. Finally, assert the correctness of the outcome. Don't forget to clean up after a test (file descriptors, slices, connectors, etc).
+* Assertion of correctness has to be complete - for example, in the case of the linkedlist, we have verified the number of elements, null fields, the actual values and so on.
+* In VS Code, you can check code coverage by pressing `Ctrl+Shift+P` and selecting `Go: Toggle test coverage in current package`. It highlights the code by test coverage. Please make sure you cover as much code as possible. This includes constructors and CRUD methods especially, since those are often the source of memory leaks and null errors and the like. Print functions are difficult to cover and can be avoided.

docs/meta2.md

@@ -0,0 +1,16 @@
+package helper
+
+import "encoding/binary"
+
+// IntToByte takes a uint64 value and converts it into a little endian byte array.
+func IntToByte(value uint64) []byte {
+	arr := make([]byte, 8)
+	binary.LittleEndian.PutUint64(arr, value)
+	return arr
+}
+
+// ByteToInt takes a little endian byte array and converts it into a uint64 value.
+func ByteToInt(arr []byte) uint64 {
+	value := binary.LittleEndian.Uint64(arr[0:])
+	return value
+}

pkg/helper/converter.go

@@ -0,0 +1,105 @@
+// Author: Neel Shah, 2020
+// linkedlist.go contains the CRUD methods for the linked-list ADT
+// to be used as part of the hash table ADT.
+
+package linkedlist
+
+import (
+	"bytes"
+
+	"github.com/neelkshah/pandora/config"
+)
+
+// LinkedList is the data structure used for the hash table.
+type LinkedList struct {
+	head  *linkedListNode
+	tail  *linkedListNode
+	count int
+}
+
+// linkedListNode is the data structure that forms the LinkedList.
+type linkedListNode struct {
+	values   []valueNode
+	nextNode *linkedListNode
+}
+
+// valueNode contains a single value to be stored in the LinkedList.
+type valueNode struct {
+	key   []byte
+	value []byte
+}
+
+// CreateLinkedList returns a pointer to a new empty linked list instance.
+func CreateLinkedList() *LinkedList {
+	linkedList := LinkedList{head: nil, tail: nil, count: 0}
+	return &linkedList
+}
+
+// Append appends a given value to the end of the referenced LinkedList instance.
+func (linkedList *LinkedList) Append(key []byte, value []byte) {
+	var newValue = valueNode{key: key, value: value}
+	if linkedList.count == 0 {
+		var newNode = linkedListNode{values: []valueNode{newValue}, nextNode: nil}
+		linkedList.head = &newNode
+		linkedList.tail = &newNode
+		linkedList.count = 1
+		return
+	}
+	var tailNode = linkedList.tail
+	if len(tailNode.values) < config.NODEFATNESS {
+		tailNode.values = append(tailNode.values, newValue)
+	} else {
+		var newNode = linkedListNode{values: []valueNode{newValue}, nextNode: nil}
+		tailNode.nextNode = &newNode
+		linkedList.tail = &newNode
+	}
+	linkedList.count++
+}
+
+// Get returns the values associate with the key.
+func (linkedList *LinkedList) Get(key []byte) ([][]byte, bool) {
+	if linkedList == nil || linkedList.head == nil {
+		return nil, true
+	}
+	var currentNode = linkedList.head
+	var result = make([][]byte, 0)
+	for {
+		if currentNode == nil {
+			break
+		}
+		for _, vnode := range (*currentNode).values {
+			if bytes.Equal(vnode.key, key) {
+				result = append(result, vnode.value)
+			}
+		}
+		currentNode = currentNode.nextNode
+	}
+	return result, false
+}
+
+// Delete deletes all key-value pairs having the key passed as parameter.
+// It returns the number of deleted pairs and a bool indicating occurrence of an error.
+func (linkedList *LinkedList) Delete(key []byte) (int, bool) {
+	if linkedList == nil || linkedList.head == nil {
+		return 0, true
+	}
+	var currentNode = linkedList.head
+	var count = 0
+	var k = 0
+	for {
+		if currentNode == nil {
+			break
+		}
+		for _, vnode := range (*currentNode).values {
+			if !bytes.Equal(vnode.key, key) {
+				(*currentNode).values[k] = vnode
+				k++
+				continue
+			}
+			count++
+		}
+		(*currentNode).values = (*currentNode).values[:k]
+		currentNode = currentNode.nextNode
+	}
+	return count, false
+}

pkg/linkedlist/linkedlist.go

@@ -0,0 +1,113 @@
+// Author: Neel Shah, 2020
+// linkedlist_test.go contains unit tests for the CRUD methods for the linked-list ADT
+// to be used as part of the hash table ADT.
+
+package linkedlist
+
+import (
+	"bytes"
+	"math/rand"
+	"testing"
+
+	"github.com/neelkshah/pandora/pkg/helper"
+
+	"github.com/neelkshah/pandora/config"
+)
+
+// Test create function.
+func TestCreateLinkedList(t *testing.T) {
+	var response = *CreateLinkedList()
+	if response.head != nil || response.tail != nil || response.count != 0 {
+		t.Fail()
+	}
+}
+
+// Test append function for single value append.
+func TestAppend(t *testing.T) {
+	var response = *CreateLinkedList()
+	response.Append([]byte("a"), helper.IntToByte(5))
+	if response.head == nil ||
+		response.tail == nil ||
+		response.count != 1 ||
+		response.head != response.tail ||
+		helper.ByteToInt(response.head.values[0].value) != 5 ||
+		len(response.head.values) != 1 {
+		t.Fail()
+	}
+}
+
+// Test whether fatness is maintained during append.
+func TestFatness(t *testing.T) {
+	var response = CreateLinkedList()
+	var N = 3 * config.NODEFATNESS
+	for i := 1; i <= N; i++ {
+		var key = helper.IntToByte(rand.Uint64())
+		var value = helper.IntToByte(rand.Uint64())
+		response.Append(key, value)
+	}
+	var responselist = *response
+	if (responselist).count != 3*config.NODEFATNESS ||
+		responselist.head == responselist.tail ||
+		responselist.head == nil ||
+		responselist.tail == nil {
+		t.Fail()
+	}
+	var currentNode = *responselist.head
+	for {
+		if len(currentNode.values) != config.NODEFATNESS {
+			t.Fail()
+		}
+		if currentNode.nextNode == nil {
+			return
+		}
+		currentNode = *currentNode.nextNode
+	}
+}
+
+// Test get
+func TestGet(t *testing.T) {
+	var response = CreateLinkedList()
+	response.Append(helper.IntToByte(5), helper.IntToByte(7))
+	if result, isEmpty := response.Get(helper.IntToByte(5)); isEmpty == true || !bytes.Equal(result[0], helper.IntToByte(7)) {
+		t.Fail()
+	}
+	if result, isEmpty := response.Get(helper.IntToByte(7)); isEmpty == true || len(result) != 0 {
+		t.Fail()
+	}
+}
+
+// Test get behaviour for an empty LinkedList instance
+func TestGetNilValidation(t *testing.T) {
+	var response = CreateLinkedList()
+	if result, isEmpty := response.Get(helper.IntToByte(5)); isEmpty == false || result != nil {
+		t.Fail()
+	}
+}
+
+// Test delete behaviour for an empty LinkedList instance
+func TestDeleteNilValidation(t *testing.T) {
+	var response = CreateLinkedList()
+	if count, isEmpty := response.Delete(helper.IntToByte(5)); isEmpty == false || count != 0 {
+		t.Fail()
+	}
+}
+
+// Test deletion
+func TestDelete(t *testing.T) {
+	var response = CreateLinkedList()
+	for i := 1; i <= 5; i++ {
+		var key = helper.IntToByte(rand.Uint64())
+		var value = helper.IntToByte(rand.Uint64())
+		response.Append(key, value)
+	}
+	response.Append(helper.IntToByte(5), helper.IntToByte(7))
+	for i := 1; i <= 5; i++ {
+		var key = helper.IntToByte(rand.Uint64())
+		var value = helper.IntToByte(rand.Uint64())
+		response.Append(key, value)
+	}
+
+	if count, status := response.Delete(helper.IntToByte(5)); count < 1 || status == true {
+		t.Fail()
+	}
+}

pkg/linkedlist/linkedlist_test.go

@@ -0,0 +1,19 @@
+package linkedlist
+
+import "fmt"
+
+// Print prints the contents of a LinkedList instance.
+func (linkedList *LinkedList) Print() {
+	fmt.Printf("Count of elements: %v\n", linkedList.count)
+	var currentNode = *linkedList.head
+	for {
+		for _, element := range currentNode.values {
+			fmt.Printf("%v, %v\t", element.key, element.value)
+		}
+		if currentNode.nextNode == nil {
+			return
+		}
+		currentNode = *currentNode.nextNode
+		fmt.Println()
+	}
+}

pkg/linkedlist/printer.go

@@ -1,15 +1,47 @@
+// Author: Neel Shah, 2020
+// linkedlist_test.go contains E2E tests for the CRUD methods for the linked-list ADT
+// to be used as part of the hash table ADT.
+
 package test
 
 import (
+	"math/rand"
 	"testing"
 
+	"github.com/neelkshah/pandora/pkg/helper"
 	"github.com/neelkshah/pandora/pkg/linkedlist"
 )
 
-func TestFiver(t *testing.T) {
-	var response = linkedlist.Fiver()
+func TestCreateLinkedList(t *testing.T) {
+	var response = linkedlist.CreateLinkedList()
+	if response == nil {
+		t.Fail()
+	}
+}
+
+func BenchmarkAppend(b *testing.B) {
+	var response = linkedlist.CreateLinkedList()
+	for i := 0; i < b.N; i++ {
+		var key = helper.IntToByte(rand.Uint64())
+		var value = helper.IntToByte(rand.Uint64())
+		response.Append(key, value)
+	}
+}
+
+func BenchmarkGet(b *testing.B) {
+	var response = populatedList()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		response.Get(helper.IntToByte(rand.Uint64()))
+	}
+}
 
-	if response != 5 {
-		t.Errorf("Expected value 5, got %v", response)
+func populatedList() *(linkedlist.LinkedList) {
+	var response = linkedlist.CreateLinkedList()
+	for i := 0; i < 10; i++ {
+		var key = helper.IntToByte(rand.Uint64())
+		var value = helper.IntToByte(rand.Uint64())
+		response.Append(key, value)
 	}
+	return response
 }