mock

package
v0.5.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 17, 2024 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Overview

Package mock is a generated GoMock package.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type MockAnimal 

type MockAnimal struct {
	// contains filtered or unexported fields
}

MockAnimal is a mock of Animal interface.

func NewMockAnimal 

func NewMockAnimal(ctrl *gomock.Controller) *MockAnimal

NewMockAnimal creates a new mock instance.

func (*MockAnimal) Breathe 

func (m *MockAnimal) Breathe()

Breathe mocks base method.

func (*MockAnimal) EXPECT 

func (m *MockAnimal) EXPECT() *MockAnimalMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockAnimal) Eat 

func (m *MockAnimal) Eat(foods ...package_mode.Food)

Eat mocks base method.

func (*MockAnimal) Sleep 

func (m *MockAnimal) Sleep(duration time.Duration)

Sleep mocks base method.

type MockAnimalBreatheCall 

type MockAnimalBreatheCall struct {
	*gomock.Call
}

MockAnimalBreatheCall wrap *gomock.Call

func (*MockAnimalBreatheCall) Do 

func (c *MockAnimalBreatheCall) Do(f func()) *MockAnimalBreatheCall

Do rewrite *gomock.Call.Do

func (*MockAnimalBreatheCall) DoAndReturn 

func (c *MockAnimalBreatheCall) DoAndReturn(f func()) *MockAnimalBreatheCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockAnimalBreatheCall) Return 

func (c *MockAnimalBreatheCall) Return() *MockAnimalBreatheCall

Return rewrite *gomock.Call.Return

type MockAnimalEatCall 

type MockAnimalEatCall struct {
	*gomock.Call
}

MockAnimalEatCall wrap *gomock.Call

func (*MockAnimalEatCall) Do 

func (c *MockAnimalEatCall) Do(f func(...package_mode.Food)) *MockAnimalEatCall

Do rewrite *gomock.Call.Do

func (*MockAnimalEatCall) DoAndReturn 

func (c *MockAnimalEatCall) DoAndReturn(f func(...package_mode.Food)) *MockAnimalEatCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockAnimalEatCall) Return 

func (c *MockAnimalEatCall) Return() *MockAnimalEatCall

Return rewrite *gomock.Call.Return

type MockAnimalMockRecorder 

type MockAnimalMockRecorder struct {
	// contains filtered or unexported fields
}

MockAnimalMockRecorder is the mock recorder for MockAnimal.

func (*MockAnimalMockRecorder) Breathe 

func (mr *MockAnimalMockRecorder) Breathe() *MockAnimalBreatheCall

Breathe indicates an expected call of Breathe.

func (*MockAnimalMockRecorder) Eat 

func (mr *MockAnimalMockRecorder) Eat(foods ...any) *MockAnimalEatCall

Eat indicates an expected call of Eat.

func (*MockAnimalMockRecorder) Sleep 

func (mr *MockAnimalMockRecorder) Sleep(duration any) *MockAnimalSleepCall

Sleep indicates an expected call of Sleep.

type MockAnimalSleepCall 

type MockAnimalSleepCall struct {
	*gomock.Call
}

MockAnimalSleepCall wrap *gomock.Call

func (*MockAnimalSleepCall) Do 

func (c *MockAnimalSleepCall) Do(f func(time.Duration)) *MockAnimalSleepCall

Do rewrite *gomock.Call.Do

func (*MockAnimalSleepCall) DoAndReturn 

func (c *MockAnimalSleepCall) DoAndReturn(f func(time.Duration)) *MockAnimalSleepCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockAnimalSleepCall) Return 

func (c *MockAnimalSleepCall) Return() *MockAnimalSleepCall

Return rewrite *gomock.Call.Return

type MockCar 

type MockCar[FuelType fuel.Fuel] struct {
	// contains filtered or unexported fields
}

MockCar is a mock of Car interface.

func NewMockCar 

func NewMockCar[FuelType fuel.Fuel](ctrl *gomock.Controller) *MockCar[FuelType]

NewMockCar creates a new mock instance.

func (*MockCar[FuelType]) Brand 

func (m *MockCar[FuelType]) Brand() string

Brand mocks base method.

func (*MockCar[FuelType]) EXPECT 

func (m *MockCar[FuelType]) EXPECT() *MockCarMockRecorder[FuelType]

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockCar[FuelType]) FuelTank 

func (m *MockCar[FuelType]) FuelTank() cars.FuelTank[FuelType]

FuelTank mocks base method.

func (*MockCar[FuelType]) Refuel 

func (m *MockCar[FuelType]) Refuel(fuel FuelType, volume int) error

Refuel mocks base method.

type MockCarBrandCall 

type MockCarBrandCall[FuelType fuel.Fuel] struct {
	*gomock.Call
}

MockCarBrandCall wrap *gomock.Call

func (*MockCarBrandCall[FuelType]) Do 

func (c *MockCarBrandCall[FuelType]) Do(f func() string) *MockCarBrandCall[FuelType]

Do rewrite *gomock.Call.Do

func (*MockCarBrandCall[FuelType]) DoAndReturn 

