// +build !solution

package testequal



func AreEqual(expected, actual interface{}) bool {
    switch expected.(type) {
    case []int:
        expectedSlice := expected.([]int)
        actualSlice := actual.([]int)

        if _, ok := actual.([]int); !ok {
            return false
        }
        if expectedSlice != nil && actualSlice == nil {
            return false
        }
        if expectedSlice == nil && actualSlice != nil {
            return false
        }

        if len(expectedSlice) != len(actualSlice) {
            return false
        }
        for idx, elem := range expectedSlice {
            if elem != actualSlice[idx] {
                return false
            }
        }
        return true
    case map[string]string:
        if _, ok := actual.(map[string]string); !ok {
            return false
        }
        expectedMap := expected.(map[string]string)
        actualMap := actual.(map[string]string)
        if expectedMap != nil && actualMap == nil {
            return false
        }
        if expectedMap == nil && actualMap != nil {
            return false
        }

        if len(expectedMap) != len(actualMap) {
            return false
        }
        for key, elem := range expectedMap {
            if elem != actualMap[key] {
                return false
            }
        }
        return true
    case []byte:
        if _, ok := actual.([]byte); !ok {
            return false
        }
        expectedSlice := expected.([]byte)
        actualSlice := actual.([]byte)
        if expectedSlice != nil && actualSlice == nil {
            return false
        }
        if expectedSlice == nil && actualSlice != nil {
            return false
        }

        if len(expectedSlice) != len(actualSlice) {
            return false
        }
        for idx, elem := range expectedSlice {
            if elem != actualSlice[idx] {
                return false
            }
        }
        return true
    case int:
        return expected == actual
    case int8:
        return expected == actual
    case int16:
        return expected == actual
    case int32:
        return expected == actual
    case int64:
        return expected == actual
    case uint8:
        return expected == actual
    case uint16:
        return expected == actual
    case uint32:
        return expected == actual
    case uint64:
        return expected == actual
    case string:
        return expected == actual
    default:
        return false
    }
}

// AssertEqual checks that expected and actual are equal.
//
// Marks caller function as having failed but continues execution.
//
// Returns true if arguments are equal.
func AssertEqual(t T, expected, actual interface{}, msgAndArgs ...interface{}) bool {
    t.Helper()
    if AreEqual(expected, actual) {
        return true
    }
    msg := ""
    if len(msgAndArgs) > 0 {
        msg = msgAndArgs[0].(string)
    }
    switch expectedValue := expected.(type) {
    default:
        switch actualValue := actual.(type) {
        default:
            t.Errorf(msg, expectedValue, actualValue)
        }
    }
    return false
}

// AssertNotEqual checks that expected and actual are not equal.
//
// Marks caller function as having failed but continues execution.
//
// Returns true iff arguments are not equal.
func AssertNotEqual(t T, expected, actual interface{}, msgAndArgs ...interface{}) bool {
    t.Helper()
    if !AreEqual(expected, actual) {
        return true
    }
    msg := ""
    if len(msgAndArgs) > 0 {
        msg = msgAndArgs[0].(string)

    }
    switch expectedValue := expected.(type) {
    default:
        switch actualValue := actual.(type) {
        default:
            t.Errorf(msg, expectedValue, actualValue)
        }
    }
    return false
}

// RequireEqual does the same as AssertEqual but fails caller test immediately.
func RequireEqual(t T, expected, actual interface{}, msgAndArgs ...interface{}) {
    t.Helper()
    if AssertEqual(t, expected, actual, msgAndArgs...) {
        return
    }
    t.FailNow()
}

// RequireNotEqual does the same as AssertNotEqual but fails caller test immediately.
func RequireNotEqual(t T, expected, actual interface{}, msgAndArgs ...interface{}) {
    t.Helper()
    if AssertNotEqual(t, expected, actual, msgAndArgs...) {
        return
    }
    t.FailNow()
}