tests and coverage

go/src/flow/internal/check/check.go

@@ -18,14 +18,16 @@ type Checker struct {
 
 //NotErr check for error
 func (t Checker) NotErr(err error) {
-	msg := fmt.Sprintf("Checking for error: %v", err)
+	msg := fmt.Sprintf("NOTERR Expect NOT [error] got '%v'", err)
 	if err != nil {
 		t.fail(msg)
 	}
 	t.pass(msg)
 }
+
+// Err expects param to be error
 func (t Checker) Err(err error) {
-	msg := fmt.Sprintf("Checking for error: %v", err)
+	msg := fmt.Sprintf("ERR: Expect [error] got '%v'", err)
 	if err == nil {
 		t.fail(msg)
 	}
@@ -34,7 +36,7 @@ func (t Checker) Err(err error) {
 
 //Eq check if equal
 func (t Checker) Eq(a, b interface{}) {
-	msg := fmt.Sprintf("Expect '%v' got '%v'", a, b)
+	msg := fmt.Sprintf("EQ Expect '%v' got '%v'", b, a)
 	if !reflect.DeepEqual(a, b) {
 		t.fail(msg)
 	}
@@ -43,12 +45,23 @@ func (t Checker) Eq(a, b interface{}) {
 
 //Diff check if different
 func (t Checker) Diff(a, b interface{}) {
-	msg := fmt.Sprintf("Expect NOT '%v' got '%v'", a, b)
+	msg := fmt.Sprintf("DIFF Expect NOT '%v' got '%v'", a, b)
+
 	if reflect.DeepEqual(a, b) {
 		t.fail(msg)
 	}
 	t.pass(msg)
 }
+
+// NotNil expect param to be non nil
+func (t Checker) NotNil(a interface{}) {
+	msg := fmt.Sprintf("NOTNIL Expect NOT [nil] got %v", a)
+	if a == nil {
+		t.fail(msg)
+	}
+	t.pass(msg)
+}
+
 func (t Checker) fail(msg string) {
 	t.Fatalf("\033[31m[FAIL] %s\033[0m", msg)
 }

go/src/flow/registry/entry_test.go

@@ -6,27 +6,13 @@ import (
 	"testing"
 )
 
-func TestNewEntry(t *testing.T) {
+func TestNewEntryInvalid(t *testing.T) {
 	exp := Expect(t)
 	e := registry.NewEntry("string")
-	exp.Err(e.Err())
-
+	exp.Eq(e.Err(), registry.ErrNotAFunc)
 }
-
-func TestRegister(t *testing.T) {
+func TestNewEntryValid(t *testing.T) {
 	exp := Expect(t)
-	r := registry.New()
-	{
-		e := r.Register("func", func(a, b int) int { return 0 })
-		exp.NotErr(e.Err())
-	}
-	{
-		e := r.Register("func", func(a int) int { return 0 })
-		exp.NotErr(e.Err())
-	}
-	{
-		e := r.Register("func", func(a int) {})
-		exp.Err(e.Err())
-	}
-
+	e := registry.NewEntry(func(a int) int { return 0 })
+	exp.NotErr(e.Err())
 }

go/src/flow/registry/registry.go

@@ -1,7 +1,6 @@
 package registry
 
 import (
-	"fmt"
 	"reflect"
 )
 
@@ -40,20 +39,23 @@ func (r *Registry) Register(name string, v interface{}) *Entry {
 func (r *Registry) Get(name string, params ...interface{}) (interface{}, error) {
 	e, ok := r.data[name]
 	if !ok {
-		return nil, fmt.Errorf("Entry '%s' not found", name)
+		return nil, ErrNotFound
 	}
 	v := e.fn
 	// We already know this is a function
 	// and that returns 1 or more values
+
 	vtyp := reflect.TypeOf(v)
-	if vtyp.Out(0).Kind() == reflect.Func {
-		fparam := make([]reflect.Value, len(params))
-		for i := range params {
-			fparam[i] = reflect.ValueOf(params[i])
-		}
-		// Call the func and return the thing
-		v = reflect.ValueOf(v).Call(fparam)[0].Interface()
+	if vtyp.Out(0).Kind() != reflect.Func {
+		return v, nil
+	}
+	// Constructor
+	fparam := make([]reflect.Value, len(params))
+	for i := range params {
+		fparam[i] = reflect.ValueOf(params[i])
 	}
+	// Call the func and return the thing
+	v = reflect.ValueOf(v).Call(fparam)[0].Interface()
 
 	return v, nil
 }

go/src/flow/registry/registry_test.go

@@ -7,19 +7,6 @@ import (
 	. "flow/internal/check"
 )
 
-func TestRegistryGet(t *testing.T) {
-	expect := Expect(t)
-
-	r := registry.New()
-	r.Register("vecadd", dummy1)
-
-	fn, err := r.Get("vecadd")
-
-	expect.NotErr(err)
-	expect.Diff(nil, fn)
-
-}
-
 func TestRegistry(t *testing.T) {
 	expect := Expect(t)
 
@@ -37,6 +24,104 @@ func TestRegistry(t *testing.T) {
 	t.Log(d)
 
 }
+
+func TestEntry(t *testing.T) {
+	exp := Expect(t)
+	r := registry.New()
+	e, err := r.Entry("bogus")
+	exp.Err(err)
+	exp.Eq(e, nil)
+
+}
+
+func TestRegister(t *testing.T) {
+	exp := Expect(t)
+	r := registry.New()
+	e := r.Register("func", func(a, b int) int { return 0 })
+	exp.NotErr(e.Err())
+}
+func TestRegisterDuplicate(t *testing.T) {
+	exp := Expect(t)
+	r := registry.New()
+	r.Register("func", func(a, b int) int { return 0 })
+	e := r.Register("func", func(b int) int { return 0 })
+	exp.NotErr(e.Err())
+}
+func TestRegisterInvalidOutput(t *testing.T) {
+	exp := Expect(t)
+	r := registry.New()
+	e := r.Register("func", func(a int) {})
+	exp.Eq(e.Err(), registry.ErrOutput)
+}
+
+func TestRegisterInvalidInput(t *testing.T) {
+	exp := Expect(t)
+	r := registry.New()
+	e := r.Register("func", func() int { return 0 })
+
+	exp.NotErr(e.Err())
+}
+
+func TestRegistryGet(t *testing.T) {
+	exp := Expect(t)
+	r := registry.New()
+	e := r.Register("func", func() int { return 0 })
+	exp.NotErr(e.Err())
+
+	fn, err := r.Get("func")
+	exp.NotErr(err)
+	exp.NotNil(fn)
+}
+
+func TestRegistryGetEmpty(t *testing.T) {
+	exp := Expect(t)
+	r := registry.New()
+	fn, err := r.Get("notfoundfunc")
+	exp.Eq(err, registry.ErrNotFound)
+	exp.Eq(fn, nil)
+}
+func TestRegistryGetConstructor(t *testing.T) {
+	exp := Expect(t)
+	r := registry.New()
+	e := r.Register("func", func() func() int {
+		return func() int {
+			return 0
+		}
+	})
+	exp.NotErr(e.Err())
+
+	ifn, err := r.Get("func")
+	exp.NotErr(err)
+
+	fn, ok := ifn.(func() int)
+	exp.Eq(ok, true)
+
+	ret := fn()
+	exp.Eq(ret, 0)
+
+}
+func TestRegistryGetConstructorParam(t *testing.T) {
+	exp := Expect(t)
+	r := registry.New()
+
+	e := r.Register("func2", func(a, b int) func() int {
+		return func() int {
+			return a + b
+		}
+	})
+	exp.NotErr(e.Err())
+	ifn, err := r.Get("func2", 1, 1)
+	exp.NotErr(err)
+	exp.NotNil(ifn)
+
+	fn, ok := ifn.(func() int)
+	exp.Eq(ok, true)
+
+	ret := fn()
+	exp.Eq(ret, 2)
+
+}
+
 func TestDescriptions(t *testing.T) {
 	expect := Expect(t)
 
@@ -46,7 +131,7 @@ func TestDescriptions(t *testing.T) {
 
 	d, err := r.Descriptions()
 	expect.NotErr(err)
-	expect.Eq(2, len(d))
+	expect.Eq(len(d), 2)
 
 	t.Log(d)