Add full test coverage for the sexp package. Also uncovered a nasty

issue with peek and io.EOF.

Author: olabini

Diff for: .gitignore

@@ -22,3 +22,5 @@ _testmain.go
 *.exe
 *.test
 *.prof
+
+coverage.out

Diff for: sexp/bignum_test.go

@@ -0,0 +1,38 @@
+package sexp
+
+import (
+	"bufio"
+	"bytes"
+	"math/big"
+	"testing"
+)
+
+func Test_BigNum_First_generatesAPanic(t *testing.T) {
+	defer checkForPanic(t, "not valid to call First on a BigNum")
+	NewBigNum("ABCD").First()
+}
+
+func Test_BigNum_Second_generatesAPanic(t *testing.T) {
+	defer checkForPanic(t, "not valid to call Second on a BigNum")
+	NewBigNum("ABCD").Second()
+}
+
+func Test_BigNum_String_generatesAValidRepresentation(t *testing.T) {
+	res := NewBigNum("ABCD").String()
+	assertEquals(t, res, "#ABCD#")
+}
+
+func Test_BigNum_Value_returnsTheBigNumInside(t *testing.T) {
+	res := NewBigNum("ABCD").Value().(*big.Int)
+	assertDeepEquals(t, res, new(big.Int).SetBytes([]byte{0xAB, 0xCD}))
+}
+
+func Test_ReadBigNum_returnsNilIfAskedToReadNonBigNum(t *testing.T) {
+	res := ReadBigNum(bufio.NewReader(bytes.NewReader([]byte(""))))
+	assertEquals(t, res, nil)
+}
+
+func Test_ReadBigNum_returnsNilIfAskedToReadBigNumThatDoesntEndCorrectly(t *testing.T) {
+	res := ReadBigNum(bufio.NewReader(bytes.NewReader([]byte("#ABCD"))))
+	assertEquals(t, res, nil)
+}

Diff for: sexp/cons_test.go

@@ -0,0 +1,37 @@
+package sexp
+
+import (
+	"bufio"
+	"bytes"
+	"testing"
+)
+
+func Test_Cons_First_ReturnsTheFirstElement(t *testing.T) {
+	c := Cons{Sstring("First"), Sstring("Second")}
+	assertEquals(t, c.First(), Sstring("First"))
+}
+
+func Test_Cons_Second_ReturnsTheSecondElement(t *testing.T) {
+	c := Cons{Sstring("First"), Sstring("Second")}
+	assertEquals(t, c.Second(), Sstring("Second"))
+}
+
+func Test_Cons_Value_ReturnsTheFirstElement(t *testing.T) {
+	c := Cons{Sstring("First"), Sstring("Second")}
+	assertEquals(t, c.Value(), Sstring("First"))
+}
+
+func Test_Cons_String_ReturnsTheConsFormatted(t *testing.T) {
+	c := Cons{Sstring("First"), Sstring("Second")}
+	assertEquals(t, c.String(), "(\"First\" . \"Second\")")
+}
+
+func Test_ReadList_returnsNilIfAskedToReadNonList(t *testing.T) {
+	res := ReadList(bufio.NewReader(bytes.NewReader([]byte("a"))))
+	assertEquals(t, res, nil)
+}
+
+func Test_ReadList_returnsNilIfAskedToReadListThatDoesntEndWell(t *testing.T) {
+	res := ReadList(bufio.NewReader(bytes.NewReader([]byte("("))))
+	assertEquals(t, res, nil)
+}

Diff for: sexp/test_helpers.go renamed to sexp/helpers_test.go

@@ -16,3 +16,11 @@ func assertDeepEquals(t *testing.T, actual, expected interface{}) {
 		t.Errorf("Expected %v to equal %v", actual, expected)
 	}
 }
+
+func checkForPanic(t *testing.T, s string) {
+	if r := recover(); r != nil {
+		assertEquals(t, r, s)
+	} else {
+		t.Errorf("Expected panic with message %v to be invoked", s)
+	}
+}

Diff for: sexp/sexp.go

@@ -15,7 +15,9 @@ type Value interface {
 
 func peek(r *bufio.Reader) (c byte, e error) {
 	c, e = r.ReadByte()
-	r.UnreadByte()
+	if e != io.EOF {
+		r.UnreadByte()
+	}
 	return
 }
 

Diff for: sexp/snil_test.go

@@ -0,0 +1,19 @@
+package sexp
+
+import "testing"
+
+func Test_Snil_First_ReturnsItself(t *testing.T) {
+	assertEquals(t, Snil{}, Snil{}.First())
+}
+
+func Test_Snil_Second_ReturnsItself(t *testing.T) {
+	assertEquals(t, Snil{}, Snil{}.Second())
+}
+
+func Test_Snil_Value_ReturnsNil(t *testing.T) {
+	assertEquals(t, nil, Snil{}.Value())
+}
+
+func Test_Snil_String_ReturnsAStringRepresentation(t *testing.T) {
+	assertEquals(t, "()", Snil{}.String())
+}

Diff for: sexp/str_test.go

@@ -0,0 +1,37 @@
+package sexp
+
+import (
+	"bufio"
+	"bytes"
+	"testing"
+)
+
+func Test_Sstring_First_generatesAPanic(t *testing.T) {
+	defer checkForPanic(t, "not valid to call First on an SString")
+	Sstring("ABCD").First()
+}
+
+func Test_Sstring_Second_generatesAPanic(t *testing.T) {
+	defer checkForPanic(t, "not valid to call Second on an SString")
+	Sstring("ABCD").Second()
+}
+
+func Test_Sstring_Value_returnsTheStringRepresentation(t *testing.T) {
+	res := Sstring("ABB").Value()
+	assertDeepEquals(t, res, "ABB")
+}
+
+func Test_Sstring_String_returnsTheStringRepresentation(t *testing.T) {
+	res := Sstring("ABB").String()
+	assertDeepEquals(t, res, "\"ABB\"")
+}
+
+func Test_ReadString_returnsNilIfAskedToReadNonString(t *testing.T) {
+	res := ReadString(bufio.NewReader(bytes.NewReader([]byte("a"))))
+	assertEquals(t, res, nil)
+}
+
+func Test_ReadString_returnsNilIfAskedToReadNonFinishedString(t *testing.T) {
+	res := ReadString(bufio.NewReader(bytes.NewReader([]byte("\"a"))))
+	assertEquals(t, res, nil)
+}

Diff for: sexp/symbol_test.go

@@ -0,0 +1,23 @@
+package sexp
+
+import "testing"
+
+func Test_Symbol_First_generatesAPanic(t *testing.T) {
+	defer checkForPanic(t, "not valid to call First on a Symbol")
+	Symbol("ABCD").First()
+}
+
+func Test_Symbol_Second_generatesAPanic(t *testing.T) {
+	defer checkForPanic(t, "not valid to call Second on a Symbol")
+	Symbol("ABCD").Second()
+}
+
+func Test_Symbol_Value_returnsTheStringRepresentation(t *testing.T) {
+	res := Symbol("ABB").Value()
+	assertDeepEquals(t, res, "ABB")
+}
+
+func Test_Symbol_String_returnsTheStringRepresentation(t *testing.T) {
+	res := Symbol("ABB").String()
+	assertDeepEquals(t, res, "ABB")
+}