func (c *MockCarBrandCall[FuelType]) DoAndReturn(f func() string) *MockCarBrandCall[FuelType]

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCarBrandCall[FuelType]) Return 

func (c *MockCarBrandCall[FuelType]) Return(arg0 string) *MockCarBrandCall[FuelType]

Return rewrite *gomock.Call.Return

type MockCarFuelTankCall 

type MockCarFuelTankCall[FuelType fuel.Fuel] struct {
	*gomock.Call
}

MockCarFuelTankCall wrap *gomock.Call

func (*MockCarFuelTankCall[FuelType]) Do 

func (c *MockCarFuelTankCall[FuelType]) Do(f func() cars.FuelTank[FuelType]) *MockCarFuelTankCall[FuelType]

Do rewrite *gomock.Call.Do

func (*MockCarFuelTankCall[FuelType]) DoAndReturn 

func (c *MockCarFuelTankCall[FuelType]) DoAndReturn(f func() cars.FuelTank[FuelType]) *MockCarFuelTankCall[FuelType]

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCarFuelTankCall[FuelType]) Return 

func (c *MockCarFuelTankCall[FuelType]) Return(arg0 cars.FuelTank[FuelType]) *MockCarFuelTankCall[FuelType]

Return rewrite *gomock.Call.Return

type MockCarMockRecorder 

type MockCarMockRecorder[FuelType fuel.Fuel] struct {
	// contains filtered or unexported fields
}

MockCarMockRecorder is the mock recorder for MockCar.

func (*MockCarMockRecorder[FuelType]) Brand 

func (mr *MockCarMockRecorder[FuelType]) Brand() *MockCarBrandCall[FuelType]

Brand indicates an expected call of Brand.

func (*MockCarMockRecorder[FuelType]) FuelTank 

func (mr *MockCarMockRecorder[FuelType]) FuelTank() *MockCarFuelTankCall[FuelType]

FuelTank indicates an expected call of FuelTank.

func (*MockCarMockRecorder[FuelType]) Refuel 

func (mr *MockCarMockRecorder[FuelType]) Refuel(fuel, volume any) *MockCarRefuelCall[FuelType]

Refuel indicates an expected call of Refuel.

type MockCarRefuelCall 

type MockCarRefuelCall[FuelType fuel.Fuel] struct {
	*gomock.Call
}

MockCarRefuelCall wrap *gomock.Call

func (*MockCarRefuelCall[FuelType]) Do 

func (c *MockCarRefuelCall[FuelType]) Do(f func(FuelType, int) error) *MockCarRefuelCall[FuelType]

Do rewrite *gomock.Call.Do

func (*MockCarRefuelCall[FuelType]) DoAndReturn 

func (c *MockCarRefuelCall[FuelType]) DoAndReturn(f func(FuelType, int) error) *MockCarRefuelCall[FuelType]

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCarRefuelCall[FuelType]) Return 

func (c *MockCarRefuelCall[FuelType]) Return(arg0 error) *MockCarRefuelCall[FuelType]

Return rewrite *gomock.Call.Return

type MockDriver 

type MockDriver[FuelType fuel.Fuel, CarType package_mode.Car[FuelType]] struct {
	// contains filtered or unexported fields
}

MockDriver is a mock of Driver interface.

func NewMockDriver 

func NewMockDriver[FuelType fuel.Fuel, CarType package_mode.Car[FuelType]](ctrl *gomock.Controller) *MockDriver[FuelType, CarType]

NewMockDriver creates a new mock instance.

func (*MockDriver[FuelType, CarType]) Drive 

func (m *MockDriver[FuelType, CarType]) Drive(car CarType)

Drive mocks base method.

func (*MockDriver[FuelType, CarType]) EXPECT 

func (m *MockDriver[FuelType, CarType]) EXPECT() *MockDriverMockRecorder[FuelType, CarType]

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockDriver[FuelType, CarType]) Wroom 

func (m *MockDriver[FuelType, CarType]) Wroom() error

Wroom mocks base method.

type MockDriverDriveCall 

type MockDriverDriveCall[FuelType fuel.Fuel, CarType package_mode.Car[FuelType]] struct {
	*gomock.Call
}

MockDriverDriveCall wrap *gomock.Call

func (*MockDriverDriveCall[FuelType, CarType]) Do 

func (c *MockDriverDriveCall[FuelType, CarType]) Do(f func(CarType)) *MockDriverDriveCall[FuelType, CarType]

Do rewrite *gomock.Call.Do

func (*MockDriverDriveCall[FuelType, CarType]) DoAndReturn 

func (c *MockDriverDriveCall[FuelType, CarType]) DoAndReturn(f func(CarType)) *MockDriverDriveCall[FuelType, CarType]

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockDriverDriveCall[FuelType, CarType]) Return 

func (c *MockDriverDriveCall[FuelType, CarType]) Return() *MockDriverDriveCall[FuelType, CarType]

Return rewrite *gomock.Call.Return

type MockDriverMockRecorder 

type MockDriverMockRecorder[FuelType fuel.Fuel, CarType package_mode.Car[FuelType]] struct {
	// contains filtered or unexported fields
}

MockDriverMockRecorder is the mock recorder for MockDriver.

