Mockall

https://docs.rs/mockall/0.13.1/mockall/
Admin
Mockall is a powerful mock object library for Rust that provides tools to create mock versions of...
Tokens:17,907
Snippets:209
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Getting Started with Mockall

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Demonstrates defining a trait with #[automock], creating a mock instance, and setting an expectation with a predicate.

```rust
use mockall::*;
use mockall::predicate::*;
#[automock]
trait MyTrait {
    fn foo(&self, x: u32) -> u32;
}

fn call_with_four(x: &dyn MyTrait) -> u32 {
    x.foo(4)
}

let mut mock = MockMyTrait::new();
mock.expect_foo()
    .with(predicate::eq(4))
    .times(1)
    .returning(|x| x + 1);
assert_eq!(5, call_with_four(&mock));
```

--------------------------------

### Using starts_with predicate

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/str/fn.starts_with.html

Demonstrates creating a predicate to check if a string starts with a specific prefix.

```rust
use predicates::prelude::*;

let predicate_fn = predicate::str::starts_with("Hello");
assert_eq!(true, predicate_fn.eval("Hello World"));
assert_eq!(false, predicate_fn.eval("Goodbye World"));
```

--------------------------------

### predicate::str::starts_with

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/str/fn.starts_with.html

Creates a new Predicate that ensures a str starts with the provided pattern.

```APIDOC
## Function: starts_with

### Description
Creates a new `Predicate` that ensures a `str` starts with the specified `pattern`.

### Signature
`pub fn starts_with<P>(pattern: P) -> StartsWithPredicate where P: Into<String>`

### Parameters
- **pattern** (P: Into<String>) - The pattern to check for at the start of the string.

### Example
```rust
use predicates::prelude::*;

let predicate_fn = predicate::str::starts_with("Hello");
assert_eq!(true, predicate_fn.eval("Hello World"));
assert_eq!(false, predicate_fn.eval("Goodbye World"));
```
```

--------------------------------

### Setting Static Return Values

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Shows how to use return_const and returning to define return values for mocked methods.

```rust
#[automock]
trait MyTrait {
    fn foo(&self) -> u32;
    fn bar(&self, x: u32, y: u32) -> u32;
}

let mut mock = MockMyTrait::new();
mock.expect_foo()
    .return_const(42u32);
mock.expect_bar()
    .returning(|x, y| x + y);
```

--------------------------------

### Using eq_file to validate file paths

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/path/fn.eq_file.html

Demonstrates creating a predicate to verify if a path matches a specific file and evaluating it against different inputs.

```rust
use std::path::Path;
use predicates::prelude::*;

let predicate_file = predicate::path::eq_file(Path::new("Cargo.toml"));
assert_eq!(true, predicate_file.eval(Path::new("Cargo.toml")));
assert_eq!(false, predicate_file.eval(Path::new("src")));
assert_eq!(false, predicate_file.eval(Path::new("src")));
```

--------------------------------

### Using is_empty predicate

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/str/fn.is_empty.html

Demonstrates creating an is_empty predicate and evaluating it against empty and non-empty strings.

```rust
use predicates::prelude::*;

let predicate_fn = predicate::str::is_empty();
assert_eq!(true, predicate_fn.eval(""));
assert_eq!(false, predicate_fn.eval("Food World"));
```

--------------------------------

### Using from_file_path

Source: https://docs.rs/mockall/0.13.1/mockall/trait.PredicateFileContentExt.html

Demonstrates adapting a string predicate to evaluate file contents using from_file_path.

```rust
use predicates::prelude::*;
use std::path::Path;

let predicate_fn = predicate::str::is_empty().not().from_utf8().from_file_path();
assert_eq!(true, predicate_fn.eval(Path::new("./tests/hello_world")));
assert_eq!(false, predicate_fn.eval(Path::new("./tests/empty_file")));
```

--------------------------------

### Create and use a less-than-or-equal-to predicate

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/fn.le.html

Demonstrates initializing the predicate with a value and evaluating it against various inputs.

```rust
use predicates::prelude::*;

let predicate_fn = predicate::le(5);
assert_eq!(true, predicate_fn.eval(&4));
assert_eq!(true, predicate_fn.eval(&5));
assert_eq!(false, predicate_fn.eval(&6));
```

--------------------------------

### Using is_file predicate

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/path/fn.is_file.html

Demonstrates how to use the is_file predicate to verify if a path points to a file.

```rust
use std::path::Path;
use predicates::prelude::*;

let predicate_fn = predicate::path::is_file();
assert_eq!(true, predicate_fn.eval(Path::new("Cargo.toml")));
assert_eq!(false, predicate_fn.eval(Path::new("src")));
assert_eq!(false, predicate_fn.eval(Path::new("non-existent-file.foo")));
```

--------------------------------

### Mocking a trait

Source: https://docs.rs/mockall/0.13.1/mockall/macro.mock.html

Demonstrates the basic syntax for mocking a trait and a structure using the mock! macro.

```rust
trait Foo {
    fn foo(&self, x: u32);
}
mock!{
    pub MyStruct<T: Clone + 'static> {
        fn bar(&self) -> u8;
    }
    impl<T: Clone + 'static> Foo for MyStruct<T> {
        fn foo(&self, x: u32);
    }
}
```

--------------------------------

### Using the lt predicate

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/fn.lt.html

Demonstrates creating and evaluating lt predicates with integers and strings.

```rust
use predicates::prelude::*;

let predicate_fn = predicate::lt(5);
assert_eq!(true, predicate_fn.eval(&4));
assert_eq!(false, predicate_fn.eval(&6));

let predicate_fn = predicate::lt("b");
assert_eq!(true, predicate_fn.eval("a"));
assert_eq!(false, predicate_fn.eval("c"));

let predicate_fn = predicate::lt(String::from("b"));
assert_eq!(true, predicate_fn.eval("a"));
assert_eq!(false, predicate_fn.eval("c"));
```

--------------------------------

### Sequence::new

Source: https://docs.rs/mockall/0.13.1/mockall/struct.Sequence.html

Creates a new, empty Sequence instance to manage the order of mock expectations.

