// Code generated by moq; DO NOT EDIT.
// github.com/matryer/moq

package jupyter

import (
	context "context"
	sync "sync"
)

// Ensure, that JupyterServerHostServerMock does implement JupyterServerHostServer.
// If this is not the case, regenerate this file with moq.
var _ JupyterServerHostServer = &JupyterServerHostServerMock{}

// JupyterServerHostServerMock is a mock implementation of JupyterServerHostServer.
//
//	func TestSomethingThatUsesJupyterServerHostServer(t *testing.T) {
//
//		// make and configure a mocked JupyterServerHostServer
//		mockedJupyterServerHostServer := &JupyterServerHostServerMock{
//			GetRunningServerFunc: func(contextMoqParam context.Context, getRunningServerRequest *GetRunningServerRequest) (*GetRunningServerResponse, error) {
//				panic("mock out the GetRunningServer method")
//			},
//			mustEmbedUnimplementedJupyterServerHostServerFunc: func()  {
//				panic("mock out the mustEmbedUnimplementedJupyterServerHostServer method")
//			},
//		}
//
//		// use mockedJupyterServerHostServer in code that requires JupyterServerHostServer
//		// and then make assertions.
//
//	}
type JupyterServerHostServerMock struct {
	// GetRunningServerFunc mocks the GetRunningServer method.
	GetRunningServerFunc func(contextMoqParam context.Context, getRunningServerRequest *GetRunningServerRequest) (*GetRunningServerResponse, error)

	// mustEmbedUnimplementedJupyterServerHostServerFunc mocks the mustEmbedUnimplementedJupyterServerHostServer method.
	mustEmbedUnimplementedJupyterServerHostServerFunc func()

	// calls tracks calls to the methods.
	calls struct {
		// GetRunningServer holds details about calls to the GetRunningServer method.
		GetRunningServer []struct {
			// ContextMoqParam is the contextMoqParam argument value.
			ContextMoqParam context.Context
			// GetRunningServerRequest is the getRunningServerRequest argument value.
			GetRunningServerRequest *GetRunningServerRequest
		}
		// mustEmbedUnimplementedJupyterServerHostServer holds details about calls to the mustEmbedUnimplementedJupyterServerHostServer method.
		mustEmbedUnimplementedJupyterServerHostServer []struct {
		}
	}
	lockGetRunningServer                              sync.RWMutex
	lockmustEmbedUnimplementedJupyterServerHostServer sync.RWMutex
}

// GetRunningServer calls GetRunningServerFunc.
func (mock *JupyterServerHostServerMock) GetRunningServer(contextMoqParam context.Context, getRunningServerRequest *GetRunningServerRequest) (*GetRunningServerResponse, error) {
	if mock.GetRunningServerFunc == nil {
		panic("JupyterServerHostServerMock.GetRunningServerFunc: method is nil but JupyterServerHostServer.GetRunningServer was just called")
	}
	callInfo := struct {
		ContextMoqParam         context.Context
		GetRunningServerRequest *GetRunningServerRequest
	}{
		ContextMoqParam:         contextMoqParam,
		GetRunningServerRequest: getRunningServerRequest,
	}
	mock.lockGetRunningServer.Lock()
	mock.calls.GetRunningServer = append(mock.calls.GetRunningServer, callInfo)
	mock.lockGetRunningServer.Unlock()
	return mock.GetRunningServerFunc(contextMoqParam, getRunningServerRequest)
}

// GetRunningServerCalls gets all the calls that were made to GetRunningServer.
// Check the length with:
//
//	len(mockedJupyterServerHostServer.GetRunningServerCalls())
func (mock *JupyterServerHostServerMock) GetRunningServerCalls() []struct {
	ContextMoqParam         context.Context
	GetRunningServerRequest *GetRunningServerRequest
} {
	var calls []struct {
		ContextMoqParam         context.Context
		GetRunningServerRequest *GetRunningServerRequest
	}
	mock.lockGetRunningServer.RLock()
	calls = mock.calls.GetRunningServer
	mock.lockGetRunningServer.RUnlock()
	return calls
}

// mustEmbedUnimplementedJupyterServerHostServer calls mustEmbedUnimplementedJupyterServerHostServerFunc.
func (mock *JupyterServerHostServerMock) mustEmbedUnimplementedJupyterServerHostServer() {
	if mock.mustEmbedUnimplementedJupyterServerHostServerFunc == nil {
		panic("JupyterServerHostServerMock.mustEmbedUnimplementedJupyterServerHostServerFunc: method is nil but JupyterServerHostServer.mustEmbedUnimplementedJupyterServerHostServer was just called")
	}
	callInfo := struct {
	}{}
	mock.lockmustEmbedUnimplementedJupyterServerHostServer.Lock()
	mock.calls.mustEmbedUnimplementedJupyterServerHostServer = append(mock.calls.mustEmbedUnimplementedJupyterServerHostServer, callInfo)
	mock.lockmustEmbedUnimplementedJupyterServerHostServer.Unlock()
	mock.mustEmbedUnimplementedJupyterServerHostServerFunc()
}

// mustEmbedUnimplementedJupyterServerHostServerCalls gets all the calls that were made to mustEmbedUnimplementedJupyterServerHostServer.
// Check the length with:
//
//	len(mockedJupyterServerHostServer.mustEmbedUnimplementedJupyterServerHostServerCalls())
func (mock *JupyterServerHostServerMock) mustEmbedUnimplementedJupyterServerHostServerCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockmustEmbedUnimplementedJupyterServerHostServer.RLock()
	calls = mock.calls.mustEmbedUnimplementedJupyterServerHostServer
	mock.lockmustEmbedUnimplementedJupyterServerHostServer.RUnlock()
	return calls
}