func (*MockDriverMockRecorder[FuelType, CarType]) Drive 

func (mr *MockDriverMockRecorder[FuelType, CarType]) Drive(car any) *MockDriverDriveCall[FuelType, CarType]

Drive indicates an expected call of Drive.

func (*MockDriverMockRecorder[FuelType, CarType]) Wroom 

func (mr *MockDriverMockRecorder[FuelType, CarType]) Wroom() *MockDriverWroomCall[FuelType, CarType]

Wroom indicates an expected call of Wroom.

type MockDriverWroomCall 

type MockDriverWroomCall[FuelType fuel.Fuel, CarType package_mode.Car[FuelType]] struct {
	*gomock.Call
}

MockDriverWroomCall wrap *gomock.Call

func (*MockDriverWroomCall[FuelType, CarType]) Do 

func (c *MockDriverWroomCall[FuelType, CarType]) Do(f func() error) *MockDriverWroomCall[FuelType, CarType]

Do rewrite *gomock.Call.Do

func (*MockDriverWroomCall[FuelType, CarType]) DoAndReturn 

func (c *MockDriverWroomCall[FuelType, CarType]) DoAndReturn(f func() error) *MockDriverWroomCall[FuelType, CarType]

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockDriverWroomCall[FuelType, CarType]) Return 

func (c *MockDriverWroomCall[FuelType, CarType]) Return(arg0 error) *MockDriverWroomCall[FuelType, CarType]

Return rewrite *gomock.Call.Return

type MockEarth 

type MockEarth struct {
	// contains filtered or unexported fields
}

MockEarth is a mock of Earth interface.

func NewMockEarth 

func NewMockEarth(ctrl *gomock.Controller) *MockEarth

NewMockEarth creates a new mock instance.

func (*MockEarth) AddHumans 

func (m *MockEarth) AddHumans(arg0 int) []package_mode.Primate

AddHumans mocks base method.

func (*MockEarth) EXPECT 

func (m *MockEarth) EXPECT() *MockEarthMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockEarth) HumanPopulation 

func (m *MockEarth) HumanPopulation() int

HumanPopulation mocks base method.

type MockEarthAddHumansCall 

type MockEarthAddHumansCall struct {
	*gomock.Call
}

MockEarthAddHumansCall wrap *gomock.Call

func (*MockEarthAddHumansCall) Do 

func (c *MockEarthAddHumansCall) Do(f func(int) []package_mode.Primate) *MockEarthAddHumansCall

Do rewrite *gomock.Call.Do

func (*MockEarthAddHumansCall) DoAndReturn 

func (c *MockEarthAddHumansCall) DoAndReturn(f func(int) []package_mode.Primate) *MockEarthAddHumansCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEarthAddHumansCall) Return 

func (c *MockEarthAddHumansCall) Return(arg0 []package_mode.Primate) *MockEarthAddHumansCall

Return rewrite *gomock.Call.Return

type MockEarthHumanPopulationCall 

type MockEarthHumanPopulationCall struct {
	*gomock.Call
}

MockEarthHumanPopulationCall wrap *gomock.Call

func (*MockEarthHumanPopulationCall) Do 

func (c *MockEarthHumanPopulationCall) Do(f func() int) *MockEarthHumanPopulationCall

Do rewrite *gomock.Call.Do

func (*MockEarthHumanPopulationCall) DoAndReturn 

func (c *MockEarthHumanPopulationCall) DoAndReturn(f func() int) *MockEarthHumanPopulationCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEarthHumanPopulationCall) Return 

func (c *MockEarthHumanPopulationCall) Return(arg0 int) *MockEarthHumanPopulationCall

Return rewrite *gomock.Call.Return

type MockEarthMockRecorder 

type MockEarthMockRecorder struct {
	// contains filtered or unexported fields
}

MockEarthMockRecorder is the mock recorder for MockEarth.

func (*MockEarthMockRecorder) AddHumans 

func (mr *MockEarthMockRecorder) AddHumans(arg0 any) *MockEarthAddHumansCall

AddHumans indicates an expected call of AddHumans.

func (*MockEarthMockRecorder) HumanPopulation 

func (mr *MockEarthMockRecorder) HumanPopulation() *MockEarthHumanPopulationCall

HumanPopulation indicates an expected call of HumanPopulation.

type MockEater 

type MockEater struct {
	// contains filtered or unexported fields
}

MockEater is a mock of Eater interface.

func NewMockEater 

func NewMockEater(ctrl *gomock.Controller) *MockEater

NewMockEater creates a new mock instance.

func (*MockEater) EXPECT 

func (m *MockEater) EXPECT() *MockEaterMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockEater) Eat 

func (m *MockEater) Eat(foods ...package_mode.Food)

Eat mocks base method.

type MockEaterEatCall 

type MockEaterEatCall struct {
	*gomock.Call
}

MockEaterEatCall wrap *gomock.Call

func (*MockEaterEatCall) Do 

func (c *MockEaterEatCall) Do(f func(...package_mode.Food)) *MockEaterEatCall

Do rewrite *gomock.Call.Do

func (*MockEaterEatCall) DoAndReturn 

