test

Documentation

Index

• type A
• type AsyncProducer
• type B
• type Blank
• type C
• type ConsulLock
• type EmbeddedGet
• type Err
  • func (e *Err) Code() uint64
  • func (e *Err) Error() string
• type Example
• type Expecter
• type Fooer
• type FuncArgsCollision
• type GenericType
• type GetGeneric
• type GetInt
• type HasConflictingNestedImports
• type ImportsSameAsPackage
• type KeyManager
• type MapFunc
• type MapToInterface
• type MyReader
• type Requester
• type Requester2
• type Requester3
• type Requester4
• type RequesterArgSameAsImport
• type RequesterArgSameAsNamedImport
• type RequesterArgSameAsPkg
• type RequesterArray
• type RequesterElided
• type RequesterGenerics
• type RequesterIface
• type RequesterNS
• type RequesterPtr
• type RequesterReturnElided
• type RequesterSlice
• type RequesterVariadic
• type SendFunc
• type Sibling
• type StructWithTag
• type UnsafeInterface
• type UsesOtherPkgIface
• type VariadicNoReturnInterface

Types

type A

type A interface {
	Call() (B, error)
}

type AsyncProducer

type AsyncProducer interface {
	Input() chan<- bool
	Output() <-chan bool
	Whatever() chan bool
}

type B

type B struct{}

type Blank

type Blank interface {
	Create(x interface{}) error
}

type C

type C int

type ConsulLock

type ConsulLock interface {
	Lock(<-chan struct{}) (<-chan struct{}, error)
	Unlock() error
}

type EmbeddedGet

type EmbeddedGet[T constraints.Signed] interface{ GetGeneric[T] }

type Err

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

func (*Err) Code

func (e *Err) Code() uint64

func (*Err) Error

func (e *Err) Error() string

type Example

type Example interface {
	A() http.Flusher
	B(fixtureshttp string) my_http.MyStruct
}

Example is an example

type Expecter

type Expecter interface {
	NoArg() string
	NoReturn(str string)
	ManyArgsReturns(str string, i int) (strs []string, err error)
	Variadic(ints ...int) error
	VariadicMany(i int, a string, intfs ...interface{}) error
}

type Fooer

type Fooer interface {
	Foo(f func(x string) string) error
	Bar(f func([]int))
	Baz(path string) func(x string) string
}

type FuncArgsCollision

type FuncArgsCollision interface {
	Foo(ret interface{}) error
}

type GenericType

type GenericType[T any, S GetInt] struct {
	Any  T
	Some []S
}

type GetGeneric

type GetGeneric[T constraints.Integer] interface{ Get() T }

type GetInt

type GetInt interface{ Get() int }

type HasConflictingNestedImports

type HasConflictingNestedImports interface {
	RequesterNS
	Z() http.MyStruct
}

type ImportsSameAsPackage

type ImportsSameAsPackage interface {
	A() test.B
	B() KeyManager
	C(C)
}

type KeyManager

type KeyManager interface {
	GetKey(string, uint16) ([]byte, *Err)
}

type MapFunc

type MapFunc interface {
	Get(m map[string]func(string) string) error
}

type MapToInterface

type MapToInterface interface {
	Foo(arg1 ...map[string]interface{})
}

type MyReader

type MyReader interface {
	io.Reader
}

type Requester

type Requester interface {
	Get(path string) (string, error)
}

type Requester2

type Requester2 interface {
	Get(path string) error
}

type Requester3

type Requester3 interface {
	Get() error
}

type Requester4

type Requester4 interface {
	Get()
}

type RequesterArgSameAsImport

type RequesterArgSameAsImport interface {
	Get(json string) *json.RawMessage
}

type RequesterArgSameAsNamedImport

type RequesterArgSameAsNamedImport interface {
	Get(json string) *json.RawMessage
}

type RequesterArgSameAsPkg

type RequesterArgSameAsPkg interface {
	Get(test string)
}

type RequesterArray

type RequesterArray interface {
	Get(path string) ([2]string, error)
}

type RequesterElided

type RequesterElided interface {
	Get(path, url string) error
}

type RequesterGenerics

type RequesterGenerics[
	TAny any,
	TComparable comparable,
	TSigned constraints.Signed,
	TIntf GetInt,
	TExternalIntf io.Writer,
	TGenIntf GetGeneric[TSigned],
	TInlineType interface{ ~int | ~uint },
	TInlineTypeGeneric interface {
		~int | GenericType[int, GetInt]
		comparable
	},
] interface {
	GenericArguments(TAny, TComparable) (TSigned, TIntf)
	GenericStructs(GenericType[TAny, TIntf]) GenericType[TSigned, TIntf]
	GenericAnonymousStructs(struct{ Type1 TExternalIntf }) struct {
		Type2 GenericType[string, EmbeddedGet[int]]
	}
}

type RequesterIface

type RequesterIface interface {
	Get() io.Reader
}

type RequesterNS

type RequesterNS interface {
	Get(path string) (http.Response, error)
}

type RequesterPtr

type RequesterPtr interface {
	Get(path string) (*string, error)
}

type RequesterReturnElided

type RequesterReturnElided interface {
	Get(path string) (a, b, c int, err error)
	Put(path string) (_ int, err error)
}

type RequesterSlice

type RequesterSlice interface {
	Get(path string) ([]string, error)
}

type RequesterVariadic

type RequesterVariadic interface {
	// cases: only variadic argument, w/ and w/out interface type
	Get(values ...string) bool
	OneInterface(a ...interface{}) bool

	// cases: normal argument + variadic argument, w/ and w/o interface type
	Sprintf(format string, a ...interface{}) string
	MultiWriteToFile(filename string, w ...io.Writer) string
}

type SendFunc

type SendFunc func(ctx context.Context, data string) (int, error)

type Sibling

type Sibling interface {
	DoSomething()
}

type StructWithTag

type StructWithTag interface {
	MethodA(v *struct {
		FieldA int `json:"field_a"`
		FieldB int `json:"field_b" xml:"field_b"`
	}) *struct {
		FieldC int `json:"field_c"`
		FieldD int `json:"field_d" xml:"field_d"`
	}
}

type UnsafeInterface

type UnsafeInterface interface {
	Do(ptr *unsafe.Pointer)
}

type UsesOtherPkgIface

type UsesOtherPkgIface interface {
	DoSomethingElse(obj Sibling)
}

type VariadicNoReturnInterface

type VariadicNoReturnInterface interface {
	VariadicNoReturn(j int, is ...interface{})
}