Struct fidl_fuchsia_test_manager::RunSuiteOptions

pub struct RunSuiteOptions {
    pub realm_options: Option<RealmOptions>,
    pub run_disabled_tests: Option<bool>,
    pub max_concurrent_test_case_runs: Option<u16>,
    pub arguments: Option<Vec<String>>,
    pub timeout: Option<i64>,
    pub test_case_filters: Option<Vec<String>>,
    pub logs_iterator_type: Option<LogsIteratorType>,
    pub log_interest: Option<Vec<LogInterestSelector>>,
    pub accumulate_debug_data: Option<bool>,
    /* private fields */
}

Options specifying how a test suite should be run.

Fields

realm_options: Option<RealmOptions>

Specifies the realm in which to run the test suite. If this field is not supplied, the test will run in a hermetic realm inside the test manager. This option is used by clients that require non-hermetic realms or test realms with custom runners.

run_disabled_tests: Option<bool>

If set to true, test cases that have been disabled by the test author will nonetheless be executed. This value is false by default.

max_concurrent_test_case_runs: Option<u16>

Defines the maximum number of test cases to run concurrently. If unspecified, the test suite component decides this value.

arguments: Option<Vec<String>>

Command-line arguments to pass to the test. Test runners decide how to pass these arguments to tests. This value is an empty vector (no arguments) by default.

timeout: Option<i64>

Timeout for the entire suite run. If unspecified, there is no timeout, and the suite run may hang indefinitely.

test_case_filters: Option<Vec<String>>

Test case filters as glob patterns [https://en.wikipedia.org/wiki/Glob_(programming)]. Negative filters may be specified by prepending ‘-’. This value is an empty vector (no filters) by default.

A given test case is run if both of the following are true:

• No positive filters are specfied, or the test case matches one of the positive filters.
• The test case does not match any specified negative filter.

For example, given that a suite has the test cases Foo.Test1, Foo.Test2, Bar.Test1, and Bar.Test2:

• The filters ["Foo.*"] will execute Foo.Test1 and Foo.Test2.
• The filters ["-Foo.*"] will execute Bar.Test1 and Bar.Test2.
• The filters ["Foo.*", "-*.Test1"] will execute Foo.Test2.

logs_iterator_type: Option<LogsIteratorType>

Specifies what kind of iterator the client will use for retrieving logs. This value is BATCH by default.

log_interest: Option<Vec<LogInterestSelector>>

Configures the minimum severity to apply when filtering logs from the test suite component.

accumulate_debug_data: Option<bool>

If set to true, debug data collected for this run will be accumulated in test manager’s tmp folder with debug data collected in previous runs with this flag set true. Defaults to false.

This option is used when many tests are run in a batch, and delivering the accumulated data is more performant than delivering the debug data one test at a time.

Trait Implementations

impl Debug for RunSuiteOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Decode<RunSuiteOptions> for RunSuiteOptions

fn new_empty() -> Self

Creates a valid instance of Self. The specific value does not matter, since it will be overwritten by decode.

unsafe fn decode( &mut self, decoder: &mut Decoder<'_>, offset: usize, depth: Depth ) -> Result<()>

Decodes an object of type T from the decoder’s buffers into self.

impl Default for RunSuiteOptions

fn default() -> RunSuiteOptions

Returns the “default value” for a type.

impl Encode<RunSuiteOptions> for &mut RunSuiteOptions

unsafe fn encode( self, encoder: &mut Encoder<'_>, offset: usize, depth: Depth ) -> Result<()>

Encodes the object into the encoder’s buffers. Any handles stored in the object are swapped for Handle::INVALID.

impl PartialEq for RunSuiteOptions

fn eq(&self, other: &RunSuiteOptions) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ResourceTypeMarker for RunSuiteOptions

type Borrowed<'a> = &'a mut RunSuiteOptions

The Rust type to use for encoding. This is a particular Encode<Self> type cheaply obtainable from &mut Self::Owned. There are three cases:

fn take_or_borrow<'a>( value: &'a mut <Self as TypeMarker>::Owned ) -> Self::Borrowed<'a>

Cheaply converts from &mut Self::Owned to Self::Borrowed. For HandleBased types this is “take” (it returns an owned handle and replaces value with Handle::invalid), and for all other types it is “borrow” (just converts from one reference to another).

impl TypeMarker for RunSuiteOptions

type Owned = RunSuiteOptions

The owned Rust type which this FIDL type decodes into.

fn inline_align(_context: Context) -> usize

Returns the minimum required alignment of the inline portion of the encoded object. It must be a (nonzero) power of two.

fn inline_size(_context: Context) -> usize

Returns the size of the inline portion of the encoded object, including padding for alignment. Must be a multiple of inline_align.

fn encode_is_copy() -> bool

Returns true if the memory layout of Self::Owned matches the FIDL wire format and encoding requires no validation. When true, we can optimize encoding arrays and vectors of Self::Owned to a single memcpy.

fn decode_is_copy() -> bool

Returns true if the memory layout of Self::Owned matches the FIDL wire format and decoding requires no validation. When true, we can optimize decoding arrays and vectors of Self::Owned to a single memcpy.

impl Standalone for RunSuiteOptions

impl StructuralPartialEq for RunSuiteOptions