diff --git a/Godeps/_workspace/src/code.google.com/p/gomock/gomock/call.go b/Godeps/_workspace/src/code.google.com/p/gomock/gomock/call.go deleted file mode 100644 index ea1e0922..00000000 --- a/Godeps/_workspace/src/code.google.com/p/gomock/gomock/call.go +++ /dev/null @@ -1,247 +0,0 @@ -// Copyright 2010 Google Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package gomock - -import ( - "fmt" - "reflect" - "strings" -) - -// Call represents an expected call to a mock. -type Call struct { - t TestReporter // for triggering test failures on invalid call setup - - receiver interface{} // the receiver of the method call - method string // the name of the method - args []Matcher // the args - rets []interface{} // the return values (if any) - - preReqs []*Call // prerequisite calls - - // Expectations - minCalls, maxCalls int - - numCalls int // actual number made - - // Actions - doFunc reflect.Value - setArgs map[int]reflect.Value -} - -func (c *Call) AnyTimes() *Call { - c.minCalls, c.maxCalls = 0, 1e8 // close enough to infinity - return c -} - -// Do declares the action to run when the call is matched. -// It takes an interface{} argument to support n-arity functions. -func (c *Call) Do(f interface{}) *Call { - // TODO: Check arity and types here, rather than dying badly elsewhere. - c.doFunc = reflect.ValueOf(f) - return c -} - -func (c *Call) Return(rets ...interface{}) *Call { - mt := c.methodType() - if len(rets) != mt.NumOut() { - c.t.Fatalf("wrong number of arguments to Return for %T.%v: got %d, want %d", - c.receiver, c.method, len(rets), mt.NumOut()) - } - for i, ret := range rets { - if got, want := reflect.TypeOf(ret), mt.Out(i); got == want { - // Identical types; nothing to do. - } else if got == nil { - // Nil needs special handling. - switch want.Kind() { - case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: - // ok - default: - c.t.Fatalf("argument %d to Return for %T.%v is nil, but %v is not nillable", - i, c.receiver, c.method, want) - } - } else if got.AssignableTo(want) { - // Assignable type relation. Make the assignment now so that the generated code - // can return the values with a type assertion. - v := reflect.New(want).Elem() - v.Set(reflect.ValueOf(ret)) - rets[i] = v.Interface() - } else { - c.t.Fatalf("wrong type of argument %d to Return for %T.%v: %v is not assignable to %v", - i, c.receiver, c.method, got, want) - } - } - - c.rets = rets - return c -} - -func (c *Call) Times(n int) *Call { - c.minCalls, c.maxCalls = n, n - return c -} - -// SetArg declares an action that will set the nth argument's value, -// indirected through a pointer. -func (c *Call) SetArg(n int, value interface{}) *Call { - if c.setArgs == nil { - c.setArgs = make(map[int]reflect.Value) - } - mt := c.methodType() - // TODO: This will break on variadic methods. - // We will need to check those at invocation time. - if n < 0 || n >= mt.NumIn() { - c.t.Fatalf("SetArg(%d, ...) called for a method with %d args", n, mt.NumIn()) - } - // Permit setting argument through an interface. - // In the interface case, we don't (nay, can't) check the type here. - at := mt.In(n) - switch at.Kind() { - case reflect.Ptr: - dt := at.Elem() - if vt := reflect.TypeOf(value); !vt.AssignableTo(dt) { - c.t.Fatalf("SetArg(%d, ...) argument is a %v, not assignable to %v", n, vt, dt) - } - case reflect.Interface: - // nothing to do - default: - c.t.Fatalf("SetArg(%d, ...) referring to argument of non-pointer non-interface type %v", n, at) - } - c.setArgs[n] = reflect.ValueOf(value) - return c -} - -// isPreReq returns true if other is a direct or indirect prerequisite to c. -func (c *Call) isPreReq(other *Call) bool { - for _, preReq := range c.preReqs { - if other == preReq || preReq.isPreReq(other) { - return true - } - } - return false -} - -// After declares that the call may only match after preReq has been exhausted. -func (c *Call) After(preReq *Call) *Call { - if preReq.isPreReq(c) { - msg := fmt.Sprintf( - "Loop in call order: %v is a prerequisite to %v (possibly indirectly).", - c, preReq, - ) - panic(msg) - } - - c.preReqs = append(c.preReqs, preReq) - return c -} - -// Returns true iff the minimum number of calls have been made. -func (c *Call) satisfied() bool { - return c.numCalls >= c.minCalls -} - -// Returns true iff the maximum number of calls have been made. -func (c *Call) exhausted() bool { - return c.numCalls >= c.maxCalls -} - -func (c *Call) String() string { - args := make([]string, len(c.args)) - for i, arg := range c.args { - args[i] = arg.String() - } - arguments := strings.Join(args, ", ") - return fmt.Sprintf("%T.%v(%s)", c.receiver, c.method, arguments) -} - -// Tests if the given call matches the expected call. -func (c *Call) matches(args []interface{}) bool { - if len(args) != len(c.args) { - return false - } - for i, m := range c.args { - if !m.Matches(args[i]) { - return false - } - } - - // Check that all prerequisite calls have been satisfied. - for _, preReqCall := range c.preReqs { - if !preReqCall.satisfied() { - return false - } - } - - return true -} - -// dropPrereqs tells the expected Call to not re-check prerequite calls any -// longer, and to return its current set. -func (c *Call) dropPrereqs() (preReqs []*Call) { - preReqs = c.preReqs - c.preReqs = nil - return -} - -func (c *Call) call(args []interface{}) (rets []interface{}, action func()) { - c.numCalls++ - - // Actions - if c.doFunc.IsValid() { - doArgs := make([]reflect.Value, len(args)) - ft := c.doFunc.Type() - for i := 0; i < ft.NumIn(); i++ { - if args[i] != nil { - doArgs[i] = reflect.ValueOf(args[i]) - } else { - // Use the zero value for the arg. - doArgs[i] = reflect.Zero(ft.In(i)) - } - } - action = func() { c.doFunc.Call(doArgs) } - } - for n, v := range c.setArgs { - reflect.ValueOf(args[n]).Elem().Set(v) - } - - rets = c.rets - if rets == nil { - // Synthesize the zero value for each of the return args' types. - mt := c.methodType() - rets = make([]interface{}, mt.NumOut()) - for i := 0; i < mt.NumOut(); i++ { - rets[i] = reflect.Zero(mt.Out(i)).Interface() - } - } - - return -} - -func (c *Call) methodType() reflect.Type { - recv := reflect.ValueOf(c.receiver) - for i := 0; i < recv.Type().NumMethod(); i++ { - if recv.Type().Method(i).Name == c.method { - return recv.Method(i).Type() - } - } - panic(fmt.Sprintf("gomock: failed finding method %s on %T", c.method, c.receiver)) -} - -// InOrder declares that the given calls should occur in order. -func InOrder(calls ...*Call) { - for i := 1; i < len(calls); i++ { - calls[i].After(calls[i-1]) - } -} diff --git a/Godeps/_workspace/src/code.google.com/p/gomock/gomock/callset.go b/Godeps/_workspace/src/code.google.com/p/gomock/gomock/callset.go deleted file mode 100644 index 1b7de4c0..00000000 --- a/Godeps/_workspace/src/code.google.com/p/gomock/gomock/callset.go +++ /dev/null @@ -1,76 +0,0 @@ -// Copyright 2011 Google Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package gomock - -// callSet represents a set of expected calls, indexed by receiver and method -// name. -type callSet map[interface{}]map[string][]*Call - -// Add adds a new expected call. -func (cs callSet) Add(call *Call) { - methodMap, ok := cs[call.receiver] - if !ok { - methodMap = make(map[string][]*Call) - cs[call.receiver] = methodMap - } - methodMap[call.method] = append(methodMap[call.method], call) -} - -// Remove removes an expected call. -func (cs callSet) Remove(call *Call) { - methodMap, ok := cs[call.receiver] - if !ok { - return - } - sl := methodMap[call.method] - for i, c := range sl { - if c == call { - // quick removal; we don't need to maintain call order - if len(sl) > 1 { - sl[i] = sl[len(sl)-1] - } - methodMap[call.method] = sl[:len(sl)-1] - break - } - } -} - -// FindMatch searches for a matching call. Returns nil if no call matched. -func (cs callSet) FindMatch(receiver interface{}, method string, args []interface{}) *Call { - methodMap, ok := cs[receiver] - if !ok { - return nil - } - calls, ok := methodMap[method] - if !ok { - return nil - } - - // Search through the unordered set of calls expected on a method on a - // receiver. - for _, call := range calls { - // A call should not normally still be here if exhausted, - // but it can happen if, for instance, .Times(0) was used. - // Pretend the call doesn't match. - if call.exhausted() { - continue - } - if call.matches(args) { - return call - } - } - - return nil -} diff --git a/Godeps/_workspace/src/code.google.com/p/gomock/gomock/controller.go b/Godeps/_workspace/src/code.google.com/p/gomock/gomock/controller.go deleted file mode 100644 index 6ca95280..00000000 --- a/Godeps/_workspace/src/code.google.com/p/gomock/gomock/controller.go +++ /dev/null @@ -1,167 +0,0 @@ -// Copyright 2010 Google Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -// GoMock - a mock framework for Go. -// -// Standard usage: -// (1) Define an interface that you wish to mock. -// type MyInterface interface { -// SomeMethod(x int64, y string) -// } -// (2) Use mockgen to generate a mock from the interface. -// (3) Use the mock in a test: -// func TestMyThing(t *testing.T) { -// mockCtrl := gomock.NewController(t) -// defer mockCtrl.Finish() -// -// mockObj := something.NewMockMyInterface(mockCtrl) -// mockObj.EXPECT().SomeMethod(4, "blah") -// // pass mockObj to a real object and play with it. -// } -// -// By default, expected calls are not enforced to run in any particular order. -// Call order dependency can be enforced by use of InOrder and/or Call.After. -// Call.After can create more varied call order dependencies, but InOrder is -// often more convenient. -// -// The following examples create equivalent call order dependencies. -// -// Example of using Call.After to chain expected call order: -// -// firstCall := mockObj.EXPECT().SomeMethod(1, "first") -// secondCall := mockObj.EXPECT().SomeMethod(2, "second").After(firstCall) -// mockObj.EXPECT().SomeMethod(3, "third").After(secondCall) -// -// Example of using InOrder to declare expected call order: -// -// gomock.InOrder( -// mockObj.EXPECT().SomeMethod(1, "first"), -// mockObj.EXPECT().SomeMethod(2, "second"), -// mockObj.EXPECT().SomeMethod(3, "third"), -// ) -// -// TODO: -// - Handle different argument/return types (e.g. ..., chan, map, interface). -package gomock - -import "sync" - -// A TestReporter is something that can be used to report test failures. -// It is satisfied by the standard library's *testing.T. -type TestReporter interface { - Errorf(format string, args ...interface{}) - Fatalf(format string, args ...interface{}) -} - -// A Controller represents the top-level control of a mock ecosystem. -// It defines the scope and lifetime of mock objects, as well as their expectations. -// It is safe to call Controller's methods from multiple goroutines. -type Controller struct { - mu sync.Mutex - t TestReporter - expectedCalls callSet -} - -func NewController(t TestReporter) *Controller { - return &Controller{ - t: t, - expectedCalls: make(callSet), - } -} - -func (ctrl *Controller) RecordCall(receiver interface{}, method string, args ...interface{}) *Call { - // TODO: check arity, types. - margs := make([]Matcher, len(args)) - for i, arg := range args { - if m, ok := arg.(Matcher); ok { - margs[i] = m - } else if arg == nil { - // Handle nil specially so that passing a nil interface value - // will match the typed nils of concrete args. - margs[i] = Nil() - } else { - margs[i] = Eq(arg) - } - } - - ctrl.mu.Lock() - defer ctrl.mu.Unlock() - - call := &Call{t: ctrl.t, receiver: receiver, method: method, args: margs, minCalls: 1, maxCalls: 1} - - ctrl.expectedCalls.Add(call) - return call -} - -func (ctrl *Controller) Call(receiver interface{}, method string, args ...interface{}) []interface{} { - ctrl.mu.Lock() - defer ctrl.mu.Unlock() - - expected := ctrl.expectedCalls.FindMatch(receiver, method, args) - if expected == nil { - ctrl.t.Fatalf("no matching expected call: %T.%v(%v)", receiver, method, args) - } - - // Two things happen here: - // * the matching call no longer needs to check prerequite calls, - // * and the prerequite calls are no longer expected, so remove them. - preReqCalls := expected.dropPrereqs() - for _, preReqCall := range preReqCalls { - ctrl.expectedCalls.Remove(preReqCall) - } - - rets, action := expected.call(args) - if expected.exhausted() { - ctrl.expectedCalls.Remove(expected) - } - - // Don't hold the lock while doing the call's action (if any) - // so that actions may execute concurrently. - // We use the deferred Unlock to capture any panics that happen above; - // here we add a deferred Lock to balance it. - ctrl.mu.Unlock() - defer ctrl.mu.Lock() - if action != nil { - action() - } - - return rets -} - -func (ctrl *Controller) Finish() { - ctrl.mu.Lock() - defer ctrl.mu.Unlock() - - // If we're currently panicking, probably because this is a deferred call, - // pass through the panic. - if err := recover(); err != nil { - panic(err) - } - - // Check that all remaining expected calls are satisfied. - failures := false - for _, methodMap := range ctrl.expectedCalls { - for _, calls := range methodMap { - for _, call := range calls { - if !call.satisfied() { - ctrl.t.Errorf("missing call(s) to %v", call) - failures = true - } - } - } - } - if failures { - ctrl.t.Fatalf("aborting test due to missing call(s)") - } -} diff --git a/Godeps/_workspace/src/code.google.com/p/gomock/gomock/controller_test.go b/Godeps/_workspace/src/code.google.com/p/gomock/gomock/controller_test.go deleted file mode 100644 index 2e64b7ce..00000000 --- a/Godeps/_workspace/src/code.google.com/p/gomock/gomock/controller_test.go +++ /dev/null @@ -1,395 +0,0 @@ -// Copyright 2011 Google Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package gomock_test - -import ( - "fmt" - "reflect" - "testing" - - "code.google.com/p/gomock/gomock" -) - -type ErrorReporter struct { - t *testing.T - log []string - failed bool - fatalToken struct{} -} - -func NewErrorReporter(t *testing.T) *ErrorReporter { - return &ErrorReporter{t: t} -} - -func (e *ErrorReporter) reportLog() { - for _, entry := range e.log { - e.t.Log(entry) - } -} - -func (e *ErrorReporter) assertPass(msg string) { - if e.failed { - e.t.Errorf("Expected pass, but got failure(s): %s", msg) - e.reportLog() - } -} - -func (e *ErrorReporter) assertFail(msg string) { - if !e.failed { - e.t.Error("Expected failure, but got pass: %s", msg) - } -} - -// Use to check that code triggers a fatal test failure. -func (e *ErrorReporter) assertFatal(fn func()) { - defer func() { - err := recover() - if err == nil { - var actual string - if e.failed { - actual = "non-fatal failure" - } else { - actual = "pass" - } - e.t.Error("Expected fatal failure, but got a", actual) - } else if token, ok := err.(*struct{}); ok && token == &e.fatalToken { - // This is okay - the panic is from Fatalf(). - return - } else { - // Some other panic. - panic(err) - } - }() - - fn() -} - -// recoverUnexpectedFatal can be used as a deferred call in test cases to -// recover from and display a call to ErrorReporter.Fatalf(). -func (e *ErrorReporter) recoverUnexpectedFatal() { - err := recover() - if err == nil { - // No panic. - } else if token, ok := err.(*struct{}); ok && token == &e.fatalToken { - // Unexpected fatal error happened. - e.t.Error("Got unexpected fatal error(s). All errors up to this point:") - e.reportLog() - return - } else { - // Some other panic. - panic(err) - } -} - -func (e *ErrorReporter) Logf(format string, args ...interface{}) { - e.log = append(e.log, fmt.Sprintf(format, args...)) -} - -func (e *ErrorReporter) Errorf(format string, args ...interface{}) { - e.Logf(format, args...) - e.failed = true -} - -func (e *ErrorReporter) Fatalf(format string, args ...interface{}) { - e.Logf(format, args...) - e.failed = true - panic(&e.fatalToken) -} - -// A type purely for use as a receiver in testing the Controller. -type Subject struct{} - -func (s *Subject) FooMethod(arg string) int { - return 0 -} - -func (s *Subject) BarMethod(arg string) int { - return 0 -} - -func assertEqual(t *testing.T, expected interface{}, actual interface{}) { - if !reflect.DeepEqual(expected, actual) { - t.Error("Expected %+v, but got %+v", expected, actual) - } -} - -func createFixtures(t *testing.T) (reporter *ErrorReporter, ctrl *gomock.Controller) { - // reporter acts as a testing.T-like object that we pass to the - // Controller. We use it to test that the mock considered tests - // successful or failed. - reporter = NewErrorReporter(t) - ctrl = gomock.NewController(reporter) - return -} - -func TestNoCalls(t *testing.T) { - reporter, ctrl := createFixtures(t) - ctrl.Finish() - reporter.assertPass("No calls expected or made.") -} - -func TestExpectedMethodCall(t *testing.T) { - reporter, ctrl := createFixtures(t) - subject := new(Subject) - - ctrl.RecordCall(subject, "FooMethod", "argument") - ctrl.Call(subject, "FooMethod", "argument") - ctrl.Finish() - - reporter.assertPass("Expected method call made.") -} - -func TestUnexpectedMethodCall(t *testing.T) { - reporter, ctrl := createFixtures(t) - subject := new(Subject) - - reporter.assertFatal(func() { - ctrl.Call(subject, "FooMethod", "argument") - }) - - ctrl.Finish() -} - -func TestRepeatedCall(t *testing.T) { - reporter, ctrl := createFixtures(t) - subject := new(Subject) - - ctrl.RecordCall(subject, "FooMethod", "argument").Times(3) - ctrl.Call(subject, "FooMethod", "argument") - ctrl.Call(subject, "FooMethod", "argument") - ctrl.Call(subject, "FooMethod", "argument") - reporter.assertPass("After expected repeated method calls.") - reporter.assertFatal(func() { - ctrl.Call(subject, "FooMethod", "argument") - }) - ctrl.Finish() - reporter.assertFail("After calling one too many times.") -} - -func TestUnexpectedArgCount(t *testing.T) { - reporter, ctrl := createFixtures(t) - defer reporter.recoverUnexpectedFatal() - subject := new(Subject) - - ctrl.RecordCall(subject, "FooMethod", "argument") - reporter.assertFatal(func() { - // This call is made with the wrong number of arguments... - ctrl.Call(subject, "FooMethod", "argument", "extra_argument") - }) - reporter.assertFatal(func() { - // ... so is this. - ctrl.Call(subject, "FooMethod") - }) - reporter.assertFatal(func() { - // The expected call wasn't made. - ctrl.Finish() - }) -} - -func TestAnyTimes(t *testing.T) { - reporter, ctrl := createFixtures(t) - subject := new(Subject) - - ctrl.RecordCall(subject, "FooMethod", "argument").AnyTimes() - for i := 0; i < 100; i++ { - ctrl.Call(subject, "FooMethod", "argument") - } - reporter.assertPass("After 100 method calls.") - ctrl.Finish() -} - -func TestDo(t *testing.T) { - _, ctrl := createFixtures(t) - subject := new(Subject) - - doCalled := false - var argument string - ctrl.RecordCall(subject, "FooMethod", "argument").Do( - func(arg string) { - doCalled = true - argument = arg - }) - if doCalled { - t.Error("Do() callback called too early.") - } - - ctrl.Call(subject, "FooMethod", "argument") - - if !doCalled { - t.Error("Do() callback not called.") - } - if "argument" != argument { - t.Error("Do callback received wrong argument.") - } - - ctrl.Finish() -} - -func TestReturn(t *testing.T) { - _, ctrl := createFixtures(t) - subject := new(Subject) - - // Unspecified return should produce "zero" result. - ctrl.RecordCall(subject, "FooMethod", "zero") - ctrl.RecordCall(subject, "FooMethod", "five").Return(5) - - assertEqual( - t, - []interface{}{0}, - ctrl.Call(subject, "FooMethod", "zero")) - - assertEqual( - t, - []interface{}{5}, - ctrl.Call(subject, "FooMethod", "five")) - ctrl.Finish() -} - -func TestUnorderedCalls(t *testing.T) { - reporter, ctrl := createFixtures(t) - defer reporter.recoverUnexpectedFatal() - subjectTwo := new(Subject) - subjectOne := new(Subject) - - ctrl.RecordCall(subjectOne, "FooMethod", "1") - ctrl.RecordCall(subjectOne, "BarMethod", "2") - ctrl.RecordCall(subjectTwo, "FooMethod", "3") - ctrl.RecordCall(subjectTwo, "BarMethod", "4") - - // Make the calls in a different order, which should be fine. - ctrl.Call(subjectOne, "BarMethod", "2") - ctrl.Call(subjectTwo, "FooMethod", "3") - ctrl.Call(subjectTwo, "BarMethod", "4") - ctrl.Call(subjectOne, "FooMethod", "1") - - reporter.assertPass("After making all calls in different order") - - ctrl.Finish() - - reporter.assertPass("After finish") -} - -func commonTestOrderedCalls(t *testing.T) (reporter *ErrorReporter, ctrl *gomock.Controller, subjectOne, subjectTwo *Subject) { - reporter, ctrl = createFixtures(t) - - subjectOne = new(Subject) - subjectTwo = new(Subject) - - gomock.InOrder( - ctrl.RecordCall(subjectOne, "FooMethod", "1").AnyTimes(), - ctrl.RecordCall(subjectTwo, "FooMethod", "2"), - ctrl.RecordCall(subjectTwo, "BarMethod", "3"), - ) - - return -} - -func TestOrderedCallsCorrect(t *testing.T) { - reporter, ctrl, subjectOne, subjectTwo := commonTestOrderedCalls(t) - - ctrl.Call(subjectOne, "FooMethod", "1") - ctrl.Call(subjectTwo, "FooMethod", "2") - ctrl.Call(subjectTwo, "BarMethod", "3") - - ctrl.Finish() - - reporter.assertPass("After finish") -} - -func TestOrderedCallsInCorrect(t *testing.T) { - reporter, ctrl, subjectOne, subjectTwo := commonTestOrderedCalls(t) - - ctrl.Call(subjectOne, "FooMethod", "1") - reporter.assertFatal(func() { - ctrl.Call(subjectTwo, "BarMethod", "3") - }) -} - -// Test that calls that are prerequites to other calls but have maxCalls > -// minCalls are removed from the expected call set. -func TestOrderedCallsWithPreReqMaxUnbounded(t *testing.T) { - reporter, ctrl, subjectOne, subjectTwo := commonTestOrderedCalls(t) - - // Initially we should be able to call FooMethod("1") as many times as we - // want. - ctrl.Call(subjectOne, "FooMethod", "1") - ctrl.Call(subjectOne, "FooMethod", "1") - - // But calling something that has it as a prerequite should remove it from - // the expected call set. This allows tests to ensure that FooMethod("1") is - // *not* called after FooMethod("2"). - ctrl.Call(subjectTwo, "FooMethod", "2") - - // Therefore this call should fail: - reporter.assertFatal(func() { - ctrl.Call(subjectOne, "FooMethod", "1") - }) -} - -func TestCallAfterLoopPanic(t *testing.T) { - _, ctrl := createFixtures(t) - - subject := new(Subject) - - firstCall := ctrl.RecordCall(subject, "Foo", "1") - secondCall := ctrl.RecordCall(subject, "Foo", "2") - thirdCall := ctrl.RecordCall(subject, "Foo", "3") - - gomock.InOrder(firstCall, secondCall, thirdCall) - - defer func() { - err := recover() - if err == nil { - t.Error("Call.After creation of dependency loop did not panic.") - } - }() - - // This should panic due to dependency loop. - firstCall.After(thirdCall) -} - -func TestPanicOverridesExpectationChecks(t *testing.T) { - ctrl := gomock.NewController(t) - reporter := NewErrorReporter(t) - - reporter.assertFatal(func() { - ctrl.RecordCall(new(Subject), "FooMethod", "1") - defer ctrl.Finish() - reporter.Fatalf("Intentional panic") - }) -} - -func TestSetArgWithBadType(t *testing.T) { - rep, ctrl := createFixtures(t) - defer ctrl.Finish() - - s := new(Subject) - // This should catch a type error: - rep.assertFatal(func() { - ctrl.RecordCall(s, "FooMethod", "1").SetArg(0, "blah") - }) - ctrl.Call(s, "FooMethod", "1") -} - -func TestTimes0(t *testing.T) { - rep, ctrl := createFixtures(t) - defer ctrl.Finish() - - s := new(Subject) - ctrl.RecordCall(s, "FooMethod", "arg").Times(0) - rep.assertFatal(func() { - ctrl.Call(s, "FooMethod", "arg") - }) -} diff --git a/Godeps/_workspace/src/code.google.com/p/gomock/gomock/matchers.go b/Godeps/_workspace/src/code.google.com/p/gomock/gomock/matchers.go deleted file mode 100644 index 32628ae8..00000000 --- a/Godeps/_workspace/src/code.google.com/p/gomock/gomock/matchers.go +++ /dev/null @@ -1,97 +0,0 @@ -// Copyright 2010 Google Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package gomock - -import ( - "fmt" - "reflect" -) - -// A Matcher is a representation of a class of values. -// It is used to represent the valid or expected arguments to a mocked method. -type Matcher interface { - // Matches returns whether y is a match. - Matches(x interface{}) bool - - // String describes what the matcher matches. - String() string -} - -type anyMatcher struct{} - -func (anyMatcher) Matches(x interface{}) bool { - return true -} - -func (anyMatcher) String() string { - return "is anything" -} - -type eqMatcher struct { - x interface{} -} - -func (e eqMatcher) Matches(x interface{}) bool { - return reflect.DeepEqual(e.x, x) -} - -func (e eqMatcher) String() string { - return fmt.Sprintf("is equal to %v", e.x) -} - -type nilMatcher struct{} - -func (nilMatcher) Matches(x interface{}) bool { - if x == nil { - return true - } - - v := reflect.ValueOf(x) - switch v.Kind() { - case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, - reflect.Ptr, reflect.Slice: - return v.IsNil() - } - - return false -} - -func (nilMatcher) String() string { - return "is nil" -} - -type notMatcher struct { - m Matcher -} - -func (n notMatcher) Matches(x interface{}) bool { - return !n.m.Matches(x) -} - -func (n notMatcher) String() string { - // TODO: Improve this if we add a NotString method to the Matcher interface. - return "not(" + n.m.String() + ")" -} - -// Constructors -func Any() Matcher { return anyMatcher{} } -func Eq(x interface{}) Matcher { return eqMatcher{x} } -func Nil() Matcher { return nilMatcher{} } -func Not(x interface{}) Matcher { - if m, ok := x.(Matcher); ok { - return notMatcher{m} - } - return notMatcher{Eq(x)} -} diff --git a/Godeps/_workspace/src/code.google.com/p/gomock/gomock/matchers_test.go b/Godeps/_workspace/src/code.google.com/p/gomock/gomock/matchers_test.go deleted file mode 100644 index 2245b20d..00000000 --- a/Godeps/_workspace/src/code.google.com/p/gomock/gomock/matchers_test.go +++ /dev/null @@ -1,70 +0,0 @@ -// Copyright 2010 Google Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package gomock_test - -import ( - "errors" - "testing" - - "code.google.com/p/gomock/gomock" - mock_matcher "code.google.com/p/gomock/gomock/mock_matcher" -) - -func TestMatchers(t *testing.T) { - type e interface{} - type testCase struct { - matcher gomock.Matcher - yes, no []e - } - tests := []testCase{ - testCase{gomock.Any(), []e{3, nil, "foo"}, nil}, - testCase{gomock.Eq(4), []e{4}, []e{3, "blah", nil, int64(4)}}, - testCase{gomock.Nil(), - []e{nil, (error)(nil), (chan bool)(nil), (*int)(nil)}, - []e{"", 0, make(chan bool), errors.New("err"), new(int)}}, - testCase{gomock.Not(gomock.Eq(4)), []e{3, "blah", nil, int64(4)}, []e{4}}, - } - for i, test := range tests { - for _, x := range test.yes { - if !test.matcher.Matches(x) { - t.Errorf(`test %d: "%v %s" should be true.`, i, x, test.matcher) - } - } - for _, x := range test.no { - if test.matcher.Matches(x) { - t.Errorf(`test %d: "%v %s" should be false.`, i, x, test.matcher) - } - } - } -} - -// A more thorough test of notMatcher -func TestNotMatcher(t *testing.T) { - ctrl := gomock.NewController(t) - defer ctrl.Finish() - - mockMatcher := mock_matcher.NewMockMatcher(ctrl) - notMatcher := gomock.Not(mockMatcher) - - mockMatcher.EXPECT().Matches(4).Return(true) - if match := notMatcher.Matches(4); match { - t.Errorf("notMatcher should not match 4") - } - - mockMatcher.EXPECT().Matches(5).Return(false) - if match := notMatcher.Matches(5); !match { - t.Errorf("notMatcher should match 5") - } -} diff --git a/Godeps/_workspace/src/code.google.com/p/gomock/gomock/mock_matcher/mock_matcher.go b/Godeps/_workspace/src/code.google.com/p/gomock/gomock/mock_matcher/mock_matcher.go deleted file mode 100644 index 2e265e78..00000000 --- a/Godeps/_workspace/src/code.google.com/p/gomock/gomock/mock_matcher/mock_matcher.go +++ /dev/null @@ -1,49 +0,0 @@ -// Automatically generated by MockGen. DO NOT EDIT! -// Source: code.google.com/p/gomock/gomock (interfaces: Matcher) - -package mock_gomock - -import ( - gomock "code.google.com/p/gomock/gomock" -) - -// Mock of Matcher interface -type MockMatcher struct { - ctrl *gomock.Controller - recorder *_MockMatcherRecorder -} - -// Recorder for MockMatcher (not exported) -type _MockMatcherRecorder struct { - mock *MockMatcher -} - -func NewMockMatcher(ctrl *gomock.Controller) *MockMatcher { - mock := &MockMatcher{ctrl: ctrl} - mock.recorder = &_MockMatcherRecorder{mock} - return mock -} - -func (_m *MockMatcher) EXPECT() *_MockMatcherRecorder { - return _m.recorder -} - -func (_m *MockMatcher) Matches(_param0 interface{}) bool { - ret := _m.ctrl.Call(_m, "Matches", _param0) - ret0, _ := ret[0].(bool) - return ret0 -} - -func (_mr *_MockMatcherRecorder) Matches(arg0 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Matches", arg0) -} - -func (_m *MockMatcher) String() string { - ret := _m.ctrl.Call(_m, "String") - ret0, _ := ret[0].(string) - return ret0 -} - -func (_mr *_MockMatcherRecorder) String() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "String") -}