| // These tests verify the inner workings of the helper methods associated |
| // with gocheck.T. |
| |
| package gocheck_test |
| |
| import ( |
| "gocheck" |
| "os" |
| ) |
| |
| |
| var helpersS = gocheck.Suite(&HelpersS{}) |
| |
| type HelpersS struct{} |
| |
| func (s *HelpersS) TestCountSuite(c *gocheck.C) { |
| suitesRun += 1 |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Fake checker and bug info to verify the behavior of Assert() and Check(). |
| |
| type MyChecker struct { |
| checkError string |
| failCheck, noExpectedValue bool |
| obtained, expected interface{} |
| } |
| |
| func (checker *MyChecker) Name() string { |
| return "MyChecker" |
| } |
| |
| func (checker *MyChecker) VarNames() (obtained, expected string) { |
| return "myobtained", "myexpected" |
| } |
| |
| func (checker *MyChecker) NeedsExpectedValue() bool { |
| return !checker.noExpectedValue |
| } |
| |
| func (checker *MyChecker) Check(obtained, expected interface{}) (bool, string) { |
| checker.obtained = obtained |
| checker.expected = expected |
| return !checker.failCheck, checker.checkError |
| } |
| |
| |
| type myBugInfo struct { |
| info string |
| } |
| |
| func (bug *myBugInfo) GetBugInfo() string { |
| return bug.info |
| } |
| |
| func myBug(info string) *myBugInfo { |
| return &myBugInfo{info} |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Ensure a real checker actually works fine. |
| |
| func (s *HelpersS) TestCheckerInterface(c *gocheck.C) { |
| testHelperSuccess(c, "Check(1, Equals, 1)", true, func() interface{} { |
| return c.Check(1, gocheck.Equals, 1) |
| }) |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Tests for Check(), mostly the same as for Assert() following these. |
| |
| func (s *HelpersS) TestCheckSucceedWithExpected(c *gocheck.C) { |
| checker := &MyChecker{} |
| testHelperSuccess(c, "Check(1, checker, 2)", true, func() interface{} { |
| return c.Check(1, checker, 2) |
| }) |
| if checker.obtained != 1 || checker.expected != 2 { |
| c.Fatalf("Bad (obtained, expected) values for check (%d, %d)", |
| checker.obtained, checker.expected) |
| } |
| } |
| |
| func (s *HelpersS) TestCheckSucceedWithoutExpected(c *gocheck.C) { |
| checker := &MyChecker{noExpectedValue: true} |
| testHelperSuccess(c, "Check(1, checker)", true, func() interface{} { |
| return c.Check(1, checker) |
| }) |
| if checker.obtained != 1 || checker.expected != nil { |
| c.Fatalf("Bad (obtained, expected) values for check (%d, %d)", |
| checker.obtained, checker.expected) |
| } |
| } |
| |
| func (s *HelpersS) TestCheckFailWithExpected(c *gocheck.C) { |
| checker := &MyChecker{failCheck: true} |
| log := "helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + |
| " return c\\.Check\\(1, checker, 2\\)\n" + |
| "\\.+ myobtained = \\(int\\) 1\n" + |
| "\\.+ myexpected = \\(int\\) 2\n\n" |
| testHelperFailure(c, "Check(1, checker, 2)", false, false, log, |
| func() interface{} { |
| return c.Check(1, checker, 2) |
| }) |
| } |
| |
| func (s *HelpersS) TestCheckFailWithExpectedAndBugInfo(c *gocheck.C) { |
| checker := &MyChecker{failCheck: true} |
| log := "helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + |
| " return c\\.Check\\(1, checker, 2, myBug\\(\"Hello world!\"\\)\\)\n" + |
| "\\.+ myobtained = \\(int\\) 1\n" + |
| "\\.+ myexpected = \\(int\\) 2\n" + |
| "\\.+ Hello world!\n\n" |
| testHelperFailure(c, "Check(1, checker, 2, msg)", false, false, log, |
| func() interface{} { |
| return c.Check(1, checker, 2, myBug("Hello world!")) |
| }) |
| } |
| |
| func (s *HelpersS) TestCheckFailWithoutExpected(c *gocheck.C) { |
| checker := &MyChecker{failCheck: true, noExpectedValue: true} |
| log := "helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + |
| " return c\\.Check\\(1, checker\\)\n" + |
| "\\.+ myobtained = \\(int\\) 1\n\n" |
| testHelperFailure(c, "Check(1, checker)", false, false, log, |
| func() interface{} { |
| return c.Check(1, checker) |
| }) |
| } |
| |
| func (s *HelpersS) TestCheckFailWithoutExpectedAndMessage(c *gocheck.C) { |
| checker := &MyChecker{failCheck: true, noExpectedValue: true} |
| log := "helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + |
| " return c\\.Check\\(1, checker, myBug\\(\"Hello world!\"\\)\\)\n" + |
| "\\.+ myobtained = \\(int\\) 1\n" + |
| "\\.+ Hello world!\n\n" |
| testHelperFailure(c, "Check(1, checker, msg)", false, false, log, |
| func() interface{} { |
| return c.Check(1, checker, myBug("Hello world!")) |
| }) |
| } |
| |
| func (s *HelpersS) TestCheckWithMissingExpected(c *gocheck.C) { |
| checker := &MyChecker{failCheck: true} |
| log := "helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + |
| " return c\\.Check\\(1, checker\\)\n" + |
| "\\.+ Check\\(myobtained, MyChecker, >myexpected<\\):\n" + |
| "\\.+ Wrong number of myexpected args for MyChecker: " + |
| "want 1, got 0\n\n" |
| testHelperFailure(c, "Check(1, checker, !?)", false, false, log, |
| func() interface{} { |
| return c.Check(1, checker) |
| }) |
| } |
| |
| func (s *HelpersS) TestCheckWithTooManyExpected(c *gocheck.C) { |
| checker := &MyChecker{noExpectedValue: true} |
| log := "helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + |
| " return c\\.Check\\(1, checker, 1\\)\n" + |
| "\\.+ Check\\(myobtained, MyChecker, >myexpected<\\):\n" + |
| "\\.+ Wrong number of myexpected args for MyChecker: " + |
| "want 0, got 1\n\n" |
| testHelperFailure(c, "Check(1, checker, !?)", false, false, log, |
| func() interface{} { |
| return c.Check(1, checker, 1) |
| }) |
| } |
| |
| func (s *HelpersS) TestCheckWithError(c *gocheck.C) { |
| checker := &MyChecker{checkError: "Some not so cool data provided!"} |
| log := "helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + |
| " return c\\.Check\\(1, checker, 2\\)\n" + |
| "\\.+ myobtained = \\(int\\) 1\n" + |
| "\\.+ myexpected = \\(int\\) 2\n" + |
| "\\.+ Some not so cool data provided!\n\n" |
| testHelperFailure(c, "Check(1, checker, 2)", false, false, log, |
| func() interface{} { |
| return c.Check(1, checker, 2) |
| }) |
| } |
| |
| func (s *HelpersS) TestCheckWithNilChecker(c *gocheck.C) { |
| log := "helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + |
| " return c\\.Check\\(1, nil\\)\n" + |
| "\\.+ Check\\(obtained, nil!\\?, \\.\\.\\.\\):\n" + |
| "\\.+ Oops\\.\\. you've provided a nil checker!\n\n" |
| testHelperFailure(c, "Check(obtained, nil)", false, false, log, |
| func() interface{} { |
| return c.Check(1, nil) |
| }) |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Tests for Assert(), mostly the same as for Check() above. |
| |
| func (s *HelpersS) TestAssertSucceedWithExpected(c *gocheck.C) { |
| checker := &MyChecker{} |
| testHelperSuccess(c, "Assert(1, checker, 2)", nil, func() interface{} { |
| c.Assert(1, checker, 2) |
| return nil |
| }) |
| if checker.obtained != 1 || checker.expected != 2 { |
| c.Fatalf("Bad (obtained, expected) values for check (%d, %d)", |
| checker.obtained, checker.expected) |
| } |
| } |
| |
| func (s *HelpersS) TestAssertSucceedWithoutExpected(c *gocheck.C) { |
| checker := &MyChecker{noExpectedValue: true} |
| testHelperSuccess(c, "Assert(1, checker)", nil, func() interface{} { |
| c.Assert(1, checker) |
| return nil |
| }) |
| if checker.obtained != 1 || checker.expected != nil { |
| c.Fatalf("Bad (obtained, expected) values for check (%d, %d)", |
| checker.obtained, checker.expected) |
| } |
| } |
| |
| func (s *HelpersS) TestAssertFailWithExpected(c *gocheck.C) { |
| checker := &MyChecker{failCheck: true} |
| log := "helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + |
| " c\\.Assert\\(1, checker, 2\\)\n" + |
| "\\.+ myobtained = \\(int\\) 1\n" + |
| "\\.+ myexpected = \\(int\\) 2\n\n" |
| testHelperFailure(c, "Assert(1, checker, 2)", nil, true, log, |
| func() interface{} { |
| c.Assert(1, checker, 2) |
| return nil |
| }) |
| } |
| |
| func (s *HelpersS) TestAssertFailWithExpectedAndMessage(c *gocheck.C) { |
| checker := &MyChecker{failCheck: true} |
| log := "helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + |
| " c\\.Assert\\(1, checker, 2, myBug\\(\"Hello world!\"\\)\\)\n" + |
| "\\.+ myobtained = \\(int\\) 1\n" + |
| "\\.+ myexpected = \\(int\\) 2\n" + |
| "\\.+ Hello world!\n\n" |
| testHelperFailure(c, "Assert(1, checker, 2, msg)", nil, true, log, |
| func() interface{} { |
| c.Assert(1, checker, 2, myBug("Hello world!")) |
| return nil |
| }) |
| } |
| |
| func (s *HelpersS) TestAssertFailWithoutExpected(c *gocheck.C) { |
| checker := &MyChecker{failCheck: true, noExpectedValue: true} |
| log := "helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + |
| " c\\.Assert\\(1, checker\\)\n" + |
| "\\.+ myobtained = \\(int\\) 1\n\n" |
| testHelperFailure(c, "Assert(1, checker)", nil, true, log, |
| func() interface{} { |
| c.Assert(1, checker) |
| return nil |
| }) |
| } |
| |
| func (s *HelpersS) TestAssertFailWithoutExpectedAndMessage(c *gocheck.C) { |
| checker := &MyChecker{failCheck: true, noExpectedValue: true} |
| log := "helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + |
| " c\\.Assert\\(1, checker, myBug\\(\"Hello world!\"\\)\\)\n" + |
| "\\.+ myobtained = \\(int\\) 1\n" + |
| "\\.+ Hello world!\n\n" |
| testHelperFailure(c, "Assert(1, checker, msg)", nil, true, log, |
| func() interface{} { |
| c.Assert(1, checker, myBug("Hello world!")) |
| return nil |
| }) |
| } |
| |
| func (s *HelpersS) TestAssertWithMissingExpected(c *gocheck.C) { |
| checker := &MyChecker{failCheck: true} |
| log := "helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + |
| " c\\.Assert\\(1, checker\\)\n" + |
| "\\.+ Assert\\(myobtained, MyChecker, >myexpected<\\):\n" + |
| "\\.+ Wrong number of myexpected args for MyChecker: " + |
| "want 1, got 0\n\n" |
| testHelperFailure(c, "Assert(1, checker, !?)", nil, true, log, |
| func() interface{} { |
| c.Assert(1, checker) |
| return nil |
| }) |
| } |
| |
| func (s *HelpersS) TestAssertWithError(c *gocheck.C) { |
| checker := &MyChecker{checkError: "Some not so cool data provided!"} |
| log := "helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + |
| " c\\.Assert\\(1, checker, 2\\)\n" + |
| "\\.+ myobtained = \\(int\\) 1\n" + |
| "\\.+ myexpected = \\(int\\) 2\n" + |
| "\\.+ Some not so cool data provided!\n\n" |
| testHelperFailure(c, "Assert(1, checker, 2)", nil, true, log, |
| func() interface{} { |
| c.Assert(1, checker, 2) |
| return nil |
| }) |
| } |
| |
| func (s *HelpersS) TestAssertWithNilChecker(c *gocheck.C) { |
| log := "helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + |
| " c\\.Assert\\(1, nil\\)\n" + |
| "\\.+ Assert\\(obtained, nil!\\?, \\.\\.\\.\\):\n" + |
| "\\.+ Oops\\.\\. you've provided a nil checker!\n\n" |
| testHelperFailure(c, "Assert(obtained, nil)", nil, true, log, |
| func() interface{} { |
| c.Assert(1, nil) |
| return nil |
| }) |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Ensure that values logged work properly in some interesting cases. |
| |
| func (s *HelpersS) TestValueLoggingWithArrays(c *gocheck.C) { |
| checker := &MyChecker{failCheck: true} |
| log := "helpers_test.go:[0-9]+:.*\nhelpers_test.go:[0-9]+:\n" + |
| " return c\\.Check\\(\\[\\]byte{1, 2}, checker, \\[\\]byte{1, 3}\\)\n" + |
| "\\.+ myobtained = \\(\\[\\]uint8\\) \\[\\]byte{0x1, 0x2}\n" + |
| "\\.+ myexpected = \\(\\[\\]uint8\\) \\[\\]byte{0x1, 0x3}\n\n" |
| testHelperFailure(c, "Check([]byte{1}, chk, []byte{3})", false, false, log, |
| func() interface{} { |
| return c.Check([]byte{1, 2}, checker, []byte{1, 3}) |
| }) |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // MakeDir() tests. |
| |
| type MkDirHelper struct { |
| path1 string |
| path2 string |
| isDir1 bool |
| isDir2 bool |
| isDir3 bool |
| isDir4 bool |
| } |
| |
| func (s *MkDirHelper) SetUpSuite(c *gocheck.C) { |
| s.path1 = c.MkDir() |
| s.isDir1 = isDir(s.path1) |
| } |
| |
| func (s *MkDirHelper) Test(c *gocheck.C) { |
| s.path2 = c.MkDir() |
| s.isDir2 = isDir(s.path2) |
| } |
| |
| func (s *MkDirHelper) TearDownSuite(c *gocheck.C) { |
| s.isDir3 = isDir(s.path1) |
| s.isDir4 = isDir(s.path2) |
| } |
| |
| |
| func (s *HelpersS) TestMkDir(c *gocheck.C) { |
| helper := MkDirHelper{} |
| output := String{} |
| gocheck.Run(&helper, &gocheck.RunConf{Output: &output}) |
| c.Assert(output.value, gocheck.Equals, "") |
| c.Check(helper.isDir1, gocheck.Equals, true) |
| c.Check(helper.isDir2, gocheck.Equals, true) |
| c.Check(helper.isDir3, gocheck.Equals, true) |
| c.Check(helper.isDir4, gocheck.Equals, true) |
| c.Check(helper.path1, gocheck.Not(gocheck.Equals), |
| helper.path2) |
| c.Check(isDir(helper.path1), gocheck.Equals, false) |
| c.Check(isDir(helper.path2), gocheck.Equals, false) |
| } |
| |
| func isDir(path string) bool { |
| if stat, err := os.Stat(path); err == nil { |
| return stat.IsDirectory() |
| } |
| return false |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // A couple of helper functions to test helper functions. :-) |
| |
| func testHelperSuccess(c *gocheck.C, name string, |
| expectedResult interface{}, |
| closure func() interface{}) { |
| var result interface{} |
| defer (func() { |
| if err := recover(); err != nil { |
| panic(err) |
| } |
| checkState(c, result, |
| &expectedState{ |
| name: name, |
| result: expectedResult, |
| failed: false, |
| log: "", |
| }) |
| })() |
| result = closure() |
| } |
| |
| func testHelperFailure(c *gocheck.C, name string, |
| expectedResult interface{}, |
| shouldStop bool, log string, |
| closure func() interface{}) { |
| var result interface{} |
| defer (func() { |
| if err := recover(); err != nil { |
| panic(err) |
| } |
| checkState(c, result, |
| &expectedState{ |
| name: name, |
| result: expectedResult, |
| failed: true, |
| log: log, |
| }) |
| })() |
| result = closure() |
| if shouldStop { |
| c.Logf("%s didn't stop when it should", name) |
| } |
| } |
