testmoqs

Documentation

Overview

Package testmoqs contains multiple test mocks and adaptors for use in unit testing

Index

• type B
• type DifficultParamNamesFn
• type DifficultResultNamesFn
• type E
• type GenericInterfaceParam
• type GenericInterfaceParamFn
• type GenericInterfaceResult
• type GenericInterfaceResultFn
• type GenericParams
• type GenericParamsFn
• type GenericResults
• type GenericResultsFn
• type InterfaceParamFn
• type InterfaceParamWriter
  • func (w *InterfaceParamWriter) Write([]byte) (int, error)
• type InterfaceResultFn
• type InterfaceResultReader
  • func (r *InterfaceResultReader) Read([]byte) (int, error)
• type MyReader
• type MyWriter
• type NoNamesFn
• type NoParamsFn
• type NoResultsFn
• type NothingFn
• type Params
• type PartialGenericParams
• type PartialGenericParamsFn
• type PartialGenericResults
• type PartialGenericResultsFn
• type PassByArrayFn
• type PassByChanFn
• type PassByEllipsisFn
• type PassByMapFn
• type PassByReferenceFn
• type PassBySliceFn
• type PassByValueFn
• type RepeatedIdsFn
• type Results
• type S
• type TimesFn
• type UnsafePointerFn
• type Usual
• type UsualFn
• type VariadicFn
• type W

Types

type B

type B struct{}

The following unused structs check that the AST cache doesn't pick up the wrong types

type DifficultParamNamesFn

type DifficultParamNamesFn func(m, r bool, sequence string, param, params, i int, result, results, _ float32)

DifficultParamNamesFn has parameters with names that have been problematic

type DifficultResultNamesFn

type DifficultResultNamesFn func() (m, r string, sequence error, param, params, i int, result, results, _ float32)

DifficultResultNamesFn has parameters with names that have been problematic

type E

type E struct{}

The following unused structs check that the AST cache doesn't pick up the wrong types

type GenericInterfaceParam

type GenericInterfaceParam[W MyWriter] interface {
	Usual(w W) (sResult string, err error)
}

type GenericInterfaceParamFn

type GenericInterfaceParamFn[W MyWriter] func(w W) (sResult string, err error)

GenericInterfaceParamFn tests passing generic interface parameters

type GenericInterfaceResult

type GenericInterfaceResult[R MyReader] interface {
	Usual(sParam string, bParam bool) (r R)
}

type GenericInterfaceResultFn

type GenericInterfaceResultFn[R MyReader] func(sParam string, bParam bool) (r R)

GenericInterfaceResultFn tests returning generic interface results

type GenericParams

type GenericParams[S, B any] interface {
	Usual(S, B) (string, error)
}

type GenericParamsFn

type GenericParamsFn[S, B any] func(S, B) (string, error)

GenericParamsFn has all generic parameters

type GenericResults

type GenericResults[S ~string, E error] interface {
	Usual(string, bool) (S, E)
}

type GenericResultsFn

type GenericResultsFn[S ~string, E error] func(string, bool) (S, E)

GenericResultsFn has all generic results

type InterfaceParamFn

type InterfaceParamFn func(w io.Writer) (sResult string, err error)

InterfaceParamFn tests passing interface parameters

type InterfaceParamWriter

type InterfaceParamWriter struct {
	SParam string
	BParam bool
}

InterfaceParamWriter is used for testing functions that take an interface as a parameter

func (*InterfaceParamWriter) Write

func (w *InterfaceParamWriter) Write([]byte) (int, error)

type InterfaceResultFn

type InterfaceResultFn func(sParam string, bParam bool) (r io.Reader)

InterfaceResultFn tests returning interface results

type InterfaceResultReader

type InterfaceResultReader struct {
	SResult string
	Err     error
}

InterfaceResultReader is used for testing functions that return an interface

func (*InterfaceResultReader) Read

func (r *InterfaceResultReader) Read([]byte) (int, error)

type MyReader

type MyReader io.Reader

type MyWriter

type MyWriter io.Writer

type NoNamesFn

type NoNamesFn func(string, bool) (string, error)

