gocat

types.go

@@ -1,4 +1,4 @@
-package main
+package gocat
 
-func main() {
+func gocat() {
 }

types_test.go

@@ -1,33 +1,30 @@
-package main
+package gocat
 
 import (
-	// "../listdict"
-	"fmt"
+	"github.com/stretchr/testify/assert"
 	"reflect"
 	"testing"
 )
 
-func assert_equal(expected, got interface{}) {
-	if expected != got {
-		fmt.Printf("Expected: %v\n     Got: %v\n", expected, got)
-		panic("not equal")
-	}
+func TestGocat(t *testing.T) {
+	gocat()
+	assert.Equal(t, nil, nil)
 }
 
 func TestInt(t *testing.T) {
-	assert_equal(3, 1+2)
-	assert_equal("int", reflect.TypeOf(2).String())
+	assert.Equal(t, 3, 1+2)
+	assert.Equal(t, "int", reflect.TypeOf(2).String())
 }
 
 func TestFloat(t *testing.T) {
-	assert_equal(3.14, 3.14)
-	assert_equal("float64", reflect.TypeOf(3.14).String())
-	assert_equal(true, 0.1 > 0)
+	assert.Equal(t, 3.14, 3.14)
+	assert.Equal(t, "float64", reflect.TypeOf(3.14).String())
+	assert.Equal(t, true, 0.1 > 0)
 }
 
 func TestString(t *testing.T) {
-	assert_equal("abc", "abc")
-	assert_equal("string", reflect.TypeOf("abc").String())
+	assert.Equal(t, "abc", "abc")
+	assert.Equal(t, "string", reflect.TypeOf("abc").String())
 }
 
 func TestArray(t *testing.T) {
@@ -36,39 +33,32 @@ func TestArray(t *testing.T) {
 		1,
 		3.14,
 	}
-	assert_equal("zero", a[0])
-	assert_equal(1, a[1])
-	assert_equal(3.14, a[2])
-	assert_equal("[]interface {}", reflect.TypeOf(a).String())
+	assert.Equal(t, "zero", a[0])
+	assert.Equal(t, 1, a[1])
+	assert.Equal(t, 3.14, a[2])
+	assert.Equal(t, "[]interface {}", reflect.TypeOf(a).String())
 }
 
 func TestMultiDimensionalArray(t *testing.T) {
 	var a = [][]string{
 		[]string{"a", "b", "c"},
 	}
-	assert_equal("a", a[0][0])
-	assert_equal("b", a[0][1])
-	assert_equal("c", a[0][2])
+	assert.Equal(t, "a", a[0][0])
+	assert.Equal(t, "b", a[0][1])
+	assert.Equal(t, "c", a[0][2])
 }
 
-// func TestDict(t *testing.T) {
-// 	var d = listdict.Dict{"one": 1, "two": 2}
-// 	assert_equal(1, d["one"])
-// 	assert_equal(2, d["two"])
-// 	assert_equal("listdict.Dict", reflect.TypeOf(d).String())
-// }
-
 func TestStruct(t *testing.T) {
 	type ABC struct {
 		v interface{}
 	}
 	var a = ABC{}
 	var b = ABC{"A"}
 	var c = ABC{1}
-	assert_equal(nil, a.v)
-	assert_equal("A", b.v)
-	assert_equal(1, c.v)
-	assert_equal("main.ABC", reflect.TypeOf(a).String())
-	assert_equal("main.ABC", reflect.TypeOf(b).String())
-	assert_equal("main.ABC", reflect.TypeOf(c).String())
+	assert.Equal(t, nil, a.v)
+	assert.Equal(t, "A", b.v)
+	assert.Equal(t, 1, c.v)
+	assert.Equal(t, "gocat.ABC", reflect.TypeOf(a).String())
+	assert.Equal(t, "gocat.ABC", reflect.TypeOf(b).String())
+	assert.Equal(t, "gocat.ABC", reflect.TypeOf(c).String())
 }