func (c *MockEaterEatCall) DoAndReturn(f func(...package_mode.Food)) *MockEaterEatCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockEaterEatCall) Return 

func (c *MockEaterEatCall) Return() *MockEaterEatCall

Return rewrite *gomock.Call.Return

type MockEaterMockRecorder 

type MockEaterMockRecorder struct {
	// contains filtered or unexported fields
}

MockEaterMockRecorder is the mock recorder for MockEater.

func (*MockEaterMockRecorder) Eat 

func (mr *MockEaterMockRecorder) Eat(foods ...any) *MockEaterEatCall

Eat indicates an expected call of Eat.

type MockFarmer 

type MockFarmer struct {
	// contains filtered or unexported fields
}

MockFarmer is a mock of Farmer interface.

func NewMockFarmer 

func NewMockFarmer(ctrl *gomock.Controller) *MockFarmer

NewMockFarmer creates a new mock instance.

func (*MockFarmer) Breathe 

func (m *MockFarmer) Breathe()

Breathe mocks base method.

func (*MockFarmer) Do 

func (m *MockFarmer) Do(work *package_mode.Work) error

Do mocks base method.

func (*MockFarmer) Drive 

func (m *MockFarmer) Drive(car cars.FordF150)

Drive mocks base method.

func (*MockFarmer) EXPECT 

func (m *MockFarmer) EXPECT() *MockFarmerMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockFarmer) Eat 

func (m *MockFarmer) Eat(foods ...package_mode.Food)

Eat mocks base method.

func (*MockFarmer) LivesInAVillage 

func (m *MockFarmer) LivesInAVillage()

LivesInAVillage mocks base method.

func (*MockFarmer) Sleep 

func (m *MockFarmer) Sleep(duration time.Duration)

Sleep mocks base method.

func (*MockFarmer) Wroom 

func (m *MockFarmer) Wroom() error

Wroom mocks base method.

type MockFarmerBreatheCall 

type MockFarmerBreatheCall struct {
	*gomock.Call
}

MockFarmerBreatheCall wrap *gomock.Call

func (*MockFarmerBreatheCall) Do 

func (c *MockFarmerBreatheCall) Do(f func()) *MockFarmerBreatheCall

Do rewrite *gomock.Call.Do

func (*MockFarmerBreatheCall) DoAndReturn 

func (c *MockFarmerBreatheCall) DoAndReturn(f func()) *MockFarmerBreatheCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockFarmerBreatheCall) Return 

func (c *MockFarmerBreatheCall) Return() *MockFarmerBreatheCall

Return rewrite *gomock.Call.Return

type MockFarmerDoCall 

type MockFarmerDoCall struct {
	*gomock.Call
}

MockFarmerDoCall wrap *gomock.Call

func (*MockFarmerDoCall) Do 

func (c *MockFarmerDoCall) Do(f func(*package_mode.Work) error) *MockFarmerDoCall

Do rewrite *gomock.Call.Do

func (*MockFarmerDoCall) DoAndReturn 

func (c *MockFarmerDoCall) DoAndReturn(f func(*package_mode.Work) error) *MockFarmerDoCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockFarmerDoCall) Return 

func (c *MockFarmerDoCall) Return(arg0 error) *MockFarmerDoCall

Return rewrite *gomock.Call.Return

type MockFarmerDriveCall 

type MockFarmerDriveCall struct {
	*gomock.Call
}

MockFarmerDriveCall wrap *gomock.Call

func (*MockFarmerDriveCall) Do 

func (c *MockFarmerDriveCall) Do(f func(cars.FordF150)) *MockFarmerDriveCall

Do rewrite *gomock.Call.Do

func (*MockFarmerDriveCall) DoAndReturn 

func (c *MockFarmerDriveCall) DoAndReturn(f func(cars.FordF150)) *MockFarmerDriveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockFarmerDriveCall) Return 

func (c *MockFarmerDriveCall) Return() *MockFarmerDriveCall

Return rewrite *gomock.Call.Return

type MockFarmerEatCall 

type MockFarmerEatCall struct {
	*gomock.Call
}

MockFarmerEatCall wrap *gomock.Call

func (*MockFarmerEatCall) Do 

func (c *MockFarmerEatCall) Do(f func(...package_mode.Food)) *MockFarmerEatCall

Do rewrite *gomock.Call.Do

func (*MockFarmerEatCall) DoAndReturn 

func (c *MockFarmerEatCall) DoAndReturn(f func(...package_mode.Food)) *MockFarmerEatCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockFarmerEatCall) Return 

func (c *MockFarmerEatCall) Return() *MockFarmerEatCall

Return rewrite *gomock.Call.Return

type MockFarmerLivesInAVillageCall 

type MockFarmerLivesInAVillageCall struct {
	*gomock.Call
}

MockFarmerLivesInAVillageCall wrap *gomock.Call

func (*MockFarmerLivesInAVillageCall) Do 

func (c *MockFarmerLivesInAVillageCall) Do(f func()) *MockFarmerLivesInAVillageCall

Do rewrite *gomock.Call.Do

func (*MockFarmerLivesInAVillageCall) DoAndReturn 

