src/chromiumos/test/dut/cmd/dutserver/dutssh/mock_dutssh/connectionmock.go

// Copyright 2021 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Code generated by MockGen. DO NOT EDIT.
// Source: test/dut/cmd/dutserver/dutssh/connection.go

// Package mock_dutssh is a generated GoMock package.
package mock_dutssh

//Removing until internal gomock gets updated
import (
	dutssh "chromiumos/test/dut/cmd/dutserver/dutssh"
	io "io"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
)

// MockClientInterface is a mock of ClientInterface interface.
type MockClientInterface struct {
	ctrl     *gomock.Controller
	recorder *MockClientInterfaceMockRecorder
}

// MockClientInterfaceMockRecorder is the mock recorder for MockClientInterface.
type MockClientInterfaceMockRecorder struct {
	mock *MockClientInterface
}

// NewMockClientInterface creates a new mock instance.
func NewMockClientInterface(ctrl *gomock.Controller) *MockClientInterface {
	mock := &MockClientInterface{ctrl: ctrl}
	mock.recorder = &MockClientInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClientInterface) EXPECT() *MockClientInterfaceMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockClientInterface) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close.
func (mr *MockClientInterfaceMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClientInterface)(nil).Close))
}

// NewSession mocks base method.
func (m *MockClientInterface) NewSession() (dutssh.SessionInterface, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewSession")
	ret0, _ := ret[0].(dutssh.SessionInterface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewSession indicates an expected call of NewSession.
func (mr *MockClientInterfaceMockRecorder) NewSession() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewSession", reflect.TypeOf((*MockClientInterface)(nil).NewSession))
}

// Wait mocks base method.
func (m *MockClientInterface) Wait() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Wait")
	ret0, _ := ret[0].(error)
	return ret0
}

// Wait indicates an expected call of Wait.
func (mr *MockClientInterfaceMockRecorder) Wait() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Wait", reflect.TypeOf((*MockClientInterface)(nil).Wait))
}

// MockSessionInterface is a mock of SessionInterface interface.
type MockSessionInterface struct {
	ctrl     *gomock.Controller
	recorder *MockSessionInterfaceMockRecorder
}

// MockSessionInterfaceMockRecorder is the mock recorder for MockSessionInterface.
type MockSessionInterfaceMockRecorder struct {
	mock *MockSessionInterface
}

// NewMockSessionInterface creates a new mock instance.
func NewMockSessionInterface(ctrl *gomock.Controller) *MockSessionInterface {
	mock := &MockSessionInterface{ctrl: ctrl}
	mock.recorder = &MockSessionInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSessionInterface) EXPECT() *MockSessionInterfaceMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockSessionInterface) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close.
func (mr *MockSessionInterfaceMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSessionInterface)(nil).Close))
}

// Output mocks base method.
func (m *MockSessionInterface) Output(cmd string) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Output", cmd)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Output indicates an expected call of Output.
func (mr *MockSessionInterfaceMockRecorder) Output(cmd interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Output", reflect.TypeOf((*MockSessionInterface)(nil).Output), cmd)
}

// Run mocks base method.
func (m *MockSessionInterface) Run(cmd string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Run", cmd)
	ret0, _ := ret[0].(error)
	return ret0
}

// Run indicates an expected call of Run.
func (mr *MockSessionInterfaceMockRecorder) Run(cmd interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockSessionInterface)(nil).Run), cmd)
}

// SetStderr mocks base method.
func (m *MockSessionInterface) SetStderr(writer io.Writer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStderr", writer)
}

// SetStderr indicates an expected call of SetStderr.
func (mr *MockSessionInterfaceMockRecorder) SetStderr(writer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStderr", reflect.TypeOf((*MockSessionInterface)(nil).SetStderr), writer)
}

// SetStdin mocks base method.
func (m *MockSessionInterface) SetStdin(reader io.Reader) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStdin", reader)
}

// SetStdin indicates an expected call of SetStdin.
func (mr *MockSessionInterfaceMockRecorder) SetStdin(reader interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStdin", reflect.TypeOf((*MockSessionInterface)(nil).SetStdin), reader)
}

// SetStdout mocks base method.
func (m *MockSessionInterface) SetStdout(writer io.Writer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStdout", writer)
}

// SetStdout indicates an expected call of SetStdout.
func (mr *MockSessionInterfaceMockRecorder) SetStdout(writer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStdout", reflect.TypeOf((*MockSessionInterface)(nil).SetStdout), writer)
}

// Start mocks base method.
func (m *MockSessionInterface) Start(cmd string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Start", cmd)
	ret0, _ := ret[0].(error)
	return ret0
}

// Start indicates an expected call of Start.
func (mr *MockSessionInterfaceMockRecorder) Start(cmd interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockSessionInterface)(nil).Start), cmd)
}

// StderrPipe mocks base method.
func (m *MockSessionInterface) StderrPipe() (io.Reader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StderrPipe")
	ret0, _ := ret[0].(io.Reader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StderrPipe indicates an expected call of StderrPipe.
func (mr *MockSessionInterfaceMockRecorder) StderrPipe() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StderrPipe", reflect.TypeOf((*MockSessionInterface)(nil).StderrPipe))
}

// StdoutPipe mocks base method.
func (m *MockSessionInterface) StdoutPipe() (io.Reader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StdoutPipe")
	ret0, _ := ret[0].(io.Reader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StdoutPipe indicates an expected call of StdoutPipe.
func (mr *MockSessionInterfaceMockRecorder) StdoutPipe() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StdoutPipe", reflect.TypeOf((*MockSessionInterface)(nil).StdoutPipe))
}