```APIDOC
## pub fn new() -> Self

### Description
Creates a new empty `Sequence` object. This object is used to group expectations that must be satisfied in a specific order.

### Signature
`pub fn new() -> Self`
```

--------------------------------

### pub fn checkpoint()

Source: https://docs.rs/mockall/0.13.1/mockall/examples/mock_my_module/fn.checkpoint.html

Verifies that all current expectations for every function in this module are satisfied and clears them.

```APIDOC
## Function: checkpoint

### Description
Verifies that all current expectations for every function in this module are satisfied and clears them.

### Signature
`pub fn checkpoint()`
```

--------------------------------

### Using is_symlink predicate

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/path/fn.is_symlink.html

Demonstrates how to create and evaluate a path predicate to check for symbolic links.

```rust
use std::path::Path;
use predicates::prelude::*;

let predicate_fn = predicate::path::is_symlink();
assert_eq!(false, predicate_fn.eval(Path::new("Cargo.toml")));
assert_eq!(false, predicate_fn.eval(Path::new("src")));
assert_eq!(false, predicate_fn.eval(Path::new("non-existent-file.foo")));
```

--------------------------------

### MockBoo::new

Source: https://docs.rs/mockall/0.13.1/mockall/examples/struct.MockBoo.html

Creates a new instance of the MockBoo mock object with no initial expectations.

```APIDOC
### pub fn new() -> Self

Creates a new mock object with no expectations.
```

--------------------------------

### Using the ge predicate

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/fn.ge.html

Demonstrates creating a greater-than-or-equal-to predicate and evaluating it against various integers.

```rust
use predicates::prelude::*;

let predicate = predicate::ge(5);
assert_eq!(false, predicate.eval(&4));
assert_eq!(true, predicate.eval(&5));
assert_eq!(true, predicate.eval(&6));
```

--------------------------------

### Using the always predicate

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/fn.always.html

Demonstrates creating an always predicate and evaluating it against various integer inputs.

```rust
use predicates::prelude::*;

let predicate_fn = predicate::always();
assert_eq!(true, predicate_fn.eval(&5));
assert_eq!(true, predicate_fn.eval(&10));
assert_eq!(true, predicate_fn.eval(&15));
// Won't work - Predicates can only operate on a single type
// assert_eq!(true, predicate_fn.eval("hello"))
```

--------------------------------

### Enforce call order with Sequence

Source: https://docs.rs/mockall/0.13.1/mockall/struct.Sequence.html

Demonstrates how to use Sequence to ensure that mock calls occur in a specific order. Each expectation must have a defined number of calls.

```rust
#[automock]
trait Foo {
    fn foo(&self);
    fn bar(&self) -> u32;
}
let mut seq = Sequence::new();

let mut mock0 = MockFoo::new();
let mut mock1 = MockFoo::new();

mock0.expect_foo()
    .times(1)
    .returning(|| ())
    .in_sequence(&mut seq);

mock1.expect_bar()
    .times(1)
    .returning(|| 42)
    .in_sequence(&mut seq);

mock0.foo();
mock1.bar();
```

--------------------------------

### Create a not-equal predicate

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/fn.ne.html

Demonstrates creating a predicate using predicate::ne and evaluating it against different values.

```rust
use predicates::prelude::*;

let predicate_fn = predicate::ne(5);
assert_eq!(false, predicate_fn.eval(&5));
assert_eq!(true, predicate_fn.eval(&10));
```

--------------------------------

### Using eq predicate with various types

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/fn.eq.html

Demonstrates creating equality predicates for integers, string literals, and owned strings.

```rust
use predicates::prelude::*;

let predicate_fn = predicate::eq(5);
assert_eq!(true, predicate_fn.eval(&5));
assert_eq!(false, predicate_fn.eval(&10));

let predicate_fn = predicate::eq("Hello");
assert_eq!(true, predicate_fn.eval("Hello"));
assert_eq!(false, predicate_fn.eval("Goodbye"));

let predicate_fn = predicate::eq(String::from("Hello"));
assert_eq!(true, predicate_fn.eval("Hello"));
assert_eq!(false, predicate_fn.eval("Goodbye"));
```

--------------------------------

### checkpoint()

Source: https://docs.rs/mockall/0.13.1/mockall/examples/mock_ffi/index.html

Verifies that all current expectations for every function in the module are satisfied and clears them.

```APIDOC
## checkpoint()

### Description
Verify that all current expectations for every function in this module are satisfied and clear them.
```

--------------------------------

### Matching arguments with predicates

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Use the `with` method to apply a `Predicate` to verify method arguments.

```rust
#[automock]
trait Foo {
    fn foo(&self, x: u32);
}

let mut mock = MockFoo::new();
mock.expect_foo()
    .with(eq(42))
    .return_const(());

mock.foo(0);    // Panics!
```

--------------------------------

### eq_file<P>(path: P) -> BinaryFilePredicate

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/path/fn.eq_file.html

Creates a new Predicate that ensures complete equality with the specified file path.

```APIDOC
## eq_file

### Description
Creates a new `Predicate` that ensures complete equality between the evaluated path and the provided target path.

### Signature
`pub fn eq_file<P>(path: P) -> BinaryFilePredicate where P: Into<PathBuf>`

### Parameters
- **path** (P: Into<PathBuf>) - The path to compare against.

### Example
```rust
use std::path::Path;
use predicates::prelude::*;

let predicate_file = predicate::path::eq_file(Path::new("Cargo.toml"));
assert_eq!(true, predicate_file.eval(Path::new("Cargo.toml")));
assert_eq!(false, predicate_file.eval(Path::new("src")));
```
```

--------------------------------

### ffi_func_context function signature

Source: https://docs.rs/mockall/0.13.1/mockall/examples/mock_ffi/fn.ffi_func_context.html

Displays the function signature for creating a mocking context.

```rust
pub fn ffi_func_context() -> Context
```

--------------------------------

### Create a Context for modfunc

Source: https://docs.rs/mockall/0.13.1/mockall/examples/mock_my_module/fn.modfunc_context.html

Initializes a Context object specifically for mocking the modfunc method.

```rust
pub fn modfunc_context() -> Context
```

--------------------------------

### predicate::path::is_file()

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/path/fn.is_file.html

Creates a new Predicate that ensures the path points to a file.

