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) } } } }
func TestRemember(t *testing.T) { ctrl := gomock.NewController(t) defer ctrl.Finish() mockIndex := mock_user.NewMockIndex(ctrl) mockIndex.EXPECT().Put("a", 1) // literals work mockIndex.EXPECT().Put("b", gomock.Eq(2)) // matchers work too // NillableRet returns error. Not declaring it should result in a nil return. mockIndex.EXPECT().NillableRet() // Calls that returns something assignable to the return type. boolc := make(chan bool) // In this case, "chan bool" is assignable to "chan<- bool". mockIndex.EXPECT().ConcreteRet().Return(boolc) // In this case, nil is assignable to "chan<- bool". mockIndex.EXPECT().ConcreteRet().Return(nil) // Should be able to place expectations on variadic methods. mockIndex.EXPECT().Ellip("%d", 0, 1, 1, 2, 3) // direct args tri := []interface{}{1, 3, 6, 10, 15} mockIndex.EXPECT().Ellip("%d", tri...) // args from slice mockIndex.EXPECT().EllipOnly(gomock.Eq("arg")) user.Remember(mockIndex, []string{"a", "b"}, []interface{}{1, 2}) // Check the ConcreteRet calls. if c := mockIndex.ConcreteRet(); c != boolc { t.Errorf("ConcreteRet: got %v, want %v", c, boolc) } if c := mockIndex.ConcreteRet(); c != nil { t.Errorf("ConcreteRet: got %v, want nil", c) } // Try one with an action. calledString := "" mockIndex.EXPECT().Put(gomock.Any(), gomock.Any()).Do(func(key string, _ interface{}) { calledString = key }) mockIndex.EXPECT().NillableRet() user.Remember(mockIndex, []string{"blah"}, []interface{}{7}) if calledString != "blah" { t.Fatalf(`Uh oh. %q != "blah"`, calledString) } // Use Do with a nil arg. mockIndex.EXPECT().Put("nil-key", gomock.Any()).Do(func(key string, value interface{}) { if value != nil { t.Errorf("Put did not pass through nil; got %v", value) } }) mockIndex.EXPECT().NillableRet() user.Remember(mockIndex, []string{"nil-key"}, []interface{}{nil}) }
func (s *HeartbeatHelperSuite) TestPong(c *C) { ctrl := gomock.NewController(c) defer ctrl.Finish() conn := NewMockConn(ctrl) helper := NewHeartbeatHelper(conn, 1*time.Second, 1) defer helper.Stop() conn.EXPECT().Write(gomock.Eq(NewStringResponse(PING))).AnyTimes() helper.Ping() helper.Pong() helper.Ping() helper.Pong() }
func TestBitmapperSolver(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() r := &FakeReader{} mockBitmapper := mock_spoj.NewMockBitmapperI(mockCtrl) expected := "the answer" gomock.InOrder( mockBitmapper.EXPECT().ReadInput(gomock.Eq(r)), mockBitmapper.EXPECT().Solve().Return(expected), ) actual := spoj.BitmapSolver(r, mockBitmapper) if actual != expected { t.Errorf("Bitmap solver method is wrong. %v != %v", expected, actual) } }