cuda

type BrokenEverywhere struct {
	Reason string
}

type BrokenInGVisor struct {
	// OnlyWhenMultipleGPU may be set to true for tests which only fail when
	// multiple GPUs are present. This should not be used for tests that
	// *require* multiple GPUs to run (use RequiresMultiGPU instead).
	// This is for tests that can run on a single or multiple GPUs alike,
	// but specifically fail in gVisor when run with multiple GPUs.
	OnlyWhenMultipleGPU bool
}

type Compatibility interface {
	// WillFail returns a string explaining why the test is expected to fail
	// in the given environment, or "" if it isn't expected to fail.
	WillFail(ctx context.Context, env *TestEnvironment) string

	// IsExpectedFailure checks whether the `logs` (from a failed run of the test
	// in the given environment) matches the failure that this test expects in
	// that environment. If they match, this function should return nil.
	// It is only called when `WillFail` returns a non-empty string for the same
	// environment, so it may assume that `env` is non-compatible.
	IsExpectedFailure(ctx context.Context, env *TestEnvironment, logs string, exitCode int) error
}

type Feature string

type FullyCompatible struct{}

type NoCrossCompile struct{}

type OnlyOnWindows struct{}

type RequiresMultiGPU struct{}

type RequiresNvSci struct{}

type RequiresP2P struct{}

type RunCudaTestArgs struct {
	// TestSuiteCompatibility maps test suites to their compatibility data.
	// Unmapped test suites are assumed to be fully compatible.
	TestSuiteCompatibility map[string]Compatibility

	// SkippedTestSuites maps test suites to a skip reason.
	// If a test suite is mapped, then all tests in that suite will be skipped.
	SkippedTestSuites map[string]string

	// TestCompatibility maps test names to their compatibility data.
	// Unmapped test names are assumed to be fully compatible.
	TestCompatibility map[string]Compatibility

	// FlakyTests is a list of tests that are flaky.
	// These will be retried up to 3 times in parallel before running 3 times
	// serially.
	FlakyTests map[string]struct{}

	// ExclusiveTests is a list of tests that must run exclusively (i.e. with
	// no other test running on the machine at the same time), or they will
	// likely fail. These tests are not attempted to be run in parallel.
	// This is usually the case for performance tests or tests that use a lot
	// of resources in general.
	// This saves the trouble to run them in parallel, while also avoiding
	// causing spurious failures for the tests that happen to be running in
	// parallel with them.
	ExclusiveTests map[string]struct{}

	// AlwaysSkippedTests don't run at all.
	// Each test is mapped to a reason why it should be skipped.
	AlwaysSkippedTests map[string]string

	// Image is the image to use for the CUDA tests.
	Image string
}

type TestEnvironment struct {
	NumGPUs         int
	RuntimeIsGVisor bool
	Features        map[Feature]bool
}