func (c *MockFarmerLivesInAVillageCall) DoAndReturn(f func()) *MockFarmerLivesInAVillageCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockFarmerLivesInAVillageCall) Return 

func (c *MockFarmerLivesInAVillageCall) Return() *MockFarmerLivesInAVillageCall

Return rewrite *gomock.Call.Return

type MockFarmerMockRecorder 

type MockFarmerMockRecorder struct {
	// contains filtered or unexported fields
}

MockFarmerMockRecorder is the mock recorder for MockFarmer.

func (*MockFarmerMockRecorder) Breathe 

func (mr *MockFarmerMockRecorder) Breathe() *MockFarmerBreatheCall

Breathe indicates an expected call of Breathe.

func (*MockFarmerMockRecorder) Do 

func (mr *MockFarmerMockRecorder) Do(work any) *MockFarmerDoCall

Do indicates an expected call of Do.

func (*MockFarmerMockRecorder) Drive 

func (mr *MockFarmerMockRecorder) Drive(car any) *MockFarmerDriveCall

Drive indicates an expected call of Drive.

func (*MockFarmerMockRecorder) Eat 

func (mr *MockFarmerMockRecorder) Eat(foods ...any) *MockFarmerEatCall

Eat indicates an expected call of Eat.

func (*MockFarmerMockRecorder) LivesInAVillage 

func (mr *MockFarmerMockRecorder) LivesInAVillage() *MockFarmerLivesInAVillageCall

LivesInAVillage indicates an expected call of LivesInAVillage.

func (*MockFarmerMockRecorder) Sleep 

func (mr *MockFarmerMockRecorder) Sleep(duration any) *MockFarmerSleepCall

Sleep indicates an expected call of Sleep.

func (*MockFarmerMockRecorder) Wroom 

func (mr *MockFarmerMockRecorder) Wroom() *MockFarmerWroomCall

Wroom indicates an expected call of Wroom.

type MockFarmerSleepCall 

type MockFarmerSleepCall struct {
	*gomock.Call
}

MockFarmerSleepCall wrap *gomock.Call

func (*MockFarmerSleepCall) Do 

func (c *MockFarmerSleepCall) Do(f func(time.Duration)) *MockFarmerSleepCall

Do rewrite *gomock.Call.Do

func (*MockFarmerSleepCall) DoAndReturn 

func (c *MockFarmerSleepCall) DoAndReturn(f func(time.Duration)) *MockFarmerSleepCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockFarmerSleepCall) Return 

func (c *MockFarmerSleepCall) Return() *MockFarmerSleepCall

Return rewrite *gomock.Call.Return

type MockFarmerWroomCall 

type MockFarmerWroomCall struct {
	*gomock.Call
}

MockFarmerWroomCall wrap *gomock.Call

func (*MockFarmerWroomCall) Do 

func (c *MockFarmerWroomCall) Do(f func() error) *MockFarmerWroomCall

Do rewrite *gomock.Call.Do

func (*MockFarmerWroomCall) DoAndReturn 

func (c *MockFarmerWroomCall) DoAndReturn(f func() error) *MockFarmerWroomCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockFarmerWroomCall) Return 

func (c *MockFarmerWroomCall) Return(arg0 error) *MockFarmerWroomCall

Return rewrite *gomock.Call.Return

type MockFood 

type MockFood struct {
	// contains filtered or unexported fields
}

MockFood is a mock of Food interface.

func NewMockFood 

func NewMockFood(ctrl *gomock.Controller) *MockFood

NewMockFood creates a new mock instance.

func (*MockFood) Calories 

func (m *MockFood) Calories() int

Calories mocks base method.

func (*MockFood) EXPECT 

func (m *MockFood) EXPECT() *MockFoodMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

type MockFoodCaloriesCall 

type MockFoodCaloriesCall struct {
	*gomock.Call
}

MockFoodCaloriesCall wrap *gomock.Call

func (*MockFoodCaloriesCall) Do 

func (c *MockFoodCaloriesCall) Do(f func() int) *MockFoodCaloriesCall

Do rewrite *gomock.Call.Do

func (*MockFoodCaloriesCall) DoAndReturn 

func (c *MockFoodCaloriesCall) DoAndReturn(f func() int) *MockFoodCaloriesCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockFoodCaloriesCall) Return 

func (c *MockFoodCaloriesCall) Return(arg0 int) *MockFoodCaloriesCall

Return rewrite *gomock.Call.Return

type MockFoodMockRecorder 

type MockFoodMockRecorder struct {
	// contains filtered or unexported fields
}

MockFoodMockRecorder is the mock recorder for MockFood.

func (*MockFoodMockRecorder) Calories 

func (mr *MockFoodMockRecorder) Calories() *MockFoodCaloriesCall

Calories indicates an expected call of Calories.

type MockHuman 

type MockHuman struct {
	// contains filtered or unexported fields
}

MockHuman is a mock of Human interface.

func NewMockHuman 

func NewMockHuman(ctrl *gomock.Controller) *MockHuman

NewMockHuman creates a new mock instance.

func (*MockHuman) Breathe 