NoNamesFn is a typical function type

type NoParamsFn

type NoParamsFn func() (sResult string, err error)

NoParamsFn is a function with no parameters

type NoResultsFn

type NoResultsFn func(sParam string, bParam bool)

NoResultsFn is a function with no return values

type NothingFn

type NothingFn func()

NothingFn is a function with no parameters and no return values

type Params

type Params struct {
	SParam string
	BParam bool
}

Params encapsulates the parameters for use in various test types

type PartialGenericParams

type PartialGenericParams[S any] interface {
	Usual(S, bool) (string, error)
}

type PartialGenericParamsFn

type PartialGenericParamsFn[S any] func(S, bool) (string, error)

PartialGenericParamsFn has some generic parameters

type PartialGenericResults

type PartialGenericResults[S ~string] interface {
	Usual(string, bool) (S, error)
}

type PartialGenericResultsFn

type PartialGenericResultsFn[S ~string] func(string, bool) (S, error)

PartialGenericResultsFn has some generic results

type PassByArrayFn

type PassByArrayFn func(p [3]Params) [3]Results

PassByArrayFn tests passing parameters and results by array

type PassByChanFn

type PassByChanFn func(p chan Params) chan Results

PassByChanFn tests passing parameters and results by channel

type PassByEllipsisFn

type PassByEllipsisFn func(p ...Params) (string, error)

PassByEllipsisFn tests passing parameters by ellipsis

type PassByMapFn

type PassByMapFn func(p map[string]Params) map[string]Results

PassByMapFn tests passing parameters and results by map

type PassByReferenceFn

type PassByReferenceFn func(p *Params) *Results

PassByReferenceFn tests passing parameters and results by reference

type PassBySliceFn

type PassBySliceFn func(p []Params) []Results

PassBySliceFn tests passing parameters and results by slice

type PassByValueFn

type PassByValueFn func(p Params) Results

PassByValueFn tests passing parameters and results by reference

type RepeatedIdsFn

type RepeatedIdsFn func(sParam1, sParam2 string, bParam bool) (sResult1, sResult2 string, err error)

RepeatedIdsFn is a function with multiple arguments of the same type

type Results

type Results struct {
	SResult string
	Err     error
}

Results encapsulates the results for use in various test types

type S

type S struct{}

The following unused structs check that the AST cache doesn't pick up the wrong types

type TimesFn

type TimesFn func(times string, bParam bool) (sResult string, err error)

TimesFn takes a parameter called times which should generate a valid moq

type UnsafePointerFn

type UnsafePointerFn func() unsafe.Pointer

type Usual

type Usual interface {
	Usual(sParam string, bParam bool) (sResult string, err error)
	NoNames(string, bool) (string, error)
	NoResults(sParam string, bParam bool)
	NoParams() (sResult string, err error)
	Nothing()
	Variadic(other bool, args ...string) (sResult string, err error)
	RepeatedIds(sParam1, sParam2 string, bParam bool) (sResult1, sResult2 string, err error)
	Times(sParam string, times bool) (sResult string, err error)
	DifficultParamNames(m, r bool, sequence string, param, params, i int, result, results, _ float32)
	DifficultResultNames() (m, r string, sequence error, param, params, i int, result, results, _ float32)
	PassByArray(p [3]Params) [3]Results
	PassByChan(p chan Params) chan Results
	PassByEllipsis(p ...Params) (string, error)
	PassByMap(p map[string]Params) map[string]Results
	PassByReference(p *Params) *Results
	PassBySlice(p []Params) []Results
	PassByValue(p Params) Results
	InterfaceParam(w io.Writer) (sResult string, err error)
	InterfaceResult(sParam string, bParam bool) (r io.Reader)
	FnParam(fn func())
	other.Other
}

Usual combines all the above function types into an interface

type UsualFn

type UsualFn func(sParam string, bParam bool) (sResult string, err error)

UsualFn is a typical function type

type VariadicFn

type VariadicFn func(other bool, args ...string) (sResult string, err error)

VariadicFn is a function with a variable number of arguments

type W

type W struct{}

The following unused structs check that the AST cache doesn't pick up the wrong types