testing

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

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

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

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

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

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

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

type Fixture struct {
	// Name is the name of the fixture.
	// Tests and fixtures use the name to specify the fixture.
	// The name must be camelCase starting with a lowercase letter and containing only digits and letters.
	Name string

	// Desc is the description of the fixture.
	Desc string

	// Contacts is a list of email addresses of persons and groups who are familiar with the
	// fixture. At least one personal email address of an active committer should be specified so
	// that we can file bugs or ask for code review.
	Contacts []string

	// Impl is the implementation of the fixture.
	Impl FixtureImpl

	// Parent specifies the parent fixture name, or empty if it has no parent.
	Parent string

	// SetUpTimeout is the timeout applied to SetUp.
	// Even if fixtures are nested, the timeout is applied only to this stage.
	// This timeout is by default 0.
	SetUpTimeout time.Duration

	// ResetTimeout is the timeout applied to Reset.
	// Even if fixtures are nested, the timeout is applied only to this stage.
	// This timeout is by default 0.
	ResetTimeout time.Duration

	// PreTestTimeout is the timeout applied to PreTest.
	// Even if fixtures are nested, the timeout is applied only to this stage.
	// This timeout is by default 0.
	PreTestTimeout time.Duration

	// PostTestTimeout is the timeout applied to PostTest.
	// Even if fixtures are nested, the timeout is applied only to this stage.
	// This timeout is by default 0.
	PostTestTimeout time.Duration

	// TearDownTimeout is the timeout applied to TearDown.
	// Even if fixtures are nested, the timeout is applied only to this stage.
	// This timeout is by default 0.
	TearDownTimeout time.Duration

	// Params lists the Param structs for parameterized fixtures.
	Params []FixtureParam

	// ServiceDeps contains a list of RPC service names in local test bundles that this remote fixture
	// will access. This field is valid only for remote fixtures.
	ServiceDeps []string

	// Vars contains the names of runtime variables used to pass out-of-band data to tests.
	// Values are supplied using "tast run -var=name=value", and tests can access values via State.Var.
	Vars []string

	// Data contains paths of data files needed by the fixture, relative to a
	// "data" subdirectory within the directory in which the fixture is registered.
	Data []string

	// PrivateAttr contains freeform text private attributres describing the fixture.
	PrivateAttr []string
}

