asserting::assertions

Trait AssertIteratorContainsInOrder

Source 
pub trait AssertIteratorContainsInOrder<'a, S, E, R> {
    // Required methods
    fn contains_exactly(self, expected: E) -> Spec<'a, S, R>;
    fn contains_sequence(self, expected: E) -> Spec<'a, S, R>;
    fn contains_all_in_order(self, expected: E) -> Spec<'a, S, R>;
    fn starts_with(self, expected: E) -> Spec<'a, S, R>;
    fn ends_with(self, expected: E) -> Spec<'a, S, R>;
}
Expand description

Assert values in an ordered collection.

These assertions are applicable to collections which iterate over their values in a defined order.

Required Methods§

Source

fn contains_exactly(self, expected: E) -> Spec<'a, S, R>

Verifies that the actual collection/iterator contains exactly the given values and nothing else in the given order.

§Examples
use asserting::prelude::*;
use std::collections::BTreeMap;

let some_array = [1, 3, 5, 7];
assert_that!(some_array).contains_exactly([1, 3, 5, 7]);

let some_slice = &['b', 'X', 'k', 'G'][..];
assert_that!(some_slice).contains_exactly(&['b', 'X', 'k', 'G']);

let some_vec = vec![12, 4, 6, 10, 8];
assert_that!(some_vec).contains_exactly([12, 4, 6, 10, 8]);

let some_btree_map = BTreeMap::from_iter([('a', 3), ('b', 0), ('c', 8)]);
assert_that!(some_btree_map).contains_exactly([('a', 3), ('b', 0), ('c', 8)]);
Source

fn contains_sequence(self, expected: E) -> Spec<'a, S, R>

Verifies that the actual collection/iterator contains the given sequence of values in the given order and without extra values between the sequence values.

May contain more values as in the given sequence before and after the sequence.

§Examples
use asserting::prelude::*;
use std::collections::BTreeMap;

let some_array = [1, 3, 5, 7, 9];
assert_that!(some_array).contains_sequence([3, 5, 7]);

let some_slice = &['b', 'X', 'k', 'G'][..];
assert_that!(some_slice).contains_sequence(&['b', 'X']);

let some_vec = vec![12, 4, 6, 10, 8];
assert_that!(some_vec).contains_sequence([6, 10, 8]);

let some_btree_map = BTreeMap::from_iter([('a', 3), ('b', 0), ('c', 8)]);
assert_that!(some_btree_map).contains_sequence([('a', 3), ('b', 0), ('c', 8)]);
Source

fn contains_all_in_order(self, expected: E) -> Spec<'a, S, R>

Verifies that the actual collection/iterator contains all the given values and in the given order, possibly with other values between them.

§Examples
use asserting::prelude::*;
use std::collections::BTreeMap;

let some_array = [1, 3, 5, 7, 9];
assert_that!(some_array).contains_all_in_order([3, 5, 9]);

let some_slice = &['b', 'X', 'k', 'G'][..];
assert_that!(some_slice).contains_all_in_order(&['b', 'G']);

let some_vec = vec![12, 4, 6, 10, 8];
assert_that!(some_vec).contains_all_in_order([12, 4, 10, 8]);

let some_btree_map = BTreeMap::from_iter([('a', 3), ('b', 0), ('c', 8)]);
assert_that!(some_btree_map).contains_all_in_order([('a', 3), ('c', 8)]);
Source

fn starts_with(self, expected: E) -> Spec<'a, S, R>

Verifies that the actual collection/iterator contains the given values as the first elements in order.

§Examples
use asserting::prelude::*;
use std::collections::BTreeMap;

let some_array = [1, 3, 5, 7];
assert_that!(some_array).starts_with([1, 3, 5]);

let some_slice = &['b', 'X', 'k', 'G'][..];
assert_that!(some_slice).starts_with(&['b', 'X']);

let some_vec = vec![12, 4, 6, 10, 8];
assert_that!(some_vec).starts_with([12, 4, 6]);

let some_btree_map = BTreeMap::from_iter([('a', 3), ('b', 0), ('c', 8)]);
assert_that!(some_btree_map).starts_with([('a', 3), ('b', 0)]);
Source

fn ends_with(self, expected: E) -> Spec<'a, S, R>

Verifies that the actual collection/iterator contains the given values as the last elements in order.

§Examples
use asserting::prelude::*;
use std::collections::BTreeMap;

let some_array = [1, 3, 5, 7];
assert_that!(some_array).ends_with([3, 5, 7]);

let some_slice = &['b', 'X', 'k', 'G'][..];
assert_that!(some_slice).ends_with(&['k', 'G']);

let some_vec = vec![12, 4, 6, 10, 8];
assert_that!(some_vec).ends_with([10, 8]);

let some_btree_map = BTreeMap::from_iter([('a', 3), ('b', 0), ('c', 8)]);
assert_that!(some_btree_map).ends_with([('b', 0), ('c', 8)]);

Implementors§