func (m *MockHuman) Breathe()

Breathe mocks base method.

func (*MockHuman) EXPECT 

func (m *MockHuman) EXPECT() *MockHumanMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockHuman) Eat 

func (m *MockHuman) Eat(foods ...package_mode.Food)

Eat mocks base method.

func (*MockHuman) Sleep 

func (m *MockHuman) Sleep(duration time.Duration)

Sleep mocks base method.

type MockHumanBreatheCall 

type MockHumanBreatheCall struct {
	*gomock.Call
}

MockHumanBreatheCall wrap *gomock.Call

func (*MockHumanBreatheCall) Do 

func (c *MockHumanBreatheCall) Do(f func()) *MockHumanBreatheCall

Do rewrite *gomock.Call.Do

func (*MockHumanBreatheCall) DoAndReturn 

func (c *MockHumanBreatheCall) DoAndReturn(f func()) *MockHumanBreatheCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockHumanBreatheCall) Return 

func (c *MockHumanBreatheCall) Return() *MockHumanBreatheCall

Return rewrite *gomock.Call.Return

type MockHumanEatCall 

type MockHumanEatCall struct {
	*gomock.Call
}

MockHumanEatCall wrap *gomock.Call

func (*MockHumanEatCall) Do 

func (c *MockHumanEatCall) Do(f func(...package_mode.Food)) *MockHumanEatCall

Do rewrite *gomock.Call.Do

func (*MockHumanEatCall) DoAndReturn 

func (c *MockHumanEatCall) DoAndReturn(f func(...package_mode.Food)) *MockHumanEatCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockHumanEatCall) Return 

func (c *MockHumanEatCall) Return() *MockHumanEatCall

Return rewrite *gomock.Call.Return

type MockHumanMockRecorder 

type MockHumanMockRecorder struct {
	// contains filtered or unexported fields
}

MockHumanMockRecorder is the mock recorder for MockHuman.

func (*MockHumanMockRecorder) Breathe 

func (mr *MockHumanMockRecorder) Breathe() *MockHumanBreatheCall

Breathe indicates an expected call of Breathe.

func (*MockHumanMockRecorder) Eat 

func (mr *MockHumanMockRecorder) Eat(foods ...any) *MockHumanEatCall

Eat indicates an expected call of Eat.

func (*MockHumanMockRecorder) Sleep 

func (mr *MockHumanMockRecorder) Sleep(duration any) *MockHumanSleepCall

Sleep indicates an expected call of Sleep.

type MockHumanSleepCall 

type MockHumanSleepCall struct {
	*gomock.Call
}

MockHumanSleepCall wrap *gomock.Call

func (*MockHumanSleepCall) Do 

func (c *MockHumanSleepCall) Do(f func(time.Duration)) *MockHumanSleepCall

Do rewrite *gomock.Call.Do

func (*MockHumanSleepCall) DoAndReturn 

func (c *MockHumanSleepCall) DoAndReturn(f func(time.Duration)) *MockHumanSleepCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockHumanSleepCall) Return 

func (c *MockHumanSleepCall) Return() *MockHumanSleepCall

Return rewrite *gomock.Call.Return

type MockPrimate 

type MockPrimate struct {
	// contains filtered or unexported fields
}

MockPrimate is a mock of Primate interface.

func NewMockPrimate 

func NewMockPrimate(ctrl *gomock.Controller) *MockPrimate

NewMockPrimate creates a new mock instance.

func (*MockPrimate) Breathe 

func (m *MockPrimate) Breathe()

Breathe mocks base method.

func (*MockPrimate) EXPECT 

func (m *MockPrimate) EXPECT() *MockPrimateMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockPrimate) Eat 

func (m *MockPrimate) Eat(foods ...package_mode.Food)

Eat mocks base method.

func (*MockPrimate) Sleep 

func (m *MockPrimate) Sleep(duration time.Duration)

Sleep mocks base method.

type MockPrimateBreatheCall 

type MockPrimateBreatheCall struct {
	*gomock.Call
}

MockPrimateBreatheCall wrap *gomock.Call

func (*MockPrimateBreatheCall) Do 

func (c *MockPrimateBreatheCall) Do(f func()) *MockPrimateBreatheCall

Do rewrite *gomock.Call.Do

func (*MockPrimateBreatheCall) DoAndReturn 

func (c *MockPrimateBreatheCall) DoAndReturn(f func()) *MockPrimateBreatheCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockPrimateBreatheCall) Return 

func (c *MockPrimateBreatheCall) Return() *MockPrimateBreatheCall

Return rewrite *gomock.Call.Return

type MockPrimateEatCall 

type MockPrimateEatCall struct {
	*gomock.Call
}

MockPrimateEatCall wrap *gomock.Call

func (*MockPrimateEatCall) Do 

func (c *MockPrimateEatCall) Do(f func(...package_mode.Food)) *MockPrimateEatCall

Do rewrite *gomock.Call.Do

func (*MockPrimateEatCall) DoAndReturn 

func (c *MockPrimateEatCall) DoAndReturn(f func(...package_mode.Food)) *MockPrimateEatCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockPrimateEatCall) Return 