type FixtureImpl interface {
	// SetUp is called by the framework to set up the environment with possibly heavy-weight
	// operations.
	//
	// The context and state passed to SetUp are associated with the fixture metadata. For example,
	// testing.ContextOutDir(ctx) and s.OutDir() return the output directory allocated for the
	// fixture itself. testing.ContextSoftwareDeps(ctx) fails since fixtures can't declare software
	// dependencies.
	//
	// TODO(oka): Consider updating ContextSoftwareDeps API so that it's meaningful for fixture
	// scoped contexts. For tests, ContextSoftwareDeps returns the dependencies the test declares,
	// and utility methods (e.g. arc.New) use it to check that tests declare proper software
	// dependencies. For fixtures, it is uncertain what ContextSoftwareDeps should return. One
	// might think it could return the intersection of the software deps of the tests depending on
	// the fixture, but it doesn't work considering arc.New checks OR condition of the software
	// deps. Still, fixtures can call functions like arc.New that calls ContextSoftwareDeps. It
	// indicates that we need to reconsider ContextSoftwareDeps API.
	//
	// The return value is made available to the direct children of this fixture in the entity
	// graph, as long as this fixture and a child live in the same process.
	// If any resource is associated with the value (e.g. Chrome browser connection), it must not
	// be released in Reset, PreTest and PostTest because descendant fixtures may cache it or
	// construct subresources derived from it (e.g. Chrome tab connection).
	//
	// SetUp is called in descending order (parents to children) when fixtures are nested.
	//
	// SetUp can be called multiple times. This happens when this fixture's TearDown is called
	// before completing all tests depending on it in the following cases:
	//  - This fixture's Reset requested it by returning an error.
	//  - Ascendant fixtures' Reset requested it by returning an error.
	// In any case, TearDown is called in a pair with a successful SetUp call.
	//
	// Errors in this method are reported as errors of the fixture itself, rather than tests
	// depending on it.
	//
	// If one or more errors are reported in SetUp by s.Error or s.Fatal, all remaining tests
	// depending on this fixture are marked failed without actually running. TearDown is not called
	// in this case. If s.Fatal is called, SetUp immediately aborts.
	//
	// This method is the best place to do a heavy-weight setup of the system environment, e.g.
	// restarting a Chrome session.
	//
	// Note that SetUpTimeout is by default 0. Change it to have a valid context.
	SetUp(ctx context.Context, s *FixtState) interface{}

	// Reset is called by the framework after each test (except for the last one) to do a
	// light-weight reset of the environment to the original state.
	//
	// The context passed to Reset is associated with the fixture metadata. See SetUp for details.
	//
	// If Reset returns a non-nil error, the framework tears down and re-sets up the fixture to
	// recover. To be accurate, the following methods are called in order:
	//  - Descendant fixtures' TearDown in ascending order
	//  - This fixture's TearDown
	//  - This fixture's SetUp
	//  - Descendant fixtures' SetUp in descending order
	// Consequently, errors Reset returns don't affect ascendant fixtures.
	//
	// Returning an error from Reset is valid when light-weight reset doesn't restore the
	// condition the fixture declares.
	//
	// Reset is called in descending order (parents to children) when fixtures are nested.
	//
	// This method is the best place to do a light-weight cleanup of the system environment to the
	// original one when the fixture was set up, e.g. closing open Chrome tabs.
	//
	// Note that ResetTimeout is by default 0. Change it to have a valid context.
	Reset(ctx context.Context) error

	// PreTest is called by the framework before each test to do a light-weight set up for the test.
	//
	// The context and state passed to PreTest are associated with the test metadata. For example,
	// testing.ContextOutDir(ctx) and s.OutDir() return the output directory allocated to the test.
	//
	// PreTest is called in descending order (parents to children) when fixtures are nested.
	//
	// s.Error or s.Fatal can be used to report errors in PreTest. When s.Fatal is called PreTest
	// immediately aborts. The error is marked as the test failure.
	//
	// This method is always called if fixture is successfully reset by SetUp or Reset.
	//
	// In any case, PostTest is called in a pair with a successful PreTest call.
	//
	// If errors are reported in PreTest, it is reported as the test failure.
	//
	// If errors are reported in PreTest, the test and PostTest are not run.
	//
	// This method is the best place to do a setup for the test runs next. e.g. redirect logs to a
	// file in the test's output directory.
	//
	// Note that PreTestTimeout is by default 0. Change it to have a valid context.
	PreTest(ctx context.Context, s *FixtTestState)

	// PostTest is called by the framework after each test to tear down changes PreTest made.
	//
	// The context and state passed to PostTest are associated with the test metadata. For example,
	// testing.ContextOutDir(ctx) and s.OutDir() return the output directory allocated to the test.
	//
	// PostTest is called in ascending order (children to parent) when fixtures are nested.
	//
	// s.Error or s.Fatal can be used to report errors in PostTest. When s.Fatal is called PostTest
	// immediately aborts. The error is marked as the test failure.
	//
	// This method is always called if PreTest succeeds.
	//
	// PostTest is always called in a pair with a successful PreTest call.
	//
	// If errors are reported in PostTest, it is reported as the test failure.
	//
	// The errors PostTest reports don't affect the order of the fixture methods the framework
	// calls.
	//
	// This method is the best place to tear down changes PreTest made. e.g. close log files in the
	// test output directory.
	//
	// Note that PostTestTimeout is by default 0. Change it to have a valid context.
	PostTest(ctx context.Context, s *FixtTestState)

	// TearDown is called by the framework to tear down the environment SetUp set up.
	//
	// The context and state passed to TearDown are associated with the fixture metadata. See SetUp
	// for details.
	//
	// TearDown is called in an ascending order (children to parents) when fixtures are nested.
	//
	// TearDown is always called in a pair with a successful SetUp call.
	//
	// Errors in this method are reported as errors of the fixture itself, rather than tests
	// depending on it.
	//
	// Errors in TearDown doesn't affect the order of the fixture methods the framework calls.
	// That is, even if this fixture's TearDown reports errors, its ascendants' TearDown are still
	// called.
	//
	// This method is the best place to tear down changes SetUp made. e.g. Unenroll enterprise
	// enrollment.
	// Changes that shouldn't hinder healthy execution of succeeding tests are not necessarily to
	// be teared down. e.g. Chrome session can be left open.
	//
	// Note that TearDownTimeout is by default 0. Change it to have a valid context.
	TearDown(ctx context.Context, s *FixtState)
}

