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, 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.

Examples

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

let some_str = "takimata te iriure nonummy";
assert_that!(some_str).has_length(26);

let some_vec = vec!['m', 'Q', 'k', 'b'];
assert_that!(&some_vec).has_length(4);

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);

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.

Examples

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

let some_str = "takimata te iriure nonummy";
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);

let some_vec = vec!['m', 'Q', 'k', 'b'];
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);

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

let some_dequeue = VecDeque::from_iter(["one", "two", "three"]);
assert_that!(&some_dequeue).has_length_in_range(2..5);
assert_that!(&some_dequeue).has_length_in_range(2..=5);
assert_that!(&some_dequeue).has_length_in_range(3..);
assert_that!(&some_dequeue).has_length_in_range(..4);
assert_that!(&some_dequeue).has_length_in_range(..=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_in_range(4..12);
assert_that!(&some_set).has_length_in_range(4..=12);
assert_that!(&some_set).has_length_in_range(8..);
assert_that!(&some_set).has_length_in_range(..9);
assert_that!(&some_set).has_length_in_range(..=8);

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

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

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

Examples

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

let some_str = "takimata te iriure nonummy";
assert_that!(some_str).has_length_less_than(40);
assert_that!(some_str).has_length_less_than(27);

let some_vec = vec!['m', 'Q', 'k', 'b'];
assert_that!(&some_vec).has_length_less_than(10);
assert_that!(&some_vec).has_length_less_than(5);

let some_btree_set = BTreeSet::from_iter([1, 3, 5, 7, 11, 13, 17, 19]);
assert_that!(&some_btree_set).has_length_less_than(20);
assert_that!(&some_btree_set).has_length_less_than(9);

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

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_less_than(15);
assert_that!(&some_set).has_length_less_than(9);

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

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

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

Examples

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

let some_str = "takimata te iriure nonummy";
assert_that!(some_str).has_length_greater_than(20);
assert_that!(some_str).has_length_greater_than(25);

let some_vec = vec!['m', 'Q', 'k', 'b'];
assert_that!(&some_vec).has_length_greater_than(1);
assert_that!(&some_vec).has_length_greater_than(3);

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

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

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_greater_than(4);
assert_that!(&some_set).has_length_greater_than(7);

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

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.

Examples

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

let some_str = "takimata te iriure nonummy";
assert_that!(some_str).has_at_most_length(30);
assert_that!(some_str).has_at_most_length(26);

let some_vec = vec!['m', 'Q', 'k', 'b'];
assert_that!(&some_vec).has_at_most_length(10);
assert_that!(&some_vec).has_at_most_length(4);

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

let some_dequeue = VecDeque::from_iter(["one", "two", "three"]);
assert_that!(&some_dequeue).has_at_most_length(10);
assert_that!(&some_dequeue).has_at_most_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_at_most_length(15);
assert_that!(&some_set).has_at_most_length(8);

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

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.

Examples

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

let some_str = "takimata te iriure nonummy";
assert_that!(some_str).has_at_least_length(20);
assert_that!(some_str).has_at_least_length(26);

let some_vec = vec!['m', 'Q', 'k', 'b'];
assert_that!(&some_vec).has_at_least_length(1);
assert_that!(&some_vec).has_at_least_length(4);

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

let some_dequeue = VecDeque::from_iter(["one", "two", "three"]);
assert_that!(&some_dequeue).has_at_least_length(1);
assert_that!(&some_dequeue).has_at_least_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_at_least_length(4);
assert_that!(&some_set).has_at_least_length(8);

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

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,