metamorphic

type CustomOption interface {
	// Name returns the name of the custom option. This is the key under which
	// the option appears in the OPTIONS file, within the [TestOptions] stanza.
	Name() string
	// Value returns the value of the custom option, serialized as it should
	// appear within the OPTIONS file.
	Value() string
	// Close is run after the test database has been closed at the end of the
	// test as well as during restart operations within the test sequence. It's
	// passed a copy of the *pebble.Options. If the custom options hold on to
	// any resources outside, Close should release them.
	Close(*pebble.Options) error
	// Open is run before the test runs and during a restart operation after the
	// test database has been closed and Close has been called. It's passed a
	// copy of the *pebble.Options. If the custom options must acquire any
	// resources before the test continues, it should reacquire them.
	Open(*pebble.Options) error
}

type FailOnMatch struct {
	*regexp.Regexp
}

type InjectErrorsRate float64

type KeepData struct{}

type KeyFormat struct {
	Name                         string
	Comparer                     *base.Comparer
	KeySchema                    *pebble.KeySchema
	BlockPropertyCollectors      []func() pebble.BlockPropertyCollector
	FormatKey                    func(UserKey) string
	FormatKeySuffix              func(UserKeySuffix) string
	ParseFormattedKey            func(string) UserKey
	ParseFormattedKeySuffix      func(string) UserKeySuffix
	NewGenerator                 func(*keyManager, *rand.Rand, OpConfig) KeyGenerator
	NewSuffixFilterMask          func() pebble.BlockPropertyFilterMask
	NewSuffixBlockPropertyFilter func(min []byte, max []byte) sstable.BlockPropertyFilter
}

type KeyGenerator interface {

	// RecordPrecedingKey may be invoked before generating keys to inform the
	// key generator of a key that was previously generated and used within a
	// related test context.
	//
	// When metamorphic tests are run as a part of cross-version metamorphic
	// tests, a database maintains state between individual runs of the
	// metamorphic test. RecordPrecedingKey is invoked to inform the key
	// generator of the keys used in the previous metamorphic test run's
	// operations.
	//
	// Implementations may use this information differently, but one expected
	// use is to update the key generator's record of the maximum suffix, so
	// that the key generator can continue to generate keys with growing
	// suffixes, modelling the typical MVCC use case.
	RecordPrecedingKey(key []byte)

	// IncMaxSuffix increases the max suffix range and returns the new maximum
	// suffix (which is guaranteed to be larger than any previously generated
	// suffix).
	IncMaxSuffix() []byte
	// ExtendPrefix extends the given prefix key with additional bytes,
	// returning a new prefix that sorts after the given prefix.
	ExtendPrefix(prefix []byte) []byte
	// RandKey returns a random key (either a previously known key, or a new
	// key). The provided probability determines the likelihood of generating a
	// new key.
	RandKey(newKeyProbability float64) []byte
	// RandKeyInRange returns a random key (either a previously known key, or a
	// new key) in the given key range.
	RandKeyInRange(newKeyProbability float64, kr pebble.KeyRange) []byte
	// RandPrefix returns a random prefix key (a key with no suffix). The
	// provided probability determines the likelihood of generating a new
	// prefix.
	RandPrefix(newPrefix float64) []byte
	// SkewedSuffix generates a random suffix according to the configuration's
	// suffix distribution. It takes a probability 0 ≤ p ≤ 1.0 indicating the
	// probability with which the generator should increase the max suffix
	// generated by the generator.
	//
	// May return a nil suffix, with the probability the configuration's suffix
	// distribution assigns to the zero suffix.
	SkewedSuffix(incMaxProb float64) []byte
	// SuffixRange generates a new uniformly random range of suffixes (low, high]
	// such that high is guaranteed to be strictly greater (as defined by
	// ComparePointSuffixes) than low.
	//
	// The high suffix may be nil, in which case the suffix range represents all
	// suffixes ≥ low.
	SuffixRange() (low, high []byte)
	// UniformSuffix returns a suffix in the same range as SkewedSuffix but with
	// a uniform distribution. This is used during reads to better exercise
	// reading a mix of older and newer keys. The suffix can be empty.
	//
	// May return a nil suffix.
	UniformSuffix() []byte
}

type MaxThreads int

type MultiInstance int

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

type OpTimeout time.Duration

type OpType int

type Ops []op

type RandomOptionsCfg struct {
	CustomOptionParsers map[string]func(string) (CustomOption, bool)
	AlwaysStrictFS      bool
	NoRemoteStorage     bool
	NoWALFailover       bool
}

type RetryPolicy func(error) bool

type RunOnceInitialStatePath string

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

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

type Seed uint64

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

type TestOptions struct {
	// Opts holds the *pebble.Options for the test.
	Opts *pebble.Options
	// Threads configures the parallelism of the test. Each thread will run in
	// an independent goroutine and be responsible for executing operations
	// against an independent set of objects. The outcome of any individual
	// operation will still be deterministic, with the metamorphic test
	// inserting synchronization where necessary.
	Threads int
	// RetryPolicy configures which errors should be retried.
	RetryPolicy RetryPolicy
	// KeyFormat defines the format of keys used within the test.
	KeyFormat KeyFormat
	// CustomOptions holds custom test options that are defined outside of this
	// package.
	CustomOpts []CustomOption
	// contains filtered or unexported fields
}

type TestingT interface {
	require.TestingT
	Failed() bool
}

type UserKey []byte

type UserKeySuffix []byte