func (s *FixtureHelper) Benchmark2(c *check.C) { s.trace("Benchmark2", c) c.SetBytes(1024) for i := 0; i < c.N; i++ { time.Sleep(s.sleep) } }
func testBucketRecreateFails(c *check.C, create func() Driver) { drivers := create() err := drivers.CreateBucket("string", "") c.Assert(err, check.IsNil) err = drivers.CreateBucket("string", "") c.Assert(err, check.Not(check.IsNil)) }
func (s *BootstrapS) TestLogfAndGetTestLog(c *check.C) { c.Logf("Hello %v", "there!") log := c.GetTestLog() if log != "Hello there!\n" { critical(fmt.Sprintf("Logf() or GetTestLog() is not working! Got: %#v", log)) } }
func (s *CheckersS) TestComment(c *check.C) { bug := check.Commentf("a %d bc", 42) comment := bug.CheckCommentString() if comment != "a 42 bc" { c.Fatalf("Commentf returned %#v", comment) } }
func (s *CheckersS) TestPanics(c *check.C) { testInfo(c, check.Panics, "Panics", []string{"function", "expected"}) // Some errors. testCheck(c, check.Panics, false, "Function has not panicked", func() bool { return false }, "BOOM") testCheck(c, check.Panics, false, "Function must take zero arguments", 1, "BOOM") // Plain strings. testCheck(c, check.Panics, true, "", func() { panic("BOOM") }, "BOOM") testCheck(c, check.Panics, false, "", func() { panic("KABOOM") }, "BOOM") testCheck(c, check.Panics, true, "", func() bool { panic("BOOM") }, "BOOM") // Error values. testCheck(c, check.Panics, true, "", func() { panic(errors.New("BOOM")) }, errors.New("BOOM")) testCheck(c, check.Panics, false, "", func() { panic(errors.New("KABOOM")) }, errors.New("BOOM")) type deep struct{ i int } // Deep value testCheck(c, check.Panics, true, "", func() { panic(&deep{99}) }, &deep{99}) // Verify params/names mutation params, names := testCheck(c, check.Panics, false, "", func() { panic(errors.New("KABOOM")) }, errors.New("BOOM")) c.Assert(params[0], check.ErrorMatches, "KABOOM") c.Assert(names[0], check.Equals, "panic") // Verify a nil panic testCheck(c, check.Panics, true, "", func() { panic(nil) }, nil) testCheck(c, check.Panics, false, "", func() { panic(nil) }, "NOPE") }
func testMultipartObjectAbort(c *check.C, create func() Driver) { drivers := create() switch { case reflect.TypeOf(drivers).String() == "*donut.donutDriver": return } err := drivers.CreateBucket("bucket", "") c.Assert(err, check.IsNil) uploadID, err := drivers.NewMultipartUpload("bucket", "key", "") c.Assert(err, check.IsNil) parts := make(map[int]string) for i := 1; i <= 10; i++ { randomPerm := rand.Perm(10) randomString := "" for _, num := range randomPerm { randomString = randomString + strconv.Itoa(num) } hasher := md5.New() hasher.Write([]byte(randomString)) expectedmd5Sum := base64.StdEncoding.EncodeToString(hasher.Sum(nil)) expectedmd5Sumhex := hex.EncodeToString(hasher.Sum(nil)) calculatedmd5sum, err := drivers.CreateObjectPart("bucket", "key", uploadID, i, "", expectedmd5Sum, int64(len(randomString)), bytes.NewBufferString(randomString)) c.Assert(err, check.IsNil) c.Assert(calculatedmd5sum, check.Equals, expectedmd5Sumhex) parts[i] = calculatedmd5sum } err = drivers.AbortMultipartUpload("bucket", "key", uploadID) c.Assert(err, check.IsNil) }
func (s *FoundationS) TestExpectFailureSucceed(c *check.C) { helper := ExpectFailureSucceedHelper{} output := String{} result := check.Run(&helper, &check.RunConf{Output: &output}) c.Assert(output.value, check.Equals, "") c.Assert(result.ExpectedFailures, check.Equals, 1) }
func testInfo(c *check.C, checker check.Checker, name string, paramNames []string) { info := checker.Info() if info.Name != name { c.Fatalf("Got name %s, expected %s", info.Name, name) } if !reflect.DeepEqual(info.Params, paramNames) { c.Fatalf("Got param names %#v, expected %#v", info.Params, paramNames) } }
func (s *BootstrapS) TestMinLogger(c *check.C) { var logger minLogger logger = log.New(os.Stderr, "", 0) logger = c logger.Output(0, "Hello there") expected := `\[LOG\] [0-9]+:[0-9][0-9]\.[0-9][0-9][0-9] +Hello there\n` output := c.GetTestLog() c.Assert(output, check.Matches, expected) }
func (s *HelpersS) TestCheckSucceedWithoutExpected(c *check.C) { checker := &MyChecker{result: true, info: &check.CheckerInfo{Params: []string{"myvalue"}}} testHelperSuccess(c, "Check(1, checker)", true, func() interface{} { return c.Check(1, checker) }) if !reflect.DeepEqual(checker.params, []interface{}{1}) { c.Fatalf("Bad params for check: %#v", checker.params) } }
func (s *FoundationS) TestSkip(c *check.C) { helper := SkipTestHelper{} output := String{} check.Run(&helper, &check.RunConf{Output: &output}) if output.value != "" { c.Error("Skip() logged something:\n", output.value) } }
func (s *HelpersS) TestCheckSucceedWithExpected(c *check.C) { checker := &MyChecker{result: true} testHelperSuccess(c, "Check(1, checker, 2)", true, func() interface{} { return c.Check(1, checker, 2) }) if !reflect.DeepEqual(checker.params, []interface{}{1, 2}) { c.Fatalf("Bad params for check: %#v", checker.params) } }
func (s *HelpersS) TestCheckWithNilChecker(c *check.C) { log := "(?s)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) }) }
func (s *HelpersS) TestCheckFailWithoutExpected(c *check.C) { checker := &MyChecker{result: false, info: &check.CheckerInfo{Params: []string{"myvalue"}}} log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + " return c\\.Check\\(1, checker\\)\n" + "\\.+ myvalue int = 1\n\n" testHelperFailure(c, "Check(1, checker)", false, false, log, func() interface{} { return c.Check(1, checker) }) }
func (s *HelpersS) TestCheckFailWithExpected(c *check.C) { checker := &MyChecker{result: false} log := "(?s)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) TestValueLoggingWithArrays(c *check.C) { checker := &MyChecker{result: false} log := "(?s)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}) }) }
func (s *HelpersS) TestAssertWithNilChecker(c *check.C) { log := "(?s)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 }) }
func (s *HelpersS) TestCheckFailWithoutExpectedAndMessage(c *check.C) { checker := &MyChecker{result: false, info: &check.CheckerInfo{Params: []string{"myvalue"}}} log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + " return c\\.Check\\(1, checker, myComment\\(\"Hello world!\"\\)\\)\n" + "\\.+ myvalue int = 1\n" + "\\.+ Hello world!\n\n" testHelperFailure(c, "Check(1, checker, msg)", false, false, log, func() interface{} { return c.Check(1, checker, myComment("Hello world!")) }) }
func (s *HelpersS) TestAssertFailWithoutExpected(c *check.C) { checker := &MyChecker{result: false, info: &check.CheckerInfo{Params: []string{"myvalue"}}} log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + " c\\.Assert\\(1, checker\\)\n" + "\\.+ myvalue int = 1\n\n" testHelperFailure(c, "Assert(1, checker)", nil, true, log, func() interface{} { c.Assert(1, checker) return nil }) }
func (s *HelpersS) TestCheckWithParamsAndNamesMutation(c *check.C) { checker := &MyChecker{result: false, params: []interface{}{3, 4}, names: []string{"newobtained", "newexpected"}} log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + " return c\\.Check\\(1, checker, 2\\)\n" + "\\.+ newobtained int = 3\n" + "\\.+ newexpected int = 4\n\n" testHelperFailure(c, "Check(1, checker, 2) with mutation", false, false, log, func() interface{} { return c.Check(1, checker, 2) }) }
func (s *HelpersS) TestCheckWithError(c *check.C) { checker := &MyChecker{result: false, error: "Some not so cool data provided!"} log := "(?s)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) TestAssertFailWithExpected(c *check.C) { checker := &MyChecker{result: false} log := "(?s)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) TestCheckWithTooManyExpected(c *check.C) { checker := &MyChecker{result: true} log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + " return c\\.Check\\(1, checker, 2, 3\\)\n" + "\\.+ Check\\(myobtained, MyChecker, myexpected\\):\n" + "\\.+ Wrong number of parameters for MyChecker: " + "want 3, got 4\n\n" testHelperFailure(c, "Check(1, checker, 2, 3)", false, false, log, func() interface{} { return c.Check(1, checker, 2, 3) }) }
func (s *HelpersS) TestCheckFailWithExpectedAndComment(c *check.C) { checker := &MyChecker{result: false} log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + " return c\\.Check\\(1, checker, 2, myComment\\(\"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, myComment("Hello world!")) }) }
func (s *FixtureHelper) trace(name string, c *check.C) { s.calls = append(s.calls, name) if name == s.panicOn { panic(name) } if s.sleep > 0 && s.sleepOn == name { time.Sleep(s.sleep) } if s.skip && s.skipOnN == len(s.calls)-1 { c.Skip("skipOnN == n") } }
func (s *HelpersS) TestAssertWithMissingExpected(c *check.C) { checker := &MyChecker{result: true} log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + " c\\.Assert\\(1, checker\\)\n" + "\\.+ Assert\\(myobtained, MyChecker, myexpected\\):\n" + "\\.+ Wrong number of parameters for MyChecker: " + "want 3, got 2\n\n" testHelperFailure(c, "Assert(1, checker, !?)", nil, true, log, func() interface{} { c.Assert(1, checker) return nil }) }
func (s *HelpersS) TestCheckFailWithExpectedAndStaticComment(c *check.C) { checker := &MyChecker{result: false} log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + " // Nice leading comment\\.\n" + " return c\\.Check\\(1, checker, 2\\) // Hello there\n" + "\\.+ myobtained int = 1\n" + "\\.+ myexpected int = 2\n\n" testHelperFailure(c, "Check(1, checker, 2, msg)", false, false, log, func() interface{} { // Nice leading comment. return c.Check(1, checker, 2) // Hello there }) }
func (s *FoundationS) TestError(c *check.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 *HelpersS) TestAssertFailWithExpectedAndMessage(c *check.C) { checker := &MyChecker{result: false} log := "(?s)helpers_test\\.go:[0-9]+:.*\nhelpers_test\\.go:[0-9]+:\n" + " c\\.Assert\\(1, checker, 2, myComment\\(\"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, myComment("Hello world!")) return nil }) }
func (s *HelpersS) TestAssertWithError(c *check.C) { checker := &MyChecker{result: false, error: "Some not so cool data provided!"} log := "(?s)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 }) }