```APIDOC
## Function: is_file

### Description
Creates a new `Predicate` that ensures the path points to a file. This can be used to validate path inputs in tests.

### Signature
`pub fn is_file() -> FileTypePredicate`

### Example
```rust
use std::path::Path;
use predicates::prelude::*;

let predicate_fn = predicate::path::is_file();
assert_eq!(true, predicate_fn.eval(Path::new("Cargo.toml")));
assert_eq!(false, predicate_fn.eval(Path::new("src")));
assert_eq!(false, predicate_fn.eval(Path::new("non-existent-file.foo")));
```
```

--------------------------------

### expect

Source: https://docs.rs/mockall/0.13.1/mockall/examples/__mock_MockFoo_Foo/__bang/struct.Context.html

Creates a new expectation for the static method.

```APIDOC
## pub fn expect<'__mockall_lt>(&self) -> ExpectationGuard<'__mockall_lt>

### Description
Create a new expectation for this method.
```

--------------------------------

### Verify path non-existence with missing predicate

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/path/fn.missing.html

Use this predicate to assert that a file or directory path does not exist. Requires the predicates crate and std::path::Path.

```rust
use std::path::Path;
use predicates::prelude::*;

let predicate_fn = predicate::path::missing();
assert_eq!(true, predicate_fn.eval(Path::new("non-existent-file.foo")));
```

--------------------------------

### Using in_iter with various types

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/fn.in_iter.html

Demonstrates creating predicates for integers, string literals, and owned strings to check for membership in a collection.

```rust
use predicates::prelude::*;

let predicate_fn = predicate::in_iter(vec![1, 3, 5]);
assert_eq!(true, predicate_fn.eval(&1));
assert_eq!(false, predicate_fn.eval(&2));
assert_eq!(true, predicate_fn.eval(&3));

let predicate_fn = predicate::in_iter(vec!["a", "c", "e"]);
assert_eq!(true, predicate_fn.eval("a"));
assert_eq!(false, predicate_fn.eval("b"));
assert_eq!(true, predicate_fn.eval("c"));

let predicate_fn = predicate::in_iter(vec![String::from("a"), String::from("c"), String::from("e")]);
assert_eq!(true, predicate_fn.eval("a"));
assert_eq!(false, predicate_fn.eval("b"));
assert_eq!(true, predicate_fn.eval("c"));
```

--------------------------------

### checkpoint

Source: https://docs.rs/mockall/0.13.1/mockall/examples/__mock_MockFoo_Foo/__bang/struct.Context.html

Verifies that all current expectations for the static method are satisfied and clears them.

```APIDOC
## pub fn checkpoint(&self)

### Description
Verify that all current expectations for this method are satisfied and clear them.
```

--------------------------------

### Mock a module of functions

Source: https://docs.rs/mockall/0.13.1/mockall/attr.automock.html

Apply #[automock] to a module to generate a mock module with the 'mock_' prefix.

```rust
#[automock]
mod mymod {
    pub fn foo() -> u32 {
       // ...
    }
}
```

--------------------------------

### Boxing a Predicate

Source: https://docs.rs/mockall/0.13.1/mockall/trait.PredicateBoxExt.html

Demonstrates how to use the boxed method to store different predicate types in a single vector.

```rust
use predicates::prelude::*;

let predicates = vec![
    predicate::always().boxed(),
    predicate::never().boxed(),
];
assert_eq!(true, predicates[0].eval(&4));
assert_eq!(false, predicates[1].eval(&4));
```

--------------------------------

### Verify path existence with predicate

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/path/fn.exists.html

Creates a predicate to check if a path exists and evaluates it against a target path.

```rust
use std::path::Path;
use predicates::prelude::*;

let predicate_fn = predicate::path::exists();
assert_eq!(true, predicate_fn.eval(Path::new("Cargo.toml")));
```

--------------------------------

### fn from_file_path(self) -> FileContentPredicate<Self>

Source: https://docs.rs/mockall/0.13.1/mockall/trait.PredicateFileContentExt.html

Adapts a predicate that operates on byte slices to operate on file paths. This method returns a FileContentPredicate that reads the file at the provided path and evaluates the underlying predicate against its content.

```APIDOC
## fn from_file_path(self) -> FileContentPredicate<Self>

### Description
Adapts a `Predicate<[u8]>` to a `Predicate<Path>`. This allows existing byte-slice predicates to be used for validating file contents.

### Example
```rust
use predicates::prelude::*;
use std::path::Path;

let predicate_fn = predicate::str::is_empty().not().from_utf8().from_file_path();
assert_eq!(true, predicate_fn.eval(Path::new("./tests/hello_world")));
assert_eq!(false, predicate_fn.eval(Path::new("./tests/empty_file")));
```
```

--------------------------------

### Using the gt predicate

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/fn.gt.html

Demonstrates creating a predicate to check if a value is greater than 5.

```rust
use predicates::prelude::*;

let predicate_fn = predicate::gt(5);
assert_eq!(false, predicate_fn.eval(&4));
assert_eq!(false, predicate_fn.eval(&5));
assert_eq!(true, predicate_fn.eval(&6));
```

--------------------------------

### Mocking modules with automock

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Mockall can derive mocks for entire modules, allowing selective import via the double attribute.

```rust
mod outer {
    use mockall::automock;
    #[automock()]
    pub(super) mod inner {
        pub fn bar(x: u32) -> i64 {
            // ...
        }
    }
}

#[double]
use outer::inner;

#[cfg(test)]
mod t {
    use super::*;

    #[test]
    fn test_foo_bar() {
        let ctx = inner::bar_context();
        ctx.expect()
            .returning(|x| i64::from(x + 1));
        assert_eq!(5, inner::bar(4));
    }
}
```

--------------------------------

### Using in_hash with various types

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/fn.in_hash.html

Demonstrates using in_hash with integers, string literals, and owned String objects. Requires items to implement Hash, Eq, and Debug traits.

