How do I unit test (default) move operations?

Question

I ran into this when I tried to write unit tests for a move-only class. I don't know how to write a test which checks if move operations actually moved the class's data members. I included here a simplified example of a class that parallels what I am working on. In reality that class supports a few more operations and (std::multimap) data members which shouldn't be relevant here.

#include <vector>

class MyClass {
 public:
  inline MyClass() = default;

  MyClass(const MyClass& other) = delete;
  MyClass(MyClass&& other) = default;

  MyClass& operator=(const MyClass& other) = delete;
  MyClass& operator=(MyClass&& other) = default;

  ~MyClass() = default;

  inline void set(const std::vector<MyStruct>& data) {data_ = data;}
  inline const std::vector<MyStruct>& get() {return data_;}
 private:
  std::vector<MyStruct> data_;
};

MyStruct contains only primitive data types (int, float and double) and some std::string types as (public) data members. For completeness, I added a definition for MyStruct at the end.

I am not sure how to even begin and couldn't find anything by searching online. Ideally, a googletest or googlemock solution would be great, but just a general approach or how it is done in other testing frame works might help me understand it and implement it in my preferred framework.

#include <string>

struct MyStruct {
  int foo;
  float bar;
  double baz;
  std::string fips;
};

Solutions so far (from comments and answers below):

Possible approach 1

Based on my exchange with @MutableSideEffect

Mock data members and test if their move operations are called when MyClass's move operations are called.

This seems simple and straightforward. This indicates whether the (defaulted) move operations of MyClass used the move operations of each of the data members. It should be the responsibility of the data members' types to provide proper move operations.

The only issue I have is that I don't know how to mock data types whose implementations I don't have access to without template-izing my entire code (as described in the google mock docs for mocking non-virtual functions).

In this particular case, though, I could still mock MyStruct and test whether its move operations are called when MyClass's move operations are called.

Possible approach 2

Based on the answer by @Eljay.

Add a data member, say Marker mark, to every class I defined, or to every class for which I want to know whether or not their data members are moved when the class's move operations are called. Instruct the Marker class to record in an internal state which of its constructors lead to its construction. Then test whether move operations of MyClass lead to internal state of its data member mark reflecting that it was moved.

I am not sure how fully this approach tests that all data members were moved and not only the mark data member. Also, this reminds me a lot to just mocking the data members which goes back to approach 1.

Answer 1

Here is a way to track the state of an object with a Marker member variable. Keeping in mind that std::move does not mean the object will be moved from, it only makes the object eligible to be moved from.

Once an object has been moved from, its in a "valid but unspecified state" suitable for either being destructed or being re-assigned to. (A few standard C++ library types have slightly stronger guarantees regarding state after being moved from, such as std::vector and std::unique_ptr.)

#include <cstring>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <cassert>

#ifndef TESTING
#define TESTING 1
#endif

namespace {

struct Marker final {
    char const* state;
    ~Marker() { state = "destructed"; }
    Marker() : state{"constructed"} {}
    Marker(Marker const&) noexcept : state{"copy constructed"} {}
    Marker(Marker&& other) noexcept : state{"move constructed"} { other.state = "move constructed husk"; }
    Marker& operator=(Marker const&) noexcept { state = "assigned"; return *this; }
    Marker& operator=(Marker&& other) noexcept { state = "move assigned"; other.state = "move assigned husk"; return *this; }
    void print(std::ostream&) const;
};

void Marker::print(std::ostream& out) const {
    out << state;
}

std::ostream& operator<<(std::ostream& out, Marker const& marker) {
    marker.print(out);
    return out;
}

void test();

class BigFancyClass {
    friend void test();
    std::vector<std::string> v;
public:
    BigFancyClass() = default;
    BigFancyClass(BigFancyClass const&) = default;
    BigFancyClass(BigFancyClass&&) = default;
    BigFancyClass& operator=(BigFancyClass const&) = default;
    BigFancyClass& operator=(BigFancyClass&&) = default;

#if TESTING
    Marker mark;
#endif
};

void test() {
    std::cout << "Running test()... ";
    BigFancyClass bfc;
    bfc.v.push_back("hello");
    bfc.v.push_back("world");
    assert(bfc.v.size() == 2);
    assert(std::strcmp(bfc.mark.state, "constructed") == 0);
    BigFancyClass bfc2 = std::move(bfc);
    assert(bfc.v.size() == 0);
    assert(bfc2.v.size() == 2);
    assert(std::strcmp(bfc.mark.state, "move constructed husk") == 0);
    assert(std::strcmp(bfc2.mark.state, "move constructed") == 0);
    BigFancyClass bfc3;
    bfc3 = std::move(bfc2);
    assert(std::strcmp(bfc2.mark.state, "move assigned husk") == 0);
    assert(std::strcmp(bfc3.mark.state, "move assigned") == 0);
    std::cout << "DONE\n";
}

} // anon

int main() {
    test();
}