plugin

type FuncDeadline func() (deadline time.Time, ok bool)

type FuncError func(args ...any)

type FuncErrorf func(format string, args ...any)

type FuncFail func()

type FuncFailNow func()

type FuncFailed func() bool

type FuncFatal func(args ...any)

type FuncFatalf func(format string, args ...any)

type FuncLog func(args ...any)

type FuncLogf func(format string, args ...any)

type FuncName func() string

type FuncParallel func()

type FuncSetenv func(key, value string)

type FuncSkip func(args ...any)

type FuncSkipNow func()

type FuncSkipf func(format string, args ...any)

type FuncSkipped func() bool

type FuncTempDir func() string

type Hook struct {
	// Priority defines execution order.
	// Lower values indicate that this hook should be run earlier than others and vice versa.
	// Zero value won't affect the order - it uses stable sort internally.
	//
	// See [TryFirst] and [TryLast] for predefined priority constants.
	Priority HookPriority

	// Func to be run for this hook.
	Func func()
}

type HookPriority int

type Hooks struct {
	// BeforeAll is called before all tests once.
	BeforeAll Hook

	// BeforeEach is called before each test.
	BeforeEach Hook

	// BeforeEachSub is called before each subtest.
	BeforeEachSub Hook

	// AfterEachSub is called after each subtest.
	AfterEachSub Hook

	// AfterEach is called after each test.
	AfterEach Hook

	// AfterAll is called after all tests once.
	AfterAll Hook
}

type Option struct {
	// Value of this option.
	Value any

	// Propagate states whether this option
	// should be passed automatically between all subtests.
	Propagate bool
}

type Override[F any] func(f F) F

type Overrides struct {
	// Log overrides [testing.T.Log] function.
	//
	// Note that overriding this function won't override internal log used for Logf
	// or other functions such as Error, Skip, Fatal, etc.
	Log Override[FuncLog]

	// Logf overrides [testing.T.Logf] function.
	//
	// Note that overriding this function won't override internal log used for Logf
	// or other functions such as Errorf, Skipf, Fatalf, etc.
	Logf Override[FuncLogf]

	Name     Override[FuncName]
	Parallel Override[FuncParallel]
	Setenv   Override[FuncSetenv]
	TempDir  Override[FuncTempDir]
	Deadline Override[FuncDeadline]
	Errorf   Override[FuncErrorf]
	Error    Override[FuncError]
	Skip     Override[FuncSkip]
	SkipNow  Override[FuncSkipNow]
	Skipf    Override[FuncSkipf]
	Skipped  Override[FuncSkipped]
	Fail     Override[FuncFail]
	FailNow  Override[FuncFailNow]
	Failed   Override[FuncFailed]
	Fatal    Override[FuncFatal]
	Fatalf   Override[FuncFatalf]
}

type PanicInfo struct {
	// Value returned by recover().
	Value any

	// Trace is a stack trace for this panic.
	Trace string
}

type ParametrizedTestInfo struct {
	// RawBaseName of the test.
	//
	// When defined like so:
	//
	//  func TestFoo(t T, params struct{ ... }) {}
	//
	// Testo will create a separate test for each case
	// and name it "TestFoo_case_N" where N is the 1-based case number.
	// Therefore, t.BaseName() would also equal to "TestFoo_case_N",
	// while this field would store "TestFoo".
	RawBaseName string

	// N is the 0-based case number of this test.
	N int

	// Params passed for the current test case.
	Params map[string]any
}

type Plan struct {
	// Modify may filter or re-order planned tests in-place.
	// Nil values are ignored.
	//
	// It will not receive subtests.
	Modify func(tests *[]PlannedTest)
}

type PlannedTest interface {
	directive.DoNotImplement

	// Name of the test.
	Name() string

	// Info about this test.
	Info() TestInfo
}

type Plugin interface {
	Plugin() Spec
}

type RegularTestInfo struct {
	// RawBaseName is the raw "unformatted" base name of this test.
	//
	// For example:
	//
	//   Run(t, "my test name!?", func(...) { ... })
	//
	// t.BaseName() would equal to my_test_name,
	// while this field would equal to "my test name!?" (the same as passed).
	//
	// This only applies to subtests, for regular test
	// functions BaseName() and this field are equal.
	RawBaseName string

	// Level indicates how deep this t is.
	// That is, it shows the number of parents it has and zero if none.
	//
	// 	- Zero level is above test methods and exists in Before/After-All hooks.
	//  - First level is the test method level.
	//  - Second and more levels are subtests.
	Level int
}

type Spec struct {
	Plan      Plan
	Hooks     Hooks
	Overrides Overrides
}

type TInfo struct {
	// Plugins used by this T.
	Plugins []Plugin

	// Test holds information about current test.
	Test TestInfo

	// Panic is panic information.
	// It is nil if the test did not panic.
	Panic *PanicInfo

	// FailureKind is test failure kind.
	FailureKind TestFailureKind
}

type TestFailureKind int

type TestInfo interface {
	// contains filtered or unexported methods
}