```rust
use predicates::prelude::*;

let predicate_fn = predicate::in_hash(vec![1, 3, 5]);
assert_eq!(true, predicate_fn.eval(&1));
assert_eq!(false, predicate_fn.eval(&2));
assert_eq!(true, predicate_fn.eval(&3));

let predicate_fn = predicate::in_hash(vec!["a", "c", "e"]);
assert_eq!(true, predicate_fn.eval("a"));
assert_eq!(false, predicate_fn.eval("b"));
assert_eq!(true, predicate_fn.eval("c"));

let predicate_fn = predicate::in_hash(vec![String::from("a"), String::from("c"), String::from("e")]);
assert_eq!(true, predicate_fn.eval("a"));
assert_eq!(false, predicate_fn.eval("b"));
assert_eq!(true, predicate_fn.eval("c"));
```

--------------------------------

### ffi_func_context()

Source: https://docs.rs/mockall/0.13.1/mockall/examples/mock_ffi/index.html

Creates a Context object used for mocking the ffi_func method.

```APIDOC
## ffi_func_context()

### Description
Create a `Context` for mocking the `ffi_func` method.
```

--------------------------------

### modfunc_context()

Source: https://docs.rs/mockall/0.13.1/mockall/examples/mock_my_module/index.html

Creates a context for mocking the modfunc method.

```APIDOC
## modfunc_context()

### Description
Create a `Context` for mocking the `modfunc` method.
```

--------------------------------

### Mocking Constructors

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Set expectations on a constructor method to return a configured mock object instance.

```rust
struct Foo{}
#[automock]
impl Foo {
    fn from_i32(x: i32) -> Self {
        // ...
    }
    fn foo(&self) -> i32 {
        // ...
    }
}

let ctx = MockFoo::from_i32_context();
ctx.expect()
    .returning(|x| {
        let mut mock = MockFoo::default();
        mock.expect_foo()
            .return_const(x);
        mock
    });
let foo = MockFoo::from_i32(42);
assert_eq!(42, foo.foo());
```

--------------------------------

### mock!

Source: https://docs.rs/mockall/0.13.1/mockall/macro.mock.html

The mock! macro is used to manually define a mock structure. It accepts a visibility specifier, the structure name with generics, a block of method signatures, and optional trait implementation blocks.

```APIDOC
## mock!

### Description
Manually mock a structure or trait when `automock` cannot be used. The macro requires the definition of the structure and its methods (without bodies) and any trait implementations (without bodies).

### Syntax
```rust
mock!{
    [visibility] [StructName]<[Generics]> {
        [method_signatures...]
    }
    [impl Trait for StructName {
        [method_signatures...]
    }]
}
```

### Usage Example
```rust
mock!{
    pub MyStruct<T: Clone + 'static> {
        fn bar(&self) -> u8;
    }
    impl<T: Clone + 'static> Foo for MyStruct<T> {
        fn foo(&self, x: u32);
    }
}
```
```

--------------------------------

### Mocking generic structures and traits

Source: https://docs.rs/mockall/0.13.1/mockall/macro.mock.html

Illustrates the requirement to use consistent generic parameter names when mocking generic structures implementing generic traits.

```rust
mock!{
    pub Rc<T> {}
    impl<T> AsRef<T> for Rc<T> {
        fn as_ref(&self) -> &T;
    }
}
```

```rust
mock!{
    pub Rc<Q> {}
    impl<T> AsRef<T> for Rc<T> {
        fn as_ref(&self) -> &T;
    }
}
```

--------------------------------

### Using multiple expectations for specificity

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Define specific expectations first, followed by a general fallback expectation.

```rust
#[automock]
trait Foo {
    fn open(&self, path: String) -> Option<u32>;
}

let mut mock = MockFoo::new();
mock.expect_open()
    .with(eq(String::from("something.txt")))
    .returning(|_| Some(5));
mock.expect_open()
    .return_const(None);
```

--------------------------------

### ExpectationGuard Definition

Source: https://docs.rs/mockall/0.13.1/mockall/examples/__mock_MockFoo_Foo/__bang/struct.ExpectationGuard.html

The structure definition for ExpectationGuard.

```rust
pub struct ExpectationGuard<'__mockall_lt> { /* private fields */ }
```

--------------------------------

### Mocking Static Methods

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Static methods require a Context object to set expectations, as they lack a mock instance. Note that these expectations are global and require manual synchronization if used across multiple tests.

```rust
#[automock]
pub trait A {
    fn foo() -> u32;
}

let ctx = MockA::foo_context();
ctx.expect().returning(|| 99);
assert_eq!(99, MockA::foo());
```

--------------------------------

### Adapt predicate for UTF-8 input

Source: https://docs.rs/mockall/0.13.1/mockall/trait.PredicateStrExt.html

Use the from_utf8 method to adapt a string predicate to evaluate byte slices or OsStr inputs.

```rust
use predicates::prelude::*;
use std::ffi::OsStr;

let predicate_fn = predicate::str::is_empty().not().from_utf8();
assert_eq!(true, predicate_fn.eval(OsStr::new("Hello")));
assert_eq!(false, predicate_fn.eval(OsStr::new("")));
let variable: &[u8] = b"";
assert_eq!(false, predicate_fn.eval(variable));
```

--------------------------------

### Using predicate::str::contains

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/str/fn.contains.html

Demonstrates creating a predicate to verify if a string contains a specific substring.

```rust
use predicates::prelude::*;\n\nlet predicate_fn = predicate::str::contains("Two");\nassert_eq!(true, predicate_fn.eval("One Two Three"));\nassert_eq!(false, predicate_fn.eval("Four Five Six"));
```

--------------------------------

### Mocking Generic Methods with Static Parameters

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Mock methods with 'static type parameters using turbofish syntax for expectations.

```rust
#[automock]
trait Foo {
    fn foo<T: 'static>(&self, t: T) -> i32;
}

let mut mock = MockFoo::new();
mock.expect_foo::<i16>()
    .returning(|t| i32::from(t));
mock.expect_foo::<i8>()
    .returning(|t| -i32::from(t));

assert_eq!(5, mock.foo(5i16));
assert_eq!(-5, mock.foo(5i8));
```

--------------------------------

### #[automock]

Source: https://docs.rs/mockall/0.13.1/mockall/attr.automock.html

The #[automock] attribute macro is applied to traits, structs, modules, or FFI blocks to generate corresponding mock types. It automatically creates a mock struct (e.g., 'MockFoo') with 'expect_...' methods for setting expectations and a 'checkpoint' method.