type FixtureInstance struct {
	// Pkg is the package from which the fixture is registered.
	Pkg string

	// Following fields are copied from Fixture.
	Name            string
	Desc            string
	Contacts        []string
	Impl            FixtureImpl
	Parent          string
	SetUpTimeout    time.Duration
	ResetTimeout    time.Duration
	PreTestTimeout  time.Duration
	PostTestTimeout time.Duration
	TearDownTimeout time.Duration
	Val             interface{}
	Data            []string
	ServiceDeps     []string
	Vars            []string
	PrivateAttr     []string

	// Bundle is the name of the test bundle this test belongs to.
	// This field is empty initially, and later set when the test is added
	// to testing.Registry.
	Bundle string
}

type FixtureParam struct {
	// Name is the name of this parameterized fixture.
	// Full name of the fixture will be category.FixtureName.param_name,
	// or category.FixtureName if Name is empty.
	// Name should match with [a-z0-9_]*.
	Name string

	// ExtraContacts is a list of extra email addresses of persons and groups who are familiar
	// with the parameter. At least one personal email address of an active committer
	// should be specified so that we can file bugs or ask for code review.
	ExtraContacts []string

	// Parent specifies the parent fixture name, or empty if it has no parent.
	// Can only be set if the enclosing fixture doesn't have one already set.
	Parent string

	// SetUpTimeout is the timeout applied to SetUp.
	// Even if fixtures are nested, the timeout is applied only to this stage.
	// Can only be set if the enclosing fixture doesn't have one already set.
	SetUpTimeout time.Duration

	// ResetTimeout is the timeout applied to Reset.
	// Even if fixtures are nested, the timeout is applied only to this stage.
	// Can only be set if the enclosing fixture doesn't have one already set.
	ResetTimeout time.Duration

	// PreTestTimeout is the timeout applied to PreTest.
	// Even if fixtures are nested, the timeout is applied only to this stage.
	// Can only be set if the enclosing fixture doesn't have one already set.
	PreTestTimeout time.Duration

	// PostTestTimeout is the timeout applied to PostTest.
	// Even if fixtures are nested, the timeout is applied only to this stage.
	// Can only be set if the enclosing fixture doesn't have one already set.
	PostTestTimeout time.Duration

	// TearDownTimeout is the timeout applied to TearDown.
	// Even if fixtures are nested, the timeout is applied only to this stage.
	// Can only be set if the enclosing fixture doesn't have one already set.
	TearDownTimeout time.Duration

	// Val is the value which can be retrieved from testing.FixtState.Param() method.
	Val interface{}

	// ExtraServiceDeps contains a list of extra RPC service names in local test bundles
	// that this remote fixture parameter will access.
	// This field is valid only for remote fixtures.
	ExtraServiceDeps []string

	// ExtraData contains paths of extra data files needed by the fixture parameter,
	// relative to a "data" subdirectory within the directory in which the fixture is registered.
	ExtraData []string

	// ExtraPrivateAttr contains extra freeform text private attributes describing the
	// fixture parameter.
	ExtraPrivateAttr []string
}

