launchpad.net/gocheck => gopkg.in/check.v1
diff --git a/benchmark.go b/benchmark.go
index dcd426f..ee1cfe6 100644
--- a/benchmark.go
+++ b/benchmark.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package gocheck
+package check
import (
"fmt"
diff --git a/benchmark_test.go b/benchmark_test.go
index 336243f..b7f7b44 100644
--- a/benchmark_test.go
+++ b/benchmark_test.go
@@ -1,9 +1,9 @@
// These tests verify the test running logic.
-package gocheck_test
+package check_test
import (
- . "launchpad.net/gocheck"
+ . "gopkg.in/check.v1"
"time"
)
@@ -21,8 +21,8 @@
runConf := RunConf{Output: &output, Verbose: true}
Run(&helper, &runConf)
- expected := "PASS: gocheck_test\\.go:[0-9]+: FixtureHelper\\.Test1\t0\\.001s\n" +
- "PASS: gocheck_test\\.go:[0-9]+: FixtureHelper\\.Test2\t0\\.000s\n"
+ expected := "PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Test1\t0\\.001s\n" +
+ "PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Test2\t0\\.000s\n"
c.Assert(output.value, Matches, expected)
}
@@ -32,7 +32,7 @@
runConf := RunConf{Output: &output, Stream: true}
Run(&helper, &runConf)
- expected := "(?s).*\nPASS: gocheck_test\\.go:[0-9]+: FixtureHelper\\.SetUpSuite\t *0\\.001s\n.*"
+ expected := "(?s).*\nPASS: check_test\\.go:[0-9]+: FixtureHelper\\.SetUpSuite\t *0\\.001s\n.*"
c.Assert(output.value, Matches, expected)
}
@@ -55,7 +55,7 @@
c.Check(helper.calls[6], Equals, "TearDownTest")
// ... and more.
- expected := "PASS: gocheck_test\\.go:[0-9]+: FixtureHelper\\.Benchmark1\t *100\t *[12][0-9]{5} ns/op\n"
+ expected := "PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Benchmark1\t *100\t *[12][0-9]{5} ns/op\n"
c.Assert(output.value, Matches, expected)
}
@@ -70,6 +70,6 @@
}
Run(&helper, &runConf)
- expected := "PASS: gocheck_test\\.go:[0-9]+: FixtureHelper\\.Benchmark2\t *100\t *[12][0-9]{5} ns/op\t *[4-9]\\.[0-9]{2} MB/s\n"
+ expected := "PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Benchmark2\t *100\t *[12][0-9]{5} ns/op\t *[4-9]\\.[0-9]{2} MB/s\n"
c.Assert(output.value, Matches, expected)
}
diff --git a/bootstrap_test.go b/bootstrap_test.go
index a3bc28c..e55f327 100644
--- a/bootstrap_test.go
+++ b/bootstrap_test.go
@@ -10,23 +10,23 @@
// Do not assume *any* internal functionality works as expected besides
// what's actually tested here.
-package gocheck_test
+package check_test
import (
"fmt"
- "launchpad.net/gocheck"
+ "gopkg.in/check.v1"
"strings"
)
type BootstrapS struct{}
-var boostrapS = gocheck.Suite(&BootstrapS{})
+var boostrapS = check.Suite(&BootstrapS{})
-func (s *BootstrapS) TestCountSuite(c *gocheck.C) {
+func (s *BootstrapS) TestCountSuite(c *check.C) {
suitesRun += 1
}
-func (s *BootstrapS) TestFailedAndFail(c *gocheck.C) {
+func (s *BootstrapS) TestFailedAndFail(c *check.C) {
if c.Failed() {
critical("c.Failed() must be false first!")
}
@@ -37,7 +37,7 @@
c.Succeed()
}
-func (s *BootstrapS) TestFailedAndSucceed(c *gocheck.C) {
+func (s *BootstrapS) TestFailedAndSucceed(c *check.C) {
c.Fail()
c.Succeed()
if c.Failed() {
@@ -45,7 +45,7 @@
}
}
-func (s *BootstrapS) TestLogAndGetTestLog(c *gocheck.C) {
+func (s *BootstrapS) TestLogAndGetTestLog(c *check.C) {
c.Log("Hello there!")
log := c.GetTestLog()
if log != "Hello there!\n" {
@@ -53,7 +53,7 @@
}
}
-func (s *BootstrapS) TestLogfAndGetTestLog(c *gocheck.C) {
+func (s *BootstrapS) TestLogfAndGetTestLog(c *check.C) {
c.Logf("Hello %v", "there!")
log := c.GetTestLog()
if log != "Hello there!\n" {
@@ -61,9 +61,9 @@
}
}
-func (s *BootstrapS) TestRunShowsErrors(c *gocheck.C) {
+func (s *BootstrapS) TestRunShowsErrors(c *check.C) {
output := String{}
- gocheck.Run(&FailHelper{}, &gocheck.RunConf{Output: &output})
+ check.Run(&FailHelper{}, &check.RunConf{Output: &output})
if strings.Index(output.value, "Expected failure!") == -1 {
critical(fmt.Sprintf("RunWithWriter() output did not contain the "+
"expected failure! Got: %#v",
@@ -71,9 +71,9 @@
}
}
-func (s *BootstrapS) TestRunDoesntShowSuccesses(c *gocheck.C) {
+func (s *BootstrapS) TestRunDoesntShowSuccesses(c *check.C) {
output := String{}
- gocheck.Run(&SuccessHelper{}, &gocheck.RunConf{Output: &output})
+ check.Run(&SuccessHelper{}, &check.RunConf{Output: &output})
if strings.Index(output.value, "Expected success!") != -1 {
critical(fmt.Sprintf("RunWithWriter() output contained a successful "+
"test! Got: %#v",
diff --git a/gocheck.go b/check.go
similarity index 98%
rename from gocheck.go
rename to check.go
index 21977db..5239f6a 100644
--- a/gocheck.go
+++ b/check.go
@@ -1,4 +1,4 @@
-package gocheck
+package check
import (
"bytes"
@@ -128,7 +128,7 @@
if td.path == "" {
var err error
for i := 0; i != 100; i++ {
- path := fmt.Sprintf("%s/gocheck-%d", os.TempDir(), rand.Int())
+ path := fmt.Sprintf("%s/check-%d", os.TempDir(), rand.Int())
if err = os.Mkdir(path, 0700); err == nil {
td.path = path
break
@@ -738,7 +738,7 @@
// Rather than a plain panic, provide a more helpful message when
// the argument type is incorrect.
c.status = panickedSt
- c.logArgPanic(c.method, "*gocheck.C")
+ c.logArgPanic(c.method, "*check.C")
return
}
if strings.HasPrefix(c.method.Info.Name, "Test") {
@@ -797,7 +797,7 @@
}
}
-// Verify if the fixture arguments are *gocheck.C. In case of errors,
+// Verify if the fixture arguments are *check.C. In case of errors,
// log the error as a panic in the fixture method call, and return false.
func (runner *suiteRunner) checkFixtureArgs() bool {
succeeded := true
@@ -808,7 +808,7 @@
if mt.NumIn() != 1 || mt.In(0) != argType {
succeeded = false
runner.runFunc(method, fixtureKd, nil, func(c *C) {
- c.logArgPanic(method, "*gocheck.C")
+ c.logArgPanic(method, "*check.C")
c.status = panickedSt
})
}
diff --git a/gocheck_test.go b/check_test.go
similarity index 81%
rename from gocheck_test.go
rename to check_test.go
index e4acda9..19c0c5b 100644
--- a/gocheck_test.go
+++ b/check_test.go
@@ -1,12 +1,12 @@
// This file contains just a few generic helpers which are used by the
// other test files.
-package gocheck_test
+package check_test
import (
"flag"
"fmt"
- "launchpad.net/gocheck"
+ "gopkg.in/check.v1"
"os"
"regexp"
"runtime"
@@ -22,8 +22,8 @@
var suitesRun int = 0
func Test(t *testing.T) {
- gocheck.TestingT(t)
- if suitesRun != suitesRunExpected && flag.Lookup("gocheck.f").Value.String() == "" {
+ check.TestingT(t)
+ if suitesRun != suitesRunExpected && flag.Lookup("check.f").Value.String() == "" {
critical(fmt.Sprintf("Expected %d suites to run rather than %d",
suitesRunExpected, suitesRun))
}
@@ -64,8 +64,8 @@
// Trivial wrapper to test errors happening on a different file
// than the test itself.
-func checkEqualWrapper(c *gocheck.C, obtained, expected interface{}) (result bool, line int) {
- return c.Check(obtained, gocheck.Equals, expected), getMyLine()
+func checkEqualWrapper(c *check.C, obtained, expected interface{}) (result bool, line int) {
+ return c.Check(obtained, check.Equals, expected), getMyLine()
}
// -----------------------------------------------------------------------
@@ -75,7 +75,7 @@
testLine int
}
-func (s *FailHelper) TestLogAndFail(c *gocheck.C) {
+func (s *FailHelper) TestLogAndFail(c *check.C) {
s.testLine = getMyLine() - 1
c.Log("Expected failure!")
c.Fail()
@@ -86,7 +86,7 @@
type SuccessHelper struct{}
-func (s *SuccessHelper) TestLogAndSucceed(c *gocheck.C) {
+func (s *SuccessHelper) TestLogAndSucceed(c *check.C) {
c.Log("Expected success!")
}
@@ -103,7 +103,7 @@
bytes int64
}
-func (s *FixtureHelper) trace(name string, c *gocheck.C) {
+func (s *FixtureHelper) trace(name string, c *check.C) {
s.calls = append(s.calls, name)
if name == s.panicOn {
panic(name)
@@ -116,38 +116,38 @@
}
}
-func (s *FixtureHelper) SetUpSuite(c *gocheck.C) {
+func (s *FixtureHelper) SetUpSuite(c *check.C) {
s.trace("SetUpSuite", c)
}
-func (s *FixtureHelper) TearDownSuite(c *gocheck.C) {
+func (s *FixtureHelper) TearDownSuite(c *check.C) {
s.trace("TearDownSuite", c)
}
-func (s *FixtureHelper) SetUpTest(c *gocheck.C) {
+func (s *FixtureHelper) SetUpTest(c *check.C) {
s.trace("SetUpTest", c)
}
-func (s *FixtureHelper) TearDownTest(c *gocheck.C) {
+func (s *FixtureHelper) TearDownTest(c *check.C) {
s.trace("TearDownTest", c)
}
-func (s *FixtureHelper) Test1(c *gocheck.C) {
+func (s *FixtureHelper) Test1(c *check.C) {
s.trace("Test1", c)
}
-func (s *FixtureHelper) Test2(c *gocheck.C) {
+func (s *FixtureHelper) Test2(c *check.C) {
s.trace("Test2", c)
}
-func (s *FixtureHelper) Benchmark1(c *gocheck.C) {
+func (s *FixtureHelper) Benchmark1(c *check.C) {
s.trace("Benchmark1", c)
for i := 0; i < c.N; i++ {
time.Sleep(s.sleep)
}
}
-func (s *FixtureHelper) Benchmark2(c *gocheck.C) {
+func (s *FixtureHelper) Benchmark2(c *check.C) {
s.trace("Benchmark2", c)
c.SetBytes(1024)
for i := 0; i < c.N; i++ {
@@ -170,7 +170,7 @@
// Verify the state of the test. Note that since this also verifies if
// the test is supposed to be in a failed state, no other checks should
// be done in addition to what is being tested.
-func checkState(c *gocheck.C, result interface{}, expected *expectedState) {
+func checkState(c *check.C, result interface{}, expected *expectedState) {
failed := c.Failed()
c.Succeed()
log := c.GetTestLog()
diff --git a/checkers.go b/checkers.go
index 5c91200..bac3387 100644
--- a/checkers.go
+++ b/checkers.go
@@ -1,4 +1,4 @@
-package gocheck
+package check
import (
"fmt"
diff --git a/checkers_test.go b/checkers_test.go
index 0945491..5c69747 100644
--- a/checkers_test.go
+++ b/checkers_test.go
@@ -1,17 +1,17 @@
-package gocheck_test
+package check_test
import (
"errors"
- "launchpad.net/gocheck"
+ "gopkg.in/check.v1"
"reflect"
"runtime"
)
type CheckersS struct{}
-var _ = gocheck.Suite(&CheckersS{})
+var _ = check.Suite(&CheckersS{})
-func testInfo(c *gocheck.C, checker gocheck.Checker, name string, paramNames []string) {
+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)
@@ -21,7 +21,7 @@
}
}
-func testCheck(c *gocheck.C, checker gocheck.Checker, result bool, error string, params ...interface{}) ([]interface{}, []string) {
+func testCheck(c *check.C, checker check.Checker, result bool, error string, params ...interface{}) ([]interface{}, []string) {
info := checker.Info()
if len(params) != len(info.Params) {
c.Fatalf("unexpected param count in test; expected %d got %d", len(info.Params), len(params))
@@ -35,238 +35,238 @@
return params, names
}
-func (s *CheckersS) TestComment(c *gocheck.C) {
- bug := gocheck.Commentf("a %d bc", 42)
+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) TestIsNil(c *gocheck.C) {
- testInfo(c, gocheck.IsNil, "IsNil", []string{"value"})
+func (s *CheckersS) TestIsNil(c *check.C) {
+ testInfo(c, check.IsNil, "IsNil", []string{"value"})
- testCheck(c, gocheck.IsNil, true, "", nil)
- testCheck(c, gocheck.IsNil, false, "", "a")
+ testCheck(c, check.IsNil, true, "", nil)
+ testCheck(c, check.IsNil, false, "", "a")
- testCheck(c, gocheck.IsNil, true, "", (chan int)(nil))
- testCheck(c, gocheck.IsNil, false, "", make(chan int))
- testCheck(c, gocheck.IsNil, true, "", (error)(nil))
- testCheck(c, gocheck.IsNil, false, "", errors.New(""))
- testCheck(c, gocheck.IsNil, true, "", ([]int)(nil))
- testCheck(c, gocheck.IsNil, false, "", make([]int, 1))
- testCheck(c, gocheck.IsNil, false, "", int(0))
+ testCheck(c, check.IsNil, true, "", (chan int)(nil))
+ testCheck(c, check.IsNil, false, "", make(chan int))
+ testCheck(c, check.IsNil, true, "", (error)(nil))
+ testCheck(c, check.IsNil, false, "", errors.New(""))
+ testCheck(c, check.IsNil, true, "", ([]int)(nil))
+ testCheck(c, check.IsNil, false, "", make([]int, 1))
+ testCheck(c, check.IsNil, false, "", int(0))
}
-func (s *CheckersS) TestNotNil(c *gocheck.C) {
- testInfo(c, gocheck.NotNil, "NotNil", []string{"value"})
+func (s *CheckersS) TestNotNil(c *check.C) {
+ testInfo(c, check.NotNil, "NotNil", []string{"value"})
- testCheck(c, gocheck.NotNil, false, "", nil)
- testCheck(c, gocheck.NotNil, true, "", "a")
+ testCheck(c, check.NotNil, false, "", nil)
+ testCheck(c, check.NotNil, true, "", "a")
- testCheck(c, gocheck.NotNil, false, "", (chan int)(nil))
- testCheck(c, gocheck.NotNil, true, "", make(chan int))
- testCheck(c, gocheck.NotNil, false, "", (error)(nil))
- testCheck(c, gocheck.NotNil, true, "", errors.New(""))
- testCheck(c, gocheck.NotNil, false, "", ([]int)(nil))
- testCheck(c, gocheck.NotNil, true, "", make([]int, 1))
+ testCheck(c, check.NotNil, false, "", (chan int)(nil))
+ testCheck(c, check.NotNil, true, "", make(chan int))
+ testCheck(c, check.NotNil, false, "", (error)(nil))
+ testCheck(c, check.NotNil, true, "", errors.New(""))
+ testCheck(c, check.NotNil, false, "", ([]int)(nil))
+ testCheck(c, check.NotNil, true, "", make([]int, 1))
}
-func (s *CheckersS) TestNot(c *gocheck.C) {
- testInfo(c, gocheck.Not(gocheck.IsNil), "Not(IsNil)", []string{"value"})
+func (s *CheckersS) TestNot(c *check.C) {
+ testInfo(c, check.Not(check.IsNil), "Not(IsNil)", []string{"value"})
- testCheck(c, gocheck.Not(gocheck.IsNil), false, "", nil)
- testCheck(c, gocheck.Not(gocheck.IsNil), true, "", "a")
+ testCheck(c, check.Not(check.IsNil), false, "", nil)
+ testCheck(c, check.Not(check.IsNil), true, "", "a")
}
type simpleStruct struct {
i int
}
-func (s *CheckersS) TestEquals(c *gocheck.C) {
- testInfo(c, gocheck.Equals, "Equals", []string{"obtained", "expected"})
+func (s *CheckersS) TestEquals(c *check.C) {
+ testInfo(c, check.Equals, "Equals", []string{"obtained", "expected"})
// The simplest.
- testCheck(c, gocheck.Equals, true, "", 42, 42)
- testCheck(c, gocheck.Equals, false, "", 42, 43)
+ testCheck(c, check.Equals, true, "", 42, 42)
+ testCheck(c, check.Equals, false, "", 42, 43)
// Different native types.
- testCheck(c, gocheck.Equals, false, "", int32(42), int64(42))
+ testCheck(c, check.Equals, false, "", int32(42), int64(42))
// With nil.
- testCheck(c, gocheck.Equals, false, "", 42, nil)
+ testCheck(c, check.Equals, false, "", 42, nil)
// Slices
- testCheck(c, gocheck.Equals, false, "runtime error: comparing uncomparable type []uint8", []byte{1, 2}, []byte{1, 2})
+ testCheck(c, check.Equals, false, "runtime error: comparing uncomparable type []uint8", []byte{1, 2}, []byte{1, 2})
// Struct values
- testCheck(c, gocheck.Equals, true, "", simpleStruct{1}, simpleStruct{1})
- testCheck(c, gocheck.Equals, false, "", simpleStruct{1}, simpleStruct{2})
+ testCheck(c, check.Equals, true, "", simpleStruct{1}, simpleStruct{1})
+ testCheck(c, check.Equals, false, "", simpleStruct{1}, simpleStruct{2})
// Struct pointers
- testCheck(c, gocheck.Equals, false, "", &simpleStruct{1}, &simpleStruct{1})
- testCheck(c, gocheck.Equals, false, "", &simpleStruct{1}, &simpleStruct{2})
+ testCheck(c, check.Equals, false, "", &simpleStruct{1}, &simpleStruct{1})
+ testCheck(c, check.Equals, false, "", &simpleStruct{1}, &simpleStruct{2})
}
-func (s *CheckersS) TestDeepEquals(c *gocheck.C) {
- testInfo(c, gocheck.DeepEquals, "DeepEquals", []string{"obtained", "expected"})
+func (s *CheckersS) TestDeepEquals(c *check.C) {
+ testInfo(c, check.DeepEquals, "DeepEquals", []string{"obtained", "expected"})
// The simplest.
- testCheck(c, gocheck.DeepEquals, true, "", 42, 42)
- testCheck(c, gocheck.DeepEquals, false, "", 42, 43)
+ testCheck(c, check.DeepEquals, true, "", 42, 42)
+ testCheck(c, check.DeepEquals, false, "", 42, 43)
// Different native types.
- testCheck(c, gocheck.DeepEquals, false, "", int32(42), int64(42))
+ testCheck(c, check.DeepEquals, false, "", int32(42), int64(42))
// With nil.
- testCheck(c, gocheck.DeepEquals, false, "", 42, nil)
+ testCheck(c, check.DeepEquals, false, "", 42, nil)
// Slices
- testCheck(c, gocheck.DeepEquals, true, "", []byte{1, 2}, []byte{1, 2})
- testCheck(c, gocheck.DeepEquals, false, "", []byte{1, 2}, []byte{1, 3})
+ testCheck(c, check.DeepEquals, true, "", []byte{1, 2}, []byte{1, 2})
+ testCheck(c, check.DeepEquals, false, "", []byte{1, 2}, []byte{1, 3})
// Struct values
- testCheck(c, gocheck.DeepEquals, true, "", simpleStruct{1}, simpleStruct{1})
- testCheck(c, gocheck.DeepEquals, false, "", simpleStruct{1}, simpleStruct{2})
+ testCheck(c, check.DeepEquals, true, "", simpleStruct{1}, simpleStruct{1})
+ testCheck(c, check.DeepEquals, false, "", simpleStruct{1}, simpleStruct{2})
// Struct pointers
- testCheck(c, gocheck.DeepEquals, true, "", &simpleStruct{1}, &simpleStruct{1})
- testCheck(c, gocheck.DeepEquals, false, "", &simpleStruct{1}, &simpleStruct{2})
+ testCheck(c, check.DeepEquals, true, "", &simpleStruct{1}, &simpleStruct{1})
+ testCheck(c, check.DeepEquals, false, "", &simpleStruct{1}, &simpleStruct{2})
}
-func (s *CheckersS) TestHasLen(c *gocheck.C) {
- testInfo(c, gocheck.HasLen, "HasLen", []string{"obtained", "n"})
+func (s *CheckersS) TestHasLen(c *check.C) {
+ testInfo(c, check.HasLen, "HasLen", []string{"obtained", "n"})
- testCheck(c, gocheck.HasLen, true, "", "abcd", 4)
- testCheck(c, gocheck.HasLen, true, "", []int{1, 2}, 2)
- testCheck(c, gocheck.HasLen, false, "", []int{1, 2}, 3)
+ testCheck(c, check.HasLen, true, "", "abcd", 4)
+ testCheck(c, check.HasLen, true, "", []int{1, 2}, 2)
+ testCheck(c, check.HasLen, false, "", []int{1, 2}, 3)
- testCheck(c, gocheck.HasLen, false, "n must be an int", []int{1, 2}, "2")
- testCheck(c, gocheck.HasLen, false, "obtained value type has no length", nil, 2)
+ testCheck(c, check.HasLen, false, "n must be an int", []int{1, 2}, "2")
+ testCheck(c, check.HasLen, false, "obtained value type has no length", nil, 2)
}
-func (s *CheckersS) TestErrorMatches(c *gocheck.C) {
- testInfo(c, gocheck.ErrorMatches, "ErrorMatches", []string{"value", "regex"})
+func (s *CheckersS) TestErrorMatches(c *check.C) {
+ testInfo(c, check.ErrorMatches, "ErrorMatches", []string{"value", "regex"})
- testCheck(c, gocheck.ErrorMatches, false, "Error value is nil", nil, "some error")
- testCheck(c, gocheck.ErrorMatches, false, "Value is not an error", 1, "some error")
- testCheck(c, gocheck.ErrorMatches, true, "", errors.New("some error"), "some error")
- testCheck(c, gocheck.ErrorMatches, true, "", errors.New("some error"), "so.*or")
+ testCheck(c, check.ErrorMatches, false, "Error value is nil", nil, "some error")
+ testCheck(c, check.ErrorMatches, false, "Value is not an error", 1, "some error")
+ testCheck(c, check.ErrorMatches, true, "", errors.New("some error"), "some error")
+ testCheck(c, check.ErrorMatches, true, "", errors.New("some error"), "so.*or")
// Verify params mutation
- params, names := testCheck(c, gocheck.ErrorMatches, false, "", errors.New("some error"), "other error")
- c.Assert(params[0], gocheck.Equals, "some error")
- c.Assert(names[0], gocheck.Equals, "error")
+ params, names := testCheck(c, check.ErrorMatches, false, "", errors.New("some error"), "other error")
+ c.Assert(params[0], check.Equals, "some error")
+ c.Assert(names[0], check.Equals, "error")
}
-func (s *CheckersS) TestMatches(c *gocheck.C) {
- testInfo(c, gocheck.Matches, "Matches", []string{"value", "regex"})
+func (s *CheckersS) TestMatches(c *check.C) {
+ testInfo(c, check.Matches, "Matches", []string{"value", "regex"})
// Simple matching
- testCheck(c, gocheck.Matches, true, "", "abc", "abc")
- testCheck(c, gocheck.Matches, true, "", "abc", "a.c")
+ testCheck(c, check.Matches, true, "", "abc", "abc")
+ testCheck(c, check.Matches, true, "", "abc", "a.c")
// Must match fully
- testCheck(c, gocheck.Matches, false, "", "abc", "ab")
- testCheck(c, gocheck.Matches, false, "", "abc", "bc")
+ testCheck(c, check.Matches, false, "", "abc", "ab")
+ testCheck(c, check.Matches, false, "", "abc", "bc")
// String()-enabled values accepted
- testCheck(c, gocheck.Matches, true, "", reflect.ValueOf("abc"), "a.c")
- testCheck(c, gocheck.Matches, false, "", reflect.ValueOf("abc"), "a.d")
+ testCheck(c, check.Matches, true, "", reflect.ValueOf("abc"), "a.c")
+ testCheck(c, check.Matches, false, "", reflect.ValueOf("abc"), "a.d")
// Some error conditions.
- testCheck(c, gocheck.Matches, false, "Obtained value is not a string and has no .String()", 1, "a.c")
- testCheck(c, gocheck.Matches, false, "Can't compile regex: error parsing regexp: missing closing ]: `[c$`", "abc", "a[c")
+ testCheck(c, check.Matches, false, "Obtained value is not a string and has no .String()", 1, "a.c")
+ testCheck(c, check.Matches, false, "Can't compile regex: error parsing regexp: missing closing ]: `[c$`", "abc", "a[c")
}
-func (s *CheckersS) TestPanics(c *gocheck.C) {
- testInfo(c, gocheck.Panics, "Panics", []string{"function", "expected"})
+func (s *CheckersS) TestPanics(c *check.C) {
+ testInfo(c, check.Panics, "Panics", []string{"function", "expected"})
// Some errors.
- testCheck(c, gocheck.Panics, false, "Function has not panicked", func() bool { return false }, "BOOM")
- testCheck(c, gocheck.Panics, false, "Function must take zero arguments", 1, "BOOM")
+ 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, gocheck.Panics, true, "", func() { panic("BOOM") }, "BOOM")
- testCheck(c, gocheck.Panics, false, "", func() { panic("KABOOM") }, "BOOM")
- testCheck(c, gocheck.Panics, true, "", func() bool { panic("BOOM") }, "BOOM")
+ 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, gocheck.Panics, true, "", func() { panic(errors.New("BOOM")) }, errors.New("BOOM"))
- testCheck(c, gocheck.Panics, false, "", func() { panic(errors.New("KABOOM")) }, errors.New("BOOM"))
+ 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, gocheck.Panics, true, "", func() { panic(&deep{99}) }, &deep{99})
+ testCheck(c, check.Panics, true, "", func() { panic(&deep{99}) }, &deep{99})
// Verify params/names mutation
- params, names := testCheck(c, gocheck.Panics, false, "", func() { panic(errors.New("KABOOM")) }, errors.New("BOOM"))
- c.Assert(params[0], gocheck.ErrorMatches, "KABOOM")
- c.Assert(names[0], gocheck.Equals, "panic")
+ 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, gocheck.Panics, true, "", func() { panic(nil) }, nil)
- testCheck(c, gocheck.Panics, false, "", func() { panic(nil) }, "NOPE")
+ testCheck(c, check.Panics, true, "", func() { panic(nil) }, nil)
+ testCheck(c, check.Panics, false, "", func() { panic(nil) }, "NOPE")
}
-func (s *CheckersS) TestPanicMatches(c *gocheck.C) {
- testInfo(c, gocheck.PanicMatches, "PanicMatches", []string{"function", "expected"})
+func (s *CheckersS) TestPanicMatches(c *check.C) {
+ testInfo(c, check.PanicMatches, "PanicMatches", []string{"function", "expected"})
// Error matching.
- testCheck(c, gocheck.PanicMatches, true, "", func() { panic(errors.New("BOOM")) }, "BO.M")
- testCheck(c, gocheck.PanicMatches, false, "", func() { panic(errors.New("KABOOM")) }, "BO.M")
+ testCheck(c, check.PanicMatches, true, "", func() { panic(errors.New("BOOM")) }, "BO.M")
+ testCheck(c, check.PanicMatches, false, "", func() { panic(errors.New("KABOOM")) }, "BO.M")
// Some errors.
- testCheck(c, gocheck.PanicMatches, false, "Function has not panicked", func() bool { return false }, "BOOM")
- testCheck(c, gocheck.PanicMatches, false, "Function must take zero arguments", 1, "BOOM")
+ testCheck(c, check.PanicMatches, false, "Function has not panicked", func() bool { return false }, "BOOM")
+ testCheck(c, check.PanicMatches, false, "Function must take zero arguments", 1, "BOOM")
// Plain strings.
- testCheck(c, gocheck.PanicMatches, true, "", func() { panic("BOOM") }, "BO.M")
- testCheck(c, gocheck.PanicMatches, false, "", func() { panic("KABOOM") }, "BOOM")
- testCheck(c, gocheck.PanicMatches, true, "", func() bool { panic("BOOM") }, "BO.M")
+ testCheck(c, check.PanicMatches, true, "", func() { panic("BOOM") }, "BO.M")
+ testCheck(c, check.PanicMatches, false, "", func() { panic("KABOOM") }, "BOOM")
+ testCheck(c, check.PanicMatches, true, "", func() bool { panic("BOOM") }, "BO.M")
// Verify params/names mutation
- params, names := testCheck(c, gocheck.PanicMatches, false, "", func() { panic(errors.New("KABOOM")) }, "BOOM")
- c.Assert(params[0], gocheck.Equals, "KABOOM")
- c.Assert(names[0], gocheck.Equals, "panic")
+ params, names := testCheck(c, check.PanicMatches, false, "", func() { panic(errors.New("KABOOM")) }, "BOOM")
+ c.Assert(params[0], check.Equals, "KABOOM")
+ c.Assert(names[0], check.Equals, "panic")
// Verify a nil panic
- testCheck(c, gocheck.PanicMatches, false, "Panic value is not a string or an error", func() { panic(nil) }, "")
+ testCheck(c, check.PanicMatches, false, "Panic value is not a string or an error", func() { panic(nil) }, "")
}
-func (s *CheckersS) TestFitsTypeOf(c *gocheck.C) {
- testInfo(c, gocheck.FitsTypeOf, "FitsTypeOf", []string{"obtained", "sample"})
+func (s *CheckersS) TestFitsTypeOf(c *check.C) {
+ testInfo(c, check.FitsTypeOf, "FitsTypeOf", []string{"obtained", "sample"})
// Basic types
- testCheck(c, gocheck.FitsTypeOf, true, "", 1, 0)
- testCheck(c, gocheck.FitsTypeOf, false, "", 1, int64(0))
+ testCheck(c, check.FitsTypeOf, true, "", 1, 0)
+ testCheck(c, check.FitsTypeOf, false, "", 1, int64(0))
// Aliases
- testCheck(c, gocheck.FitsTypeOf, false, "", 1, errors.New(""))
- testCheck(c, gocheck.FitsTypeOf, false, "", "error", errors.New(""))
- testCheck(c, gocheck.FitsTypeOf, true, "", errors.New("error"), errors.New(""))
+ testCheck(c, check.FitsTypeOf, false, "", 1, errors.New(""))
+ testCheck(c, check.FitsTypeOf, false, "", "error", errors.New(""))
+ testCheck(c, check.FitsTypeOf, true, "", errors.New("error"), errors.New(""))
// Structures
- testCheck(c, gocheck.FitsTypeOf, false, "", 1, simpleStruct{})
- testCheck(c, gocheck.FitsTypeOf, false, "", simpleStruct{42}, &simpleStruct{})
- testCheck(c, gocheck.FitsTypeOf, true, "", simpleStruct{42}, simpleStruct{})
- testCheck(c, gocheck.FitsTypeOf, true, "", &simpleStruct{42}, &simpleStruct{})
+ testCheck(c, check.FitsTypeOf, false, "", 1, simpleStruct{})
+ testCheck(c, check.FitsTypeOf, false, "", simpleStruct{42}, &simpleStruct{})
+ testCheck(c, check.FitsTypeOf, true, "", simpleStruct{42}, simpleStruct{})
+ testCheck(c, check.FitsTypeOf, true, "", &simpleStruct{42}, &simpleStruct{})
// Some bad values
- testCheck(c, gocheck.FitsTypeOf, false, "Invalid sample value", 1, interface{}(nil))
- testCheck(c, gocheck.FitsTypeOf, false, "", interface{}(nil), 0)
+ testCheck(c, check.FitsTypeOf, false, "Invalid sample value", 1, interface{}(nil))
+ testCheck(c, check.FitsTypeOf, false, "", interface{}(nil), 0)
}
-func (s *CheckersS) TestImplements(c *gocheck.C) {
- testInfo(c, gocheck.Implements, "Implements", []string{"obtained", "ifaceptr"})
+func (s *CheckersS) TestImplements(c *check.C) {
+ testInfo(c, check.Implements, "Implements", []string{"obtained", "ifaceptr"})
var e error
var re runtime.Error
- testCheck(c, gocheck.Implements, true, "", errors.New(""), &e)
- testCheck(c, gocheck.Implements, false, "", errors.New(""), &re)
+ testCheck(c, check.Implements, true, "", errors.New(""), &e)
+ testCheck(c, check.Implements, false, "", errors.New(""), &re)
// Some bad values
- testCheck(c, gocheck.Implements, false, "ifaceptr should be a pointer to an interface variable", 0, errors.New(""))
- testCheck(c, gocheck.Implements, false, "ifaceptr should be a pointer to an interface variable", 0, interface{}(nil))
- testCheck(c, gocheck.Implements, false, "", interface{}(nil), &e)
+ testCheck(c, check.Implements, false, "ifaceptr should be a pointer to an interface variable", 0, errors.New(""))
+ testCheck(c, check.Implements, false, "ifaceptr should be a pointer to an interface variable", 0, interface{}(nil))
+ testCheck(c, check.Implements, false, "", interface{}(nil), &e)
}
diff --git a/export_test.go b/export_test.go
index ad29621..0e6cfe0 100644
--- a/export_test.go
+++ b/export_test.go
@@ -1,4 +1,4 @@
-package gocheck
+package check
func PrintLine(filename string, line int) (string, error) {
return printLine(filename, line)
diff --git a/fixture_test.go b/fixture_test.go
index 63f392e..07cf83f 100644
--- a/fixture_test.go
+++ b/fixture_test.go
@@ -1,9 +1,9 @@
// Tests for the behavior of the test fixture system.
-package gocheck_test
+package check_test
import (
- . "launchpad.net/gocheck"
+ . "gopkg.in/check.v1"
)
// -----------------------------------------------------------------------
@@ -52,13 +52,13 @@
c.Check(len(helper.calls), Equals, 8)
expected := "^\n-+\n" +
- "PANIC: gocheck_test\\.go:[0-9]+: FixtureHelper.Test1\n\n" +
+ "PANIC: check_test\\.go:[0-9]+: FixtureHelper.Test1\n\n" +
"\\.\\.\\. Panic: Test1 \\(PC=[xA-F0-9]+\\)\n\n" +
".+:[0-9]+\n" +
" in panic\n" +
- ".*gocheck_test.go:[0-9]+\n" +
+ ".*check_test.go:[0-9]+\n" +
" in FixtureHelper.trace\n" +
- ".*gocheck_test.go:[0-9]+\n" +
+ ".*check_test.go:[0-9]+\n" +
" in FixtureHelper.Test1\n$"
c.Check(output.value, Matches, expected)
@@ -75,17 +75,17 @@
c.Check(len(helper.calls), Equals, 4)
expected := "^\n-+\n" +
- "PANIC: gocheck_test\\.go:[0-9]+: " +
+ "PANIC: check_test\\.go:[0-9]+: " +
"FixtureHelper\\.SetUpTest\n\n" +
"\\.\\.\\. Panic: SetUpTest \\(PC=[xA-F0-9]+\\)\n\n" +
".+:[0-9]+\n" +
" in panic\n" +
- ".*gocheck_test.go:[0-9]+\n" +
+ ".*check_test.go:[0-9]+\n" +
" in FixtureHelper.trace\n" +
- ".*gocheck_test.go:[0-9]+\n" +
+ ".*check_test.go:[0-9]+\n" +
" in FixtureHelper.SetUpTest\n" +
"\n-+\n" +
- "PANIC: gocheck_test\\.go:[0-9]+: " +
+ "PANIC: check_test\\.go:[0-9]+: " +
"FixtureHelper\\.Test1\n\n" +
"\\.\\.\\. Panic: Fixture has panicked " +
"\\(see related PANIC\\)\n$"
@@ -105,17 +105,17 @@
c.Check(len(helper.calls), Equals, 5)
expected := "^\n-+\n" +
- "PANIC: gocheck_test\\.go:[0-9]+: " +
+ "PANIC: check_test\\.go:[0-9]+: " +
"FixtureHelper.TearDownTest\n\n" +
"\\.\\.\\. Panic: TearDownTest \\(PC=[xA-F0-9]+\\)\n\n" +
".+:[0-9]+\n" +
" in panic\n" +
- ".*gocheck_test.go:[0-9]+\n" +
+ ".*check_test.go:[0-9]+\n" +
" in FixtureHelper.trace\n" +
- ".*gocheck_test.go:[0-9]+\n" +
+ ".*check_test.go:[0-9]+\n" +
" in FixtureHelper.TearDownTest\n" +
"\n-+\n" +
- "PANIC: gocheck_test\\.go:[0-9]+: " +
+ "PANIC: check_test\\.go:[0-9]+: " +
"FixtureHelper\\.Test1\n\n" +
"\\.\\.\\. Panic: Fixture has panicked " +
"\\(see related PANIC\\)\n$"
@@ -132,14 +132,14 @@
c.Check(len(helper.calls), Equals, 2)
expected := "^\n-+\n" +
- "PANIC: gocheck_test\\.go:[0-9]+: " +
+ "PANIC: check_test\\.go:[0-9]+: " +
"FixtureHelper.SetUpSuite\n\n" +
"\\.\\.\\. Panic: SetUpSuite \\(PC=[xA-F0-9]+\\)\n\n" +
".+:[0-9]+\n" +
" in panic\n" +
- ".*gocheck_test.go:[0-9]+\n" +
+ ".*check_test.go:[0-9]+\n" +
" in FixtureHelper.trace\n" +
- ".*gocheck_test.go:[0-9]+\n" +
+ ".*check_test.go:[0-9]+\n" +
" in FixtureHelper.SetUpSuite\n$"
c.Check(output.value, Matches, expected)
@@ -160,14 +160,14 @@
c.Check(len(helper.calls), Equals, 8)
expected := "^\n-+\n" +
- "PANIC: gocheck_test\\.go:[0-9]+: " +
+ "PANIC: check_test\\.go:[0-9]+: " +
"FixtureHelper.TearDownSuite\n\n" +
"\\.\\.\\. Panic: TearDownSuite \\(PC=[xA-F0-9]+\\)\n\n" +
".+:[0-9]+\n" +
" in panic\n" +
- ".*gocheck_test.go:[0-9]+\n" +
+ ".*check_test.go:[0-9]+\n" +
" in FixtureHelper.trace\n" +
- ".*gocheck_test.go:[0-9]+\n" +
+ ".*check_test.go:[0-9]+\n" +
" in FixtureHelper.TearDownSuite\n$"
c.Check(output.value, Matches, expected)
@@ -193,7 +193,7 @@
"PANIC: fixture_test\\.go:[0-9]+: " +
"WrongTestArgHelper\\.Test1\n\n" +
"\\.\\.\\. Panic: WrongTestArgHelper\\.Test1 argument " +
- "should be \\*gocheck\\.C\n"
+ "should be \\*check\\.C\n"
c.Check(output.value, Matches, expected)
}
@@ -209,7 +209,7 @@
"PANIC: fixture_test\\.go:[0-9]+: " +
"WrongSetUpTestArgHelper\\.SetUpTest\n\n" +
"\\.\\.\\. Panic: WrongSetUpTestArgHelper\\.SetUpTest argument " +
- "should be \\*gocheck\\.C\n"
+ "should be \\*check\\.C\n"
c.Check(output.value, Matches, expected)
}
@@ -225,7 +225,7 @@
"PANIC: fixture_test\\.go:[0-9]+: " +
"WrongSetUpSuiteArgHelper\\.SetUpSuite\n\n" +
"\\.\\.\\. Panic: WrongSetUpSuiteArgHelper\\.SetUpSuite argument " +
- "should be \\*gocheck\\.C\n"
+ "should be \\*check\\.C\n"
c.Check(output.value, Matches, expected)
}
@@ -250,7 +250,7 @@
"PANIC: fixture_test\\.go:[0-9]+: " +
"WrongTestArgCountHelper\\.Test1\n\n" +
"\\.\\.\\. Panic: WrongTestArgCountHelper\\.Test1 argument " +
- "should be \\*gocheck\\.C\n"
+ "should be \\*check\\.C\n"
c.Check(output.value, Matches, expected)
}
@@ -266,7 +266,7 @@
"PANIC: fixture_test\\.go:[0-9]+: " +
"WrongSetUpTestArgCountHelper\\.SetUpTest\n\n" +
"\\.\\.\\. Panic: WrongSetUpTestArgCountHelper\\.SetUpTest argument " +
- "should be \\*gocheck\\.C\n"
+ "should be \\*check\\.C\n"
c.Check(output.value, Matches, expected)
}
@@ -282,7 +282,7 @@
"PANIC: fixture_test\\.go:[0-9]+: " +
"WrongSetUpSuiteArgCountHelper\\.SetUpSuite\n\n" +
"\\.\\.\\. Panic: WrongSetUpSuiteArgCountHelper" +
- "\\.SetUpSuite argument should be \\*gocheck\\.C\n"
+ "\\.SetUpSuite argument should be \\*check\\.C\n"
c.Check(output.value, Matches, expected)
}
diff --git a/foundation_test.go b/foundation_test.go
index 12dfd36..8ecf791 100644
--- a/foundation_test.go
+++ b/foundation_test.go
@@ -4,11 +4,11 @@
// still have to be taken when using external functions, since they should
// of course not rely on functionality tested here.
-package gocheck_test
+package check_test
import (
"fmt"
- "launchpad.net/gocheck"
+ "gopkg.in/check.v1"
"log"
"os"
"regexp"
@@ -20,13 +20,13 @@
type FoundationS struct{}
-var foundationS = gocheck.Suite(&FoundationS{})
+var foundationS = check.Suite(&FoundationS{})
-func (s *FoundationS) TestCountSuite(c *gocheck.C) {
+func (s *FoundationS) TestCountSuite(c *check.C) {
suitesRun += 1
}
-func (s *FoundationS) TestErrorf(c *gocheck.C) {
+func (s *FoundationS) TestErrorf(c *check.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"+
@@ -45,7 +45,7 @@
}
}
-func (s *FoundationS) TestError(c *gocheck.C) {
+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",
@@ -59,7 +59,7 @@
})
}
-func (s *FoundationS) TestFailNow(c *gocheck.C) {
+func (s *FoundationS) TestFailNow(c *check.C) {
defer (func() {
if !c.Failed() {
c.Error("FailNow() didn't fail the test")
@@ -75,7 +75,7 @@
c.Log("FailNow() didn't stop the test")
}
-func (s *FoundationS) TestSucceedNow(c *gocheck.C) {
+func (s *FoundationS) TestSucceedNow(c *check.C) {
defer (func() {
if c.Failed() {
c.Error("SucceedNow() didn't succeed the test")
@@ -90,14 +90,14 @@
c.Log("SucceedNow() didn't stop the test")
}
-func (s *FoundationS) TestFailureHeader(c *gocheck.C) {
+func (s *FoundationS) TestFailureHeader(c *check.C) {
output := String{}
failHelper := FailHelper{}
- gocheck.Run(&failHelper, &gocheck.RunConf{Output: &output})
+ check.Run(&failHelper, &check.RunConf{Output: &output})
header := fmt.Sprintf(""+
"\n-----------------------------------"+
"-----------------------------------\n"+
- "FAIL: gocheck_test.go:%d: FailHelper.TestLogAndFail\n",
+ "FAIL: check_test.go:%d: FailHelper.TestLogAndFail\n",
failHelper.testLine)
if strings.Index(output.value, header) == -1 {
c.Errorf(""+
@@ -107,7 +107,7 @@
}
}
-func (s *FoundationS) TestFatal(c *gocheck.C) {
+func (s *FoundationS) TestFatal(c *check.C) {
var line int
defer (func() {
if !c.Failed() {
@@ -129,7 +129,7 @@
c.Log("Fatal() didn't stop the test")
}
-func (s *FoundationS) TestFatalf(c *gocheck.C) {
+func (s *FoundationS) TestFatalf(c *check.C) {
var line int
defer (func() {
if !c.Failed() {
@@ -151,14 +151,14 @@
c.Log("Fatalf() didn't stop the test")
}
-func (s *FoundationS) TestCallerLoggingInsideTest(c *gocheck.C) {
+func (s *FoundationS) TestCallerLoggingInsideTest(c *check.C) {
log := fmt.Sprintf(""+
"foundation_test.go:%d:\n"+
- " result := c.Check\\(10, gocheck.Equals, 20\\)\n"+
+ " result := c.Check\\(10, check.Equals, 20\\)\n"+
"\\.\\.\\. obtained int = 10\n"+
"\\.\\.\\. expected int = 20\n\n",
getMyLine()+1)
- result := c.Check(10, gocheck.Equals, 20)
+ result := c.Check(10, check.Equals, 20)
checkState(c, result,
&expectedState{
name: "Check(10, Equals, 20)",
@@ -168,14 +168,14 @@
})
}
-func (s *FoundationS) TestCallerLoggingInDifferentFile(c *gocheck.C) {
+func (s *FoundationS) TestCallerLoggingInDifferentFile(c *check.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"+
+ "check_test.go:%d:\n"+
+ " return c.Check\\(obtained, check.Equals, expected\\), getMyLine\\(\\)\n"+
"\\.\\.\\. obtained int = 10\n"+
"\\.\\.\\. expected int = 20\n\n",
testLine, line)
@@ -193,21 +193,21 @@
type ExpectFailureSucceedHelper struct{}
-func (s *ExpectFailureSucceedHelper) TestSucceed(c *gocheck.C) {
+func (s *ExpectFailureSucceedHelper) TestSucceed(c *check.C) {
c.ExpectFailure("It booms!")
c.Error("Boom!")
}
type ExpectFailureFailHelper struct{}
-func (s *ExpectFailureFailHelper) TestFail(c *gocheck.C) {
+func (s *ExpectFailureFailHelper) TestFail(c *check.C) {
c.ExpectFailure("Bug #XYZ")
}
-func (s *FoundationS) TestExpectFailureFail(c *gocheck.C) {
+func (s *FoundationS) TestExpectFailureFail(c *check.C) {
helper := ExpectFailureFailHelper{}
output := String{}
- result := gocheck.Run(&helper, &gocheck.RunConf{Output: &output})
+ result := check.Run(&helper, &check.RunConf{Output: &output})
expected := "" +
"^\n-+\n" +
@@ -223,22 +223,22 @@
c.Error("ExpectFailure() didn't log properly:\n", output.value)
}
- c.Assert(result.ExpectedFailures, gocheck.Equals, 0)
+ c.Assert(result.ExpectedFailures, check.Equals, 0)
}
-func (s *FoundationS) TestExpectFailureSucceed(c *gocheck.C) {
+func (s *FoundationS) TestExpectFailureSucceed(c *check.C) {
helper := ExpectFailureSucceedHelper{}
output := String{}
- result := gocheck.Run(&helper, &gocheck.RunConf{Output: &output})
+ result := check.Run(&helper, &check.RunConf{Output: &output})
- c.Assert(output.value, gocheck.Equals, "")
- c.Assert(result.ExpectedFailures, gocheck.Equals, 1)
+ c.Assert(output.value, check.Equals, "")
+ c.Assert(result.ExpectedFailures, check.Equals, 1)
}
-func (s *FoundationS) TestExpectFailureSucceedVerbose(c *gocheck.C) {
+func (s *FoundationS) TestExpectFailureSucceedVerbose(c *check.C) {
helper := ExpectFailureSucceedHelper{}
output := String{}
- result := gocheck.Run(&helper, &gocheck.RunConf{Output: &output, Verbose: true})
+ result := check.Run(&helper, &check.RunConf{Output: &output, Verbose: true})
expected := "" +
"FAIL EXPECTED: foundation_test\\.go:[0-9]+:" +
@@ -251,7 +251,7 @@
c.Error("ExpectFailure() didn't log properly:\n", output.value)
}
- c.Assert(result.ExpectedFailures, gocheck.Equals, 1)
+ c.Assert(result.ExpectedFailures, check.Equals, 1)
}
// -----------------------------------------------------------------------
@@ -259,25 +259,25 @@
type SkipTestHelper struct{}
-func (s *SkipTestHelper) TestFail(c *gocheck.C) {
+func (s *SkipTestHelper) TestFail(c *check.C) {
c.Skip("Wrong platform or whatever")
c.Error("Boom!")
}
-func (s *FoundationS) TestSkip(c *gocheck.C) {
+func (s *FoundationS) TestSkip(c *check.C) {
helper := SkipTestHelper{}
output := String{}
- gocheck.Run(&helper, &gocheck.RunConf{Output: &output})
+ check.Run(&helper, &check.RunConf{Output: &output})
if output.value != "" {
c.Error("Skip() logged something:\n", output.value)
}
}
-func (s *FoundationS) TestSkipVerbose(c *gocheck.C) {
+func (s *FoundationS) TestSkipVerbose(c *check.C) {
helper := SkipTestHelper{}
output := String{}
- gocheck.Run(&helper, &gocheck.RunConf{Output: &output, Verbose: true})
+ check.Run(&helper, &check.RunConf{Output: &output, Verbose: true})
expected := "SKIP: foundation_test\\.go:[0-9]+: SkipTestHelper\\.TestFail" +
" \\(Wrong platform or whatever\\)"
@@ -290,20 +290,20 @@
}
// -----------------------------------------------------------------------
-// Check minimum *log.Logger interface provided by *gocheck.C.
+// Check minimum *log.Logger interface provided by *check.C.
type minLogger interface {
Output(calldepth int, s string) error
}
-func (s *BootstrapS) TestMinLogger(c *gocheck.C) {
+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, gocheck.Matches, expected)
+ c.Assert(output, check.Matches, expected)
}
// -----------------------------------------------------------------------
@@ -318,18 +318,18 @@
EmbeddedInternalS
}
-var embeddedS = gocheck.Suite(&EmbeddedS{})
+var embeddedS = check.Suite(&EmbeddedS{})
-func (s *EmbeddedS) TestCountSuite(c *gocheck.C) {
+func (s *EmbeddedS) TestCountSuite(c *check.C) {
suitesRun += 1
}
-func (s *EmbeddedInternalS) TestMethod(c *gocheck.C) {
+func (s *EmbeddedInternalS) TestMethod(c *check.C) {
c.Error("TestMethod() of the embedded type was called!?")
}
-func (s *EmbeddedS) TestMethod(c *gocheck.C) {
+func (s *EmbeddedS) TestMethod(c *check.C) {
// http://code.google.com/p/go/issues/detail?id=906
- c.Check(s.called, gocheck.Equals, false) // Go issue 906 is affecting the runner?
+ c.Check(s.called, check.Equals, false) // Go issue 906 is affecting the runner?
s.called = true
}
diff --git a/helpers.go b/helpers.go
index 5b8b3fd..5576d47 100644
--- a/helpers.go
+++ b/helpers.go
@@ -1,4 +1,4 @@
-package gocheck
+package check
import (
"fmt"
diff --git a/helpers_test.go b/helpers_test.go
index fb9ef8e..0c81d6d 100644
--- a/helpers_test.go
+++ b/helpers_test.go
@@ -1,21 +1,21 @@
// These tests verify the inner workings of the helper methods associated
-// with gocheck.T.
+// with check.T.
-package gocheck_test
+package check_test
import (
- "launchpad.net/gocheck"
+ "gopkg.in/check.v1"
"os"
"reflect"
"runtime"
"sync"
)
-var helpersS = gocheck.Suite(&HelpersS{})
+var helpersS = check.Suite(&HelpersS{})
type HelpersS struct{}
-func (s *HelpersS) TestCountSuite(c *gocheck.C) {
+func (s *HelpersS) TestCountSuite(c *check.C) {
suitesRun += 1
}
@@ -23,16 +23,16 @@
// Fake checker and bug info to verify the behavior of Assert() and Check().
type MyChecker struct {
- info *gocheck.CheckerInfo
+ info *check.CheckerInfo
params []interface{}
names []string
result bool
error string
}
-func (checker *MyChecker) Info() *gocheck.CheckerInfo {
+func (checker *MyChecker) Info() *check.CheckerInfo {
if checker.info == nil {
- return &gocheck.CheckerInfo{Name: "MyChecker", Params: []string{"myobtained", "myexpected"}}
+ return &check.CheckerInfo{Name: "MyChecker", Params: []string{"myobtained", "myexpected"}}
}
return checker.info
}
@@ -64,16 +64,16 @@
// -----------------------------------------------------------------------
// Ensure a real checker actually works fine.
-func (s *HelpersS) TestCheckerInterface(c *gocheck.C) {
+func (s *HelpersS) TestCheckerInterface(c *check.C) {
testHelperSuccess(c, "Check(1, Equals, 1)", true, func() interface{} {
- return c.Check(1, gocheck.Equals, 1)
+ return c.Check(1, check.Equals, 1)
})
}
// -----------------------------------------------------------------------
// Tests for Check(), mostly the same as for Assert() following these.
-func (s *HelpersS) TestCheckSucceedWithExpected(c *gocheck.C) {
+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)
@@ -83,8 +83,8 @@
}
}
-func (s *HelpersS) TestCheckSucceedWithoutExpected(c *gocheck.C) {
- checker := &MyChecker{result: true, info: &gocheck.CheckerInfo{Params: []string{"myvalue"}}}
+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)
})
@@ -93,7 +93,7 @@
}
}
-func (s *HelpersS) TestCheckFailWithExpected(c *gocheck.C) {
+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" +
@@ -105,7 +105,7 @@
})
}
-func (s *HelpersS) TestCheckFailWithExpectedAndComment(c *gocheck.C) {
+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" +
@@ -118,7 +118,7 @@
})
}
-func (s *HelpersS) TestCheckFailWithExpectedAndStaticComment(c *gocheck.C) {
+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" +
@@ -132,8 +132,8 @@
})
}
-func (s *HelpersS) TestCheckFailWithoutExpected(c *gocheck.C) {
- checker := &MyChecker{result: false, info: &gocheck.CheckerInfo{Params: []string{"myvalue"}}}
+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"
@@ -143,8 +143,8 @@
})
}
-func (s *HelpersS) TestCheckFailWithoutExpectedAndMessage(c *gocheck.C) {
- checker := &MyChecker{result: false, info: &gocheck.CheckerInfo{Params: []string{"myvalue"}}}
+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" +
@@ -155,7 +155,7 @@
})
}
-func (s *HelpersS) TestCheckWithMissingExpected(c *gocheck.C) {
+func (s *HelpersS) TestCheckWithMissingExpected(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\\)\n" +
@@ -168,7 +168,7 @@
})
}
-func (s *HelpersS) TestCheckWithTooManyExpected(c *gocheck.C) {
+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" +
@@ -181,7 +181,7 @@
})
}
-func (s *HelpersS) TestCheckWithError(c *gocheck.C) {
+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" +
@@ -194,7 +194,7 @@
})
}
-func (s *HelpersS) TestCheckWithNilChecker(c *gocheck.C) {
+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" +
@@ -205,7 +205,7 @@
})
}
-func (s *HelpersS) TestCheckWithParamsAndNamesMutation(c *gocheck.C) {
+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" +
@@ -220,7 +220,7 @@
// -----------------------------------------------------------------------
// Tests for Assert(), mostly the same as for Check() above.
-func (s *HelpersS) TestAssertSucceedWithExpected(c *gocheck.C) {
+func (s *HelpersS) TestAssertSucceedWithExpected(c *check.C) {
checker := &MyChecker{result: true}
testHelperSuccess(c, "Assert(1, checker, 2)", nil, func() interface{} {
c.Assert(1, checker, 2)
@@ -231,8 +231,8 @@
}
}
-func (s *HelpersS) TestAssertSucceedWithoutExpected(c *gocheck.C) {
- checker := &MyChecker{result: true, info: &gocheck.CheckerInfo{Params: []string{"myvalue"}}}
+func (s *HelpersS) TestAssertSucceedWithoutExpected(c *check.C) {
+ checker := &MyChecker{result: true, info: &check.CheckerInfo{Params: []string{"myvalue"}}}
testHelperSuccess(c, "Assert(1, checker)", nil, func() interface{} {
c.Assert(1, checker)
return nil
@@ -242,7 +242,7 @@
}
}
-func (s *HelpersS) TestAssertFailWithExpected(c *gocheck.C) {
+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" +
@@ -255,7 +255,7 @@
})
}
-func (s *HelpersS) TestAssertFailWithExpectedAndMessage(c *gocheck.C) {
+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" +
@@ -269,8 +269,8 @@
})
}
-func (s *HelpersS) TestAssertFailWithoutExpected(c *gocheck.C) {
- checker := &MyChecker{result: false, info: &gocheck.CheckerInfo{Params: []string{"myvalue"}}}
+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"
@@ -281,8 +281,8 @@
})
}
-func (s *HelpersS) TestAssertFailWithoutExpectedAndMessage(c *gocheck.C) {
- checker := &MyChecker{result: false, info: &gocheck.CheckerInfo{Params: []string{"myvalue"}}}
+func (s *HelpersS) TestAssertFailWithoutExpectedAndMessage(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, myComment\\(\"Hello world!\"\\)\\)\n" +
"\\.+ myvalue int = 1\n" +
@@ -294,7 +294,7 @@
})
}
-func (s *HelpersS) TestAssertWithMissingExpected(c *gocheck.C) {
+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" +
@@ -308,7 +308,7 @@
})
}
-func (s *HelpersS) TestAssertWithError(c *gocheck.C) {
+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" +
@@ -322,7 +322,7 @@
})
}
-func (s *HelpersS) TestAssertWithNilChecker(c *gocheck.C) {
+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" +
@@ -337,7 +337,7 @@
// -----------------------------------------------------------------------
// Ensure that values logged work properly in some interesting cases.
-func (s *HelpersS) TestValueLoggingWithArrays(c *gocheck.C) {
+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" +
@@ -349,7 +349,7 @@
})
}
-func (s *HelpersS) TestValueLoggingWithMultiLine(c *gocheck.C) {
+func (s *HelpersS) TestValueLoggingWithMultiLine(c *check.C) {
checker := &MyChecker{result: false}
log := "(?s)helpers_test.go:[0-9]+:.*\nhelpers_test.go:[0-9]+:\n" +
" return c\\.Check\\(\"a\\\\nb\\\\n\", checker, \"a\\\\nb\\\\nc\"\\)\n" +
@@ -366,7 +366,7 @@
})
}
-func (s *HelpersS) TestValueLoggingWithMultiLineException(c *gocheck.C) {
+func (s *HelpersS) TestValueLoggingWithMultiLineException(c *check.C) {
// If the newline is at the end of the string, don't log as multi-line.
checker := &MyChecker{result: false}
log := "(?s)helpers_test.go:[0-9]+:.*\nhelpers_test.go:[0-9]+:\n" +
@@ -393,34 +393,34 @@
isDir4 bool
}
-func (s *MkDirHelper) SetUpSuite(c *gocheck.C) {
+func (s *MkDirHelper) SetUpSuite(c *check.C) {
s.path1 = c.MkDir()
s.isDir1 = isDir(s.path1)
}
-func (s *MkDirHelper) Test(c *gocheck.C) {
+func (s *MkDirHelper) Test(c *check.C) {
s.path2 = c.MkDir()
s.isDir2 = isDir(s.path2)
}
-func (s *MkDirHelper) TearDownSuite(c *gocheck.C) {
+func (s *MkDirHelper) TearDownSuite(c *check.C) {
s.isDir3 = isDir(s.path1)
s.isDir4 = isDir(s.path2)
}
-func (s *HelpersS) TestMkDir(c *gocheck.C) {
+func (s *HelpersS) TestMkDir(c *check.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),
+ check.Run(&helper, &check.RunConf{Output: &output})
+ c.Assert(output.value, check.Equals, "")
+ c.Check(helper.isDir1, check.Equals, true)
+ c.Check(helper.isDir2, check.Equals, true)
+ c.Check(helper.isDir3, check.Equals, true)
+ c.Check(helper.isDir4, check.Equals, true)
+ c.Check(helper.path1, check.Not(check.Equals),
helper.path2)
- c.Check(isDir(helper.path1), gocheck.Equals, false)
- c.Check(isDir(helper.path2), gocheck.Equals, false)
+ c.Check(isDir(helper.path1), check.Equals, false)
+ c.Check(isDir(helper.path2), check.Equals, false)
}
func isDir(path string) bool {
@@ -432,7 +432,7 @@
// Concurrent logging should not corrupt the underling buffer.
// Use go test -race to detect the race in this test.
-func (s *HelpersS) TestConcurrentLogging(c *gocheck.C) {
+func (s *HelpersS) TestConcurrentLogging(c *check.C) {
defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(runtime.NumCPU()))
var start, stop sync.WaitGroup
start.Add(1)
@@ -453,7 +453,7 @@
// -----------------------------------------------------------------------
// A couple of helper functions to test helper functions. :-)
-func testHelperSuccess(c *gocheck.C, name string, expectedResult interface{}, closure func() interface{}) {
+func testHelperSuccess(c *check.C, name string, expectedResult interface{}, closure func() interface{}) {
var result interface{}
defer (func() {
if err := recover(); err != nil {
@@ -470,7 +470,7 @@
result = closure()
}
-func testHelperFailure(c *gocheck.C, name string, expectedResult interface{}, shouldStop bool, log string, closure func() interface{}) {
+func testHelperFailure(c *check.C, name string, expectedResult interface{}, shouldStop bool, log string, closure func() interface{}) {
var result interface{}
defer (func() {
if err := recover(); err != nil {
diff --git a/printer.go b/printer.go
index 103ab14..e0f7557 100644
--- a/printer.go
+++ b/printer.go
@@ -1,4 +1,4 @@
-package gocheck
+package check
import (
"bytes"
diff --git a/printer_test.go b/printer_test.go
index 547a92d..538b2d5 100644
--- a/printer_test.go
+++ b/printer_test.go
@@ -1,7 +1,7 @@
-package gocheck_test
+package check_test
import (
- . "launchpad.net/gocheck"
+ . "gopkg.in/check.v1"
)
var _ = Suite(&PrinterS{})
diff --git a/run.go b/run.go
index 642ca80..2dbd8c3 100644
--- a/run.go
+++ b/run.go
@@ -1,4 +1,4 @@
-package gocheck
+package check
import (
"bufio"
@@ -26,28 +26,40 @@
// Public running interface.
var (
- filterFlag = flag.String("gocheck.f", "", "Regular expression selecting which tests and/or suites to run")
- verboseFlag = flag.Bool("gocheck.v", false, "Verbose mode")
- streamFlag = flag.Bool("gocheck.vv", false, "Super verbose mode (disables output caching)")
- benchFlag = flag.Bool("gocheck.b", false, "Run benchmarks")
- benchTime = flag.Duration("gocheck.btime", 1*time.Second, "approximate run time for each benchmark")
- listFlag = flag.Bool("gocheck.list", false, "List the names of all tests that will be run")
- workFlag = flag.Bool("gocheck.work", false, "Display and do not remove the test working directory")
+ oldFilterFlag = flag.String("gocheck.f", "", "Regular expression selecting which tests and/or suites to run")
+ oldVerboseFlag = flag.Bool("gocheck.v", false, "Verbose mode")
+ oldStreamFlag = flag.Bool("gocheck.vv", false, "Super verbose mode (disables output caching)")
+ oldBenchFlag = flag.Bool("gocheck.b", false, "Run benchmarks")
+ oldBenchTime = flag.Duration("gocheck.btime", 1*time.Second, "approximate run time for each benchmark")
+ oldListFlag = flag.Bool("gocheck.list", false, "List the names of all tests that will be run")
+ oldWorkFlag = flag.Bool("gocheck.work", false, "Display and do not remove the test working directory")
+
+ newFilterFlag = flag.String("check.f", "", "Regular expression selecting which tests and/or suites to run")
+ newVerboseFlag = flag.Bool("check.v", false, "Verbose mode")
+ newStreamFlag = flag.Bool("check.vv", false, "Super verbose mode (disables output caching)")
+ newBenchFlag = flag.Bool("check.b", false, "Run benchmarks")
+ newBenchTime = flag.Duration("check.btime", 1*time.Second, "approximate run time for each benchmark")
+ newListFlag = flag.Bool("check.list", false, "List the names of all tests that will be run")
+ newWorkFlag = flag.Bool("check.work", false, "Display and do not remove the test working directory")
)
// Run all test suites registered with the Suite() function, printing
// results to stdout, and reporting any failures back to the 'testing'
// module.
func TestingT(testingT *testing.T) {
- conf := &RunConf{
- Filter: *filterFlag,
- Verbose: *verboseFlag,
- Stream: *streamFlag,
- Benchmark: *benchFlag,
- BenchmarkTime: *benchTime,
- KeepWorkDir: *workFlag,
+ benchTime := *newBenchTime
+ if benchTime == 1*time.Second {
+ benchTime = *oldBenchTime
}
- if *listFlag {
+ conf := &RunConf{
+ Filter: *oldFilterFlag + *newFilterFlag,
+ Verbose: *oldVerboseFlag || *newVerboseFlag,
+ Stream: *oldStreamFlag || *newStreamFlag,
+ Benchmark: *oldBenchFlag || *newBenchFlag,
+ BenchmarkTime: benchTime,
+ KeepWorkDir: *oldWorkFlag || *newWorkFlag,
+ }
+ if *oldListFlag || *newListFlag {
w := bufio.NewWriter(os.Stdout)
for _, name := range ListAll(conf) {
fmt.Fprintln(w, name)
diff --git a/run_test.go b/run_test.go
index d59bd1c..f41fffc 100644
--- a/run_test.go
+++ b/run_test.go
@@ -1,10 +1,10 @@
// These tests verify the test running logic.
-package gocheck_test
+package check_test
import (
"errors"
- . "launchpad.net/gocheck"
+ . "gopkg.in/check.v1"
"os"
"sync"
)
@@ -307,8 +307,8 @@
runConf := RunConf{Output: &output, Verbose: true}
Run(&helper, &runConf)
- expected := "PASS: gocheck_test\\.go:[0-9]+: FixtureHelper\\.Test1\t *[.0-9]+s\n" +
- "PASS: gocheck_test\\.go:[0-9]+: FixtureHelper\\.Test2\t *[.0-9]+s\n"
+ expected := "PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Test1\t *[.0-9]+s\n" +
+ "PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Test2\t *[.0-9]+s\n"
c.Assert(output.value, Matches, expected)
}
@@ -320,7 +320,7 @@
Run(&helper, &runConf)
expected := "(?s).*PANIC.*\n-+\n" + // Should have an extra line.
- "PASS: gocheck_test\\.go:[0-9]+: FixtureHelper\\.Test2\t *[.0-9]+s\n"
+ "PASS: check_test\\.go:[0-9]+: FixtureHelper\\.Test2\t *[.0-9]+s\n"
c.Assert(output.value, Matches, expected)
}