```APIDOC
## #[automock]

### Description
Automatically generates mock types for traits, structs, modules, and foreign functions. The generated mock type is named by prepending 'Mock' to the original name (or 'mock_' for modules).

### Usage
Apply the attribute directly to the item definition:

```rust
#[automock]
pub trait Foo {
    fn foo(&self, key: i16);
}

// Usage
let mock = MockFoo::new();
```

### Advanced Configuration
For traits with associated types, provide the type mapping within the attribute:

```rust
#[automock(type Item=u32;)]
trait Foo {
    type Item;
    fn foo(&self) -> Self::Item;
}
```

### Limitations
- Does not support structs with multiple `impl` blocks.
- Does not support structs or traits defined in external crates.
- Does not support traits with trait bounds.
- Cannot customize the generated mock struct name.
```

--------------------------------

### Use context checkpoints for static methods

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

The context object manages expectations for static methods and can be used to trigger panics if expectations are not met.

```rust
#[automock]
pub trait A {
    fn foo() -> u32;
}

let ctx = MockA::foo_context();
ctx.expect()
    .times(1)
    .returning(|| 99);
ctx.checkpoint();   // Panics!
```

--------------------------------

### Mocking with derive attributes

Source: https://docs.rs/mockall/0.13.1/mockall/macro.mock.html

Shows how to mock a structure that requires a derived trait like Clone.

```rust
#[derive(Clone)]
struct MyStruct;

mock!{
    pub MyStruct {
        fn bar(&self);
    }
    impl Clone for MyStruct {
        fn clone(&self) -> Self;
    }
}
```

--------------------------------

### Predicate Factory Functions

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/index.html

A collection of functions to create predicates for mock expectations.

```APIDOC
## Functions

- **always()**: Creates a new `Predicate` that always returns `true`.
- **never()**: Creates a new `Predicate` that always returns `false`.
- **eq(variable)**: Creates a new predicate that returns `true` when the given `variable` is equal to a pre-defined value.
- **ne(variable)**: Creates a new predicate that returns `true` when the given `variable` is not equal to a pre-defined value.
- **gt(variable)**: Creates a new predicate that returns `true` when the given `variable` is greater than a pre-defined value.
- **ge(variable)**: Creates a new predicate that returns `true` when the given `variable` is greater than or equal to a pre-defined value.
- **lt(variable)**: Creates a new predicate that returns `true` when the given `variable` is less than a pre-defined value.
- **le(variable)**: Creates a new predicate that returns `true` when the given `variable` is less than or equal to a pre-defined value.
- **in_hash(items)**: Creates a new predicate that returns `true` when the given `variable` is contained within the provided set of items.
- **in_iter(items)**: Creates a new predicate that returns `true` when the given `variable` is contained within the provided set of items.
- **function(f)**: Creates a new predicate that wraps over the given function.
```

--------------------------------

### predicate::path::exists()

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/path/fn.exists.html

Creates a new Predicate that ensures the path exists.

```APIDOC
## Function: exists

### Description
Creates a new `Predicate` that ensures the path exists.

### Signature
`pub fn exists() -> ExistencePredicate`

### Example
```rust
use std::path::Path;
use predicates::prelude::*;

let predicate_fn = predicate::path::exists();
assert_eq!(true, predicate_fn.eval(Path::new("Cargo.toml")));
```
```

--------------------------------

### is_dir()

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/path/fn.is_dir.html

Creates a new Predicate that ensures the path points to a directory.

```APIDOC
## Function: is_dir()

### Description
Creates a new `Predicate` that ensures the path points to a directory. This is used to validate path-based inputs in mock objects.

### Signature
`pub fn is_dir() -> FileTypePredicate`

### Usage Example
```rust
use std::path::Path;
use predicates::prelude::*;

let predicate_fn = predicate::path::is_dir();
assert_eq!(false, predicate_fn.eval(Path::new("Cargo.toml")));
assert_eq!(true, predicate_fn.eval(Path::new("src")));
```
```

--------------------------------

### Using predicate::never

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/fn.never.html

Demonstrates creating a predicate that always evaluates to false regardless of the input value.

```rust
use predicates::prelude::*;\n\nlet predicate_fn = predicate::never();\nassert_eq!(false, predicate_fn.eval(&5));\nassert_eq!(false, predicate_fn.eval(&10));\nassert_eq!(false, predicate_fn.eval(&15));\n// Won't work - Predicates can only operate on a single type\n// assert_eq!(false, predicate_fn.eval("hello"))
```

--------------------------------

### Define MockFoo struct

Source: https://docs.rs/mockall/0.13.1/mockall/examples/struct.MockFoo.html

The structure definition for the generated mock object.

```rust
pub struct MockFoo { /* private fields */ }
```

--------------------------------

### MockBoo Struct Definition

Source: https://docs.rs/mockall/0.13.1/mockall/examples/struct.MockBoo.html

The definition of the MockBoo struct as generated by the mockall framework.

```rust
pub struct MockBoo { /* private fields */ }
```

--------------------------------

### Using nightly feature for default return values

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

When the nightly feature is enabled, methods returning types that implement Default do not require explicit return values.

```rust
#[automock]
trait Foo {
    fn foo(&self) -> Vec<u32>;
}

let mut mock = MockFoo::new();
mock.expect_foo();
assert!(mock.foo().is_empty());
```

--------------------------------

### Mocking Structs with mockall_double

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Use the mockall_double crate to handle namespace issues when mocking structs with a single impl block.

```rust
use mockall_double::double;
mod thing {
    use mockall::automock;
    pub struct Thing{}
    #[automock]
    impl Thing {
        pub fn foo(&self) -> u32 {
            // ...
        }
    }
}

#[double]
use thing::Thing;

fn do_stuff(thing: &Thing) -> u32 {
    thing.foo()
}

#[cfg(test)]
mod t {
    use super::*;

    #[test]
    fn test_foo() {
        let mut mock = Thing::default();
        mock.expect_foo().returning(|| 42);
        do_stuff(&mock);
    }
}
```

--------------------------------

### modfunc

Source: https://docs.rs/mockall/0.13.1/mockall/examples/my_module/index.html