func (c *MockPrimateEatCall) Return() *MockPrimateEatCall

Return rewrite *gomock.Call.Return

type MockPrimateMockRecorder 

type MockPrimateMockRecorder struct {
	// contains filtered or unexported fields
}

MockPrimateMockRecorder is the mock recorder for MockPrimate.

func (*MockPrimateMockRecorder) Breathe 

func (mr *MockPrimateMockRecorder) Breathe() *MockPrimateBreatheCall

Breathe indicates an expected call of Breathe.

func (*MockPrimateMockRecorder) Eat 

func (mr *MockPrimateMockRecorder) Eat(foods ...any) *MockPrimateEatCall

Eat indicates an expected call of Eat.

func (*MockPrimateMockRecorder) Sleep 

func (mr *MockPrimateMockRecorder) Sleep(duration any) *MockPrimateSleepCall

Sleep indicates an expected call of Sleep.

type MockPrimateSleepCall 

type MockPrimateSleepCall struct {
	*gomock.Call
}

MockPrimateSleepCall wrap *gomock.Call

func (*MockPrimateSleepCall) Do 

func (c *MockPrimateSleepCall) Do(f func(time.Duration)) *MockPrimateSleepCall

Do rewrite *gomock.Call.Do

func (*MockPrimateSleepCall) DoAndReturn 

func (c *MockPrimateSleepCall) DoAndReturn(f func(time.Duration)) *MockPrimateSleepCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockPrimateSleepCall) Return 

func (c *MockPrimateSleepCall) Return() *MockPrimateSleepCall

Return rewrite *gomock.Call.Return

type MockUrbanResident 

type MockUrbanResident struct {
	// contains filtered or unexported fields
}

MockUrbanResident is a mock of UrbanResident interface.

func NewMockUrbanResident 

func NewMockUrbanResident(ctrl *gomock.Controller) *MockUrbanResident

NewMockUrbanResident creates a new mock instance.

func (*MockUrbanResident) Breathe 

func (m *MockUrbanResident) Breathe()

Breathe mocks base method.

func (*MockUrbanResident) Do 

func (m *MockUrbanResident) Do(work *package_mode.Work) error

Do mocks base method.

func (*MockUrbanResident) Drive 

func (m *MockUrbanResident) Drive(car cars.HyundaiSolaris)

Drive mocks base method.

func (*MockUrbanResident) EXPECT 

func (m *MockUrbanResident) EXPECT() *MockUrbanResidentMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockUrbanResident) Eat 

func (m *MockUrbanResident) Eat(foods ...package_mode.Food)

Eat mocks base method.

func (*MockUrbanResident) LivesInACity 

func (m *MockUrbanResident) LivesInACity()

LivesInACity mocks base method.

func (*MockUrbanResident) Sleep 

func (m *MockUrbanResident) Sleep(duration time.Duration)

Sleep mocks base method.

func (*MockUrbanResident) Wroom 

func (m *MockUrbanResident) Wroom() error

Wroom mocks base method.

type MockUrbanResidentBreatheCall 

type MockUrbanResidentBreatheCall struct {
	*gomock.Call
}

MockUrbanResidentBreatheCall wrap *gomock.Call

func (*MockUrbanResidentBreatheCall) Do 

func (c *MockUrbanResidentBreatheCall) Do(f func()) *MockUrbanResidentBreatheCall

Do rewrite *gomock.Call.Do

func (*MockUrbanResidentBreatheCall) DoAndReturn 

func (c *MockUrbanResidentBreatheCall) DoAndReturn(f func()) *MockUrbanResidentBreatheCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockUrbanResidentBreatheCall) Return 

func (c *MockUrbanResidentBreatheCall) Return() *MockUrbanResidentBreatheCall

Return rewrite *gomock.Call.Return

type MockUrbanResidentDoCall 

type MockUrbanResidentDoCall struct {
	*gomock.Call
}

MockUrbanResidentDoCall wrap *gomock.Call

func (*MockUrbanResidentDoCall) Do 

func (c *MockUrbanResidentDoCall) Do(f func(*package_mode.Work) error) *MockUrbanResidentDoCall

Do rewrite *gomock.Call.Do

func (*MockUrbanResidentDoCall) DoAndReturn 

func (c *MockUrbanResidentDoCall) DoAndReturn(f func(*package_mode.Work) error) *MockUrbanResidentDoCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockUrbanResidentDoCall) Return 

func (c *MockUrbanResidentDoCall) Return(arg0 error) *MockUrbanResidentDoCall

Return rewrite *gomock.Call.Return

type MockUrbanResidentDriveCall 

type MockUrbanResidentDriveCall struct {
	*gomock.Call
}

MockUrbanResidentDriveCall wrap *gomock.Call

func (*MockUrbanResidentDriveCall) Do 

func (c *MockUrbanResidentDriveCall) Do(f func(cars.HyundaiSolaris)) *MockUrbanResidentDriveCall

Do rewrite *gomock.Call.Do

func (*MockUrbanResidentDriveCall) DoAndReturn 

func (c *MockUrbanResidentDriveCall) DoAndReturn(f func(cars.HyundaiSolaris)) *MockUrbanResidentDriveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockUrbanResidentDriveCall) Return 

