Fixes a bug in Equal()

This fixes a bug in theEqual and NotEqual functions in how it deals with
integers in private structures. Before it could panic where not it
handles the properly.

This also adds a function for checking that a returned error contains
a given string message in its Error() output.

equal.go

@@ -334,9 +334,76 @@ func (t *T) deepEqual(
 			}
 		}
 
+	case reflect.Bool:
+		haveBool := have.Bool()
+		wantBool := want.Bool()
+		if haveBool != wantBool {
+			return []string{
+				fmt.Sprintf("%s: not equal.", desc),
+				fmt.Sprintf("  have: bool(%s)\n", haveBool),
+				fmt.Sprintf("  want: bool(%s)\n", wantBool),
+			}
+		}
+
+	case reflect.Int:
+		fallthrough
+	case reflect.Int8:
+		fallthrough
+	case reflect.Int16:
+		fallthrough
+	case reflect.Int32:
+		fallthrough
+	case reflect.Int64:
+	// Basic integer types.
+		haveInt := have.Int()
+		wantInt := want.Int()
+		if haveInt != wantInt {
+			return []string{
+				fmt.Sprintf("%s: not equal", desc),
+				fmt.Sprintf("  have: %s(%i)\n", have.Type(), haveInt),
+				fmt.Sprintf("  want: %s(%i)\n", want.Type(), wantInt),
+			}
+		}
+
+	case reflect.Uint:
+		fallthrough
+	case reflect.Uint8:
+		fallthrough
+	case reflect.Uint16:
+		fallthrough
+	case reflect.Uint32:
+		fallthrough
+	case reflect.Uint64:
+	// Basic unsigned integer types.
+		haveUint := have.Uint()
+		wantUint := want.Uint()
+		if haveUint != wantUint {
+			return []string{
+				fmt.Sprintf("%s: not equal", desc),
+				fmt.Sprintf("  have: %s(%i)\n", have.Type(), haveUint),
+				fmt.Sprintf("  want: %s(%i)\n", want.Type(), wantUint),
+			}
+		}
+
+	case reflect.Float32:
+		fallthrough
+	case reflect.Float64:
+		// Float types.
+		haveFloat := have.Float()
+		wantFloat := want.Float()
+		if haveFloat != wantFloat {
+			return []string{
+				fmt.Sprintf("%s: not equal", desc),
+				fmt.Sprintf("  have: %s(%f)\n", have.Type(), haveFloat),
+				fmt.Sprintf("  want: %s(%f)\n", want.Type(), wantFloat),
+			}
+		}
+
+
 	default:
 		// All other cases are primitive and therefor reflect.DeepEqual
 		// actually handles them very well.
+		fmt.Printf("%s   %s %s\n", desc, have.Type(), want.Type())
 		if !reflect.DeepEqual(want.Interface(), have.Interface()) {
 			return []string{
 				fmt.Sprintf("%s: not equal.", desc),

expect.go

@@ -43,5 +43,20 @@ func (t *T) ExpectSuccess(err error, desc ...string) {
 	if len(desc) > 0 {
 		prefix = strings.Join(desc, " ") + ": "
 	}
-	t.Fatalf("%sUnexpected error encountered: %#v", prefix, err)
+	t.Fatalf("%sUnexpected error encountered: %#v (%s)",
+		prefix, err, err.Error())
+}
+
+// Fails if the error message does not contain the given string.
+func (t *T) ExpectErrorMessage(err error, msg string, desc ...string) {
+	prefix := ""
+	if len(desc) > 0 {
+		prefix = strings.Join(desc, " ") + ": "
+	}
+	if err == nil {
+		t.Fatalf("%sExpected error was not returned.", prefix)
+	} else if !strings.Contains(err.Error(), msg) {
+		t.Fatalf("%sError message didn't contain the expected message:\n"+
+		"Error message=%s\nExpected string=%s",	prefix, err.Error(), msg)
+	}
 }

expect_test.go

@@ -55,3 +55,32 @@ func TestT_ExpectSuccess(t *testing.T) {
 		t.Fatalf("The prefix was not prepended to the message: '''%s'''", msg)
 	}
 }
+
+func TestT_ExpectErrorMessage(t *testing.T) {
+	t.Parallel()
+	m, T := testSetup()
+
+	// Capture the error message.
+	msg := ""
+	m.funcFatal = func(args ...interface{}) {
+		msg = fmt.Sprint(args...)
+	}
+	m.CheckFail(t, func() {
+		T.ExpectErrorMessage(nil, "test")
+	})
+	m.CheckFail(t, func() {
+		T.ExpectErrorMessage(fmt.Errorf("XXX"), "test")
+	})
+	m.CheckFail(t, func() {
+		T.ExpectErrorMessage(fmt.Errorf("ERROR"), "test", "prefix")
+	})
+	if msg == "" {
+		t.Fatalf("No error message was reported.")
+	} else if !strings.HasPrefix(msg, "prefix: ") {
+		t.Fatalf("The prefix was not prepended to the message: '''%s'''", msg)
+	}
+
+	m.CheckPass(t, func() {
+		T.ExpectErrorMessage(fmt.Errorf("XXX"), "XXX")
+	})
+}