| // These tests check that the foundations of gocheck are working properly. |
| // They already assume that fundamental failing is working already, though, |
| // since this was tested in bootstrap_test.go. Even then, some care may |
| // still have to be taken when using external functions, since they should |
| // of course not rely on functionality tested here. |
| |
| package gocheck_test |
| |
| import ( |
| "launchpad.net/gocheck" |
| "strings" |
| "regexp" |
| "fmt" |
| ) |
| |
| |
| // ----------------------------------------------------------------------- |
| // Foundation test suite. |
| |
| type FoundationS struct{} |
| |
| var foundationS = gocheck.Suite(&FoundationS{}) |
| |
| func (s *FoundationS) TestCountSuite(c *gocheck.C) { |
| suitesRun += 1 |
| } |
| |
| func (s *FoundationS) TestErrorf(c *gocheck.C) { |
| // Do not use checkState() here. It depends on Errorf() working. |
| expectedLog := fmt.Sprintf("foundation_test.go:%d:\n"+ |
| " c.Errorf(\"Error %%v!\", \"message\")\n"+ |
| "... Error: Error message!\n\n", |
| getMyLine()+1) |
| c.Errorf("Error %v!", "message") |
| failed := c.Failed() |
| c.Succeed() |
| if log := c.GetTestLog(); log != expectedLog { |
| c.Logf("Errorf() logged %#v rather than %#v", log, expectedLog) |
| c.Fail() |
| } |
| if !failed { |
| c.Logf("Errorf() didn't put the test in a failed state") |
| c.Fail() |
| } |
| } |
| |
| func (s *FoundationS) TestError(c *gocheck.C) { |
| expectedLog := fmt.Sprintf("foundation_test.go:%d:\n"+ |
| " c\\.Error\\(\"Error \", \"message!\"\\)\n"+ |
| "\\.\\.\\. Error: Error message!\n\n", |
| getMyLine()+1) |
| c.Error("Error ", "message!") |
| checkState(c, nil, |
| &expectedState{ |
| name: "Error(`Error `, `message!`)", |
| failed: true, |
| log: expectedLog, |
| }) |
| } |
| |
| func (s *FoundationS) TestFailNow(c *gocheck.C) { |
| defer (func() { |
| if !c.Failed() { |
| c.Error("FailNow() didn't fail the test") |
| } else { |
| c.Succeed() |
| if c.GetTestLog() != "" { |
| c.Error("Something got logged:\n" + c.GetTestLog()) |
| } |
| } |
| })() |
| |
| c.FailNow() |
| c.Log("FailNow() didn't stop the test") |
| } |
| |
| func (s *FoundationS) TestSucceedNow(c *gocheck.C) { |
| defer (func() { |
| if c.Failed() { |
| c.Error("SucceedNow() didn't succeed the test") |
| } |
| if c.GetTestLog() != "" { |
| c.Error("Something got logged:\n" + c.GetTestLog()) |
| } |
| })() |
| |
| c.Fail() |
| c.SucceedNow() |
| c.Log("SucceedNow() didn't stop the test") |
| } |
| |
| func (s *FoundationS) TestFailureHeader(c *gocheck.C) { |
| output := String{} |
| failHelper := FailHelper{} |
| gocheck.Run(&failHelper, &gocheck.RunConf{Output: &output}) |
| header := fmt.Sprintf(""+ |
| "\n-----------------------------------"+ |
| "-----------------------------------\n"+ |
| "FAIL: gocheck_test.go:%d: FailHelper.TestLogAndFail\n", |
| failHelper.testLine) |
| if strings.Index(output.value, header) == -1 { |
| c.Errorf(""+ |
| "Failure didn't print a proper header.\n"+ |
| "... Got:\n%s... Expected something with:\n%s", |
| output.value, header) |
| } |
| } |
| |
| func (s *FoundationS) TestFatal(c *gocheck.C) { |
| var line int |
| defer (func() { |
| if !c.Failed() { |
| c.Error("Fatal() didn't fail the test") |
| } else { |
| c.Succeed() |
| expected := fmt.Sprintf("foundation_test.go:%d:\n"+ |
| " c.Fatal(\"Die \", \"now!\")\n"+ |
| "... Error: Die now!\n\n", |
| line) |
| if c.GetTestLog() != expected { |
| c.Error("Incorrect log:", c.GetTestLog()) |
| } |
| } |
| })() |
| |
| line = getMyLine() + 1 |
| c.Fatal("Die ", "now!") |
| c.Log("Fatal() didn't stop the test") |
| } |
| |
| func (s *FoundationS) TestFatalf(c *gocheck.C) { |
| var line int |
| defer (func() { |
| if !c.Failed() { |
| c.Error("Fatalf() didn't fail the test") |
| } else { |
| c.Succeed() |
| expected := fmt.Sprintf("foundation_test.go:%d:\n"+ |
| " c.Fatalf(\"Die %%s!\", \"now\")\n"+ |
| "... Error: Die now!\n\n", |
| line) |
| if c.GetTestLog() != expected { |
| c.Error("Incorrect log:", c.GetTestLog()) |
| } |
| } |
| })() |
| |
| line = getMyLine() + 1 |
| c.Fatalf("Die %s!", "now") |
| c.Log("Fatalf() didn't stop the test") |
| } |
| |
| |
| func (s *FoundationS) TestCallerLoggingInsideTest(c *gocheck.C) { |
| log := fmt.Sprintf(""+ |
| "foundation_test.go:%d:\n"+ |
| " result := c.Check\\(10, gocheck.Equals, 20\\)\n"+ |
| "\\.\\.\\. obtained int = 10\n"+ |
| "\\.\\.\\. expected int = 20\n\n", |
| getMyLine()+1) |
| result := c.Check(10, gocheck.Equals, 20) |
| checkState(c, result, |
| &expectedState{ |
| name: "Check(10, Equals, 20)", |
| result: false, |
| failed: true, |
| log: log, |
| }) |
| } |
| |
| func (s *FoundationS) TestCallerLoggingInDifferentFile(c *gocheck.C) { |
| result, line := checkEqualWrapper(c, 10, 20) |
| testLine := getMyLine() - 1 |
| log := fmt.Sprintf(""+ |
| "foundation_test.go:%d:\n"+ |
| " result, line := checkEqualWrapper\\(c, 10, 20\\)\n"+ |
| "gocheck_test.go:%d:\n"+ |
| " return c.Check\\(obtained, gocheck.Equals, expected\\), getMyLine\\(\\)\n"+ |
| "\\.\\.\\. obtained int = 10\n"+ |
| "\\.\\.\\. expected int = 20\n\n", |
| testLine, line) |
| checkState(c, result, |
| &expectedState{ |
| name: "Check(10, Equals, 20)", |
| result: false, |
| failed: true, |
| log: log, |
| }) |
| } |
| |
| // ----------------------------------------------------------------------- |
| // ExpectFailure() inverts the logic of failure. |
| |
| type ExpectFailureSucceedHelper struct{} |
| |
| func (s *ExpectFailureSucceedHelper) TestSucceed(c *gocheck.C) { |
| c.ExpectFailure("It booms!") |
| c.Error("Boom!") |
| } |
| |
| type ExpectFailureFailHelper struct{} |
| |
| func (s *ExpectFailureFailHelper) TestFail(c *gocheck.C) { |
| c.ExpectFailure("Bug #XYZ") |
| } |
| |
| func (s *FoundationS) TestExpectFailureFail(c *gocheck.C) { |
| helper := ExpectFailureFailHelper{} |
| output := String{} |
| result := gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| |
| expected := "" + |
| "^\n-+\n" + |
| "FAIL: foundation_test\\.go:[0-9]+:" + |
| " ExpectFailureFailHelper\\.TestFail\n\n" + |
| "\\.\\.\\. Error: Test succeeded, but was expected to fail\n" + |
| "\\.\\.\\. Reason: Bug #XYZ\n$" |
| |
| matched, err := regexp.MatchString(expected, output.value) |
| if err != nil { |
| c.Error("Bad expression: ", expected) |
| } else if !matched { |
| c.Error("ExpectFailure() didn't log properly:\n", output.value) |
| } |
| |
| c.Assert(result.ExpectedFailures, gocheck.Equals, 0) |
| } |
| |
| func (s *FoundationS) TestExpectFailureSucceed(c *gocheck.C) { |
| helper := ExpectFailureSucceedHelper{} |
| output := String{} |
| result := gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| |
| c.Assert(output.value, gocheck.Equals, "") |
| c.Assert(result.ExpectedFailures, gocheck.Equals, 1) |
| } |
| |
| func (s *FoundationS) TestExpectFailureSucceedVerbose(c *gocheck.C) { |
| helper := ExpectFailureSucceedHelper{} |
| output := String{} |
| result := gocheck.Run(&helper, &gocheck.RunConf{Output: &output, Verbose: true}) |
| |
| expected := "" + |
| "FAIL EXPECTED: foundation_test\\.go:[0-9]+:" + |
| " ExpectFailureSucceedHelper\\.TestSucceed \\(It booms!\\)\n" |
| |
| matched, err := regexp.MatchString(expected, output.value) |
| if err != nil { |
| c.Error("Bad expression: ", expected) |
| } else if !matched { |
| c.Error("ExpectFailure() didn't log properly:\n", output.value) |
| } |
| |
| c.Assert(result.ExpectedFailures, gocheck.Equals, 1) |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Skip() allows stopping a test without positive/negative results. |
| |
| type SkipTestHelper struct{} |
| |
| func (s *SkipTestHelper) TestFail(c *gocheck.C) { |
| c.Skip("Wrong platform or whatever") |
| c.Error("Boom!") |
| } |
| |
| func (s *FoundationS) TestSkip(c *gocheck.C) { |
| helper := SkipTestHelper{} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| |
| if output.value != "" { |
| c.Error("Skip() logged something:\n", output.value) |
| } |
| } |
| |
| func (s *FoundationS) TestSkipVerbose(c *gocheck.C) { |
| helper := SkipTestHelper{} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output, Verbose: true}) |
| |
| expected := "SKIP: foundation_test\\.go:[0-9]+: SkipTestHelper\\.TestFail" + |
| " \\(Wrong platform or whatever\\)" |
| matched, err := regexp.MatchString(expected, output.value) |
| if err != nil { |
| c.Error("Bad expression: ", expected) |
| } else if !matched { |
| c.Error("Skip() didn't log properly:\n", output.value) |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Ensure that suites with embedded types are working fine, including the |
| // the workaround for issue 906. |
| |
| type EmbeddedInternalS struct { |
| called bool |
| } |
| |
| type EmbeddedS struct { |
| EmbeddedInternalS |
| } |
| |
| var embeddedS = gocheck.Suite(&EmbeddedS{}) |
| |
| func (s *EmbeddedS) TestCountSuite(c *gocheck.C) { |
| suitesRun += 1 |
| } |
| |
| func (s *EmbeddedInternalS) TestMethod(c *gocheck.C) { |
| c.Error("TestMethod() of the embedded type was called!?") |
| } |
| |
| func (s *EmbeddedS) TestMethod(c *gocheck.C) { |
| // http://code.google.com/p/go/issues/detail?id=906 |
| c.Check(s.called, gocheck.Equals, false, |
| gocheck.Bug("The bug described in issue 906 is "+ |
| "affecting the runner")) |
| s.called = true |
| } |