type LacrosMetadata int

type LifeCycle int

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

type Meta struct {
	// TastPath contains the absolute path to the tast executable.
	TastPath string
	// Target contains information about the DUT as "[<user>@]host[:<port>]".
	// DEPRECATED: Use ConnectionSpec instead.
	Target string
	// Flags contains flags that should be passed to the tast command's "run" subcommands.
	RunFlags []string
	// Flags contains flags that should be passed to the tast command's "list" subcommands.
	ListFlags []string
	// ConnectionSpec contains information about the DUT as "[<user>@]host[:<port>]".
	ConnectionSpec string
}

type OnErrorHandler func(errMsg string)

type OnFatalHandler func(errMsg string)

type OutputStream interface {
	// Log reports an informational log message from an entity.
	Log(level logging.Level, ts time.Time, msg string) error

	// Error reports an error from by an entity. An entity that reported one or
	// more errors should be considered failure.
	Error(e *protocol.Error) error
}

type Param struct {
	// Name is the name of this parameterized test.
	// Full name of the test case will be category.TestFuncName.param_name,
	// or category.TestFuncName if Name is empty.
	// Name should match with [a-z0-9_]*.
	Name string

	// ExtraAttr contains freeform text attributes describing the test,
	// in addition to Attr declared in the enclosing Test.
	ExtraAttr []string

	// ExtraPrivateAttr contains freeform text private attributes describing the test,
	// in addition to PrivateAttr declared in the enclosing Test.
	ExtraPrivateAttr []string

	// ExtraSearchFlags contains name-value pairs describing the test,
	// in addition to SearchFlags declared in the enclosing Test.
	ExtraSearchFlags []*protocol.StringPair

	// ExtraData contains paths of data files needed by the test case of this
	// param in addition to Data declared in the enclosing Test.
	ExtraData []string

	// ExtraSoftwareDeps lists software features that are required to run the test case for this param,
	// in addition to SoftwareDeps in the enclosing Test.
	ExtraSoftwareDeps []string

	// ExtraHardwareDeps describes hardware features and setup that are required to run the test for this
	// param, in addition to HardwareDeps in the enclosing Test.
	ExtraHardwareDeps hwdep.Deps

	// ExtraRequirements are used for linking test cases to requirements. These are not used by
	// tests themselves, but added to test metadata definitions used by infra services.  This slice is
	// appended to an Requirements declared by the test.
	ExtraRequirements []string

	// ExtraTestBedDeps are used for defining test bed dependencies only, i.e., 'carrier:verizon'.
	// These are not used by tests themselves, but added to test metadata definitions used by
	// infra services. This slice is appended to the TestBedDeps in the enclosing Test.
	//
	// For details about what dependencies are supported and how they are parsed,
	// see the converter and reverter functions in
	// https://source.chromium.org/chromium/infra/infra/+/main:go/src/infra/libs/skylab/inventory/autotest/labels/.
	ExtraTestBedDeps []string

	// Pre contains a precondition that must be met before the test is run.
	// Can only be set if the enclosing test doesn't have one already set.
	Pre Precondition

	// Fixture is the name of the fixture the test depends on.
	// Can only be set if the enclosing test doesn't have one already set.
	Fixture string

	// Timeout contains the maximum duration for which Func may run before the test is aborted.
	// Can only be set if the enclosing test doesn't have one already set.
	Timeout time.Duration

	// Val is the value which can be retrieved from testing.State.Param() method.
	Val interface{}

	// ExtraSoftwareDepsForAll lists software features of all DUTs
	// that are required to run the test case for this param,
	// in addition to SoftwareDepsForAll in the enclosing Test.
	// The primary DUT software dependency will be the union of
	// SoftwareDeps, SoftwareDepsForAll[""], ExtraSoftwareDeps and
	// ExtraSoftwareDepsForAll[""].
	// It is a map of companion roles and software features.
	ExtraSoftwareDepsForAll map[string][]string

	// ExtraHardwareDepsForAll describes hardware features and setup
	// companion DUTs that are required to run the test case for this param,
	// in addition to HardwareDepsForAll in the enclosing Test.
	// It is a map of companion roles and hardware features.
	// The role for primary DUT should be ""
	// The primary DUT hardware dependency will be the union of
	// HardwareDeps, HardwareDepsForAll[""], ExtraHardwareDeps and
	// ExtraHardwareDep and ExtraHardwareDepsForAll[""].
	ExtraHardwareDepsForAll map[string]hwdep.Deps

	// BugComponent overrides BugComponent defined in the test.
	// This field is for infra/external use only and should not be used
	// or referenced within the test code.
	BugComponent string

	// LifeCycleStage overrides the LifeCycleStage defined in the test.
	// This field is not to be used or referenced by test code.
	LifeCycleStage LifeCycle

	// VariantCategory defines hardware and software capabilities of the device or test rigging it
	// needs, which can influence the behavior of the test and its outcome.
	// Not required for the legacy pipeline.
	VariantCategory string
}

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

