func FuncNameSpec(c nanospec.Context) { c.Specify("The name of a function can be retrieved from a function reference", func() { name := functionName(dummyFunction) c.Expect(name).Equals("gospec.dummyFunction") }) c.Specify("Getting the name of an anonymous functions will fail gracefully", func() { name := functionName(func() {}) //c.Expect(name).Equals("<unknown function>") // since weekly.2012-01-15 even anonymous functions have a name c.Expect(name).Satisfies(strings.HasPrefix(name, "gospec._func_")) }) }
func ConcurrencySpec(c nanospec.Context) { r := NewRunner() r.AddSpec(VerySlowDummySpec) start := time.Now() r.Run() end := time.Now() totalTime := end.Sub(start).Nanoseconds() // If the spec is executed single-threadedly, then it would take // at least 4*DELAY to execute. If executed multi-threadedly, it // would take at least 2*DELAY to execute, because the first spec // needs to be executed fully before the other specs are found, but // after that the other specs can be executed in parallel. expectedMaxTime := int64(math.Floor(2.9 * DELAY)) if totalTime > expectedMaxTime { c.Errorf("Expected the run to take less than %v ms but it took %v ms", expectedMaxTime/MILLISECOND, totalTime/MILLISECOND) } runCounts := countSpecNames(r.executed) c.Expect(runCounts["Child A"]).Equals(1) c.Expect(runCounts["Child B"]).Equals(1) c.Expect(runCounts["Child C"]).Equals(1) c.Expect(runCounts["Child D"]).Equals(1) }
func LocationSpec(c nanospec.Context) { c.Specify("Location of the current method can be found", func() { loc := currentLocation() // line 15 c.Expect(loc.FileName()).Equals("location_test.go") c.Expect(loc.Line()).Equals(15) }) c.Specify("The line number is that of the call instruction; not where the call will return to", func() { // This indirection is needed to reproduce the off-by-one issue, because // there must be no instructions on the same line after the call itself. var loc *Location f := func() { loc = callerLocation() } f() // line 26; call returns to line 27 c.Expect(loc.Line()).Equals(26) }) c.Specify("Location of the calling method can be found", func() { loc := callerLocation() c.Expect(loc.FileName()).Equals("context.go") }) c.Specify("The name of the method is provided", func() { loc := methodWhereLocationIsCalled() c.Expect(loc.Name()).Equals("gospec.methodWhereLocationIsCalled") }) c.Specify("Calls to newLocation are synced with the helper methods", func() { c.Expect(newLocation(0).Name()).Equals(currentLocation().Name()) c.Expect(newLocation(0).File()).Equals(currentLocation().File()) c.Expect(newLocation(1).Name()).Equals(callerLocation().Name()) c.Expect(newLocation(1).File()).Equals(callerLocation().File()) }) c.Specify("Program Counters can be converted to Locations", func() { expectedLine := currentLocation().Line() + 1 pc, _, _, _ := runtime.Caller(0) loc := locationForPC(pc) c.Expect(loc.FileName()).Equals("location_test.go") c.Expect(loc.Line()).Equals(expectedLine) }) }
func RecoverSpec(c nanospec.Context) { c.Specify("When the called function panics", func() { err := recoverOnPanic(boom2) c.Specify("the cause is returned", func() { c.Expect(err.Cause).Equals("boom!") }) c.Specify("the stack trace begins with the panicking line", func() { c.Expect(err.StackTrace[0].Name()).Equals(fmt.Sprintf("%v.boom0", pkgPath)) }) c.Specify("the stack trace includes all parent functions", func() { c.Expect(err.StackTrace[1].Name()).Equals(fmt.Sprintf("%v.boom1", pkgPath)) }) c.Specify("the stack trace ends with the called function", func() { lastEntry := err.StackTrace[len(err.StackTrace)-1] c.Expect(lastEntry.Name()).Equals(fmt.Sprintf("%v.boom2", pkgPath)) }) c.Specify("the stack trace line numbers are the line of the call; not where the call will return", func() { // For an explanation, see the comments at http://code.google.com/p/go/issues/detail?id=1100 c.Expect(err.StackTrace[0].Line()).Equals(19) }) }) c.Specify("When the called function does not panic", func() { err := recoverOnPanic(noBoom) c.Specify("there is no error", func() { c.Expect(err == nil).IsTrue() }) }) }
func ContextSpec(c nanospec.Context) { c.Specify("When specs are executed", func() { result := runSpecWithContext(DummySpecWithTwoChildren, newInitialContext()) executed := result.executedSpecs postponed := result.postponedSpecs c.Specify("executed specs are reported", func() { c.Expect(len(executed)).Equals(2) c.Expect(executed[0].name).Equals("RootSpec") c.Expect(executed[1].name).Equals("Child A") }) c.Specify("postponed specs are reported", func() { c.Expect(len(postponed)).Equals(1) c.Expect(postponed[0].name).Equals("Child B") }) }) c.Specify("When some of the specs have previously been executed", func() { result := runSpecWithContext(DummySpecWithTwoChildren, newExplicitContext([]int{1})) executed := result.executedSpecs postponed := result.postponedSpecs c.Specify("previously executed specs are NOT reported", func() { c.Expect(len(executed)).Equals(2) c.Expect(executed[0].name).Equals("RootSpec") c.Expect(executed[1].name).Equals("Child B") c.Expect(len(postponed)).Equals(0) }) }) c.Specify("Postponed specs are scheduled for execution, until they all have been executed", func() { r := NewRunner() r.AddSpec(DummySpecWithTwoChildren) r.Run() runCounts := countSpecNames(r.executed) c.Expect(len(runCounts)).Equals(3) c.Expect(runCounts["gospec.DummySpecWithTwoChildren"]).Equals(2) c.Expect(runCounts["Child A"]).Equals(1) c.Expect(runCounts["Child B"]).Equals(1) }) c.Specify("Multiple specs can be executed in one batch", func() { r := NewRunner() r.AddSpec(DummySpecWithOneChild) r.AddSpec(DummySpecWithTwoChildren) r.Run() runCounts := countSpecNames(r.executed) c.Expect(runCounts["gospec.DummySpecWithOneChild"]).Equals(1) c.Expect(runCounts["gospec.DummySpecWithTwoChildren"]).Equals(2) }) }
func ExpectationsSpec(c nanospec.Context) { c.Specify("When a spec has passing expectations or assumptions", func() { results := runSpec(func(c Context) { c.Expect(1, Equals, 1) c.Assume(1, Equals, 1) c.Specify("Child", func() {}) }) c.Specify("then the spec passes", func() { c.Expect(results.FailCount()).Equals(0) }) c.Specify("then its children are executed", func() { c.Expect(results.TotalCount()).Equals(2) }) }) c.Specify("When a spec has failing expectations", func() { results := runSpec(func(c Context) { c.Expect(1, Equals, 2) c.Specify("Child", func() {}) }) c.Specify("then the spec fails", func() { c.Expect(results.FailCount()).Equals(1) }) c.Specify("then its children are executed", func() { c.Expect(results.TotalCount()).Equals(2) }) }) c.Specify("When a spec has failing assumptions", func() { results := runSpec(func(c Context) { c.Assume(1, Equals, 2) c.Specify("Child", func() {}) }) c.Specify("then the spec fails", func() { c.Expect(results.FailCount()).Equals(1) }) c.Specify("then its children are NOT executed", func() { c.Expect(results.TotalCount()).Equals(1) }) }) c.Specify("The location of a failed expectation is reported", func() { results := runSpec(func(c Context) { c.Expect(1, Equals, 2) }) c.Expect(fileOfError(results)).Equals("expectations_test.go") }) c.Specify("The location of a failed assumption is reported", func() { results := runSpec(func(c Context) { c.Assume(1, Equals, 2) }) c.Expect(fileOfError(results)).Equals("expectations_test.go") }) }
func ResultsSpec(c nanospec.Context) { results := newResultCollector() c.Specify("When results have many root specs", func() { results.Update(newSpecRun("RootSpec2", nil, nil, nil)) results.Update(newSpecRun("RootSpec1", nil, nil, nil)) results.Update(newSpecRun("RootSpec3", nil, nil, nil)) c.Specify("then the roots are sorted alphabetically", func() { c.Expect(results).Matches(ReportIs(` - RootSpec1 - RootSpec2 - RootSpec3 3 specs, 0 failures `)) }) }) c.Specify("When results have many child specs", func() { // In tests, when a spec has many children, make sure // to pass a common parent instance to all the siblings. // Otherwise the parent's numberOfChildren is not // incremented and the children's paths will be wrong. // use names which would not sort alphabetically root := newSpecRun("RootSpec", nil, nil, nil) child1 := newSpecRun("one", nil, root, nil) child2 := newSpecRun("two", nil, root, nil) child3 := newSpecRun("three", nil, root, nil) // register in random order results.Update(root) results.Update(child1) results.Update(root) results.Update(child3) results.Update(root) results.Update(child2) c.Specify("then the children are sorted by their declaration order", func() { c.Expect(results).Matches(ReportIs(` - RootSpec - one - two - three 4 specs, 0 failures `)) }) }) c.Specify("Case: zero specs", func() { c.Expect(results).Matches(ReportIs(` 0 specs, 0 failures `)) }) c.Specify("Case: spec with no children", func() { a1 := newSpecRun("RootSpec", nil, nil, nil) results.Update(a1) c.Expect(results).Matches(ReportIs(` - RootSpec 1 specs, 0 failures `)) }) c.Specify("Case: spec with a child", func() { a1 := newSpecRun("RootSpec", nil, nil, nil) a2 := newSpecRun("Child A", nil, a1, nil) results.Update(a1) results.Update(a2) c.Expect(results).Matches(ReportIs(` - RootSpec - Child A 2 specs, 0 failures `)) }) c.Specify("Case: spec with nested children", func() { a1 := newSpecRun("RootSpec", nil, nil, nil) a2 := newSpecRun("Child A", nil, a1, nil) a3 := newSpecRun("Child AA", nil, a2, nil) results.Update(a1) results.Update(a2) results.Update(a3) c.Expect(results).Matches(ReportIs(` - RootSpec - Child A - Child AA 3 specs, 0 failures `)) }) c.Specify("Case: spec with multiple nested children", func() { runner := NewRunner() runner.AddSpec(DummySpecWithMultipleNestedChildren) runner.Run() c.Expect(runner.Results()).Matches(ReportIs(` - gospec.DummySpecWithMultipleNestedChildren - Child A - Child AA - Child AB - Child B - Child BA - Child BB - Child BC 8 specs, 0 failures `)) }) c.Specify("When specs fail", func() { a1 := newSpecRun("Failing", nil, nil, nil) a1.AddError(newError(OtherError, "X did not equal Y", "", []*Location{})) results.Update(a1) b1 := newSpecRun("Passing", nil, nil, nil) b2 := newSpecRun("Child failing", nil, b1, nil) b2.AddError(newError(OtherError, "moon was not cheese", "", []*Location{})) results.Update(b1) results.Update(b2) c.Specify("then the errors are reported", func() { c.Expect(results).Matches(ReportIs(` - Failing [FAIL] *** X did not equal Y - Passing - Child failing [FAIL] *** moon was not cheese 3 specs, 2 failures `)) }) }) c.Specify("When spec passes on 1st run but fails on 2nd run", func() { i := 0 runner := NewRunner() runner.AddNamedSpec("RootSpec", func(c Context) { if i == 1 { c.Expect(10, Equals, 20) } i++ c.Specify("Child A", func() {}) c.Specify("Child B", func() {}) }) runner.Run() c.Specify("then the error is reported", func() { c.Expect(runner.Results()).Matches(ReportIs(` - RootSpec [FAIL] *** Expected: equals “20” got: “10” at results_test.go - Child A - Child B 3 specs, 1 failures `)) }) }) c.Specify("When root spec fails sporadically", func() { runner := NewRunner() runner.AddNamedSpec("RootSpec", func(c Context) { i := 0 c.Specify("Child A", func() { i = 1 }) c.Specify("Child B", func() { i = 2 }) c.Expect(10, Equals, 20) // stays same - will be reported once c.Expect(10+i, Equals, 20) // changes - will be reported many times }) runner.Run() c.Specify("then the errors are merged together", func() { c.Expect(runner.Results()).Matches(ReportIs(` - RootSpec [FAIL] *** Expected: equals “20” got: “10” at results_test.go *** Expected: equals “20” got: “11” at results_test.go *** Expected: equals “20” got: “12” at results_test.go - Child A - Child B 3 specs, 1 failures `)) }) }) c.Specify("When non-root spec fails sporadically", func() { runner := NewRunner() runner.AddNamedSpec("RootSpec", func(c Context) { c.Specify("Failing", func() { i := 0 c.Specify("Child A", func() { i = 1 }) c.Specify("Child B", func() { i = 2 }) c.Expect(10, Equals, 20) // stays same - will be reported once c.Expect(10+i, Equals, 20) // changes - will be reported many times }) }) runner.Run() c.Specify("then the errors are merged together", func() { c.Expect(runner.Results()).Matches(ReportIs(` - RootSpec - Failing [FAIL] *** Expected: equals “20” got: “10” at results_test.go *** Expected: equals “20” got: “11” at results_test.go *** Expected: equals “20” got: “12” at results_test.go - Child A - Child B 4 specs, 1 failures `)) }) }) c.Specify("When an expectation gives an error", func() { runner := NewRunner() runner.AddNamedSpec("RootSpec", func(c Context) { c.Expect(1, IsWithin(0.1), 1.0) }) runner.Run() c.Specify("the error is reported as-is", func() { c.Expect(runner.Results()).Matches(ReportIs(` - RootSpec [FAIL] *** type error: expected a float, but was “1” of type “int” at results_test.go 1 specs, 1 failures `)) }) }) c.Specify("When a spec panics", func() { runner := NewRunner() runner.AddNamedSpec("RootSpec", func(c Context) { c.Specify("Child A", func() { boom2() }) }) runner.Run() c.Specify("then the panic's stack trace is reported", func() { c.Expect(runner.Results()).Matches(ReportIs(` - RootSpec - Child A [FAIL] *** panic: boom! at recover_test.go at recover_test.go at recover_test.go at results_test.go 2 specs, 1 failures `)) }) }) c.Specify("When a root spec panics", func() { runner := NewRunner() runner.AddNamedSpec("RootSpec", func(c Context) { boom2() }) runner.Run() c.Specify("the bootstrap code in runner.go does not show up in the stack trace", func() { c.Expect(runner.Results()).Matches(ReportIs(` - RootSpec [FAIL] *** panic: boom! at recover_test.go at recover_test.go at recover_test.go at results_test.go 1 specs, 1 failures `)) }) }) }
func MatchersSpec(c nanospec.Context) { c.Specify("Matcher: Equals", func() { c.Specify("strings", func() { c.Expect(E("apple", Equals, "apple")).Matches(Passes) c.Expect(E("apple", Equals, "orange")).Matches(FailsWithMessage( "equals “orange”", "does NOT equal “orange”")) }) c.Specify("ints", func() { c.Expect(E(42, Equals, 42)).Matches(Passes) c.Expect(E(42, Equals, 999)).Matches(Fails) }) c.Specify("structs", func() { c.Expect(E(DummyStruct{42, 1}, Equals, DummyStruct{42, 2})).Matches(Passes) c.Expect(E(DummyStruct{42, 1}, Equals, DummyStruct{999, 2})).Matches(Fails) }) c.Specify("struct pointers", func() { c.Expect(E(&DummyStruct{42, 1}, Equals, &DummyStruct{42, 2})).Matches(Passes) c.Expect(E(&DummyStruct{42, 1}, Equals, &DummyStruct{999, 2})).Matches(Fails) }) }) c.Specify("Matcher: IsSame", func() { a1 := new(os.File) a2 := a1 b := new(os.File) c.Expect(E(a1, IsSame, a2)).Matches(Passes) c.Expect(E(a1, IsSame, b)).Matches(FailsWithMessage( fmt.Sprintf("is same as “%v”", b), fmt.Sprintf("is NOT same as “%v”", b))) c.Specify("cannot compare values, but only pointers", func() { c.Expect(E(1, IsSame, b)).Matches(GivesError("type error: expected a pointer, but was “1” of type “int”")) c.Expect(E(b, IsSame, 1)).Matches(GivesError("type error: expected a pointer, but was “1” of type “int”")) }) }) c.Specify("Matcher: IsNil", func() { c.Expect(E(nil, IsNil)).Matches(Passes) // interface value nil c.Expect(E((*int)(nil), IsNil)).Matches(Passes) // typed pointer nil inside an interface value c.Expect(E(new(int), IsNil)).Matches(Fails) c.Expect(E(1, IsNil)).Matches(FailsWithMessage( "is <nil>", "is NOT <nil>")) }) c.Specify("Matcher: IsTrue", func() { c.Expect(E(true, IsTrue)).Matches(Passes) c.Expect(E(false, IsTrue)).Matches(FailsWithMessage( "is <true>", "is NOT <true>")) }) c.Specify("Matcher: IsFalse", func() { c.Expect(E(false, IsFalse)).Matches(Passes) c.Expect(E(true, IsFalse)).Matches(FailsWithMessage( "is <false>", "is NOT <false>")) }) c.Specify("Matcher: Satisfies", func() { value := 42 c.Expect(E(value, Satisfies, value < 100)).Matches(Passes) c.Expect(E(value, Satisfies, value > 100)).Matches(FailsWithMessage( "satisfies the criteria", "does NOT satisfy the criteria")) }) c.Specify("Matcher: IsWithin", func() { value := float64(3.141) pi := float64(math.Pi) c.Expect(E(value, IsWithin(0.001), pi)).Matches(Passes) c.Expect(E(value, IsWithin(0.0001), pi)).Matches(FailsWithMessage( "is within 3.141592653589793 ± 0.0001", "is NOT within 3.141592653589793 ± 0.0001")) c.Specify("cannot compare ints", func() { value := int(3) pi := float64(math.Pi) c.Expect(E(value, IsWithin(0.001), pi)).Matches(GivesError("type error: expected a float, but was “3” of type “int”")) c.Expect(E(pi, IsWithin(0.001), value)).Matches(GivesError("type error: expected a float, but was “3” of type “int”")) }) }) c.Specify("Matcher: Contains", func() { values := []string{"one", "two", "three"} c.Expect(E(values, Contains, "one")).Matches(Passes) c.Expect(E(values, Contains, "two")).Matches(Passes) c.Expect(E(values, Contains, "three")).Matches(Passes) c.Expect(E(values, Contains, "four")).Matches(FailsWithMessage( "contains “four”", "does NOT contain “four”")) }) c.Specify("Matcher: ContainsAll", func() { values := []string{"one", "two", "three"} c.Expect(E(values, ContainsAll, Values())).Matches(Passes) c.Expect(E(values, ContainsAll, Values("one"))).Matches(Passes) c.Expect(E(values, ContainsAll, Values("three", "two"))).Matches(Passes) c.Expect(E(values, ContainsAll, Values("one", "two", "three"))).Matches(Passes) c.Expect(E(values, ContainsAll, Values("four"))).Matches(Fails) c.Expect(E(values, ContainsAll, Values("one", "four"))).Matches(FailsWithMessage( "contains all of “[one four]”", "does NOT contain all of “[one four]”")) }) c.Specify("Matcher: ContainsAny", func() { values := []string{"one", "two", "three"} c.Expect(E(values, ContainsAny, Values("one"))).Matches(Passes) c.Expect(E(values, ContainsAny, Values("three", "two"))).Matches(Passes) c.Expect(E(values, ContainsAny, Values("four", "one", "five"))).Matches(Passes) c.Expect(E(values, ContainsAny, Values("one", "two", "three"))).Matches(Passes) c.Expect(E(values, ContainsAny, Values())).Matches(Fails) c.Expect(E(values, ContainsAny, Values("four"))).Matches(Fails) c.Expect(E(values, ContainsAny, Values("four", "five"))).Matches(FailsWithMessage( "contains any of “[four five]”", "does NOT contain any of “[four five]”")) }) c.Specify("Matcher: ContainsExactly", func() { values := []string{"one", "two", "three"} c.Expect(E(values, ContainsExactly, Values("one", "two", "three"))).Matches(Passes) c.Expect(E(values, ContainsExactly, Values("three", "one", "two"))).Matches(Passes) c.Expect(E(values, ContainsExactly, Values())).Matches(Fails) c.Expect(E(values, ContainsExactly, Values("four"))).Matches(Fails) c.Expect(E(values, ContainsExactly, Values("one", "two"))).Matches(Fails) c.Expect(E(values, ContainsExactly, Values("one", "two", "three", "four"))).Matches(FailsWithMessage( "contains exactly “[one two three four]”", "does NOT contain exactly “[one two three four]”")) // duplicate values are allowed values = []string{"a", "a", "b"} c.Expect(E(values, ContainsExactly, Values("a", "a", "b"))).Matches(Passes) c.Expect(E(values, ContainsExactly, Values("a", "b", "a"))).Matches(Passes) c.Expect(E(values, ContainsExactly, Values("a", "b", "b"))).Matches(Fails) c.Expect(E(values, ContainsExactly, Values("a", "a", "a", "b"))).Matches(Fails) c.Expect(E(values, ContainsExactly, Values("a", "a", "b", "b"))).Matches(Fails) }) c.Specify("Matcher: ContainsInOrder", func() { values := []string{"one", "two", "three"} c.Expect(E(values, ContainsInOrder, Values("one", "two", "three"))).Matches(Passes) c.Expect(E(values, ContainsInOrder, Values())).Matches(Fails) c.Expect(E(values, ContainsInOrder, Values("one", "two"))).Matches(Fails) c.Expect(E(values, ContainsInOrder, Values("one", "two", "four"))).Matches(Fails) c.Expect(E(values, ContainsInOrder, Values("one", "two", "three", "four"))).Matches(Fails) c.Expect(E(values, ContainsInOrder, Values("three", "one", "two"))).Matches(FailsWithMessage( "contains in order “[three one two]”", "does NOT contain in order “[three one two]”")) }) c.Specify("Matcher: ContainsInPartialOrder", func() { values := []string{"1", "2", "2", "3", "4"} c.Expect(E(values, ContainsInPartialOrder, Values())).Matches(Passes) c.Expect(E(values, ContainsInPartialOrder, Values("1"))).Matches(Passes) c.Expect(E(values, ContainsInPartialOrder, Values("1", "2", "2"))).Matches(Passes) c.Expect(E(values, ContainsInPartialOrder, Values("1", "2", "3"))).Matches(Passes) c.Expect(E(values, ContainsInPartialOrder, Values("1", "2", "2", "3", "4"))).Matches(Passes) c.Expect(E(values, ContainsInPartialOrder, Values("1", "1"))).Matches(Fails) c.Expect(E(values, ContainsInPartialOrder, Values("2", "1"))).Matches(Fails) c.Expect(E(values, ContainsInPartialOrder, Values("2", "2", "2"))).Matches(Fails) c.Expect(E(values, ContainsInPartialOrder, Values("1", "4", "3"))).Matches(FailsWithMessage( "contains in partial order “[1 4 3]”", "does NOT contain in partial order “[1 4 3]”")) }) c.Specify("Conversions for containment matchers", func() { c.Specify("array to array", func() { values := [...]string{"one", "two", "three"} result, _ := toArray(values) c.Expect(len(result)).Equals(3) c.Expect(result[0]).Equals("one") c.Expect(result[1]).Equals("two") c.Expect(result[2]).Equals("three") }) c.Specify("channel to array", func() { values := make(chan string, 10) values <- "one" values <- "two" values <- "three" close(values) result, _ := toArray(values) c.Expect(len(result)).Equals(3) c.Expect(result[0]).Equals("one") c.Expect(result[1]).Equals("two") c.Expect(result[2]).Equals("three") }) c.Specify("list to array", func() { values := list.New() values.PushBack("one") values.PushBack("two") values.PushBack("three") result, _ := toArray(values) c.Expect(len(result)).Equals(3) c.Expect(result[0]).Equals("one") c.Expect(result[1]).Equals("two") c.Expect(result[2]).Equals("three") }) c.Specify("unsupported value to array", func() { _, err := toArray("foo") c.Expect(err.Error()).Equals("type error: expected a collection type, but was “foo” of type “string”") }) }) c.Specify("Containment matchers convert the actual value to a printable array "+ "when it's not originally printable", func() { values := list.New() values.PushBack("one") values.PushBack("two") values.PushBack("three") nonPrintableList := values listAsString := "[one two three]" c.Expect(fmt.Sprint(nonPrintableList)).NotEquals(listAsString) c.Specify("Matcher: Contains", func() { c.Expect(func(c Context) { c.Expect(nonPrintableList, Contains, "xxx") }).Matches(SpecsReportContains(listAsString)) }) multiValueMatchers := []Matcher{ ContainsAll, ContainsAny, ContainsExactly, ContainsInOrder, ContainsInPartialOrder, } for _, matcher := range multiValueMatchers { c.Specify("Matcher: "+functionName(matcher), func() { c.Expect(func(c Context) { c.Expect(nonPrintableList, matcher, Values("xxx")) }).Matches(SpecsReportContains(listAsString)) }) } }) }
func MatcherMessagesSpec(c nanospec.Context) { spy := new(SpyErrorLogger) m := newMatcherAdapter(nil, spy, ExpectFailed) c.Specify("Positive expectation failures are reported with the positive message", func() { m.Expect(1, DummyEquals, 1) c.Expect(spy.LastError()).Equals("") m.Expect(1, DummyEquals, 2) c.Expect(spy.LastError()).Equals("1 should equal 2") }) c.Specify("Negative expectation failures are reported with the negative message", func() { m.Expect(1, Not(DummyEquals), 2) c.Expect(spy.LastError()).Equals("") m.Expect(1, Not(DummyEquals), 1) c.Expect(spy.LastError()).Equals("1 should NOT equal 1") }) c.Specify("Errors in expectations are reported with the error message", func() { m.Expect(666, DummyEquals, 1) c.Expect(spy.LastError()).Equals("666 illegal value") }) }