Refactor tests

1) Refactor tests to make them easier to extend, also reduce duplicated code.
2) Add one or two additional tests to increase code coverage score.

Author: mramshaw

.gitignore

@@ -1 +1,2 @@
+coverage.html
 coverage.txt

.travis.yml

@@ -7,8 +7,10 @@ go:
   - master
 
 script:
-  - go test -v
-  - go test -race -coverprofile=coverage.txt -covermode=atomic .
+  - make test
+
+notifications:
+  email: false
 
 after_success:
   - bash <(curl -s https://codecov.io/bash)

Makefile

@@ -1,20 +1,24 @@
-GOPATH		:= /go
 GOOS		:= linux
 GOARCH		:= amd64
 
-.PHONY:		run, clean
+.PHONY:		clean
 
 all:		test
 
 # .go files are reformatted to conform to gofmt standards
 fmt:
-		GOPATH=$(GOPATH) GOOS=$(GOOS) GOARCH=$(GOARCH) gofmt -d -e -s -w *.go
+		GOOS=$(GOOS) GOARCH=$(GOARCH) gofmt -d -e -s -w *.go
 
 lint:		fmt
-		GOPATH=$(GOPATH) GOOS=$(GOOS) GOARCH=$(GOARCH) golint -set_exit_status *.go
+		GOOS=$(GOOS) GOARCH=$(GOARCH) golint -set_exit_status *.go
 
 vet:		lint
-		GOPATH=$(GOPATH) GOOS=$(GOOS) GOARCH=$(GOARCH) go tool vet *.go
+		GOOS=$(GOOS) GOARCH=$(GOARCH) go tool vet *.go
 
 test:		vet
-		GOPATH=$(GOPATH) GOOS=$(GOOS) GOARCH=$(GOARCH) go test -v
+		GOOS=$(GOOS) GOARCH=$(GOARCH) go test -race -coverprofile=coverage.txt -covermode=atomic -v .
+		GOOS=$(GOOS) GOARCH=$(GOARCH) go tool cover -html=coverage.txt -o coverage.html
+
+clean:
+		@rm -f coverage.html
+		@rm -f coverage.txt

README.md

@@ -18,15 +18,17 @@ UPDATE: I found this example (also from Wikipedia) that shows an interesting edg
 
 ![Edge_case](https://upload.wikimedia.org/wikipedia/commons/6/63/An_example_of_how_to_find_a_string_in_a_Patricia_trie.png)
 
-It shows that __slow__ can be both a node - and a leaf - at the same time, something which
-I had not considered. Interestingly, my understanding was that the root node of the trie
-(trie apparently comes from _retrieval_ - although I have my doubts about this) was always
-a single character whereas this diagram shows the root node as the entire word `slow`.
+It shows that __slow__ can be both a node - and a leaf - at the same time. This is something
+which I had not considered (another example might be __real__ and __realistic__). Interestingly,
+my understanding was that the root node of the trie (it may - or may not - be true that trie
+comes from _retrieval_) is always a single character whereas this diagram shows the root node
+as the entire word `slow`.
 
 For retrieval purposes I am inclined to persist with using a single character as a root.
 The only practical purpose for a trie that I have been able to find is for search bars
 and the like and being able to respond quickly to that first typed character sounds like
-what I am after.
+what I am after. In the case of __bytes__ this would make it possible to use the initial
+byte as an offset index, although I doubt this would be practical for runes.
 
 ## Motivation
 
@@ -113,6 +115,7 @@ than for system testing.
 ## To Do
 
 - [ ] Investigate applications of Patricia tries
+- [x] Refactor tests to avoid some of the duplicated code
 - [ ] Find out the idiom for stacking __Insert__ and __Find__ tests (avoiding mocks)
 - [ ] Investigate whether byte-based __and__ rune-based options are viable
 - [ ] Find more examples of tries in use - specifically Rune-based CJKV (Chinese, Japanese, Korean, Vietnamese)

node.go

@@ -11,7 +11,7 @@ type Node struct {
 	childCount int
 }
 
-// IsLeaf may be called to determine of the current node is a leaf.
+// IsLeaf may be called to determine if the current node is a leaf.
 func (n *Node) IsLeaf() bool {
 	return n.childCount == 0
 }

trie.go

@@ -13,8 +13,8 @@ type Trie struct {
 }
 
 // NewTrie is used to create a new radix trie.
-func NewTrie() *Trie {
-	return &Trie{}
+func NewTrie() Trie {
+	return Trie{}
 }
 
 // Count returns the number of nodes in the trie.
@@ -111,7 +111,7 @@ func (t *Trie) Find(s string) (bool, *Node) {
 	trimmed := strings.TrimSpace(s)
 
 	// Sanity check (should catch empty strings too)
-	if len(s) < 2 {
+	if len(trimmed) < 2 {
 		return false, nil
 	}