type Precondition interface {
	// Prepare is called immediately before starting each test that depends on the precondition.
	// The returned value will be made available to the test via State.PreValue.
	// To report an error, Prepare can call either s.Error/Errorf or s.Fatal/Fatalf.
	// If an error is reported, the test will not run, but the Precondition must be left
	// in a state where future calls to Prepare (and Close) can still succeed.
	Prepare(ctx context.Context, s *PreState) interface{}

	// Close is called immediately after completing the final test that depends on the precondition.
	// This method may be called without an earlier call to Prepare in rare cases (e.g. if
	// RuntimeConfig.PreTestFunc fails); preconditions must be able to handle this.
	Close(ctx context.Context, s *PreState)

	// String returns a short, underscore-separated name for the precondition.
	// "chrome_logged_in" and "arc_booted" are examples of good names for preconditions
	// defined by the "chrome" and "arc" packages, respectively.
	String() string

	// Timeout returns the amount of time dedicated to prepare and close the precondition.
	Timeout() time.Duration
}

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

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

type RemoteData struct {
	// Meta contains information about how the tast process was run.
	Meta *Meta
	// RPCHint contains information needed to establish gRPC connections.
	RPCHint *RPCHint
	// DUT is an SSH connection shared among remote entities.
	DUT *dut.DUT
	// CompanionDUTs are other DUTs that can be used in remote test.
	CompanionDUTs map[string]*dut.DUT
}

type RuntimeConfig struct {
	// DataDir is the directory in which the test's data files are located.
	DataDir string
	// OutDir is the directory to which the test will write output files.
	OutDir string
	// Vars contains names and values of out-of-band variables passed to tests at runtime.
	// Names must be registered in Test.Vars and values may be accessed using State.Var.
	Vars map[string]string
	// Features contains hardware features for all DUTs used in the test.
	Features map[string]*protocol.DUTFeatures
	// CloudStorage is a client to read files on Google Cloud Storage.
	CloudStorage *CloudStorage
	// RemoteData contains information relevant to remote tests.
	// This is nil for local tests.
	RemoteData *RemoteData
	// FixtValue is a value returned by a parent fixture.
	// It is nil if not available.
	FixtValue interface{}
	// FixtSerializedValue is a serialized value returned by a parent fixture.
	// It is nil if not available.
	FixtSerializedValue func() ([]byte, error)
	// FixtCtx is the context that lives as long as the fixture.
	// It can be accessed only from testing.FixtState.
	FixtCtx context.Context
	// PreCtx is the context that lives as long as the precondition.
	// It can be accessed only from testing.PreState.
	PreCtx context.Context
	// Purgeable is a list of file paths which are not used for now and thus
	// can be deleted if the disk space is low.
	Purgeable []string
	// MaxSysMsgLogSize is a size of flag for truncate log file.
	MaxSysMsgLogSize int64
	// DUTLabConfig is the lab configuration for all DUTs.
	DUTLabConfig *protocol.DUTLabConfig
}