A function available within the mocked module.

```APIDOC
## modfunc

### Description
A function in a mocked module.

### Signature
`pub fn modfunc()`
```

--------------------------------

### fn from_utf8(self) -> Utf8Predicate<Self>

Source: https://docs.rs/mockall/0.13.1/mockall/trait.PredicateStrExt.html

Returns a Utf8Predicate that adapts the current string predicate to function as a [u8] predicate.

```APIDOC
## fn from_utf8(self) -> Utf8Predicate<Self>

### Description
Returns a Utf8Predicate that adapts the current string predicate to function as a [u8] predicate.

### Example
```rust
use predicates::prelude::*;
use std::ffi::OsStr;

let predicate_fn = predicate::str::is_empty().not().from_utf8();
assert_eq!(true, predicate_fn.eval(OsStr::new("Hello")));
assert_eq!(false, predicate_fn.eval(OsStr::new("")));
let variable: &[u8] = b"";
assert_eq!(false, predicate_fn.eval(variable));
```
```

--------------------------------

### Mocking async traits

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Mockall supports async traits via the async_trait crate, provided the automock attribute precedes the async_trait attribute.

```rust
// async_trait works with both #[automock]
#[automock]
#[async_trait]
pub trait Foo {
   async fn foo(&self) -> u32;
}
// and mock!
mock! {
    pub Bar {}
    #[async_trait]
    impl Foo for Bar {
        async fn foo(&self) -> u32;
    }
}
```

--------------------------------

### Using checkpoints to validate and reset expectations

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Checkpoints validate current expectations and clear them, allowing for new expectations to be set.

```rust
#[automock]
trait Foo {
    fn foo(&self);
}

let mut mock = MockFoo::new();
mock.expect_foo()
    .times(2)
    .returning(|| ());

mock.foo();
mock.checkpoint();  // Panics!  foo hasn't yet been called twice.
```

```rust
#[automock]
trait Foo {
    fn foo(&self);
}

let mut mock = MockFoo::new();
mock.expect_foo()
    .times(1)
    .returning(|| ());

mock.foo();
mock.checkpoint();
mock.foo();         // Panics!  The expectation has been cleared.
```

--------------------------------

### Mock foreign functions

Source: https://docs.rs/mockall/0.13.1/mockall/attr.automock.html

Apply #[automock] to an extern block within a module to mock FFI functions.

```rust
#[automock]
mod ffi {
    extern "C" {
        pub fn foo() -> u32;
    }
}
```

--------------------------------

### Mocking impl Future

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Use Box::pin when mocking methods that return impl Future.

```rust
struct Foo {}
#[automock]
impl Foo {
    fn foo(&self) -> impl Future<Output=i32> {
        // ...
    }
}

let mut mock = MockFoo::new();
mock.expect_foo()
    .returning(|| Box::pin(future::ready(42)));
```

--------------------------------

### Mock a struct

Source: https://docs.rs/mockall/0.13.1/mockall/attr.automock.html

Apply #[automock] to an impl block to mock a struct.

```rust
struct Foo {}
#[automock]
impl Foo {
    fn foo(&self) -> u32 {
        // ...
    }
}
```

--------------------------------

### Mock a simple trait

Source: https://docs.rs/mockall/0.13.1/mockall/attr.automock.html

Use #[automock] on a trait to generate a mock struct with the prefix 'Mock'.

```rust
#[automock]
pub trait Foo {
    fn foo(&self, key: i16);
}

let mock = MockFoo::new();
```

--------------------------------

### Expectation Methods

Source: https://docs.rs/mockall/0.13.1/mockall/examples/__mock_MockFoo_Foo/__foo/struct.Expectation.html

Methods available on the Expectation struct to configure mock behavior.

```APIDOC
## return_const

### Description
Return a constant value from the Expectation. The output type must be Clone.

### Signature
pub fn return_const<MockallOutput>(&mut self, __mockall_c: MockallOutput) -> &mut Self

## return_once

### Description
Supply an FnOnce closure that will provide the return value for this Expectation. Useful for return types that aren't Clone.

### Signature
pub fn return_once<MockallF>(&mut self, __mockall_f: MockallF) -> &mut Self

## returning

### Description
Supply a closure that will provide the return value for this Expectation. The method's arguments are passed to the closure by value.

### Signature
pub fn returning<MockallF>(&mut self, __mockall_f: MockallF) -> &mut Self

## times

### Description
Restrict the number of times that this method may be called using fixed numbers or ranges.

### Signature
pub fn times<MockallR>(&mut self, __mockall_r: MockallR) -> &mut Self

## with

### Description
Set matching criteria for this Expectation using predicates.

### Signature
pub fn with<MockallMatcher0, MockallMatcher1>(&mut self, x: MockallMatcher0, y: MockallMatcher1) -> &mut Self
```

--------------------------------

### checkpoint function signature

Source: https://docs.rs/mockall/0.13.1/mockall/examples/mock_ffi/fn.checkpoint.html

The function signature for checkpoint as defined in the mock_ffi module.

```rust
pub fn checkpoint()
```

--------------------------------

### Validate directory path with is_dir

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/path/fn.is_dir.html

Demonstrates using is_dir to verify if a path is a directory, returning false for files and non-existent paths.

```rust
use std::path::Path;
use predicates::prelude::*;

let predicate_fn = predicate::path::is_dir();
assert_eq!(false, predicate_fn.eval(Path::new("Cargo.toml")));
assert_eq!(true, predicate_fn.eval(Path::new("src")));
assert_eq!(false, predicate_fn.eval(Path::new("non-existent-file.foo")));
```

--------------------------------

### Matching arguments with withf

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Use `withf` as a shorthand for function-based predicates, where arguments are passed by reference.

```rust
#[automock]
trait Foo {
    fn foo(&self, x: u32, y: u32);
}

let mut mock = MockFoo::new();
mock.expect_foo()
    .withf(|x: &u32, y: &u32| x == y)
    .return_const(());

mock.foo(2 + 2, 5);    // Panics!
```

--------------------------------

### Trim string predicate input

Source: https://docs.rs/mockall/0.13.1/mockall/trait.PredicateStrExt.html

