mimicpp::RelocationWatcher Class Reference

A watcher type, which reports it's move-constructor and -assignment calls. More...

#include <ObjectWatcher.hpp>

Public Member Functions
	~RelocationWatcher ()=default
	Defaulted destructor.
	RelocationWatcher ()=default
	Defaulted default constructor.
	RelocationWatcher (const RelocationWatcher &other)
	Copy-constructor.
RelocationWatcher &	operator= (const RelocationWatcher &other)
	Copy-assignment-operator.
	RelocationWatcher (RelocationWatcher &&other) noexcept(false)
	Move-constructor, which reports a relocation.
RelocationWatcher &	operator= (RelocationWatcher &&other) noexcept(false)
	Move-assignment-operator, which reports a relocation.
auto	expect_relocate ()
	Begins a relocation-expectation construction.

Detailed Description

A watcher type, which reports it's move-constructor and -assignment calls.

This watcher is designed to track, whether a move has been performed. During a move, it reports the relocation to the framework, which can be tracked by a previously created relocation-expectation.

    namespace expect = mimicpp::expect;
    namespace then = mimicpp::then;
 
    mimicpp::Watched<
        mimicpp::Mock<void()>,
        mimicpp::LifetimeWatcher,
        mimicpp::RelocationWatcher>
        watched{};
 
    SCOPED_EXP watched.expect_destruct();
    int relocationCounter{};
    SCOPED_EXP watched.expect_relocate()
        and then::invoke([&] { ++relocationCounter; })
        and expect::at_least(1);
 
    std::optional wrapped{std::move(watched)}; // satisfies one relocate-expectation
    std::optional other{std::move(wrapped)};   // satisfies a second relocate-expectation
    wrapped.reset();                           // won't require a destruct-expectation, as moved-from objects are considered dead
    other.reset();                             // fulfills the destruct-expectation
    REQUIRE(2 == relocationCounter);           // let's see, how often the instance has been relocated

Moving

This watcher can be freely moved around, but any relocation events must match with a previously created relocation-expectation.

Copying

This watcher is copyable, but with very special behaviour.

As this watcher is generally designed to be part of a bigger object, it would be very limiting not supporting copy-operations at all. The question is, how should a copy look like?

In general a copy should be a logical duplicate of its source and the general expectation is: if B is a copy of A, then A == B should yield true.

Note

This doesn't say, that if B is not a copy of A, then A == B has to yield false!

This won't be the case for RelocationWatchers, as active relocation-expectations won't be copied over to the target. In general, if a RelocationWatcher is used, we want to be very precise with our move, thus an implicit expectation copy would be against the purpose of this helper. Due to this, each RelocationWatcher will be created as a fresh instance, when copy-construction is used. The same logic also applies to copy-assignment.

Constructor & Destructor Documentation

~RelocationWatcher()

mimicpp::RelocationWatcher::~RelocationWatcher ( )

default

Defaulted destructor.

RelocationWatcher() [1/3]

mimicpp::RelocationWatcher::RelocationWatcher ( )

nodiscarddefault

Defaulted default constructor.

Here is the caller graph for this function:

RelocationWatcher() [2/3]

mimicpp::RelocationWatcher::RelocationWatcher ( const RelocationWatcher & other )

inlinenodiscard

Copy-constructor.

Parameters

other

The other object.

This copy-constructor's purpose is to provide syntactically correct copy operations, but semantically this does not copy anything. In fact, it simply default-constructs the new instance, without even touching the other.

Here is the call graph for this function:

RelocationWatcher() [3/3]

mimicpp::RelocationWatcher::RelocationWatcher ( RelocationWatcher && other )

inlinenodiscard

Move-constructor, which reports a relocation.

Note

A no-match error may occur, if no relocation-expectation has been defined.

Parameters

other

The other object.

Here is the call graph for this function:

Member Function Documentation

expect_relocate()

auto mimicpp::RelocationWatcher::expect_relocate ( )

inlinenodiscard

Begins a relocation-expectation construction.

Returns

A newly created expectation-builder-instance.

Note

This function creates a new expectation-builder-instance, which isn't an expectation yet. User must convert this to an actual expectation, by handing it over to a new ScopedExpectation instance. This can either be done manually or via MIMICPP_SCOPED_EXPECTATION (or the shorthand version SCOPED_EXP).

operator=() [1/2]

RelocationWatcher & mimicpp::RelocationWatcher::operator= ( const RelocationWatcher & other )

inline

Copy-assignment-operator.

Parameters

other

The other object.

This copy-assignment-operator's purpose is to provide syntactically correct copy operations, but semantically this does not copy anything. In fact, it simply overrides its internals with a fresh instance, without even touching the other.

Here is the call graph for this function:

operator=() [2/2]

RelocationWatcher & mimicpp::RelocationWatcher::operator= ( RelocationWatcher && other )

inline

Move-assignment-operator, which reports a relocation.

Note

A no-match error may occur, if no relocation-expectation has been defined.

Parameters

other

The other object.

Here is the call graph for this function:

---

The documentation for this class was generated from the following file:

• mimic++/ObjectWatcher.hpp