fixtures

Documentation

Index

• type AliasedInterface
• type CustomOutput
• type DotImports
• type EmbedsInterfaces
• type FirstInterface
• type HasImports
• type HasOtherTypes
• type HasVarArgs
• type HasVarArgsWithLocalTypes
• type ImportsGoHyphenPackage
• type InlineStructParams
• type InterfaceToEmbed
• type LocalType
• type Params
• type Request
• type RequestFactory
• type ReusesArgTypes
• type SecondInterface
• type SomeFunc
• type SomeNum
• type SomeString
• type Something
• type SomethingElse
• type SomethingFactory
• type SomethingWithForeignInterface

Types

type AliasedInterface

type AliasedInterface interface {
	alias.AnotherInterface
}

AliasedInterface is an interface that embeds an interface in an aliased package.

type CustomOutput

type CustomOutput interface {
	CustomFolder()
}

type DotImports

type DotImports interface {
	DoThings(io.Writer, *File) *http.Client
}

type EmbedsInterfaces

type EmbedsInterfaces interface {
	http.Handler
	another_package.AnotherInterface
	InterfaceToEmbed

	DoThings()
}

type FirstInterface

type FirstInterface interface {
	DoThings()
}

type HasImports

type HasImports interface {
	DoThings(io.Writer, *some_alias.File) *http.Client
}

type HasOtherTypes

type HasOtherTypes interface {
	GetThing(SomeString) SomeFunc
}

type HasVarArgs

type HasVarArgs interface {
	DoThings(int, ...string) int
	DoMoreThings(int, int, ...string) int
}

type HasVarArgsWithLocalTypes

type HasVarArgsWithLocalTypes interface {
	DoThings(...LocalType)
}

type ImportsGoHyphenPackage

type ImportsGoHyphenPackage interface {
	UseHyphenType(hyphenpackage.HyphenType)
}

type InlineStructParams

type InlineStructParams interface {
	DoSomething(ctx context.Context, body struct {
		SomeString        string
		SomeStringPointer *string
		SomeTime          time.Time
		SomeTimePointer   *time.Time
		HTTPRequest       http.Request
	}) error
}

type InterfaceToEmbed

type InterfaceToEmbed interface {
	EmbeddedMethod() string
}

type LocalType

type LocalType struct{}

type Params

type Params struct{}

type Request

type Request struct{}

type RequestFactory

type RequestFactory func(Params, map[string]interface{}) (Request, error)

type ReusesArgTypes

type ReusesArgTypes interface {
	DoThings(x, y string)
}

type SecondInterface

type SecondInterface interface {
	EmbeddedMethod() string
}

type SomeFunc

type SomeFunc func(SomeNum) bool

type SomeNum

type SomeNum uint64

type SomeString

type SomeString string

type Something

type Something interface {
	DoThings(string, uint64) (int, error)
	DoNothing()
	DoASlice([]byte)
	DoAnArray([4]byte)
}

type SomethingElse

type SomethingElse interface {
	ReturnStuff() (a, b int)
}

type SomethingFactory

type SomethingFactory func(string, map[string]interface{}) string

type SomethingWithForeignInterface

type SomethingWithForeignInterface interface {
	the_aliased_package.InAliasedPackage
}

SomethingWithForeignInterface is an interface that embeds a foreign interface.