// Dead mocks base method
421791
func (m *MockBaseWatcher) Dead() <-chan struct{} {
	ret := m.ctrl.Call(m, "Dead")
	ret0, _ := ret[0].(<-chan struct{})
	return ret0
}
369617
func (mr *MockServiceDiscoveryMockRecorder) Init() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockServiceDiscovery)(nil).Init))
}
123642
func (m *Memberlist) deadNode(d *dead) {
	m.nodeLock.Lock()
	defer m.nodeLock.Unlock()
	state, ok := m.nodeMap[d.Node]

	// If we've never heard about this node before, ignore it
	if !ok {
		return
	}

	// Ignore old incarnation numbers
	if d.Incarnation < state.Incarnation {
		return
	}

	// Clear out any suspicion timer that may be in effect.
	delete(m.nodeTimers, d.Node)

	// Ignore if node is already dead
	if state.State == stateDead {
		return
	}

	// Check if this is us
	if state.Name == m.config.Name {
		// If we are not leaving we need to refute
		if !m.hasLeft() {
			m.refute(state, d.Incarnation)
			m.logger.Printf("[WARN] memberlist: Refuting a dead message (from: %s)", d.From)
			return // Do not mark ourself dead
		}

		// If we are leaving, we broadcast and wait
		m.encodeBroadcastNotify(d.Node, deadMsg, d, m.leaveBroadcast)
	} else {
		m.encodeAndBroadcast(d.Node, deadMsg, d)
	}

	// Update metrics
	metrics.IncrCounter([]string{"memberlist", "msg", "dead"}, 1)

	// Update the state
	state.Incarnation = d.Incarnation
	state.State = stateDead
	state.StateChange = time.Now()

	// Notify of death
	if m.config.Events != nil {
		m.config.Events.NotifyLeave(&state.Node)
	}
}
1113526
func (s *MockDeliverServer) Disconnect(err error) {
	s.Lock()
	defer s.Unlock()
	s.disconnErr = err
}
220296
func NewDecoderMock() *Mock {
	return &Mock{
		responses: make([]*WhenResp, 0),
		eventChan: make(chan fsnotify.Event),
	}
}
199081
func (m *Mocker) Done() bool {
	m.mutex.Lock()
	defer m.mutex.Unlock()
	return m.disabled || (!m.request.Persisted && m.request.Counter == 0)
}
720868
func (m *MockContext) Abort() <-chan struct{} {
	ret := m.ctrl.Call(m, "Abort")
	ret0, _ := ret[0].(<-chan struct{})
	return ret0
}
517502
func (m *Mock) fail(format string, args ...interface{}) {
	m.mutex.Lock()
	defer m.mutex.Unlock()

	if m.test == nil {
		panic(fmt.Sprintf(format, args...))
	}
	m.test.Errorf(format, args...)
	m.test.FailNow()
}
401464
func (c *conn) MarkAsAlive() {
	c.Lock()
	c.dead = false
	c.Unlock()
}
581014
func (m *MockEmbed) EmbeddedMethod() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EmbeddedMethod")
}
978303
func (c *Client) killed() bool {
	c.l.Lock()
	defer c.l.Unlock()
	return c.processKilled
}
1331763
func (m *MockSendAlgorithm) OnPacketAcked(arg0 protocol.PacketNumber, arg1, arg2 protocol.ByteCount, arg3 time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnPacketAcked", arg0, arg1, arg2, arg3)
}
958848
func (m *MockStateCharm) IsUploaded() bool {
	ret := m.ctrl.Call(m, "IsUploaded")
	ret0, _ := ret[0].(bool)
	return ret0
}
833400
func (_m *MockType) Fetch(_a0 FetchOptions, _a1 Request) (FetchResult, error) {
	ret := _m.Called(_a0, _a1)

	var r0 FetchResult
	if rf, ok := ret.Get(0).(func(FetchOptions, Request) FetchResult); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Get(0).(FetchResult)
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(FetchOptions, Request) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}
116640
func (m *MockResources) Stop(arg0 string) error {
	ret := m.ctrl.Call(m, "Stop", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
842073
func (mr *MockMutaterMachineMockRecorder) Life() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Life", reflect.TypeOf((*MockMutaterMachine)(nil).Life))
}
884281
func (m *MockIndex) Anon(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Anon", arg0)
}