testcase

May 28, 2024

Changes in this version

+ func Let2[V, B any](spec *Spec, blk func(*T) (V, B)) (Var[V], Var[B])

+ func Let3[V, B, N any](spec *Spec, blk func(*T) (V, B, N)) (Var[V], Var[B], Var[N])

May 2, 2024

Changes in this version

type SpecSuite

+ N string

May 1, 2024

Changes in this version

type Spec

+ func (spec *Spec) Benchmark(desc string, test tBlock, opts ...SpecOption)

Feb 24, 2024

Changes in this version

type Var

+ Deps Vars

+ type Vars []tetcaseVar

Oct 16, 2023

Changes in this version

+ const EnvKeyOrdering

+ const EnvKeySeed

+ const OrderingAsDefined

+ const OrderingAsRandom

+ var DefaultEventually = assert.Eventually

+ var Global global

+ func Append(t *T, v Var[V], x ...interface{})

+ func Race(fn1, fn2 func(), more ...func())

+ func RetryCount(times int) assert.RetryStrategy

+ func RunOpenSuite(tb TBS, contracts ...OpenSuite)

+ func RunSuite(tb TBS, contracts ...Suite)

+ func Sandbox(fn func()) sandbox.RunOutcome

+ func SetEnv(tb testing.TB, key, value string)

+ func SkipUntil(tb testing.TB, year int, month time.Month, day int, hour int)

+ func TableTest(tbs TBS, tcs map[string]TC, act Act)

+ func UnsetEnv(tb testing.TB, key string)

+ type Eventually = assert.Eventually

+ type OpenSuite interface

+ Benchmark func(*testing.B)

+ Test func(*testing.T)

+ type OpenSuiteAdapter struct

+ func (c OpenSuiteAdapter) Spec(s *Spec)

+ type RetryStrategy = assert.RetryStrategy

+ type RetryStrategyFunc = assert.RetryStrategyFunc

+ type Spec struct

+ func NewSpec(tb testing.TB, opts ...SpecOption) *Spec

+ func ToSpec(tbs TBS) *Spec

+ func (spec *Spec) After(afterBlock tBlock)

+ func (spec *Spec) And(desc string, testContextBlock sBlock, opts ...SpecOption)

+ func (spec *Spec) Around(block hookBlock)

+ func (spec *Spec) AsSuite() SpecSuite

+ func (spec *Spec) Before(beforeBlock tBlock)

+ func (spec *Spec) BeforeAll(blk func(tb testing.TB))

+ func (spec *Spec) Context(desc string, testContextBlock sBlock, opts ...SpecOption)

+ func (spec *Spec) Describe(subjectTopic string, specification sBlock, opts ...SpecOption)

+ func (spec *Spec) Finish()

+ func (spec *Spec) HasSideEffect()

+ func (spec *Spec) Let(varName string, blk VarInit[any]) Var[any]

+ func (spec *Spec) LetValue(varName string, value any) Var[any]

+ func (spec *Spec) NoSideEffect()

+ func (spec *Spec) Parallel()

+ func (spec *Spec) Sequential()

+ func (spec *Spec) SkipBenchmark()

+ func (spec *Spec) Spec(oth *Spec)

+ func (spec *Spec) Tag(tags ...string)

+ func (spec *Spec) Test(desc string, test tBlock, opts ...SpecOption)

+ func (spec *Spec) Then(desc string, test tBlock, opts ...SpecOption)

+ func (spec *Spec) When(desc string, testContextBlock sBlock, opts ...SpecOption)

+ type SpecOption interface

+ func AsSuite(name ...string) SpecOption

+ func Flaky(CountOrTimeout interface{}) SpecOption

+ func Group(name string) SpecOption

+ func RetryStrategyForEventually(strategy assert.RetryStrategy) SpecOption

+ func SkipBenchmark() SpecOption

+ type SpecSuite struct

+ S *Spec

+ func (suite SpecSuite) Benchmark(b *testing.B)

+ func (suite SpecSuite) Name() string

+ func (suite SpecSuite) Spec(s *Spec)

+ func (suite SpecSuite) Test(t *testing.T)

+ type StubTB = doubles.TB

+ type Suite interface

+ Spec func(s *Spec)

+ type T struct

+ Random *random.Random

+ func NewT(tb testing.TB, spec *Spec) *T

+ func ToT(tb TBs) *T

+ func (t *T) Cleanup(fn func())

+ func (t *T) Defer(fn interface{}, args ...interface{})

+ func (t *T) Eventually(blk func(t assert.It), retryOpts ...interface{})

+ func (t *T) HasTag(tag string) bool

+ func (t *T) LogPretty(vs ...any)

+ func (t *T) SetEnv(key, value string)

+ func (t *T) Setenv(key, value string)

+ func (t *T) SkipUntil(year int, month time.Month, day int, hour int)

+ func (t *T) UnsetEnv(key string)

+ type TBRunner interface

+ Run func(name string, blk func(tb testing.TB)) bool

+ type Var struct

+ Before func(t *T, v Var[V])

+ ID string

+ Init VarInit[V]

+ OnLet func(s *Spec, v Var[V])

+ func Let(spec *Spec, blk VarInit[V]) Var[V]

+ func LetValue(spec *Spec, value V) Var[V]

+ func (v Var[V]) Bind(s *Spec) Var[V]

+ func (v Var[V]) EagerLoading(s *Spec) Var[V]

+ func (v Var[V]) Get(t *T) V

+ func (v Var[V]) Let(s *Spec, blk VarInit[V]) Var[V]

+ func (v Var[V]) LetValue(s *Spec, value V) Var[V]

+ func (v Var[V]) PreviousValue(t *T) V

+ func (v Var[V]) Set(t *T, value V)

+ func (v Var[V]) Super(t *T) V

+ type VarInit func(*T) V

+ type VarInitFunc func(*T) V

+ type Waiter = assert.Waiter