Trait AssertHasLength

pub trait AssertHasLength<E> {
    // Required methods
    fn has_length(self, expected_length: E) -> Self;
    fn has_length_in_range<U>(self, expected_range: U) -> Self
       where U: RangeBounds<usize> + Debug;
    fn has_length_less_than(self, expected_length: E) -> Self;
    fn has_length_greater_than(self, expected_length: E) -> Self;
    fn has_at_most_length(self, expected_length: E) -> Self;
    fn has_at_least_length(self, expected_length: E) -> Self;
}

Assert the length of a subject.

These assertions are implemented for all types T that implement the trait LengthProperty. This property trait is implemented for string like types and collection like types of the std lib. For example:

• String, &str, OsString, OsStr
• Vec, array, slice, VecDeque, LinkedList, etc.
• HashMap, HashSet, BTreeSet, etc.

Examples

use std::collections::{BTreeSet, HashMap, HashSet, VecDeque};
use asserting::prelude::*;

let some_str = "takimata te iriure nonummy";
assert_that!(some_str).has_length(26);
assert_that!(some_str).has_length_in_range(12..32);
assert_that!(some_str).has_length_in_range(12..=32);
assert_that!(some_str).has_length_in_range(12..);
assert_that!(some_str).has_length_in_range(..32);
assert_that!(some_str).has_length_in_range(..=32);
assert_that!(some_str).has_length_less_than(27);
assert_that!(some_str).has_length_greater_than(25);
assert_that!(some_str).has_at_most_length(26);
assert_that!(some_str).has_at_most_length(30);
assert_that!(some_str).has_at_least_length(26);
assert_that!(some_str).has_at_least_length(20);

let some_vec = vec!['m', 'Q', 'k', 'b'];
assert_that!(&some_vec).has_length(4);
assert_that!(&some_vec).has_length_in_range(2..6);
assert_that!(&some_vec).has_length_in_range(2..=6);
assert_that!(&some_vec).has_length_in_range(2..);
assert_that!(&some_vec).has_length_in_range(..6);
assert_that!(&some_vec).has_length_in_range(..=6);
assert_that!(&some_vec).has_length_less_than(5);
assert_that!(&some_vec).has_length_greater_than(3);
assert_that!(&some_vec).has_at_most_length(4);
assert_that!(&some_vec).has_at_most_length(10);
assert_that!(&some_vec).has_at_least_length(4);
assert_that!(&some_vec).has_at_least_length(1);

let some_btree_set = BTreeSet::from_iter([1, 3, 5, 7, 11, 13, 17, 19]);
assert_that!(some_btree_set).has_length(8);

let some_dequeue = VecDeque::from_iter(["one", "two", "three"]);
assert_that!(&some_dequeue).has_length(3);

with crate feature std enabled:

use std::collections::{HashMap, HashSet};
use asserting::prelude::*;

let some_set: HashSet<u8> = [1, 3, 5, 7, 11, 13, 17, 19].into_iter().collect();
assert_that!(some_set).has_length(8);

let some_map: HashMap<char, usize> = [('A', 25), ('B', 2), ('C', 12), ('D', 18)].into_iter().collect();
assert_that!(&some_map).has_length(4);

Required Methods

fn has_length(self, expected_length: E) -> Self

Verifies that the subject has the expected length.

fn has_length_in_range<U>(self, expected_range: U) -> Self

where U: RangeBounds<usize> + Debug,

Verifies that the subject has a length in the expected range.

The expected range can be any type of range.

fn has_length_less_than(self, expected_length: E) -> Self

Verifies that the subject has a length that is less than the expected length.

fn has_length_greater_than(self, expected_length: E) -> Self

Verifies that the subject has a length that is greater than the expected length.

fn has_at_most_length(self, expected_length: E) -> Self

Verifies that the subject has a length that is at most the expected length.

In other words, the length shall be less than or equal to the expected length.

fn has_at_least_length(self, expected_length: E) -> Self

Verifies that the subject has a length that is at least the expected length.

In other words, the length shall be greater than or equal to the expected length.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<S, R> AssertHasLength<usize> for Spec<'_, S, R>

where S: LengthProperty + Debug, R: FailingStrategy,