type Service struct {
	// Register is a function called by the framework to register a gRPC service
	// to grpc.Server. This should be a simple function that constructs a gRPC
	// service implementation and calls pb.Register*Server.
	Register func(srv *grpc.Server, s *ServiceState)
	// Vars contains the names of runtime variables used by the service.
	Vars []string
	// GuaranteeCompatibility indicates that the service needs to strictly adhere to
	// the backward and forward compatibility guarantees when evolving proto definition
	// and implementation.
	// Once the flag is marked as True, it cannot be change to False in subsequent
	// versions.
	// The service will be exposed to non-Tast test harness clients.
	GuaranteeCompatibility bool
}

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

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

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

type Test struct {
	// Func is the function to be executed to perform the test.
	Func TestFunc

	// Desc is a short one-line description of the test.
	Desc string

	// Contacts is a list of email addresses of persons and groups who are familiar with the test.
	// At least one personal email address of an active committer should be specified so that we can
	// file bugs or ask for code reviews.
	//
	// The first address must be the team alias for whichever team/product area ultimately owns the test.
	// Partner tests should have a Googler contact, but addresses outside of google or chromium are OK
	// for the second+ entries. Please make sure your group alias can be emailed by Googlers outside of the group.
	//
	// Additional email aliases should all be people who want to be added to
	// bugs/emails/communication about the test.
	Contacts []string

	// Attr contains freeform text attributes describing the test.
	// See https://chromium.googlesource.com/chromiumos/platform/tast/+/HEAD/docs/test_attributes.md
	// for commonly-used attributes.
	Attr []string

	// PrivateAttr contains freeform text private attributes describing the test.
	// This should not be used other than Tast and tests.
	// Note: this info is not retrievable in test results.
	PrivateAttr []string

	// SearchFlags contains key-value pairs describing the test.
	// This information will be available in the test results, and can be used
	// for custom test results filtering or any other mapping.
	SearchFlags []*protocol.StringPair

	// Data contains paths of data files needed by the test, relative to a "data" subdirectory within the
	// directory in which Func is located.
	Data []string

	// Vars contains the names of runtime variables used to pass out-of-band data to tests.
	// Values are supplied using "tast run -var=name=value", and tests can access values via State.Var.
	Vars []string

	// VarDeps serves similar purpose as Vars but lists runtime variables that
	// are required to run the test.
	// Whether test fails or skipped when runtime variables in VarDeps is
	// missing is controlled by the flag -maybemissingvars for the Tast CLI.
	//
	// Tests should access runtime variables in VarDeps via State.RequiredVar.
	VarDeps []string

	// SoftwareDeps lists software features that are required to run the test.
	// If any dependencies are not satisfied by the DUT, the test will be skipped.
	// See https://chromium.googlesource.com/chromiumos/platform/tast/+/HEAD/docs/test_dependencies.md
	// for more information about dependencies.
	SoftwareDeps []string

	// HardwareDeps describes hardware features and setup that are required to run the test.
	HardwareDeps hwdep.Deps

	// Pre contains a precondition that must be met before the test is run.
	Pre Precondition

	// Fixture is the name of the fixture the test depends on.
	Fixture string

	// Timeout contains the maximum duration for which Func may run before the test is aborted.
	// This should almost always be set. If not specified, a reasonable default will be used,
	// but tests should not depend on it.
	// This field is serialized as an integer nanosecond count.
	Timeout time.Duration

	// Params lists the Param structs for parameterized tests.
	Params []Param

	// ServiceDeps contains a list of RPC service names in local test bundles that this remote test
	// will access. This field is valid only for remote tests.
	ServiceDeps []string

	// LacrosStatus indicates whether lacros variants have been considered for this test or not.
	LacrosStatus LacrosMetadata

	// SoftwareDepsForAll lists software features of all DUTs that
	// are required to run the test.
	// It is a map of companion roles and software features.
	// The role for primary DUT should be "".
	// The primary DUT software dependency will be the union of
	// SoftwareDeps and SoftwareDepsForAll[""].
	// If any dependencies are not satisfied, the test will be skipped.
	SoftwareDepsForAll map[string][]string

	// HardwareDepsForAll describes hardware features and setup of all
	// DUTs that are required to run the test.
	// It is a map of companion roles and hardware features.
	// The role for primary DUT should be "".
	// The primary DUT hardware dependency will be the union of
	// HardwareDeps and HardwareDepsForAll[""].
	// If any dependencies are not satisfied, the test will be skipped.
	HardwareDepsForAll map[string]hwdep.Deps

	// TestBedDeps are used for defining test bed dependencies only, i.e., 'carrier:verizon'.
	// These are not used by tests themselves, but added to test metadata definitions used by
	// infra services.
	//
	// For details about what dependencies are supported and how they are parsed,
	// see the converter and reverter functions in
	// https://source.chromium.org/chromium/infra/infra/+/main:go/src/infra/libs/skylab/inventory/autotest/labels/.
	TestBedDeps []string

	// Requirements are used for linking test cases to requirements. These are not used by
	// tests themselves, but added to test metadata definitions used by infra services.
	Requirements []string

	// Bug component id for filing bugs against this test, i.e. 'b:1234'. This field is not
	// to be used by tests themselves, but added to test metadata definitions used by infra services.
	BugComponent string

	// Life cycle metadata to indicate the usage of this test. This field is not
	// to be used by tests themselves, but added to test metadata definitions used by infra services.
	LifeCycleStage LifeCycle

	// VariantCategory defines hardware and software capabilities of the device or test rigging it
	// needs, which can influence the behavior of the test and its outcome.
	// Not required for the legacy pipeline.
	VariantCategory string
}

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

