| // Tests for the behavior of the test fixture system. |
| |
| package gocheck_test |
| |
| |
| import ( |
| "gocheck" |
| . "gocheck/local" |
| ) |
| |
| |
| // ----------------------------------------------------------------------- |
| // Fixture test suite. |
| |
| type FixtureS struct{} |
| |
| var fixtureS = gocheck.Suite(&FixtureS{}) |
| |
| func (s *FixtureS) TestCountSuite(c *gocheck.C) { |
| suitesRun += 1 |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Basic fixture ordering verification. |
| |
| func (s *FixtureS) TestOrder(c *gocheck.C) { |
| helper := FixtureHelper{} |
| gocheck.Run(&helper, nil) |
| c.Check(helper.calls[0], Equals, "SetUpSuite") |
| c.Check(helper.calls[1], Equals, "SetUpTest") |
| c.Check(helper.calls[2], Equals, "Test1") |
| c.Check(helper.calls[3], Equals, "TearDownTest") |
| c.Check(helper.calls[4], Equals, "SetUpTest") |
| c.Check(helper.calls[5], Equals, "Test2") |
| c.Check(helper.calls[6], Equals, "TearDownTest") |
| c.Check(helper.calls[7], Equals, "TearDownSuite") |
| c.Check(helper.n, Equals, 8) |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Check the behavior when panics occur within tests and fixtures. |
| |
| func (s *FixtureS) TestPanicOnTest(c *gocheck.C) { |
| helper := FixtureHelper{panicOn: "Test1"} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| c.Check(helper.calls[0], Equals, "SetUpSuite") |
| c.Check(helper.calls[1], Equals, "SetUpTest") |
| c.Check(helper.calls[2], Equals, "Test1") |
| c.Check(helper.calls[3], Equals, "TearDownTest") |
| c.Check(helper.calls[4], Equals, "SetUpTest") |
| c.Check(helper.calls[5], Equals, "Test2") |
| c.Check(helper.calls[6], Equals, "TearDownTest") |
| c.Check(helper.calls[7], Equals, "TearDownSuite") |
| c.Check(helper.n, Equals, 8) |
| |
| expected := "^\n-+\n" + |
| "PANIC: gocheck_test\\.go:[0-9]+: FixtureHelper.Test1\n\n" + |
| "\\.\\.\\. Panic: Test1 \\(PC=[xA-F0-9]+\\)\n\n" + |
| ".+:[0-9]+\n" + |
| " in runtime.panic\n" + |
| ".*gocheck_test.go:[0-9]+\n" + |
| " in FixtureHelper.trace\n" + |
| ".*gocheck_test.go:[0-9]+\n" + |
| " in FixtureHelper.Test1\n$" |
| |
| c.Check(output.value, Matches, expected) |
| } |
| |
| func (s *FixtureS) TestPanicOnSetUpTest(c *gocheck.C) { |
| helper := FixtureHelper{panicOn: "SetUpTest"} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| c.Check(helper.calls[0], Equals, "SetUpSuite") |
| c.Check(helper.calls[1], Equals, "SetUpTest") |
| c.Check(helper.calls[2], Equals, "TearDownTest") |
| c.Check(helper.calls[3], Equals, "TearDownSuite") |
| c.Check(helper.n, Equals, 4) |
| |
| expected := "^\n-+\n" + |
| "PANIC: gocheck_test\\.go:[0-9]+: " + |
| "FixtureHelper\\.SetUpTest\n\n" + |
| "\\.\\.\\. Panic: SetUpTest \\(PC=[xA-F0-9]+\\)\n\n" + |
| ".+:[0-9]+\n" + |
| " in runtime.panic\n" + |
| ".*gocheck_test.go:[0-9]+\n" + |
| " in FixtureHelper.trace\n" + |
| ".*gocheck_test.go:[0-9]+\n" + |
| " in FixtureHelper.SetUpTest\n" + |
| "\n-+\n" + |
| "PANIC: gocheck_test\\.go:[0-9]+: " + |
| "FixtureHelper\\.Test1\n\n" + |
| "\\.\\.\\. Panic: Fixture has panicked " + |
| "\\(see related PANIC\\)\n$" |
| |
| c.Check(output.value, Matches, expected) |
| } |
| |
| func (s *FixtureS) TestPanicOnTearDownTest(c *gocheck.C) { |
| helper := FixtureHelper{panicOn: "TearDownTest"} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| c.Check(helper.calls[0], Equals, "SetUpSuite") |
| c.Check(helper.calls[1], Equals, "SetUpTest") |
| c.Check(helper.calls[2], Equals, "Test1") |
| c.Check(helper.calls[3], Equals, "TearDownTest") |
| c.Check(helper.calls[4], Equals, "TearDownSuite") |
| c.Check(helper.n, Equals, 5) |
| |
| expected := "^\n-+\n" + |
| "PANIC: gocheck_test\\.go:[0-9]+: " + |
| "FixtureHelper.TearDownTest\n\n" + |
| "\\.\\.\\. Panic: TearDownTest \\(PC=[xA-F0-9]+\\)\n\n" + |
| ".+:[0-9]+\n" + |
| " in runtime.panic\n" + |
| ".*gocheck_test.go:[0-9]+\n" + |
| " in FixtureHelper.trace\n" + |
| ".*gocheck_test.go:[0-9]+\n" + |
| " in FixtureHelper.TearDownTest\n" + |
| "\n-+\n" + |
| "PANIC: gocheck_test\\.go:[0-9]+: " + |
| "FixtureHelper\\.Test1\n\n" + |
| "\\.\\.\\. Panic: Fixture has panicked " + |
| "\\(see related PANIC\\)\n$" |
| |
| c.Check(output.value, Matches, expected) |
| } |
| |
| func (s *FixtureS) TestPanicOnSetUpSuite(c *gocheck.C) { |
| helper := FixtureHelper{panicOn: "SetUpSuite"} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| c.Check(helper.calls[0], Equals, "SetUpSuite") |
| c.Check(helper.calls[1], Equals, "TearDownSuite") |
| c.Check(helper.n, Equals, 2) |
| |
| expected := "^\n-+\n" + |
| "PANIC: gocheck_test\\.go:[0-9]+: " + |
| "FixtureHelper.SetUpSuite\n\n" + |
| "\\.\\.\\. Panic: SetUpSuite \\(PC=[xA-F0-9]+\\)\n\n" + |
| ".+:[0-9]+\n" + |
| " in runtime.panic\n" + |
| ".*gocheck_test.go:[0-9]+\n" + |
| " in FixtureHelper.trace\n" + |
| ".*gocheck_test.go:[0-9]+\n" + |
| " in FixtureHelper.SetUpSuite\n$" |
| |
| c.Check(output.value, Matches, expected) |
| } |
| |
| func (s *FixtureS) TestPanicOnTearDownSuite(c *gocheck.C) { |
| helper := FixtureHelper{panicOn: "TearDownSuite"} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| c.Check(helper.calls[0], Equals, "SetUpSuite") |
| c.Check(helper.calls[1], Equals, "SetUpTest") |
| c.Check(helper.calls[2], Equals, "Test1") |
| c.Check(helper.calls[3], Equals, "TearDownTest") |
| c.Check(helper.calls[4], Equals, "SetUpTest") |
| c.Check(helper.calls[5], Equals, "Test2") |
| c.Check(helper.calls[6], Equals, "TearDownTest") |
| c.Check(helper.calls[7], Equals, "TearDownSuite") |
| c.Check(helper.n, Equals, 8) |
| |
| expected := "^\n-+\n" + |
| "PANIC: gocheck_test\\.go:[0-9]+: " + |
| "FixtureHelper.TearDownSuite\n\n" + |
| "\\.\\.\\. Panic: TearDownSuite \\(PC=[xA-F0-9]+\\)\n\n" + |
| ".+:[0-9]+\n" + |
| " in runtime.panic\n" + |
| ".*gocheck_test.go:[0-9]+\n" + |
| " in FixtureHelper.trace\n" + |
| ".*gocheck_test.go:[0-9]+\n" + |
| " in FixtureHelper.TearDownSuite\n$" |
| |
| c.Check(output.value, Matches, expected) |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // A wrong argument on a test or fixture will produce a nice error. |
| |
| func (s *FixtureS) TestPanicOnWrongTestArg(c *gocheck.C) { |
| helper := WrongTestArgHelper{} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| c.Check(helper.calls[0], Equals, "SetUpSuite") |
| c.Check(helper.calls[1], Equals, "SetUpTest") |
| c.Check(helper.calls[2], Equals, "TearDownTest") |
| c.Check(helper.calls[3], Equals, "SetUpTest") |
| c.Check(helper.calls[4], Equals, "Test2") |
| c.Check(helper.calls[5], Equals, "TearDownTest") |
| c.Check(helper.calls[6], Equals, "TearDownSuite") |
| c.Check(helper.n, Equals, 7) |
| |
| expected := "^\n-+\n" + |
| "PANIC: fixture_test\\.go:[0-9]+: " + |
| "WrongTestArgHelper\\.Test1\n\n" + |
| "\\.\\.\\. Panic: WrongTestArgHelper\\.Test1 argument " + |
| "should be \\*gocheck\\.C\n" |
| |
| c.Check(output.value, Matches, expected) |
| } |
| |
| func (s *FixtureS) TestPanicOnWrongSetUpTestArg(c *gocheck.C) { |
| helper := WrongSetUpTestArgHelper{} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| c.Check(helper.n, Equals, 0) |
| |
| expected := |
| "^\n-+\n" + |
| "PANIC: fixture_test\\.go:[0-9]+: " + |
| "WrongSetUpTestArgHelper\\.SetUpTest\n\n" + |
| "\\.\\.\\. Panic: WrongSetUpTestArgHelper\\.SetUpTest argument " + |
| "should be \\*gocheck\\.C\n" |
| |
| c.Check(output.value, Matches, expected) |
| } |
| |
| func (s *FixtureS) TestPanicOnWrongSetUpSuiteArg(c *gocheck.C) { |
| helper := WrongSetUpSuiteArgHelper{} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| c.Check(helper.n, Equals, 0) |
| |
| expected := |
| "^\n-+\n" + |
| "PANIC: fixture_test\\.go:[0-9]+: " + |
| "WrongSetUpSuiteArgHelper\\.SetUpSuite\n\n" + |
| "\\.\\.\\. Panic: WrongSetUpSuiteArgHelper\\.SetUpSuite argument " + |
| "should be \\*gocheck\\.C\n" |
| |
| c.Check(output.value, Matches, expected) |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Nice errors also when tests or fixture have wrong arg count. |
| |
| func (s *FixtureS) TestPanicOnWrongTestArgCount(c *gocheck.C) { |
| helper := WrongTestArgCountHelper{} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| c.Check(helper.calls[0], Equals, "SetUpSuite") |
| c.Check(helper.calls[1], Equals, "SetUpTest") |
| c.Check(helper.calls[2], Equals, "TearDownTest") |
| c.Check(helper.calls[3], Equals, "SetUpTest") |
| c.Check(helper.calls[4], Equals, "Test2") |
| c.Check(helper.calls[5], Equals, "TearDownTest") |
| c.Check(helper.calls[6], Equals, "TearDownSuite") |
| c.Check(helper.n, Equals, 7) |
| |
| expected := "^\n-+\n" + |
| "PANIC: fixture_test\\.go:[0-9]+: " + |
| "WrongTestArgCountHelper\\.Test1\n\n" + |
| "\\.\\.\\. Panic: WrongTestArgCountHelper\\.Test1 argument " + |
| "should be \\*gocheck\\.C\n" |
| |
| c.Check(output.value, Matches, expected) |
| } |
| |
| func (s *FixtureS) TestPanicOnWrongSetUpTestArgCount(c *gocheck.C) { |
| helper := WrongSetUpTestArgCountHelper{} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| c.Check(helper.n, Equals, 0) |
| |
| expected := |
| "^\n-+\n" + |
| "PANIC: fixture_test\\.go:[0-9]+: " + |
| "WrongSetUpTestArgCountHelper\\.SetUpTest\n\n" + |
| "\\.\\.\\. Panic: WrongSetUpTestArgCountHelper\\.SetUpTest argument " + |
| "should be \\*gocheck\\.C\n" |
| |
| c.Check(output.value, Matches, expected) |
| } |
| |
| func (s *FixtureS) TestPanicOnWrongSetUpSuiteArgCount(c *gocheck.C) { |
| helper := WrongSetUpSuiteArgCountHelper{} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| c.Check(helper.n, Equals, 0) |
| |
| expected := |
| "^\n-+\n" + |
| "PANIC: fixture_test\\.go:[0-9]+: " + |
| "WrongSetUpSuiteArgCountHelper\\.SetUpSuite\n\n" + |
| "\\.\\.\\. Panic: WrongSetUpSuiteArgCountHelper" + |
| "\\.SetUpSuite argument should be \\*gocheck\\.C\n" |
| |
| c.Check(output.value, Matches, expected) |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Helper test suites with wrong function arguments. |
| |
| type WrongTestArgHelper struct { |
| FixtureHelper |
| } |
| |
| func (s *WrongTestArgHelper) Test1(t int) { |
| } |
| |
| type WrongSetUpTestArgHelper struct { |
| FixtureHelper |
| } |
| |
| func (s *WrongSetUpTestArgHelper) SetUpTest(t int) { |
| } |
| |
| type WrongSetUpSuiteArgHelper struct { |
| FixtureHelper |
| } |
| |
| func (s *WrongSetUpSuiteArgHelper) SetUpSuite(t int) { |
| } |
| |
| type WrongTestArgCountHelper struct { |
| FixtureHelper |
| } |
| |
| func (s *WrongTestArgCountHelper) Test1(c *gocheck.C, i int) { |
| } |
| |
| type WrongSetUpTestArgCountHelper struct { |
| FixtureHelper |
| } |
| |
| func (s *WrongSetUpTestArgCountHelper) SetUpTest(c *gocheck.C, i int) { |
| } |
| |
| type WrongSetUpSuiteArgCountHelper struct { |
| FixtureHelper |
| } |
| |
| func (s *WrongSetUpSuiteArgCountHelper) SetUpSuite(c *gocheck.C, i int) { |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Ensure fixture doesn't run without tests. |
| |
| type NoTestsHelper struct{ |
| hasRun bool |
| } |
| |
| func (s *NoTestsHelper) SetUpSuite(c *gocheck.C) { |
| s.hasRun = true |
| } |
| |
| func (s *NoTestsHelper) TearDownSuite(c *gocheck.C) { |
| s.hasRun = true |
| } |
| |
| func (s *FixtureS) TestFixtureDoesntRunWithoutTests(c *gocheck.C) { |
| helper := NoTestsHelper{} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| c.Check(helper.hasRun, Equals, false) |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Verify that checks and assertions work correctly inside the fixture. |
| |
| type FixtureCheckHelper struct{ |
| fail string |
| completed bool |
| } |
| |
| func (s *FixtureCheckHelper) SetUpSuite(c *gocheck.C) { |
| switch s.fail { |
| case "SetUpSuiteAssert": |
| c.Assert(false, Equals, true) |
| case "SetUpSuiteCheck": |
| c.Check(false, Equals, true) |
| } |
| s.completed = true |
| } |
| |
| func (s *FixtureCheckHelper) SetUpTest(c *gocheck.C) { |
| switch s.fail { |
| case "SetUpTestAssert": |
| c.Assert(false, Equals, true) |
| case "SetUpTestCheck": |
| c.Check(false, Equals, true) |
| } |
| s.completed = true |
| } |
| |
| func (s *FixtureCheckHelper) Test(c *gocheck.C) { |
| // Do nothing. |
| } |
| |
| func (s *FixtureS) TestSetUpSuiteCheck(c *gocheck.C) { |
| helper := FixtureCheckHelper{fail: "SetUpSuiteCheck"} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| c.Assert(output.value, Matches, |
| "\n---+\n" + |
| "FAIL: fixture_test\\.go:[0-9]+: " + |
| "FixtureCheckHelper\\.SetUpSuite\n\n" + |
| "fixture_test\\.go:[0-9]+:\n" + |
| "\\.+ Check\\(obtained, Equals, expected\\):\n" + |
| "\\.+ Obtained \\(bool\\): false\n" + |
| "\\.+ Expected \\(bool\\): true\n\n") |
| c.Assert(helper.completed, Equals, true) |
| } |
| |
| func (s *FixtureS) TestSetUpSuiteAssert(c *gocheck.C) { |
| helper := FixtureCheckHelper{fail: "SetUpSuiteAssert"} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| c.Assert(output.value, Matches, |
| "\n---+\n" + |
| "FAIL: fixture_test\\.go:[0-9]+: " + |
| "FixtureCheckHelper\\.SetUpSuite\n\n" + |
| "fixture_test\\.go:[0-9]+:\n" + |
| "\\.+ Assert\\(obtained, Equals, expected\\):\n" + |
| "\\.+ Obtained \\(bool\\): false\n" + |
| "\\.+ Expected \\(bool\\): true\n\n") |
| c.Assert(helper.completed, Equals, false) |
| } |