Struct RustBinaryId

pub struct RustBinaryId(/* private fields */);

A unique identifier for a test suite (a Rust binary).

Implementations

impl RustBinaryId

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

Creates a new RustBinaryId from a string.

pub fn from_parts( package_name: &str, kind: &RustTestBinaryKind, target_name: &str, ) -> Self

Creates a new RustBinaryId from its constituent parts:

• package_name: The name of the package as defined in Cargo.toml.
• kind: The kind of the target (see RustTestBinaryKind).
• target_name: The name of the target.

The algorithm is as follows:

1. If the kind is lib or proc-macro (i.e. for unit tests), the binary ID is the same as the package name. There can only be one library per package, so this will always be unique.
2. If the target is an integration test, the binary ID is package_name::target_name.
3. Otherwise, the binary ID is package_name::{kind}/{target_name}.

This format is part of nextest’s stable API.

Examples

use nextest_metadata::{RustBinaryId, RustTestBinaryKind};

// The lib and proc-macro kinds.
assert_eq!(
    RustBinaryId::from_parts("foo-lib", &RustTestBinaryKind::LIB, "foo_lib"),
    RustBinaryId::new("foo-lib"),
);
assert_eq!(
   RustBinaryId::from_parts("foo-derive", &RustTestBinaryKind::PROC_MACRO, "derive"),
   RustBinaryId::new("foo-derive"),
);

// Integration tests.
assert_eq!(
   RustBinaryId::from_parts("foo-lib", &RustTestBinaryKind::TEST, "foo_test"),
   RustBinaryId::new("foo-lib::foo_test"),
);

// Other kinds.
assert_eq!(
    RustBinaryId::from_parts("foo-lib", &RustTestBinaryKind::BIN, "foo_bin"),
    RustBinaryId::new("foo-lib::bin/foo_bin"),
);

pub fn as_str(&self) -> &str

Returns the identifier as a string.

pub fn len(&self) -> usize

Returns the length of the identifier in bytes.

pub fn is_empty(&self) -> bool

Returns true if the identifier is empty.

pub fn components(&self) -> RustBinaryIdComponents<'_>

Returns the components of this identifier.

Trait Implementations

impl Clone for RustBinaryId

fn clone(&self) -> RustBinaryId

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RustBinaryId

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RustBinaryId

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for RustBinaryId

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

Formats the value using the given formatter.

impl<S> From<S> for RustBinaryId

where S: AsRef<str>,

fn from(s: S) -> Self

Converts to this type from the input type.

impl Hash for RustBinaryId

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 Ord for RustBinaryId

fn cmp(&self, other: &RustBinaryId) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for RustBinaryId

fn eq(&self, other: &RustBinaryId) -> 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 PartialOrd for RustBinaryId

fn partial_cmp(&self, other: &RustBinaryId) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for RustBinaryId

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for RustBinaryId

impl StructuralPartialEq for RustBinaryId