Log expected failures in verbose mode, and present them in the status line.
diff --git a/foundation_test.go b/foundation_test.go
index 83adafa..fe2b724 100644
--- a/foundation_test.go
+++ b/foundation_test.go
@@ -185,26 +185,28 @@
// -----------------------------------------------------------------------
// ExpectFailure() inverts the logic of failure.
-type ExpectFailureHelper struct{}
+type ExpectFailureSucceedHelper struct{}
-func (s *ExpectFailureHelper) TestFail(c *gocheck.C) {
+func (s *ExpectFailureSucceedHelper) TestSucceed(c *gocheck.C) {
c.ExpectFailure("It booms!")
c.Error("Boom!")
}
-func (s *ExpectFailureHelper) TestSucceed(c *gocheck.C) {
+type ExpectFailureFailHelper struct{}
+
+func (s *ExpectFailureFailHelper) TestFail(c *gocheck.C) {
c.ExpectFailure("Bug #XYZ")
}
-func (s *FoundationS) TestExpectFailure(c *gocheck.C) {
- helper := ExpectFailureHelper{}
+func (s *FoundationS) TestExpectFailureFail(c *gocheck.C) {
+ helper := ExpectFailureFailHelper{}
output := String{}
- gocheck.Run(&helper, &gocheck.RunConf{Output: &output})
+ result := gocheck.Run(&helper, &gocheck.RunConf{Output: &output})
expected := "" +
"^\n-+\n" +
"FAIL: foundation_test\\.go:[0-9]+:" +
- " ExpectFailureHelper\\.TestSucceed\n\n" +
+ " ExpectFailureFailHelper\\.TestFail\n\n" +
"\\.\\.\\. Error: Test succeeded, but was expected to fail\n" +
"\\.\\.\\. Reason: Bug #XYZ\n$"
@@ -214,6 +216,36 @@
} else if !matched {
c.Error("ExpectFailure() didn't log properly:\n", output.value)
}
+
+ c.Assert(result.ExpectedFailures, gocheck.Equals, 0)
+}
+
+func (s *FoundationS) TestExpectFailureSucceed(c *gocheck.C) {
+ helper := ExpectFailureSucceedHelper{}
+ output := String{}
+ result := gocheck.Run(&helper, &gocheck.RunConf{Output: &output})
+
+ c.Assert(output.value, gocheck.Equals, "")
+ c.Assert(result.ExpectedFailures, gocheck.Equals, 1)
+}
+
+func (s *FoundationS) TestExpectFailureSucceedVerbose(c *gocheck.C) {
+ helper := ExpectFailureSucceedHelper{}
+ output := String{}
+ result := gocheck.Run(&helper, &gocheck.RunConf{Output: &output, Verbose: true})
+
+ expected := "" +
+ "FAIL EXPECTED: foundation_test\\.go:[0-9]+:" +
+ " ExpectFailureSucceedHelper\\.TestSucceed \\(It booms!\\)\n"
+
+ matched, err := regexp.MatchString(expected, output.value)
+ if err != nil {
+ c.Error("Bad expression: ", expected)
+ } else if !matched {
+ c.Error("ExpectFailure() didn't log properly:\n", output.value)
+ }
+
+ c.Assert(result.ExpectedFailures, gocheck.Equals, 1)
}
diff --git a/gocheck.go b/gocheck.go
index 791ad2b..afad53a 100644
--- a/gocheck.go
+++ b/gocheck.go
@@ -278,13 +278,14 @@
// Result tracker to aggregate call results.
type Result struct {
- Succeeded int
- Failed int
- Skipped int
- Panicked int
- FixturePanicked int
- Missed int // Not even tried to run, related to a panic in the fixture.
- RunError os.Error // Houston, we've got a problem.
+ Succeeded int
+ Failed int
+ Skipped int
+ Panicked int
+ FixturePanicked int
+ ExpectedFailures int
+ Missed int // Not even tried to run, related to a panic in the fixture.
+ RunError os.Error // Houston, we've got a problem.
}
type resultTracker struct {
@@ -333,7 +334,11 @@
switch c.status {
case succeededSt:
if c.kind == testKd {
- tracker.result.Succeeded++
+ if c.mustFail {
+ tracker.result.ExpectedFailures++
+ } else {
+ tracker.result.Succeeded++
+ }
}
case failedSt:
tracker.result.Failed++
@@ -677,7 +682,11 @@
runner.tracker.callDone(c)
switch c.status {
case succeededSt:
- runner.output.WriteCallSuccess("PASS", c)
+ if c.mustFail {
+ runner.output.WriteCallSuccess("FAIL EXPECTED", c)
+ } else {
+ runner.output.WriteCallSuccess("PASS", c)
+ }
case skippedSt:
runner.output.WriteCallSuccess("SKIP", c)
case failedSt:
diff --git a/run.go b/run.go
index ab83225..94847ed 100644
--- a/run.go
+++ b/run.go
@@ -109,6 +109,9 @@
if r.Skipped != 0 {
value += fmt.Sprintf(", %d skipped", r.Skipped)
}
+ if r.ExpectedFailures != 0 {
+ value += fmt.Sprintf(", %d expected failures", r.ExpectedFailures)
+ }
if r.Failed != 0 {
value += fmt.Sprintf(", %d FAILED", r.Failed)
}
@@ -116,7 +119,7 @@
value += fmt.Sprintf(", %d PANICKED", r.Panicked)
}
if r.FixturePanicked != 0 {
- value += fmt.Sprintf(", %d FIXTURE PANICKED", r.FixturePanicked)
+ value += fmt.Sprintf(", %d FIXTURE-PANICKED", r.FixturePanicked)
}
if r.Missed != 0 {
value += fmt.Sprintf(", %d MISSED", r.Missed)
diff --git a/run_test.go b/run_test.go
index 54402a5..8ac687e 100644
--- a/run_test.go
+++ b/run_test.go
@@ -147,6 +147,11 @@
c.Check(result.String(), Equals, "OK: 0 passed, 5 skipped")
}
+func (s *RunS) TestPrintExpectedFailures(c *C) {
+ result := &Result{ExpectedFailures: 5}
+ c.Check(result.String(), Equals, "OK: 0 passed, 5 expected failures")
+}
+
func (s *RunS) TestPrintPanicked(c *C) {
result := &Result{Panicked: 5}
c.Check(result.String(), Equals, "OOPS: 0 passed, 5 PANICKED")
@@ -154,7 +159,7 @@
func (s *RunS) TestPrintFixturePanicked(c *C) {
result := &Result{FixturePanicked: 5}
- c.Check(result.String(), Equals, "OOPS: 0 passed, 5 FIXTURE PANICKED")
+ c.Check(result.String(), Equals, "OOPS: 0 passed, 5 FIXTURE-PANICKED")
}
func (s *RunS) TestPrintMissed(c *C) {
@@ -163,11 +168,11 @@
}
func (s *RunS) TestPrintAll(c *C) {
- result := &Result{Succeeded: 1, Skipped: 2, Panicked: 3,
- FixturePanicked: 4, Missed: 5}
+ result := &Result{Succeeded: 1, Skipped: 2, ExpectedFailures: 3,
+ Panicked: 4, FixturePanicked: 5, Missed: 6}
c.Check(result.String(), Equals,
- "OOPS: 1 passed, 2 skipped, 3 PANICKED, "+
- "4 FIXTURE PANICKED, 5 MISSED")
+ "OOPS: 1 passed, 2 skipped, 3 expected failures, 4 PANICKED, "+
+ "5 FIXTURE-PANICKED, 6 MISSED")
}
func (s *RunS) TestPrintRunError(c *C) {
