github.com/danielpfeifer02/quic-go-prio-packs@v0.41.0-28/mock_conn_runner_test.go (about) 1 // Code generated by MockGen. DO NOT EDIT. 2 // Source: github.com/danielpfeifer02/quic-go-prio-packs (interfaces: ConnRunner) 3 // 4 // Generated by this command: 5 // 6 // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/danielpfeifer02/quic-go-prio-packs -destination mock_conn_runner_test.go github.com/danielpfeifer02/quic-go-prio-packs ConnRunner 7 // 8 // Package quic is a generated GoMock package. 9 package quic 10 11 import ( 12 reflect "reflect" 13 14 protocol "github.com/danielpfeifer02/quic-go-prio-packs/internal/protocol" 15 gomock "go.uber.org/mock/gomock" 16 ) 17 18 // MockConnRunner is a mock of ConnRunner interface. 19 type MockConnRunner struct { 20 ctrl *gomock.Controller 21 recorder *MockConnRunnerMockRecorder 22 } 23 24 // MockConnRunnerMockRecorder is the mock recorder for MockConnRunner. 25 type MockConnRunnerMockRecorder struct { 26 mock *MockConnRunner 27 } 28 29 // NewMockConnRunner creates a new mock instance. 30 func NewMockConnRunner(ctrl *gomock.Controller) *MockConnRunner { 31 mock := &MockConnRunner{ctrl: ctrl} 32 mock.recorder = &MockConnRunnerMockRecorder{mock} 33 return mock 34 } 35 36 // EXPECT returns an object that allows the caller to indicate expected use. 37 func (m *MockConnRunner) EXPECT() *MockConnRunnerMockRecorder { 38 return m.recorder 39 } 40 41 // Add mocks base method. 42 func (m *MockConnRunner) Add(arg0 protocol.ConnectionID, arg1 packetHandler) bool { 43 m.ctrl.T.Helper() 44 ret := m.ctrl.Call(m, "Add", arg0, arg1) 45 ret0, _ := ret[0].(bool) 46 return ret0 47 } 48 49 // Add indicates an expected call of Add. 50 func (mr *MockConnRunnerMockRecorder) Add(arg0, arg1 any) *ConnRunnerAddCall { 51 mr.mock.ctrl.T.Helper() 52 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockConnRunner)(nil).Add), arg0, arg1) 53 return &ConnRunnerAddCall{Call: call} 54 } 55 56 // ConnRunnerAddCall wrap *gomock.Call 57 type ConnRunnerAddCall struct { 58 *gomock.Call 59 } 60 61 // Return rewrite *gomock.Call.Return 62 func (c *ConnRunnerAddCall) Return(arg0 bool) *ConnRunnerAddCall { 63 c.Call = c.Call.Return(arg0) 64 return c 65 } 66 67 // Do rewrite *gomock.Call.Do 68 func (c *ConnRunnerAddCall) Do(f func(protocol.ConnectionID, packetHandler) bool) *ConnRunnerAddCall { 69 c.Call = c.Call.Do(f) 70 return c 71 } 72 73 // DoAndReturn rewrite *gomock.Call.DoAndReturn 74 func (c *ConnRunnerAddCall) DoAndReturn(f func(protocol.ConnectionID, packetHandler) bool) *ConnRunnerAddCall { 75 c.Call = c.Call.DoAndReturn(f) 76 return c 77 } 78 79 // AddResetToken mocks base method. 80 func (m *MockConnRunner) AddResetToken(arg0 protocol.StatelessResetToken, arg1 packetHandler) { 81 m.ctrl.T.Helper() 82 m.ctrl.Call(m, "AddResetToken", arg0, arg1) 83 } 84 85 // AddResetToken indicates an expected call of AddResetToken. 86 func (mr *MockConnRunnerMockRecorder) AddResetToken(arg0, arg1 any) *ConnRunnerAddResetTokenCall { 87 mr.mock.ctrl.T.Helper() 88 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddResetToken", reflect.TypeOf((*MockConnRunner)(nil).AddResetToken), arg0, arg1) 89 return &ConnRunnerAddResetTokenCall{Call: call} 90 } 91 92 // ConnRunnerAddResetTokenCall wrap *gomock.Call 93 type ConnRunnerAddResetTokenCall struct { 94 *gomock.Call 95 } 96 97 // Return rewrite *gomock.Call.Return 98 func (c *ConnRunnerAddResetTokenCall) Return() *ConnRunnerAddResetTokenCall { 99 c.Call = c.Call.Return() 100 return c 101 } 102 103 // Do rewrite *gomock.Call.Do 104 func (c *ConnRunnerAddResetTokenCall) Do(f func(protocol.StatelessResetToken, packetHandler)) *ConnRunnerAddResetTokenCall { 105 c.Call = c.Call.Do(f) 106 return c 107 } 108 109 // DoAndReturn rewrite *gomock.Call.DoAndReturn 110 func (c *ConnRunnerAddResetTokenCall) DoAndReturn(f func(protocol.StatelessResetToken, packetHandler)) *ConnRunnerAddResetTokenCall { 111 c.Call = c.Call.DoAndReturn(f) 112 return c 113 } 114 115 // GetStatelessResetToken mocks base method. 116 func (m *MockConnRunner) GetStatelessResetToken(arg0 protocol.ConnectionID) protocol.StatelessResetToken { 117 m.ctrl.T.Helper() 118 ret := m.ctrl.Call(m, "GetStatelessResetToken", arg0) 119 ret0, _ := ret[0].(protocol.StatelessResetToken) 120 return ret0 121 } 122 123 // GetStatelessResetToken indicates an expected call of GetStatelessResetToken. 124 func (mr *MockConnRunnerMockRecorder) GetStatelessResetToken(arg0 any) *ConnRunnerGetStatelessResetTokenCall { 125 mr.mock.ctrl.T.Helper() 126 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatelessResetToken", reflect.TypeOf((*MockConnRunner)(nil).GetStatelessResetToken), arg0) 127 return &ConnRunnerGetStatelessResetTokenCall{Call: call} 128 } 129 130 // ConnRunnerGetStatelessResetTokenCall wrap *gomock.Call 131 type ConnRunnerGetStatelessResetTokenCall struct { 132 *gomock.Call 133 } 134 135 // Return rewrite *gomock.Call.Return 136 func (c *ConnRunnerGetStatelessResetTokenCall) Return(arg0 protocol.StatelessResetToken) *ConnRunnerGetStatelessResetTokenCall { 137 c.Call = c.Call.Return(arg0) 138 return c 139 } 140 141 // Do rewrite *gomock.Call.Do 142 func (c *ConnRunnerGetStatelessResetTokenCall) Do(f func(protocol.ConnectionID) protocol.StatelessResetToken) *ConnRunnerGetStatelessResetTokenCall { 143 c.Call = c.Call.Do(f) 144 return c 145 } 146 147 // DoAndReturn rewrite *gomock.Call.DoAndReturn 148 func (c *ConnRunnerGetStatelessResetTokenCall) DoAndReturn(f func(protocol.ConnectionID) protocol.StatelessResetToken) *ConnRunnerGetStatelessResetTokenCall { 149 c.Call = c.Call.DoAndReturn(f) 150 return c 151 } 152 153 // Remove mocks base method. 154 func (m *MockConnRunner) Remove(arg0 protocol.ConnectionID) { 155 m.ctrl.T.Helper() 156 m.ctrl.Call(m, "Remove", arg0) 157 } 158 159 // Remove indicates an expected call of Remove. 160 func (mr *MockConnRunnerMockRecorder) Remove(arg0 any) *ConnRunnerRemoveCall { 161 mr.mock.ctrl.T.Helper() 162 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockConnRunner)(nil).Remove), arg0) 163 return &ConnRunnerRemoveCall{Call: call} 164 } 165 166 // ConnRunnerRemoveCall wrap *gomock.Call 167 type ConnRunnerRemoveCall struct { 168 *gomock.Call 169 } 170 171 // Return rewrite *gomock.Call.Return 172 func (c *ConnRunnerRemoveCall) Return() *ConnRunnerRemoveCall { 173 c.Call = c.Call.Return() 174 return c 175 } 176 177 // Do rewrite *gomock.Call.Do 178 func (c *ConnRunnerRemoveCall) Do(f func(protocol.ConnectionID)) *ConnRunnerRemoveCall { 179 c.Call = c.Call.Do(f) 180 return c 181 } 182 183 // DoAndReturn rewrite *gomock.Call.DoAndReturn 184 func (c *ConnRunnerRemoveCall) DoAndReturn(f func(protocol.ConnectionID)) *ConnRunnerRemoveCall { 185 c.Call = c.Call.DoAndReturn(f) 186 return c 187 } 188 189 // RemoveResetToken mocks base method. 190 func (m *MockConnRunner) RemoveResetToken(arg0 protocol.StatelessResetToken) { 191 m.ctrl.T.Helper() 192 m.ctrl.Call(m, "RemoveResetToken", arg0) 193 } 194 195 // RemoveResetToken indicates an expected call of RemoveResetToken. 196 func (mr *MockConnRunnerMockRecorder) RemoveResetToken(arg0 any) *ConnRunnerRemoveResetTokenCall { 197 mr.mock.ctrl.T.Helper() 198 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveResetToken", reflect.TypeOf((*MockConnRunner)(nil).RemoveResetToken), arg0) 199 return &ConnRunnerRemoveResetTokenCall{Call: call} 200 } 201 202 // ConnRunnerRemoveResetTokenCall wrap *gomock.Call 203 type ConnRunnerRemoveResetTokenCall struct { 204 *gomock.Call 205 } 206 207 // Return rewrite *gomock.Call.Return 208 func (c *ConnRunnerRemoveResetTokenCall) Return() *ConnRunnerRemoveResetTokenCall { 209 c.Call = c.Call.Return() 210 return c 211 } 212 213 // Do rewrite *gomock.Call.Do 214 func (c *ConnRunnerRemoveResetTokenCall) Do(f func(protocol.StatelessResetToken)) *ConnRunnerRemoveResetTokenCall { 215 c.Call = c.Call.Do(f) 216 return c 217 } 218 219 // DoAndReturn rewrite *gomock.Call.DoAndReturn 220 func (c *ConnRunnerRemoveResetTokenCall) DoAndReturn(f func(protocol.StatelessResetToken)) *ConnRunnerRemoveResetTokenCall { 221 c.Call = c.Call.DoAndReturn(f) 222 return c 223 } 224 225 // ReplaceWithClosed mocks base method. 226 func (m *MockConnRunner) ReplaceWithClosed(arg0 []protocol.ConnectionID, arg1 []byte) { 227 m.ctrl.T.Helper() 228 m.ctrl.Call(m, "ReplaceWithClosed", arg0, arg1) 229 } 230 231 // ReplaceWithClosed indicates an expected call of ReplaceWithClosed. 232 func (mr *MockConnRunnerMockRecorder) ReplaceWithClosed(arg0, arg1 any) *ConnRunnerReplaceWithClosedCall { 233 mr.mock.ctrl.T.Helper() 234 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceWithClosed", reflect.TypeOf((*MockConnRunner)(nil).ReplaceWithClosed), arg0, arg1) 235 return &ConnRunnerReplaceWithClosedCall{Call: call} 236 } 237 238 // ConnRunnerReplaceWithClosedCall wrap *gomock.Call 239 type ConnRunnerReplaceWithClosedCall struct { 240 *gomock.Call 241 } 242 243 // Return rewrite *gomock.Call.Return 244 func (c *ConnRunnerReplaceWithClosedCall) Return() *ConnRunnerReplaceWithClosedCall { 245 c.Call = c.Call.Return() 246 return c 247 } 248 249 // Do rewrite *gomock.Call.Do 250 func (c *ConnRunnerReplaceWithClosedCall) Do(f func([]protocol.ConnectionID, []byte)) *ConnRunnerReplaceWithClosedCall { 251 c.Call = c.Call.Do(f) 252 return c 253 } 254 255 // DoAndReturn rewrite *gomock.Call.DoAndReturn 256 func (c *ConnRunnerReplaceWithClosedCall) DoAndReturn(f func([]protocol.ConnectionID, []byte)) *ConnRunnerReplaceWithClosedCall { 257 c.Call = c.Call.DoAndReturn(f) 258 return c 259 } 260 261 // Retire mocks base method. 262 func (m *MockConnRunner) Retire(arg0 protocol.ConnectionID) { 263 m.ctrl.T.Helper() 264 m.ctrl.Call(m, "Retire", arg0) 265 } 266 267 // Retire indicates an expected call of Retire. 268 func (mr *MockConnRunnerMockRecorder) Retire(arg0 any) *ConnRunnerRetireCall { 269 mr.mock.ctrl.T.Helper() 270 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Retire", reflect.TypeOf((*MockConnRunner)(nil).Retire), arg0) 271 return &ConnRunnerRetireCall{Call: call} 272 } 273 274 // ConnRunnerRetireCall wrap *gomock.Call 275 type ConnRunnerRetireCall struct { 276 *gomock.Call 277 } 278 279 // Return rewrite *gomock.Call.Return 280 func (c *ConnRunnerRetireCall) Return() *ConnRunnerRetireCall { 281 c.Call = c.Call.Return() 282 return c 283 } 284 285 // Do rewrite *gomock.Call.Do 286 func (c *ConnRunnerRetireCall) Do(f func(protocol.ConnectionID)) *ConnRunnerRetireCall { 287 c.Call = c.Call.Do(f) 288 return c 289 } 290 291 // DoAndReturn rewrite *gomock.Call.DoAndReturn 292 func (c *ConnRunnerRetireCall) DoAndReturn(f func(protocol.ConnectionID)) *ConnRunnerRetireCall { 293 c.Call = c.Call.DoAndReturn(f) 294 return c 295 }