Trait AssertMapContainsKey 

pub trait AssertMapContainsKey<E> {
    // Required methods
    fn contains_key(self, expected_key: E) -> Self;
    fn does_not_contain_key(self, expected_key: E) -> Self;
    fn contains_keys(self, expected_keys: impl IntoIterator<Item = E>) -> Self;
    fn does_not_contain_keys(
        self,
        expected_keys: impl IntoIterator<Item = E>,
    ) -> Self;
    fn contains_exactly_keys(
        self,
        expected_keys: impl IntoIterator<Item = E>,
    ) -> Self;
}

Assertions for the keys of a map.

Examples

use asserting::prelude::*;
use std::collections::HashMap;

let subject: HashMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).contains_key(5);
assert_that!(&subject).does_not_contain_key(3);
assert_that!(&subject).contains_keys([4, 8]);
assert_that!(&subject).does_not_contain_keys([3, 2, 7]);
assert_that!(&subject).contains_exactly_keys([4, 1, 5, 8]);

use asserting::prelude::*;
use hashbrown::HashMap;

let subject: HashMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).contains_key(4);
assert_that!(&subject).does_not_contain_key(7);
assert_that!(&subject).contains_keys([1, 5]);
assert_that!(&subject).does_not_contain_keys([2, 7, 6]);
assert_that!(&subject).contains_exactly_keys([1, 4, 5, 8]);

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

let subject: BTreeMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).contains_key(4);
assert_that!(&subject).does_not_contain_key(2);
assert_that!(&subject).contains_keys([1, 4, 8]);
assert_that!(&subject).does_not_contain_keys([2, 3, 6]);
assert_that!(&subject).contains_exactly_keys([4, 5, 8, 1]);

Required Methods

fn contains_key(self, expected_key: E) -> Self

Verify that the actual map contains a mapping for the given key.

Examples

use asserting::prelude::*;
use std::collections::HashMap;

let subject: HashMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).contains_key(5);
assert_that!(subject).contains_key(1);

use asserting::prelude::*;
use hashbrown::HashMap;

let subject: HashMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).contains_key(4);
assert_that!(subject).contains_key(8);

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

let subject: BTreeMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).contains_key(4);
assert_that!(subject).contains_key(5);

fn does_not_contain_key(self, expected_key: E) -> Self

Verify that the actual map does not contain any mapping for the given key.

Examples

use asserting::prelude::*;
use std::collections::HashMap;

let subject: HashMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).does_not_contain_key(2);
assert_that!(subject).does_not_contain_key(3);

use asserting::prelude::*;
use hashbrown::HashMap;

let subject: HashMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).does_not_contain_key(6);
assert_that!(subject).does_not_contain_key(7);

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

let subject: BTreeMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).does_not_contain_key(3);
assert_that!(subject).does_not_contain_key(9);

fn contains_keys(self, expected_keys: impl IntoIterator<Item = E>) -> Self

Verify that the actual map contains a mapping for each of the given keys.

The order of the keys is not relevant and duplicates are ignored.

Examples

use asserting::prelude::*;
use std::collections::HashMap;

let subject: HashMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).contains_keys([4, 5]);
assert_that!(&subject).contains_keys([8, 1, 5]);
assert_that!(&subject).contains_keys([8, 1, 1]);

use asserting::prelude::*;
use hashbrown::HashMap;

let subject: HashMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).contains_keys([1, 5]);
assert_that!(&subject).contains_keys([8, 1, 4]);
assert_that!(&subject).contains_keys([8, 4, 4]);

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

let subject: BTreeMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).contains_keys([1, 4, 5, 8]);
assert_that!(&subject).contains_keys([5, 4, 8]);
assert_that!(&subject).contains_keys([5, 5, 8]);

fn does_not_contain_keys( self, expected_keys: impl IntoIterator<Item = E>, ) -> Self

Verify that the actual map does not contain any mapping for one of the given keys.

The order of the keys is not relevant and duplicates are ignored.

Examples

use asserting::prelude::*;
use std::collections::HashMap;

let subject: HashMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).does_not_contain_keys([2, 3]);
assert_that!(&subject).does_not_contain_keys([6, 3, 7]);
assert_that!(&subject).does_not_contain_keys([3, 6, 3]);

use asserting::prelude::*;
use hashbrown::HashMap;

let subject: HashMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).does_not_contain_keys([6, 7]);
assert_that!(&subject).does_not_contain_keys([3, 2, 6]);
assert_that!(&subject).does_not_contain_keys([7, 2, 7]);

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

let subject: BTreeMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).does_not_contain_keys([2, 3, 6, 7]);
assert_that!(&subject).does_not_contain_keys([7, 3, 6]);
assert_that!(&subject).does_not_contain_keys([2, 2, 9]);

fn contains_exactly_keys( self, expected_keys: impl IntoIterator<Item = E>, ) -> Self

Verifies that the actual map contains a mapping for each of the expected keys but no more.

The order of the keys is not relevant and duplicates are ignored.

Examples

use asserting::prelude::*;
use std::collections::HashMap;

let subject: HashMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).contains_exactly_keys([4, 1, 5, 8]);
assert_that!(&subject).contains_exactly_keys([1, 4, 5, 8]);
assert_that!(&subject).contains_exactly_keys([1, 4, 5, 8, 8]);

use asserting::prelude::*;
use hashbrown::HashMap;

let subject: HashMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).contains_exactly_keys([4, 1, 5, 8]);
assert_that!(&subject).contains_exactly_keys([1, 4, 5, 8]);
assert_that!(&subject).contains_exactly_keys([1, 1, 4, 5, 8]);

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

let subject: BTreeMap<_, _> = [(4, "four"), (1, "one"), (5, "five"), (8, "eight")].into();

assert_that!(&subject).contains_exactly_keys([1, 4, 5, 8]);
assert_that!(&subject).contains_exactly_keys([5, 4, 1, 8]);
assert_that!(&subject).contains_exactly_keys([5, 4, 4, 1, 8]);

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, E, R> AssertMapContainsKey<E> for Spec<'_, S, R>

where S: MapProperties + Debug, <S as MapProperties>::Key: PartialEq<E> + Debug, <S as MapProperties>::Value: Debug, E: Debug, R: FailingStrategy,