Use the trim method to ensure the input string is trimmed before evaluation by the predicate.

```rust
use predicates::prelude::*;

let predicate_fn = predicate::str::is_empty().trim();
assert_eq!(true, predicate_fn.eval("    "));
assert_eq!(false, predicate_fn.eval("    Hello    "));
```

--------------------------------

### Mocking Multiple and Inherited Traits

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Use the mock! macro to define a struct that implements multiple traits simultaneously.

```rust
pub trait A {
    fn foo(&self);
}

pub trait B: A {
    fn bar(&self);
}

mock! {
    // Structure to mock
    C {}
    // First trait to implement on C
    impl A for C {
        fn foo(&self);
    }
    // Second trait to implement on C
    impl B for C {
        fn bar(&self);
    }
}
let mut mock = MockC::new();
mock.expect_foo().returning(|| ());
mock.expect_bar().returning(|| ());
mock.foo();
mock.bar();
```

--------------------------------

### Mocking associated types

Source: https://docs.rs/mockall/0.13.1/mockall/macro.mock.html

Shows how to mock associated types by providing a concrete type within the mock! invocation.

```rust
mock!{
    MyIter {}
    impl Iterator for MyIter {
        type Item=u32;

        fn next(&mut self) -> Option<<Self as Iterator>::Item>;
    }
}
```

--------------------------------

### Matching multiple calls with FIFO order

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Expectations are evaluated in FIFO order; the first matching expectation is used.

```rust
#[automock]
trait Foo {
    fn foo(&self, x: u32) -> u32;
}

let mut mock = MockFoo::new();
mock.expect_foo()
    .with(eq(5))
    .return_const(50u32);
mock.expect_foo()
    .with(eq(6))
    .return_const(60u32);
```

--------------------------------

### Mocking static reference return values

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Use return_const to return a static reference from a mock method.

```rust
struct Thing(u32);

#[automock]
trait Container {
    fn get(&self, i: u32) -> &'static Thing;
}

const THING: Thing = Thing(42);
let mut mock = MockContainer::new();
mock.expect_get()
    .return_const(&THING);

assert_eq!(42, mock.get(0).0);
```

--------------------------------

### Mocking methods with reference arguments

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

When mocking methods with reference arguments, predicates receive the arguments by value.

```rust
#[automock]
trait Foo {
    fn foo(&self, x: &u32) -> u32;
}

let mut mock = MockFoo::new();
let e = mock.expect_foo()
    // Note that x is a &u32, not a &&u32
    .withf(|x: &u32| *x == 5)
    .returning(|x: &u32| *x + 1);

assert_eq!(6, mock.foo(&5));
```

--------------------------------

### predicate::str::is_empty()

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/str/fn.is_empty.html

Creates a new Predicate that ensures a str is empty.

```APIDOC
## predicate::str::is_empty

### Description
Creates a new `Predicate` that ensures a str is empty.

### Signature
`pub fn is_empty() -> IsEmptyPredicate`

### Usage Example
```rust
use predicates::prelude::*;

let predicate_fn = predicate::str::is_empty();
assert_eq!(true, predicate_fn.eval(""));
assert_eq!(false, predicate_fn.eval("Food World"));
```
```

--------------------------------

### is_symlink()

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/path/fn.is_symlink.html

Creates a new Predicate that ensures the path points to a symlink.

```APIDOC
## Function: is_symlink

### Description
Creates a new `Predicate` that ensures the path points to a symlink.

### Signature
`pub fn is_symlink() -> FileTypePredicate`

### Usage Example
```rust
use std::path::Path;
use predicates::prelude::*;

let predicate_fn = predicate::path::is_symlink();
assert_eq!(false, predicate_fn.eval(Path::new("Cargo.toml")));
assert_eq!(false, predicate_fn.eval(Path::new("src")));
assert_eq!(false, predicate_fn.eval(Path::new("non-existent-file.foo")));
```
```

--------------------------------

### pub fn never() -> BooleanPredicate

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/fn.never.html

Creates a new Predicate that always returns false.

```APIDOC
## Function: never

### Description
Creates a new `Predicate` that always returns `false`.

### Signature
`pub fn never() -> BooleanPredicate`

### Example
```rust
use predicates::prelude::*;

let predicate_fn = predicate::never();
assert_eq!(false, predicate_fn.eval(&5));
assert_eq!(false, predicate_fn.eval(&10));
assert_eq!(false, predicate_fn.eval(&15));
```
```

--------------------------------

### Returning Non-Clone Values with Side Effects

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Demonstrates using return_once with a closure to perform side effects while returning a non-Clone value.

```rust
fn do_something() {}

struct NonClone();

#[automock]
trait Foo {
    fn foo(&self) -> NonClone;
}

let mut mock = MockFoo::new();
let r = NonClone{};
mock.expect_foo()
    .return_once(move || {
        do_something();
        r
    });
```

--------------------------------

### #[concretize]

Source: https://docs.rs/mockall/0.13.1/mockall/attr.concretize.html

An attribute macro used to decorate methods or functions with generic arguments, enabling them to be mocked by treating generic parameters as trait objects.

```APIDOC
## #[concretize]

### Description
Decorates a method or function to tell Mockall to treat its generic arguments as trait objects when creating expectations. This allows users to use non-'static generic parameters.

### Usage
Apply the attribute to a method within an `#[automock]` trait:

```rust
#[automock]
trait Foo {
    #[mockall::concretize]
    fn foo<P: AsRef<Path>>(&self, p: P);
}
```

### Limitations
- Generic methods will share expectations for all argument types.
- Cannot be used on methods with a closure argument.
- Expectations must be matched with `.withf` or `.withf_st`, not `.with`.
- Only works for parameters that can be turned into a trait object (e.g., T, &T, &mut T, &[T]).
```

--------------------------------

### Perform logical AND with PredicateBooleanExt

Source: https://docs.rs/mockall/0.13.1/mockall/trait.PredicateBooleanExt.html

Combines two predicates using the and method to return true only if both evaluate to true.

```rust
use predicates::prelude::*;

