mock_user_test.go

Documentation: github.com/golang/mock/sample

     1  // Code generated by MockGen. DO NOT EDIT.
     2  // Source: github.com/golang/mock/sample (interfaces: Index,Embed,Embedded)
     3  
     4  // Package user_test is a generated GoMock package.
     5  package user_test
     6  
     7  import (
     8  	bufio "bufio"
     9  	bytes "bytes"
    10  	hash "hash"
    11  	template "html/template"
    12  	io "io"
    13  	http "net/http"
    14  	reflect "reflect"
    15  	template0 "text/template"
    16  
    17  	gomock "github.com/golang/mock/gomock"
    18  	imp1 "github.com/golang/mock/sample/imp1"
    19  	imp2 "github.com/golang/mock/sample/imp2"
    20  	imp3 "github.com/golang/mock/sample/imp3"
    21  	imp_four "github.com/golang/mock/sample/imp4"
    22  )
    23  
    24  // MockIndex is a mock of Index interface.
    25  type MockIndex struct {
    26  	ctrl     *gomock.Controller
    27  	recorder *MockIndexMockRecorder
    28  }
    29  
    30  // MockIndexMockRecorder is the mock recorder for MockIndex.
    31  type MockIndexMockRecorder struct {
    32  	mock *MockIndex
    33  }
    34  
    35  // NewMockIndex creates a new mock instance.
    36  func NewMockIndex(ctrl *gomock.Controller) *MockIndex {
    37  	mock := &MockIndex{ctrl: ctrl}
    38  	mock.recorder = &MockIndexMockRecorder{mock}
    39  	return mock
    40  }
    41  
    42  // EXPECT returns an object that allows the caller to indicate expected use.
    43  func (m *MockIndex) EXPECT() *MockIndexMockRecorder {
    44  	return m.recorder
    45  }
    46  
    47  // Anon mocks base method.
    48  func (m *MockIndex) Anon(arg0 string) {
    49  	m.ctrl.T.Helper()
    50  	m.ctrl.Call(m, "Anon", arg0)
    51  }
    52  
    53  // Anon indicates an expected call of Anon.
    54  func (mr *MockIndexMockRecorder) Anon(arg0 interface{}) *gomock.Call {
    55  	mr.mock.ctrl.T.Helper()
    56  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Anon", reflect.TypeOf((*MockIndex)(nil).Anon), arg0)
    57  }
    58  
    59  // Chan mocks base method.
    60  func (m *MockIndex) Chan(arg0 chan int, arg1 chan<- hash.Hash) {
    61  	m.ctrl.T.Helper()
    62  	m.ctrl.Call(m, "Chan", arg0, arg1)
    63  }
    64  
    65  // Chan indicates an expected call of Chan.
    66  func (mr *MockIndexMockRecorder) Chan(arg0, arg1 interface{}) *gomock.Call {
    67  	mr.mock.ctrl.T.Helper()
    68  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chan", reflect.TypeOf((*MockIndex)(nil).Chan), arg0, arg1)
    69  }
    70  
    71  // ConcreteRet mocks base method.
    72  func (m *MockIndex) ConcreteRet() chan<- bool {
    73  	m.ctrl.T.Helper()
    74  	ret := m.ctrl.Call(m, "ConcreteRet")
    75  	ret0, _ := ret[0].(chan<- bool)
    76  	return ret0
    77  }
    78  
    79  // ConcreteRet indicates an expected call of ConcreteRet.
    80  func (mr *MockIndexMockRecorder) ConcreteRet() *gomock.Call {
    81  	mr.mock.ctrl.T.Helper()
    82  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConcreteRet", reflect.TypeOf((*MockIndex)(nil).ConcreteRet))
    83  }
    84  
    85  // Ellip mocks base method.
    86  func (m *MockIndex) Ellip(arg0 string, arg1 ...interface{}) {
    87  	m.ctrl.T.Helper()
    88  	varargs := []interface{}{arg0}
    89  	for _, a := range arg1 {
    90  		varargs = append(varargs, a)
    91  	}
    92  	m.ctrl.Call(m, "Ellip", varargs...)
    93  }
    94  
    95  // Ellip indicates an expected call of Ellip.
    96  func (mr *MockIndexMockRecorder) Ellip(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
    97  	mr.mock.ctrl.T.Helper()
    98  	varargs := append([]interface{}{arg0}, arg1...)
    99  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ellip", reflect.TypeOf((*MockIndex)(nil).Ellip), varargs...)
   100  }
   101  
   102  // EllipOnly mocks base method.
   103  func (m *MockIndex) EllipOnly(arg0 ...string) {
   104  	m.ctrl.T.Helper()
   105  	varargs := []interface{}{}
   106  	for _, a := range arg0 {
   107  		varargs = append(varargs, a)
   108  	}
   109  	m.ctrl.Call(m, "EllipOnly", varargs...)
   110  }
   111  
   112  // EllipOnly indicates an expected call of EllipOnly.
   113  func (mr *MockIndexMockRecorder) EllipOnly(arg0 ...interface{}) *gomock.Call {
   114  	mr.mock.ctrl.T.Helper()
   115  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EllipOnly", reflect.TypeOf((*MockIndex)(nil).EllipOnly), arg0...)
   116  }
   117  
   118  // ForeignFour mocks base method.
   119  func (m *MockIndex) ForeignFour(arg0 imp_four.Imp4) {
   120  	m.ctrl.T.Helper()
   121  	m.ctrl.Call(m, "ForeignFour", arg0)
   122  }
   123  
   124  // ForeignFour indicates an expected call of ForeignFour.
   125  func (mr *MockIndexMockRecorder) ForeignFour(arg0 interface{}) *gomock.Call {
   126  	mr.mock.ctrl.T.Helper()
   127  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForeignFour", reflect.TypeOf((*MockIndex)(nil).ForeignFour), arg0)
   128  }
   129  
   130  // ForeignOne mocks base method.
   131  func (m *MockIndex) ForeignOne(arg0 imp1.Imp1) {
   132  	m.ctrl.T.Helper()
   133  	m.ctrl.Call(m, "ForeignOne", arg0)
   134  }
   135  
   136  // ForeignOne indicates an expected call of ForeignOne.
   137  func (mr *MockIndexMockRecorder) ForeignOne(arg0 interface{}) *gomock.Call {
   138  	mr.mock.ctrl.T.Helper()
   139  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForeignOne", reflect.TypeOf((*MockIndex)(nil).ForeignOne), arg0)
   140  }
   141  
   142  // ForeignThree mocks base method.
   143  func (m *MockIndex) ForeignThree(arg0 imp3.Imp3) {
   144  	m.ctrl.T.Helper()
   145  	m.ctrl.Call(m, "ForeignThree", arg0)
   146  }
   147  
   148  // ForeignThree indicates an expected call of ForeignThree.
   149  func (mr *MockIndexMockRecorder) ForeignThree(arg0 interface{}) *gomock.Call {
   150  	mr.mock.ctrl.T.Helper()
   151  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForeignThree", reflect.TypeOf((*MockIndex)(nil).ForeignThree), arg0)
   152  }
   153  
   154  // ForeignTwo mocks base method.
   155  func (m *MockIndex) ForeignTwo(arg0 imp2.Imp2) {
   156  	m.ctrl.T.Helper()
   157  	m.ctrl.Call(m, "ForeignTwo", arg0)
   158  }
   159  
   160  // ForeignTwo indicates an expected call of ForeignTwo.
   161  func (mr *MockIndexMockRecorder) ForeignTwo(arg0 interface{}) *gomock.Call {
   162  	mr.mock.ctrl.T.Helper()
   163  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForeignTwo", reflect.TypeOf((*MockIndex)(nil).ForeignTwo), arg0)
   164  }
   165  
   166  // Func mocks base method.
   167  func (m *MockIndex) Func(arg0 func(http.Request) (int, bool)) {
   168  	m.ctrl.T.Helper()
   169  	m.ctrl.Call(m, "Func", arg0)
   170  }
   171  
   172  // Func indicates an expected call of Func.
   173  func (mr *MockIndexMockRecorder) Func(arg0 interface{}) *gomock.Call {
   174  	mr.mock.ctrl.T.Helper()
   175  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Func", reflect.TypeOf((*MockIndex)(nil).Func), arg0)
   176  }
   177  
   178  // Get mocks base method.
   179  func (m *MockIndex) Get(arg0 string) interface{} {
   180  	m.ctrl.T.Helper()
   181  	ret := m.ctrl.Call(m, "Get", arg0)
   182  	ret0, _ := ret[0].(interface{})
   183  	return ret0
   184  }
   185  
   186  // Get indicates an expected call of Get.
   187  func (mr *MockIndexMockRecorder) Get(arg0 interface{}) *gomock.Call {
   188  	mr.mock.ctrl.T.Helper()
   189  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockIndex)(nil).Get), arg0)
   190  }
   191  
   192  // GetTwo mocks base method.
   193  func (m *MockIndex) GetTwo(arg0, arg1 string) (interface{}, interface{}) {
   194  	m.ctrl.T.Helper()
   195  	ret := m.ctrl.Call(m, "GetTwo", arg0, arg1)
   196  	ret0, _ := ret[0].(interface{})
   197  	ret1, _ := ret[1].(interface{})
   198  	return ret0, ret1
   199  }
   200  
   201  // GetTwo indicates an expected call of GetTwo.
   202  func (mr *MockIndexMockRecorder) GetTwo(arg0, arg1 interface{}) *gomock.Call {
   203  	mr.mock.ctrl.T.Helper()
   204  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTwo", reflect.TypeOf((*MockIndex)(nil).GetTwo), arg0, arg1)
   205  }
   206  
   207  // Map mocks base method.
   208  func (m *MockIndex) Map(arg0 map[int]hash.Hash) {
   209  	m.ctrl.T.Helper()
   210  	m.ctrl.Call(m, "Map", arg0)
   211  }
   212  
   213  // Map indicates an expected call of Map.
   214  func (mr *MockIndexMockRecorder) Map(arg0 interface{}) *gomock.Call {
   215  	mr.mock.ctrl.T.Helper()
   216  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Map", reflect.TypeOf((*MockIndex)(nil).Map), arg0)
   217  }
   218  
   219  // NillableRet mocks base method.
   220  func (m *MockIndex) NillableRet() error {
   221  	m.ctrl.T.Helper()
   222  	ret := m.ctrl.Call(m, "NillableRet")
   223  	ret0, _ := ret[0].(error)
   224  	return ret0
   225  }
   226  
   227  // NillableRet indicates an expected call of NillableRet.
   228  func (mr *MockIndexMockRecorder) NillableRet() *gomock.Call {
   229  	mr.mock.ctrl.T.Helper()
   230  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NillableRet", reflect.TypeOf((*MockIndex)(nil).NillableRet))
   231  }
   232  
   233  // Other mocks base method.
   234  func (m *MockIndex) Other() hash.Hash {
   235  	m.ctrl.T.Helper()
   236  	ret := m.ctrl.Call(m, "Other")
   237  	ret0, _ := ret[0].(hash.Hash)
   238  	return ret0
   239  }
   240  
   241  // Other indicates an expected call of Other.
   242  func (mr *MockIndexMockRecorder) Other() *gomock.Call {
   243  	mr.mock.ctrl.T.Helper()
   244  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Other", reflect.TypeOf((*MockIndex)(nil).Other))
   245  }
   246  
   247  // Ptr mocks base method.
   248  func (m *MockIndex) Ptr(arg0 *int) {
   249  	m.ctrl.T.Helper()
   250  	m.ctrl.Call(m, "Ptr", arg0)
   251  }
   252  
   253  // Ptr indicates an expected call of Ptr.
   254  func (mr *MockIndexMockRecorder) Ptr(arg0 interface{}) *gomock.Call {
   255  	mr.mock.ctrl.T.Helper()
   256  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ptr", reflect.TypeOf((*MockIndex)(nil).Ptr), arg0)
   257  }
   258  
   259  // Put mocks base method.
   260  func (m *MockIndex) Put(arg0 string, arg1 interface{}) {
   261  	m.ctrl.T.Helper()
   262  	m.ctrl.Call(m, "Put", arg0, arg1)
   263  }
   264  
   265  // Put indicates an expected call of Put.
   266  func (mr *MockIndexMockRecorder) Put(arg0, arg1 interface{}) *gomock.Call {
   267  	mr.mock.ctrl.T.Helper()
   268  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockIndex)(nil).Put), arg0, arg1)
   269  }
   270  
   271  // Slice mocks base method.
   272  func (m *MockIndex) Slice(arg0 []int, arg1 []byte) [3]int {
   273  	m.ctrl.T.Helper()
   274  	ret := m.ctrl.Call(m, "Slice", arg0, arg1)
   275  	ret0, _ := ret[0].([3]int)
   276  	return ret0
   277  }
   278  
   279  // Slice indicates an expected call of Slice.
   280  func (mr *MockIndexMockRecorder) Slice(arg0, arg1 interface{}) *gomock.Call {
   281  	mr.mock.ctrl.T.Helper()
   282  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Slice", reflect.TypeOf((*MockIndex)(nil).Slice), arg0, arg1)
   283  }
   284  
   285  // Struct mocks base method.
   286  func (m *MockIndex) Struct(arg0 struct{}) {
   287  	m.ctrl.T.Helper()
   288  	m.ctrl.Call(m, "Struct", arg0)
   289  }
   290  
   291  // Struct indicates an expected call of Struct.
   292  func (mr *MockIndexMockRecorder) Struct(arg0 interface{}) *gomock.Call {
   293  	mr.mock.ctrl.T.Helper()
   294  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Struct", reflect.TypeOf((*MockIndex)(nil).Struct), arg0)
   295  }
   296  
   297  // StructChan mocks base method.
   298  func (m *MockIndex) StructChan(arg0 chan struct{}) {
   299  	m.ctrl.T.Helper()
   300  	m.ctrl.Call(m, "StructChan", arg0)
   301  }
   302  
   303  // StructChan indicates an expected call of StructChan.
   304  func (mr *MockIndexMockRecorder) StructChan(arg0 interface{}) *gomock.Call {
   305  	mr.mock.ctrl.T.Helper()
   306  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StructChan", reflect.TypeOf((*MockIndex)(nil).StructChan), arg0)
   307  }
   308  
   309  // Summary mocks base method.
   310  func (m *MockIndex) Summary(arg0 *bytes.Buffer, arg1 io.Writer) {
   311  	m.ctrl.T.Helper()
   312  	m.ctrl.Call(m, "Summary", arg0, arg1)
   313  }
   314  
   315  // Summary indicates an expected call of Summary.
   316  func (mr *MockIndexMockRecorder) Summary(arg0, arg1 interface{}) *gomock.Call {
   317  	mr.mock.ctrl.T.Helper()
   318  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Summary", reflect.TypeOf((*MockIndex)(nil).Summary), arg0, arg1)
   319  }
   320  
   321  // Templates mocks base method.
   322  func (m *MockIndex) Templates(arg0 template.CSS, arg1 template0.FuncMap) {
   323  	m.ctrl.T.Helper()
   324  	m.ctrl.Call(m, "Templates", arg0, arg1)
   325  }
   326  
   327  // Templates indicates an expected call of Templates.
   328  func (mr *MockIndexMockRecorder) Templates(arg0, arg1 interface{}) *gomock.Call {
   329  	mr.mock.ctrl.T.Helper()
   330  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Templates", reflect.TypeOf((*MockIndex)(nil).Templates), arg0, arg1)
   331  }
   332  
   333  // MockEmbed is a mock of Embed interface.
   334  type MockEmbed struct {
   335  	ctrl     *gomock.Controller
   336  	recorder *MockEmbedMockRecorder
   337  }
   338  
   339  // MockEmbedMockRecorder is the mock recorder for MockEmbed.
   340  type MockEmbedMockRecorder struct {
   341  	mock *MockEmbed
   342  }
   343  
   344  // NewMockEmbed creates a new mock instance.
   345  func NewMockEmbed(ctrl *gomock.Controller) *MockEmbed {
   346  	mock := &MockEmbed{ctrl: ctrl}
   347  	mock.recorder = &MockEmbedMockRecorder{mock}
   348  	return mock
   349  }
   350  
   351  // EXPECT returns an object that allows the caller to indicate expected use.
   352  func (m *MockEmbed) EXPECT() *MockEmbedMockRecorder {
   353  	return m.recorder
   354  }
   355  
   356  // EmbeddedMethod mocks base method.
   357  func (m *MockEmbed) EmbeddedMethod() {
   358  	m.ctrl.T.Helper()
   359  	m.ctrl.Call(m, "EmbeddedMethod")
   360  }
   361  
   362  // EmbeddedMethod indicates an expected call of EmbeddedMethod.
   363  func (mr *MockEmbedMockRecorder) EmbeddedMethod() *gomock.Call {
   364  	mr.mock.ctrl.T.Helper()
   365  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EmbeddedMethod", reflect.TypeOf((*MockEmbed)(nil).EmbeddedMethod))
   366  }
   367  
   368  // ForeignEmbeddedMethod mocks base method.
   369  func (m *MockEmbed) ForeignEmbeddedMethod() *bufio.Reader {
   370  	m.ctrl.T.Helper()
   371  	ret := m.ctrl.Call(m, "ForeignEmbeddedMethod")
   372  	ret0, _ := ret[0].(*bufio.Reader)
   373  	return ret0
   374  }
   375  
   376  // ForeignEmbeddedMethod indicates an expected call of ForeignEmbeddedMethod.
   377  func (mr *MockEmbedMockRecorder) ForeignEmbeddedMethod() *gomock.Call {
   378  	mr.mock.ctrl.T.Helper()
   379  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForeignEmbeddedMethod", reflect.TypeOf((*MockEmbed)(nil).ForeignEmbeddedMethod))
   380  }
   381  
   382  // ImplicitPackage mocks base method.
   383  func (m *MockEmbed) ImplicitPackage(arg0 string, arg1 imp1.ImpT, arg2 []imp1.ImpT, arg3 *imp1.ImpT, arg4 chan imp1.ImpT) {
   384  	m.ctrl.T.Helper()
   385  	m.ctrl.Call(m, "ImplicitPackage", arg0, arg1, arg2, arg3, arg4)
   386  }
   387  
   388  // ImplicitPackage indicates an expected call of ImplicitPackage.
   389  func (mr *MockEmbedMockRecorder) ImplicitPackage(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
   390  	mr.mock.ctrl.T.Helper()
   391  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImplicitPackage", reflect.TypeOf((*MockEmbed)(nil).ImplicitPackage), arg0, arg1, arg2, arg3, arg4)
   392  }
   393  
   394  // RegularMethod mocks base method.
   395  func (m *MockEmbed) RegularMethod() {
   396  	m.ctrl.T.Helper()
   397  	m.ctrl.Call(m, "RegularMethod")
   398  }
   399  
   400  // RegularMethod indicates an expected call of RegularMethod.
   401  func (mr *MockEmbedMockRecorder) RegularMethod() *gomock.Call {
   402  	mr.mock.ctrl.T.Helper()
   403  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegularMethod", reflect.TypeOf((*MockEmbed)(nil).RegularMethod))
   404  }
   405  
   406  // MockEmbedded is a mock of Embedded interface.
   407  type MockEmbedded struct {
   408  	ctrl     *gomock.Controller
   409  	recorder *MockEmbeddedMockRecorder
   410  }
   411  
   412  // MockEmbeddedMockRecorder is the mock recorder for MockEmbedded.
   413  type MockEmbeddedMockRecorder struct {
   414  	mock *MockEmbedded
   415  }
   416  
   417  // NewMockEmbedded creates a new mock instance.
   418  func NewMockEmbedded(ctrl *gomock.Controller) *MockEmbedded {
   419  	mock := &MockEmbedded{ctrl: ctrl}
   420  	mock.recorder = &MockEmbeddedMockRecorder{mock}
   421  	return mock
   422  }
   423  
   424  // EXPECT returns an object that allows the caller to indicate expected use.
   425  func (m *MockEmbedded) EXPECT() *MockEmbeddedMockRecorder {
   426  	return m.recorder
   427  }
   428  
   429  // EmbeddedMethod mocks base method.
   430  func (m *MockEmbedded) EmbeddedMethod() {
   431  	m.ctrl.T.Helper()
   432  	m.ctrl.Call(m, "EmbeddedMethod")
   433  }
   434  
   435  // EmbeddedMethod indicates an expected call of EmbeddedMethod.
   436  func (mr *MockEmbeddedMockRecorder) EmbeddedMethod() *gomock.Call {
   437  	mr.mock.ctrl.T.Helper()
   438  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EmbeddedMethod", reflect.TypeOf((*MockEmbedded)(nil).EmbeddedMethod))
   439  }
   440
View as plain text