type TestFunc func(context.Context, *State)

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

type TestInstance struct {
	// Name specifies the test's name as "category.TestName".
	// The name is derived from Func's package and function name.
	// The category is the final component of the package.
	Name string

	// Pkg contains the Go package in which Func is located.
	Pkg string

	// ExitTimeout contains the maximum duration to wait for Func to exit after a timeout.
	// The context passed to Func has a deadline based on Timeout, but Tast waits for an additional ExitTimeout to elapse
	// before reporting that the test has timed out; this gives the test function time to return after it
	// sees that its context has expired before an additional error is added about the timeout.
	// This is exposed for unit tests and should almost always be omitted when defining tests;
	// a reasonable default will be used.
	// TODO(oka): Remove ExitTimeout using CustomGracePeriod in planner.Config .
	ExitTimeout time.Duration

	// Val contains the value inherited from the expanded Param struct for a parameterized test case.
	// This can be retrieved from testing.State.Param().
	Val interface{}

	Func         TestFunc
	Desc         string
	Contacts     []string
	Attr         []string
	PrivateAttr  []string
	SearchFlags  []*protocol.StringPair
	Data         []string
	Vars         []string
	VarDeps      []string
	SoftwareDeps map[string]dep.SoftwareDeps
	// HardwareDeps field is not in the protocol yet. When the scheduler in infra is
	// implemented, it is needed.
	HardwareDeps map[string]dep.HardwareDeps
	ServiceDeps  []string
	LacrosStatus LacrosMetadata
	Pre          Precondition
	Fixture      string
	Timeout      time.Duration

	// Bundle is the name of the test bundle this test belongs to.
	// This field is empty initially, and later set when the test is added
	// to testing.Registry.
	Bundle string

	// TestBedDeps, Requirements, Purpose, BugComponent, and LifeCycleStage
	// are only used by infra and should not be used in tests.
	TestBedDeps     []string
	Requirements    []string
	BugComponent    string
	LifeCycleStage  LifeCycle
	VariantCategory string
}

type Var interface {
	// Unmarshal convert a string to Var's value type and set it to Var.
	Unmarshal(data string) error

	// Name return the name of the variable.
	Name() string
}

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