let predicate_fn1 = predicate::always().and(predicate::always());
let predicate_fn2 = predicate::always().and(predicate::never());
assert_eq!(true, predicate_fn1.eval(&4));
assert_eq!(false, predicate_fn2.eval(&4));
```

--------------------------------

### Setting call count constraints

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Use `times` to verify that an expectation is called a specific number of times.

```rust
#[automock]
trait Foo {
    fn foo(&self, x: u32);
}

let mut mock = MockFoo::new();
mock.expect_foo()
    .times(1)
    .return_const(());

mock.foo(0);    // Ok
mock.foo(1);    // Panics!
```

--------------------------------

### Importing concretize with a custom name

Source: https://docs.rs/mockall/0.13.1/mockall/attr.concretize.html

The attribute must be imported using its canonical name to function correctly.

```rust
use mockall::concretize as something_else;
#[mockall::automock]
trait Foo {
    #[something_else]
    fn foo<T>(&self, t: T);
}
```

--------------------------------

### Create a function predicate

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/fn.function.html

Wraps a closure into a predicate that can be evaluated against a type. The resulting predicate supports combinators like .and().

```rust
use predicates::prelude::*;

struct Example {
    string: String,
    number: i32,
}

let string_check = predicate::function(|x: &Example| x.string == "hello");
let number_check = predicate::function(|x: &Example| x.number == 42);
let predicate_fn = string_check.and(number_check);
let good_example = Example { string: "hello".into(), number: 42 };
assert_eq!(true, predicate_fn.eval(&good_example));
let bad_example = Example { string: "goodbye".into(), number: 0 };
assert_eq!(false, predicate_fn.eval(&bad_example));
```

--------------------------------

### predicate::path::missing()

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/path/fn.missing.html

Creates a new Predicate that ensures the path does not exist.

```APIDOC
## Function: missing()

### Description
Creates a new `Predicate` that ensures the path does not exist.

### Signature
`pub fn missing() -> ExistencePredicate`

### Example
```rust
use std::path::Path;
use predicates::prelude::*;

let predicate_fn = predicate::path::missing();
assert_eq!(true, predicate_fn.eval(Path::new("non-existent-file.foo")));
```
```

--------------------------------

### Using ends_with predicate

Source: https://docs.rs/mockall/0.13.1/mockall/predicate/str/fn.ends_with.html

Demonstrates creating a predicate to check if a string ends with a specific suffix.

```rust
use predicates::prelude::*;

let predicate_fn = predicate::str::ends_with("World");
assert_eq!(true, predicate_fn.eval("Hello World"));
assert_eq!(false, predicate_fn.eval("Hello Moon"));
```

--------------------------------

### Mocking foreign functions

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Modules containing foreign functions can be mocked, with expectations applied globally.

```rust
mod outer {
    #[automock]
    pub mod ffi {
        extern "C" {
            pub fn foo(x: u32) -> i64;
        }
    }
}

#[double]
use outer::ffi;

fn do_stuff() -> i64 {
    unsafe{ ffi::foo(42) }
}

#[cfg(test)]
mod t {
    use super::*;

    #[test]
    fn test_foo() {
        let ctx = ffi::foo_context();
        ctx.expect()
            .returning(|x| i64::from(x + 1));
        assert_eq!(43, do_stuff());
    }
}
```

--------------------------------

### MockBoo::expect_bah

Source: https://docs.rs/mockall/0.13.1/mockall/examples/struct.MockBoo.html

Creates an expectation for the 'bah' method on the mock object.

```APIDOC
### pub fn expect_bah(&mut self) -> &mut Expectation

Create an `Expectation` for mocking the `bah` method.
```

--------------------------------

### fn trim(self) -> TrimPredicate<Self>

Source: https://docs.rs/mockall/0.13.1/mockall/trait.PredicateStrExt.html

Returns a TrimPredicate that ensures the data passed to the underlying predicate is trimmed before evaluation.

```APIDOC
## fn trim(self) -> TrimPredicate<Self>

### Description
Returns a TrimPredicate that ensures the data passed to the underlying predicate is trimmed before evaluation.

### Example
```rust
use predicates::prelude::*;

let predicate_fn = predicate::str::is_empty().trim();
assert_eq!(true, predicate_fn.eval("    "));
assert_eq!(false, predicate_fn.eval("    Hello    "));
```
```

--------------------------------

### MockBoo::checkpoint

Source: https://docs.rs/mockall/0.13.1/mockall/examples/struct.MockBoo.html

Validates that all current expectations for all methods have been satisfied and discards them.

```APIDOC
### pub fn checkpoint(&mut self)

Validates that all current expectations for all methods have been satisfied, and discards them.
```

--------------------------------

### Trait Definition

Source: https://docs.rs/mockall/0.13.1/mockall/trait.PredicateFileContentExt.html

The definition of the PredicateFileContentExt trait and its provided method.

```rust
pub trait PredicateFileContentExt: Predicate<[u8]> + Sized {
    // Provided method
    fn from_file_path(self) -> FileContentPredicate<Self> { ... }
}
```

--------------------------------

### Context struct definition

Source: https://docs.rs/mockall/0.13.1/mockall/examples/__mock_MockFoo_Foo/__bang/struct.Context.html

The definition of the Context struct, which contains private fields.

```rust
pub struct Context { /* private fields */ }
```

--------------------------------

### Mocking unsized types

Source: https://docs.rs/mockall/0.13.1/mockall/index.html

Mockall automatically handles owned forms for common unsized types like str.

```rust
#[automock]
trait Foo {
    fn name(&self) -> &str;
}

let mut mock = MockFoo::new();
mock.expect_name().return_const("abcd".to_owned());
assert_eq!("abcd", mock.name());
```

--------------------------------

### Perform logical OR with PredicateBooleanExt

Source: https://docs.rs/mockall/0.13.1/mockall/trait.PredicateBooleanExt.html

Combines two predicates using the or method to return true if at least one evaluates to true.

```rust
use predicates::prelude::*;

let predicate_fn1 = predicate::always().or(predicate::always());
let predicate_fn2 = predicate::always().or(predicate::never());
let predicate_fn3 = predicate::never().or(predicate::never());
assert_eq!(true, predicate_fn1.eval(&4));
assert_eq!(true, predicate_fn2.eval(&4));
assert_eq!(false, predicate_fn3.eval(&4));
```
Tokens:
Raw