func (c *MockUrbanResidentDriveCall) Return() *MockUrbanResidentDriveCall

Return rewrite *gomock.Call.Return

type MockUrbanResidentEatCall 

type MockUrbanResidentEatCall struct {
	*gomock.Call
}

MockUrbanResidentEatCall wrap *gomock.Call

func (*MockUrbanResidentEatCall) Do 

func (c *MockUrbanResidentEatCall) Do(f func(...package_mode.Food)) *MockUrbanResidentEatCall

Do rewrite *gomock.Call.Do

func (*MockUrbanResidentEatCall) DoAndReturn 

func (c *MockUrbanResidentEatCall) DoAndReturn(f func(...package_mode.Food)) *MockUrbanResidentEatCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockUrbanResidentEatCall) Return 

func (c *MockUrbanResidentEatCall) Return() *MockUrbanResidentEatCall

Return rewrite *gomock.Call.Return

type MockUrbanResidentLivesInACityCall 

type MockUrbanResidentLivesInACityCall struct {
	*gomock.Call
}

MockUrbanResidentLivesInACityCall wrap *gomock.Call

func (*MockUrbanResidentLivesInACityCall) Do 

func (c *MockUrbanResidentLivesInACityCall) Do(f func()) *MockUrbanResidentLivesInACityCall

Do rewrite *gomock.Call.Do

func (*MockUrbanResidentLivesInACityCall) DoAndReturn 

func (c *MockUrbanResidentLivesInACityCall) DoAndReturn(f func()) *MockUrbanResidentLivesInACityCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockUrbanResidentLivesInACityCall) Return 

func (c *MockUrbanResidentLivesInACityCall) Return() *MockUrbanResidentLivesInACityCall

Return rewrite *gomock.Call.Return

type MockUrbanResidentMockRecorder 

type MockUrbanResidentMockRecorder struct {
	// contains filtered or unexported fields
}

MockUrbanResidentMockRecorder is the mock recorder for MockUrbanResident.

func (*MockUrbanResidentMockRecorder) Breathe 

func (mr *MockUrbanResidentMockRecorder) Breathe() *MockUrbanResidentBreatheCall

Breathe indicates an expected call of Breathe.

func (*MockUrbanResidentMockRecorder) Do 

func (mr *MockUrbanResidentMockRecorder) Do(work any) *MockUrbanResidentDoCall

Do indicates an expected call of Do.

func (*MockUrbanResidentMockRecorder) Drive 

func (mr *MockUrbanResidentMockRecorder) Drive(car any) *MockUrbanResidentDriveCall

Drive indicates an expected call of Drive.

func (*MockUrbanResidentMockRecorder) Eat 

func (mr *MockUrbanResidentMockRecorder) Eat(foods ...any) *MockUrbanResidentEatCall

Eat indicates an expected call of Eat.

func (*MockUrbanResidentMockRecorder) LivesInACity 

func (mr *MockUrbanResidentMockRecorder) LivesInACity() *MockUrbanResidentLivesInACityCall

LivesInACity indicates an expected call of LivesInACity.

func (*MockUrbanResidentMockRecorder) Sleep 

func (mr *MockUrbanResidentMockRecorder) Sleep(duration any) *MockUrbanResidentSleepCall

Sleep indicates an expected call of Sleep.

func (*MockUrbanResidentMockRecorder) Wroom 

func (mr *MockUrbanResidentMockRecorder) Wroom() *MockUrbanResidentWroomCall

Wroom indicates an expected call of Wroom.

type MockUrbanResidentSleepCall 

type MockUrbanResidentSleepCall struct {
	*gomock.Call
}

MockUrbanResidentSleepCall wrap *gomock.Call

func (*MockUrbanResidentSleepCall) Do 

func (c *MockUrbanResidentSleepCall) Do(f func(time.Duration)) *MockUrbanResidentSleepCall

Do rewrite *gomock.Call.Do

func (*MockUrbanResidentSleepCall) DoAndReturn 

func (c *MockUrbanResidentSleepCall) DoAndReturn(f func(time.Duration)) *MockUrbanResidentSleepCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockUrbanResidentSleepCall) Return 

func (c *MockUrbanResidentSleepCall) Return() *MockUrbanResidentSleepCall

Return rewrite *gomock.Call.Return

type MockUrbanResidentWroomCall 

type MockUrbanResidentWroomCall struct {
	*gomock.Call
}

MockUrbanResidentWroomCall wrap *gomock.Call

func (*MockUrbanResidentWroomCall) Do 

func (c *MockUrbanResidentWroomCall) Do(f func() error) *MockUrbanResidentWroomCall

Do rewrite *gomock.Call.Do

func (*MockUrbanResidentWroomCall) DoAndReturn 

func (c *MockUrbanResidentWroomCall) DoAndReturn(f func() error) *MockUrbanResidentWroomCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockUrbanResidentWroomCall) Return 

func (c *MockUrbanResidentWroomCall) Return(arg0 error) *MockUrbanResidentWroomCall

Return rewrite *gomock.Call.Return

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.