| package gocheck |
| |
| |
| import ( |
| "reflect" |
| "strings" |
| "regexp" |
| "fmt" |
| "os" |
| ) |
| |
| |
| // ----------------------------------------------------------------------- |
| // Basic succeeding/failing logic. |
| |
| // Return true if the currently running test has already failed. |
| func (c *C) Failed() bool { |
| return c.status == failedSt |
| } |
| |
| // Mark the currently running test as failed. Something ought to have been |
| // previously logged so that the developer knows what went wrong. The higher |
| // level helper functions will fail the test and do the logging properly. |
| func (c *C) Fail() { |
| c.status = failedSt |
| } |
| |
| // Mark the currently running test as failed, and stop running the test. |
| // Something ought to have been previously logged so that the developer |
| // knows what went wrong. The higher level helper functions will fail the |
| // test and do the logging properly. |
| func (c *C) FailNow() { |
| c.Fail() |
| c.stopNow() |
| } |
| |
| // Mark the currently running test as succeeded, undoing any previous |
| // failures. |
| func (c *C) Succeed() { |
| c.status = succeededSt |
| } |
| |
| // Mark the currently running test as succeeded, undoing any previous |
| // failures, and stop running the test. |
| func (c *C) SucceedNow() { |
| c.Succeed() |
| c.stopNow() |
| } |
| |
| // Expect the currently running test to fail, for the given reason. If the |
| // test does not fail, an error will be reported to raise the attention to |
| // this fact. The reason string is just a summary of why the given test is |
| // supposed to fail. This method is useful to temporarily disable tests |
| // which cover well known problems until a better time to fix the problem |
| // is found, without forgetting about the fact that a failure still exists. |
| func (c *C) ExpectFailure(reason string) { |
| c.expectedFailure = &reason |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Basic logging. |
| |
| // Return the current test error output. |
| func (c *C) GetTestLog() string { |
| return c.logv |
| } |
| |
| // Log some information into the test error output. The provided arguments |
| // will be assembled together into a string using fmt.Sprint(). |
| func (c *C) Log(args ...interface{}) { |
| c.log(args...) |
| } |
| |
| // Log some information into the test error output. The provided arguments |
| // will be assembled together into a string using fmt.Sprintf(). |
| func (c *C) Logf(format string, args ...interface{}) { |
| c.logf(format, args...) |
| } |
| |
| // Log an error into the test error output, and mark the test as failed. |
| // The provided arguments will be assembled together into a string using |
| // fmt.Sprint(). |
| func (c *C) Error(args ...interface{}) { |
| c.logCaller(1, fmt.Sprint("Error: ", fmt.Sprint(args...))) |
| c.Fail() |
| } |
| |
| // Log an error into the test error output, and mark the test as failed. |
| // The provided arguments will be assembled together into a string using |
| // fmt.Sprintf(). |
| func (c *C) Errorf(format string, args ...interface{}) { |
| c.logCaller(1, fmt.Sprintf("Error: " + format, args...)) |
| c.Fail() |
| } |
| |
| // Log an error into the test error output, mark the test as failed, and |
| // stop the test execution. The provided arguments will be assembled |
| // together into a string using fmt.Sprint(). |
| func (c *C) Fatal(args ...interface{}) { |
| c.logCaller(1, fmt.Sprint("Error: ", fmt.Sprint(args...))) |
| c.FailNow() |
| } |
| |
| // Log an error into the test error output, mark the test as failed, and |
| // stop the test execution. The provided arguments will be assembled |
| // together into a string using fmt.Sprintf(). |
| func (c *C) Fatalf(format string, args ...interface{}) { |
| c.logCaller(1, fmt.Sprint("Error: ", fmt.Sprintf(format, args...))) |
| c.FailNow() |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Equality testing. |
| |
| // Verify if the first value is equal to the second value. In case |
| // they're not equal, an error will be logged, the test will be marked as |
| // failed, and the test execution will continue. The extra arguments are |
| // optional and, if provided, will be assembled together with fmt.Sprint() |
| // and printed next to the reported problem in case of errors. The returned |
| // value will be false in case the verification fails. |
| func (c *C) CheckEqual(obtained interface{}, expected interface{}, |
| issue ...interface{}) bool { |
| summary := "CheckEqual(obtained, expected):" |
| return c.internalCheckEqual(obtained, expected, true, summary, issue...) |
| } |
| |
| // Verify if the first value is not equal to the second value. In case |
| // they are equal, an error will be logged, the test will be marked as |
| // failed, and the test execution will continue. The extra arguments are |
| // optional and, if provided, will be assembled together with fmt.Sprint() |
| // and printed next to the reported problem in case of errors. The returned |
| // value will be false in case the verification fails. |
| func (c *C) CheckNotEqual(obtained interface{}, expected interface{}, |
| issue ...interface{}) bool { |
| summary := "CheckNotEqual(obtained, unexpected):" |
| return c.internalCheckEqual(obtained, expected, false, summary, issue...) |
| } |
| |
| // Ensure that the first value is equal to the second value. In case |
| // they're not equal, an error will be logged, the test will be marked as |
| // failed, and the test execution will stop. The extra arguments are |
| // optional and, if provided, will be assembled together with fmt.Sprint() |
| // and printed next to the reported problem in case of errors. |
| func (c *C) AssertEqual(obtained interface{}, expected interface{}, |
| issue ...interface{}) { |
| summary := "AssertEqual(obtained, expected):" |
| if !c.internalCheckEqual(obtained, expected, true, summary, issue...) { |
| c.stopNow() |
| } |
| } |
| |
| // Ensure that the first value is not equal to the second value. In case |
| // they are equal, an error will be logged, the test will be marked as |
| // failed, and the test execution will stop. The extra arguments are |
| // optional and, if provided, will be assembled together with fmt.Sprint() |
| // and printed next to the reported problem in case of errors. |
| func (c *C) AssertNotEqual(obtained interface{}, expected interface{}, |
| issue ...interface{}) { |
| summary := "AssertNotEqual(obtained, unexpected):" |
| if !c.internalCheckEqual(obtained, expected, false, summary, issue...) { |
| c.stopNow() |
| } |
| } |
| |
| |
| var usedDeprecatedChecks = false |
| |
| func (c *C) internalCheckEqual(a interface{}, b interface{}, equal bool, |
| summary string, issue ...interface{}) bool { |
| usedDeprecatedChecks = true |
| typeA := reflect.Typeof(a) |
| typeB := reflect.Typeof(b) |
| if (typeA == typeB && checkEqual(a, b)) != equal { |
| c.logCaller(2, summary) |
| if equal { |
| c.logValue("Obtained", a) |
| c.logValue("Expected", b) |
| } else { |
| c.logValue("Both", a) |
| } |
| if len(issue) != 0 { |
| c.logString(fmt.Sprint(issue...)) |
| } |
| c.logNewLine() |
| c.Fail() |
| return false |
| } |
| return true |
| } |
| |
| // This will use a fast path to check for equality of normal types, |
| // and then fallback to reflect.DeepEqual if things go wrong. |
| func checkEqual(a interface{}, b interface{}) (result bool) { |
| defer func() { |
| if recover() != nil { |
| result = reflect.DeepEqual(a, b) |
| } |
| }() |
| return (a == b) |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // String matching testing. |
| |
| // Verify if the value provided matches with the given regular expression. |
| // The value must be either a string, or a value which provides the String() |
| // method. In case it doesn't match, an error will be logged, the test will |
| // be marked as failed, and the test execution will continue. The extra |
| // arguments are optional and, if provided, will be assembled together with |
| // fmt.Sprint() and printed next to the reported problem in case of errors. |
| func (c *C) CheckMatch(value interface{}, expression string, |
| issue ...interface{}) bool { |
| summary := "CheckMatch(value, expression):" |
| return c.internalCheckMatch(value, expression, true, summary, issue...) |
| } |
| |
| // Ensure that the value provided matches with the given regular expression. |
| // The value must be either a string, or a value which provides the String() |
| // method. In case it doesn't match, an error will be logged, the test will |
| // be marked as failed, and the test execution will stop. The extra |
| // arguments are optional and, if provided, will be assembled together with |
| // fmt.Sprint() and printed next to the reported problem in case of errors. |
| func (c *C) AssertMatch(value interface{}, expression string, |
| issue ...interface{}) { |
| summary := "AssertMatch(value, expression):" |
| if !c.internalCheckMatch(value, expression, true, summary, issue...) { |
| c.stopNow() |
| } |
| } |
| |
| func (c *C) internalCheckMatch(value interface{}, expression string, |
| equal bool, summary string, |
| issue ...interface{}) bool { |
| usedDeprecatedChecks = true |
| valueStr, valueIsStr := value.(string) |
| if !valueIsStr { |
| if valueWithStr, valueHasStr := value.(hasString); valueHasStr { |
| valueStr, valueIsStr = valueWithStr.String(), true |
| } |
| } |
| var err os.Error |
| var matches bool |
| if valueIsStr { |
| matches, err = regexp.MatchString("^" + expression + "$", valueStr) |
| } |
| if !matches || err != nil { |
| c.logCaller(2, summary) |
| var msg string |
| if !matches { |
| c.logValue("Value", value) |
| msg = fmt.Sprintf("Expected to match expression: %#v", expression) |
| } else { |
| msg = fmt.Sprintf("Can't compile match expression: %#v", expression) |
| } |
| c.logString(msg) |
| if len(issue) != 0 { |
| c.logString(fmt.Sprint(issue...)) |
| } |
| c.logNewLine() |
| c.Fail() |
| return false |
| } |
| return true |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Generic checks and assertions based on checkers. |
| |
| // Verify if the first value matches with the expected value. What |
| // matching means is defined by the provided checker. In case they do not |
| // match, an error will be logged, the test will be marked as failed, and |
| // the test execution will continue. Some checkers may not need the expected |
| // argument (e.g. IsNil). In either case, any extra arguments provided to |
| // the function will be logged next to the reported problem when the |
| // matching fails. This is a handy way to provide problem-specific hints. |
| func (c *C) Check(obtained interface{}, checker Checker, |
| args ...interface{}) bool { |
| return c.internalCheck("Check", obtained, checker, args...) |
| } |
| |
| // Ensure that the first value matches with the expected value. What |
| // matching means is defined by the provided checker. In case they do not |
| // match, an error will be logged, the test will be marked as failed, and |
| // the test execution will stop. Some checkers may not need the expected |
| // argument (e.g. IsNil). In either case, any extra arguments provided to |
| // the function will be logged next to the reported problem when the |
| // matching fails. This is a handy way to provide problem-specific hints. |
| func (c *C) Assert(obtained interface{}, checker Checker, |
| args ...interface{}) { |
| if !c.internalCheck("Assert", obtained, checker, args...) { |
| c.stopNow() |
| } |
| } |
| |
| func (c *C) internalCheck(funcName string, |
| obtained interface{}, checker Checker, |
| args ...interface{}) bool { |
| if checker == nil { |
| c.logCaller(2, fmt.Sprintf("%s(obtained, nil!?, ...):", funcName)) |
| c.logString("Oops.. you've provided a nil checker!") |
| goto fail |
| } |
| |
| // If the last argument is a bug info, extract it out. |
| var bug BugInfo |
| if len(args) > 0 { |
| if gotBug, hasBug := args[len(args)-1].(BugInfo); hasBug { |
| bug = gotBug |
| args = args[:len(args)-1] |
| } |
| } |
| |
| // Ensure we got the needed number of arguments in expected. Note that |
| // this logic is a bit more complex than it ought to be, mainly because |
| // it's leaving the door open to multiple expected values. |
| var expectedWanted int |
| var expected interface{} |
| if checker.NeedsExpectedValue() { |
| expectedWanted = 1 |
| } |
| if len(args) == expectedWanted { |
| if expectedWanted > 0 { |
| expected = args[0] |
| } |
| } else { |
| obtainedName, expectedName := checker.VarNames() |
| c.logCaller(2, fmt.Sprintf("%s(%s, %s, >%s<):", funcName, obtainedName, |
| checker.Name(), expectedName)) |
| c.logString(fmt.Sprintf("Wrong number of %s args for %s: " + |
| "want %d, got %d", expectedName, checker.Name(), |
| expectedWanted, len(args))) |
| goto fail |
| } |
| |
| // Do the actual check. |
| result, error := checker.Check(obtained, expected) |
| if !result || error != "" { |
| obtainedName, expectedName := checker.VarNames() |
| var summary string |
| if expectedWanted > 0 { |
| summary = fmt.Sprintf("%s(%s, %s, %s):", funcName, obtainedName, |
| checker.Name(), expectedName) |
| } else { |
| summary = fmt.Sprintf("%s(%s, %s):", funcName, obtainedName, |
| checker.Name()) |
| } |
| c.logCaller(2, summary) |
| c.logValue(strings.Title(obtainedName), obtained) |
| if expectedWanted > 0 { |
| c.logValue(strings.Title(expectedName), expected) |
| } |
| if error != "" { |
| c.logString(error) |
| } else if bug != nil { |
| c.logString(bug.GetBugInfo()) |
| } |
| goto fail |
| } |
| return true |
| |
| fail: |
| c.logNewLine() |
| c.Fail() |
| return false |
| } |
