Enum etest::ResourceIdImpl

pub enum ResourceIdImpl<'a> {
    Id(Cow<'a, str>),
    None,
    Basic,
}

A resource which can be “used” or “consumed”

To be used with the uses and consumes parameters of #[etest]. For type safety custom types can be specified which implement Into<ResourceId>.

E.g.

enum Output {
    Auto,
    Hdmi,
    Lvds,
}

impl From<Output> for ResourceId
{
    fn from(o: Output) -> Self {
        let o = match o {
            // this is evaluated at runtime of the test
            Output::Auto if is_hdmi_connected() => Output::Hdmi,
            Output::Auto                        => Output::Lvds,
            o => o,
        };

        match o {
            Output::Hdmi => "hdmi".into(),
            Output::Lvds => "lvds".into(),
            Output::Auto => unreachable!(),
        }
    }
}

#[etest(consumes=[Output])]
fn test() {}

Variants

Id(Cow<'a, str>)

Normal resource

None

An empty resource which will be ignored.

Used e.g. when generating a list of resources dynamically where some of the resources are optional and can be omitted.

Basic

Basic resource which is used by all tests.

Unless specified else (by the no_default_uses attribute), this resource will be implicitly added to the “uses” list of every test. To avoid parallel execution with other ones, a test can add this resource type to its “consumes” list by the notparallel attribute.

Implementations

impl<'a> ResourceIdImpl<'a>

pub const fn new(id: &'a str) -> Self

pub fn from_string(s: String) -> Self

pub fn is_some(&self) -> bool

Trait Implementations

impl<'a> Clone for ResourceIdImpl<'a>

fn clone(&self) -> ResourceIdImpl<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for ResourceIdImpl<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a str> for ResourceIdImpl<'a>

fn from(val: &'a str) -> Self

Converts to this type from the input type.

impl<'a, T> From<Option<T>> for ResourceIdImpl<'a>

where T: Into<ResourceIdImpl<'a>>,

Maps an option to a ResourceId.

Value of None maps to the special ResourceId::None resource type which will be ignored when building list of resources dynamically.

fn from(val: Option<T>) -> Self

Converts to this type from the input type.

impl From<String> for ResourceIdImpl<'_>

fn from(val: String) -> Self

Converts to this type from the input type.

impl<'a> Hash for ResourceIdImpl<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for ResourceIdImpl<'a>

fn eq(&self, other: &ResourceIdImpl<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Eq for ResourceIdImpl<'a>

impl<'a> StructuralPartialEq for ResourceIdImpl<'a>