libcryfs/test/cpp-utils/EitherTest.cpp

#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <boost/optional/optional_io.hpp>
#include "cpp-utils/either.h"
#include "cpp-utils/macros.h"
#include <sstream>

//TODO Go through all test cases and think about whether it makes sense to add the same test case but with primitive types.

using std::ostringstream;
using std::string;
using std::vector;
using std::pair;
using std::make_pair;
using namespace cpputils;
using ::testing::Test;

class OnlyMoveable {
public:
  OnlyMoveable(int value_): value(value_)  {}
  OnlyMoveable(OnlyMoveable &&source): value(source.value) {source.value = -1;}
  bool operator==(const OnlyMoveable &rhs) const {
    return value == rhs.value;
  }
  int value;
private:
  DISALLOW_COPY_AND_ASSIGN(OnlyMoveable);
};

template<typename T>
struct StoreWith1ByteFlag {
  T val;
  char flag;
};

class EitherTest: public Test {
public:
  template<class Left, class Right>
  void EXPECT_IS_LEFT(const either<Left,Right> &val) {
    EXPECT_TRUE(val.is_left());
    EXPECT_FALSE(val.is_right());
  }
  template<class Left, class Right>
  void EXPECT_IS_RIGHT(const either<Left,Right> &val) {
    EXPECT_FALSE(val.is_left());
    EXPECT_TRUE(val.is_right());
  }
  template<class Left, class Right, class Expected>
  void EXPECT_LEFT_IS(const Expected &expected, either<Left, Right> &value) {
    EXPECT_IS_LEFT(value);
    EXPECT_EQ(expected, value.left());
    EXPECT_EQ(expected, value.left_opt().get());
    EXPECT_EQ(boost::none, value.right_opt());
    const either<Left, Right> &const_value = value;
    EXPECT_EQ(expected, const_value.left());
    EXPECT_EQ(expected, const_value.left_opt().get());
    EXPECT_EQ(boost::none, const_value.right_opt());
  }
  template<class Left, class Right, class Expected>
  void EXPECT_RIGHT_IS(const Expected &expected, either<Left, Right> &value) {
    EXPECT_IS_RIGHT(value);
    EXPECT_EQ(expected, value.right());
    EXPECT_EQ(expected, value.right_opt().get());
    EXPECT_EQ(boost::none, value.left_opt());
    const either<Left, Right> &const_value = value;
    EXPECT_EQ(expected, const_value.right());
    EXPECT_EQ(expected, const_value.right_opt().get());
    EXPECT_EQ(boost::none, const_value.left_opt());
  }
};

template<typename Left, typename Right>
void TestSpaceUsage() {
  EXPECT_EQ(std::max(sizeof(StoreWith1ByteFlag<Left>), sizeof(StoreWith1ByteFlag<Right>)), sizeof(either<Left, Right>));
}

TEST_F(EitherTest, SpaceUsage) {
  TestSpaceUsage<char, int>();
  TestSpaceUsage<int, short>();
  TestSpaceUsage<char, short>();
  TestSpaceUsage<int, string>();
  TestSpaceUsage<string, vector<string>>();
}

TEST_F(EitherTest, LeftCanBeConstructed) {
  either<int, string> val = 3;
  UNUSED(val);
}

TEST_F(EitherTest, RightCanBeConstructed) {
  either<int, string> val = string("string");
  UNUSED(val);
}

TEST_F(EitherTest, IsLeft) {
  either<int, string> val = 3;
  EXPECT_IS_LEFT(val);
}

TEST_F(EitherTest, IsRight) {
  either<int, string> val = string("string");
  EXPECT_IS_RIGHT(val);
}

TEST_F(EitherTest, LeftIsStored) {
  either<int, string> val = 3;
  EXPECT_LEFT_IS(3, val);
}

TEST_F(EitherTest, RightIsStored) {
  either<int, string> val = string("string");
  EXPECT_RIGHT_IS("string", val);
}

TEST_F(EitherTest, LeftCanBeMoveContructed) {
  either<OnlyMoveable, string> val = OnlyMoveable(1);
  UNUSED(val);
}

TEST_F(EitherTest, RightCanBeMoveContructed) {
  either<string, OnlyMoveable> val = OnlyMoveable(1);
  UNUSED(val);
}

TEST_F(EitherTest, IsLeftWhenMoveContructed) {
  either<OnlyMoveable, string> val = OnlyMoveable(1);
  EXPECT_IS_LEFT(val);
}

TEST_F(EitherTest, IsRightWhenMoveContructed) {
  either<string, OnlyMoveable> val = OnlyMoveable(1);
  EXPECT_IS_RIGHT(val);
}

TEST_F(EitherTest, LeftIsStoredWhenMoveContructed) {
  either<OnlyMoveable, string> val = OnlyMoveable(2);
  EXPECT_LEFT_IS(OnlyMoveable(2), val);
}

TEST_F(EitherTest, RightIsStoredWhenMoveContructed) {
  either<string, OnlyMoveable> val = OnlyMoveable(3);
  EXPECT_RIGHT_IS(OnlyMoveable(3), val);
}

TEST_F(EitherTest, LeftCanBeCopied) {
  either<string, int> val = string("string");
  either<string, int> val2 = val;
  EXPECT_LEFT_IS("string", val2);
}

TEST_F(EitherTest, CopyingLeftDoesntChangeSource) {
  either<string, int> val = string("string");
  either<string, int> val2 = val;
  EXPECT_LEFT_IS("string", val);
}

TEST_F(EitherTest, RightCanBeCopied) {
  either<int, string> val = string("string");
  either<int, string> val2 = val;
  EXPECT_RIGHT_IS("string", val2);
}

TEST_F(EitherTest, CopyingRightDoesntChangeSource) {
  either<int, string> val = string("string");
  either<int, string> val2 = val;
  EXPECT_RIGHT_IS("string", val);
}

TEST_F(EitherTest, LeftCanBeMoved) {
  either<OnlyMoveable, int> val = OnlyMoveable(5);
  either<OnlyMoveable, int> val2 = std::move(val);
  EXPECT_LEFT_IS(OnlyMoveable(5), val2);
}

TEST_F(EitherTest, RightCanBeMoved) {
  either<int, OnlyMoveable> val = OnlyMoveable(5);
  either<int, OnlyMoveable> val2 = std::move(val);
  EXPECT_RIGHT_IS(OnlyMoveable(5), val2);
}

TEST_F(EitherTest, LeftCanBeAssigned) {
  either<string, int> val = string("string");
  either<string, int> val2 = string("otherstring");
  val2 = val;
  EXPECT_LEFT_IS("string", val2);
}

TEST_F(EitherTest, RightCanBeAssigned) {
  either<int, string> val = string("string");
  either<int, string> val2 = string("otherstring");
  val2 = val;
  EXPECT_RIGHT_IS("string", val2);
}

TEST_F(EitherTest, LeftCanBeMoveAssigned) {
  either<OnlyMoveable, int> val = OnlyMoveable(3);
  either<OnlyMoveable, int> val2 = OnlyMoveable(4);
  val2 = std::move(val);
  EXPECT_LEFT_IS(OnlyMoveable(3), val2);
}

TEST_F(EitherTest, RightCanBeMoveAssigned) {
  either<int, OnlyMoveable> val = OnlyMoveable(3);
  either<int, OnlyMoveable> val2 = OnlyMoveable(4);
  val2 = std::move(val);
  EXPECT_RIGHT_IS(OnlyMoveable(3), val2);
}

TEST_F(EitherTest, LeftCanBeDirectlyAssigned) {
  either<string, int> val = string("string");
  val = string("otherstring");
  EXPECT_LEFT_IS("otherstring", val);
}

TEST_F(EitherTest, RightCanBeDirectlyAssigned) {
  either<int, string> val = string("string");
  val = string("otherstring");
  EXPECT_RIGHT_IS("otherstring", val);
}

TEST_F(EitherTest, LeftCanBeDirectlyMoveAssigned) {
  either<OnlyMoveable, int> val = OnlyMoveable(3);
  val = OnlyMoveable(5);
  EXPECT_LEFT_IS(OnlyMoveable(5), val);
}

TEST_F(EitherTest, RightCanBeDirectlyMoveAssigned) {
  either<int, OnlyMoveable> val = OnlyMoveable(3);
  val = OnlyMoveable(5);
  EXPECT_RIGHT_IS(OnlyMoveable(5), val);
}

TEST_F(EitherTest, ModifyLeft) {
  either<string, int> val = string("mystring1");
  val.left() = "mystring2";
  EXPECT_LEFT_IS("mystring2", val);
}

TEST_F(EitherTest, ModifyRight) {
  either<int, string> val = string("mystring1");
  val.right() = "mystring2";
  EXPECT_RIGHT_IS("mystring2", val);
}

TEST_F(EitherTest, ModifyLeftOpt) {
  either<string, int> val = string("mystring1");
  val.left_opt().get() = "mystring2";
  EXPECT_LEFT_IS("mystring2", val);
}

TEST_F(EitherTest, ModifyRightOpt) {
  either<int, string> val = string("mystring1");
  val.right_opt().value() = "mystring2";
  EXPECT_RIGHT_IS("mystring2", val);
}

TEST_F(EitherTest, LeftEquals) {
  either<string, int> val1 = string("mystring");
  either<string, int> val2 = string("mystring");
  EXPECT_TRUE(val1 == val2);
  EXPECT_TRUE(val2 == val1);
  EXPECT_FALSE(val1 != val2);
  EXPECT_FALSE(val2 != val1);
}

TEST_F(EitherTest, LeftNotEquals) {
  either<string, int> val1 = string("mystring");
  either<string, int> val2 = string("mystring2");
  EXPECT_TRUE(val1 != val2);
  EXPECT_TRUE(val2 != val1);
  EXPECT_FALSE(val1 == val2);
  EXPECT_FALSE(val2 == val1);
}

TEST_F(EitherTest, RightEquals) {
  either<int, string> val1 = string("mystring");
  either<int, string> val2 = string("mystring");
  EXPECT_TRUE(val1 == val2);
  EXPECT_TRUE(val2 == val1);
  EXPECT_FALSE(val1 != val2);
  EXPECT_FALSE(val2 != val1);
}

TEST_F(EitherTest, RightNotEquals) {
  either<int, string> val1 = string("mystring");
  either<int, string> val2 = string("mystring2");
  EXPECT_TRUE(val1 != val2);
  EXPECT_TRUE(val2 != val1);
  EXPECT_FALSE(val1 == val2);
  EXPECT_FALSE(val2 == val1);
}

TEST_F(EitherTest, LeftNotEqualsRight) {
  either<string, int> val1 = string("mystring");
  either<string, int> val2 = 3;
  EXPECT_TRUE(val1 != val2);
  EXPECT_TRUE(val2 != val1);
  EXPECT_FALSE(val1 == val2);
  EXPECT_FALSE(val2 == val1);
}

TEST_F(EitherTest, OutputLeft) {
  ostringstream str;
  str << either<string, int>("mystring");
  EXPECT_EQ("Left(mystring)", str.str());
}

TEST_F(EitherTest, OutputRight) {
  ostringstream str;
  str << either<int, string>("mystring");
  EXPECT_EQ("Right(mystring)", str.str());
}

TEST_F(EitherTest, MakeLeft) {
  either<string, int> var = make_left<string, int>("mystring");
  EXPECT_LEFT_IS("mystring", var);
}

TEST_F(EitherTest, MakeLeft_OnlyMoveable) {
  either<OnlyMoveable, int> var = make_left<OnlyMoveable, int>(4);
  EXPECT_LEFT_IS(OnlyMoveable(4), var);
}

TEST_F(EitherTest, MakeLeft_MultiParam) {
  either<pair<int, int>, int> var = make_left<pair<int, int>, int>(4, 5);
  EXPECT_LEFT_IS(make_pair(4,5), var);
}

TEST_F(EitherTest, MakeRight) {
  either<int, string> var = make_right<int, string>("mystring");
  EXPECT_RIGHT_IS("mystring", var);
}

TEST_F(EitherTest, MakeRight_OnlyMoveable) {
  either<int, OnlyMoveable> var = make_right<int, OnlyMoveable>(4);
  EXPECT_RIGHT_IS(OnlyMoveable(4), var);
}

TEST_F(EitherTest, MakeRight_MultiParam) {
  either<int, pair<int, int>> var = make_right<int, pair<int, int>>(4, 5);
  EXPECT_RIGHT_IS(make_pair(4,5), var);
}

TEST_F(EitherTest, LeftCanBeQueriedAsRvalue) {
  OnlyMoveable val = make_left<OnlyMoveable, int>(3).left();
  EXPECT_EQ(OnlyMoveable(3), val);
}

TEST_F(EitherTest, RightCanBeQueriedAsRvalue) {
  OnlyMoveable val = make_right<int, OnlyMoveable>(3).right();
  EXPECT_EQ(OnlyMoveable(3), val);
}

TEST_F(EitherTest, LeftOptCanBeQueriedAsRvalue) {
  OnlyMoveable val = make_left<OnlyMoveable, int>(3).left_opt().value();
  EXPECT_EQ(OnlyMoveable(3), val);
}

TEST_F(EitherTest, RightOptCanBeQueriedAsRvalue) {
  OnlyMoveable val = make_right<int, OnlyMoveable>(3).right_opt().value();
  EXPECT_EQ(OnlyMoveable(3), val);
}

class DestructorCallback {
public:
  MOCK_CONST_METHOD0(call, void());

  void EXPECT_CALLED(int times = 1) {
    EXPECT_CALL(*this, call()).Times(times);
  }
};
class ClassWithDestructorCallback {
public:
  ClassWithDestructorCallback(const DestructorCallback *destructorCallback) : _destructorCallback(destructorCallback) {}
  ClassWithDestructorCallback(const ClassWithDestructorCallback &rhs): _destructorCallback(rhs._destructorCallback) {}

  ~ClassWithDestructorCallback() {
    _destructorCallback->call();
  }

private:
  const DestructorCallback *_destructorCallback;

  ClassWithDestructorCallback &operator=(const ClassWithDestructorCallback &rhs) = delete;
};
class OnlyMoveableClassWithDestructorCallback {
public:
  OnlyMoveableClassWithDestructorCallback(const DestructorCallback *destructorCallback) : _destructorCallback(destructorCallback) { }
  OnlyMoveableClassWithDestructorCallback(OnlyMoveableClassWithDestructorCallback &&source): _destructorCallback(source._destructorCallback) {}

  ~OnlyMoveableClassWithDestructorCallback() {
    _destructorCallback->call();
  }

private:
  DISALLOW_COPY_AND_ASSIGN(OnlyMoveableClassWithDestructorCallback);
  const DestructorCallback *_destructorCallback;
};

class EitherTest_Destructor: public EitherTest {
};

TEST_F(EitherTest_Destructor, LeftDestructorIsCalled) {
  DestructorCallback destructorCallback;
  destructorCallback.EXPECT_CALLED(2);  //Once for the temp object, once when the either class destructs

  ClassWithDestructorCallback temp(&destructorCallback);
  either<ClassWithDestructorCallback, string> var = temp;
}

TEST_F(EitherTest_Destructor, RightDestructorIsCalled) {
  DestructorCallback destructorCallback;
  destructorCallback.EXPECT_CALLED(2);  //Once for the temp object, once when the either class destructs

  ClassWithDestructorCallback temp(&destructorCallback);
  either<string, ClassWithDestructorCallback> var = temp;
}

TEST_F(EitherTest_Destructor, LeftDestructorIsCalledAfterCopying) {
  DestructorCallback destructorCallback;
  destructorCallback.EXPECT_CALLED(3);  //Once for the temp object, once for var1 and once for var2

  ClassWithDestructorCallback temp(&destructorCallback);
  either<ClassWithDestructorCallback, string> var1 = temp;
  either<ClassWithDestructorCallback, string> var2 = var1;
}

TEST_F(EitherTest_Destructor, RightDestructorIsCalledAfterCopying) {
  DestructorCallback destructorCallback;
  destructorCallback.EXPECT_CALLED(3);  //Once for the temp object, once for var1 and once for var2

  ClassWithDestructorCallback temp(&destructorCallback);
  either<string, ClassWithDestructorCallback> var1 = temp;
  either<string, ClassWithDestructorCallback> var2 = var1;
}

TEST_F(EitherTest_Destructor, LeftDestructorIsCalledAfterMoving) {
  DestructorCallback destructorCallback;
  destructorCallback.EXPECT_CALLED(3);  //Once for the temp object, once for var1 and once for var2

  OnlyMoveableClassWithDestructorCallback temp(&destructorCallback);
  either<OnlyMoveableClassWithDestructorCallback, string> var1 = std::move(temp);
  either<OnlyMoveableClassWithDestructorCallback, string> var2 = std::move(var1);
}

TEST_F(EitherTest_Destructor, RightDestructorIsCalledAfterMoving) {
  DestructorCallback destructorCallback;
  destructorCallback.EXPECT_CALLED(3);  //Once for the temp object, once for var1 and once for var2

  OnlyMoveableClassWithDestructorCallback temp(&destructorCallback);
  either<string, OnlyMoveableClassWithDestructorCallback> var1 = std::move(temp);
  either<string, OnlyMoveableClassWithDestructorCallback> var2 = std::move(var1);
}

TEST_F(EitherTest_Destructor, LeftDestructorIsCalledAfterAssignment) {
  DestructorCallback destructorCallback1;
  DestructorCallback destructorCallback2;
  destructorCallback1.EXPECT_CALLED(2); //Once for the temp1 object, once at the assignment
  destructorCallback2.EXPECT_CALLED(3); //Once for the temp2 object, once in destructor of var2, once in destructor of var1

  ClassWithDestructorCallback temp1(&destructorCallback1);
  either<ClassWithDestructorCallback, string> var1 = temp1;
  ClassWithDestructorCallback temp2(&destructorCallback2);
  either<ClassWithDestructorCallback, string> var2 = temp2;
  var1 = var2;
}

TEST_F(EitherTest_Destructor, RightDestructorIsCalledAfterAssignment) {
  DestructorCallback destructorCallback1;
  DestructorCallback destructorCallback2;
  destructorCallback1.EXPECT_CALLED(2); //Once for the temp1 object, once at the assignment
  destructorCallback2.EXPECT_CALLED(3); //Once for the temp2 object, once in destructor of var2, once in destructor of var1

  ClassWithDestructorCallback temp1(&destructorCallback1);
  either<string, ClassWithDestructorCallback> var1 = temp1;
  ClassWithDestructorCallback temp2(&destructorCallback2);
  either<string, ClassWithDestructorCallback> var2 = temp2;
  var1 = var2;
}

TEST_F(EitherTest_Destructor, LeftDestructorIsCalledAfterMoveAssignment) {
  DestructorCallback destructorCallback1;
  DestructorCallback destructorCallback2;
  destructorCallback1.EXPECT_CALLED(2); //Once for the temp1 object, once at the assignment
  destructorCallback2.EXPECT_CALLED(3); //Once for the temp2 object, once in destructor of var2, once in destructor of var1

  OnlyMoveableClassWithDestructorCallback temp1(&destructorCallback1);
  either<OnlyMoveableClassWithDestructorCallback, string> var1 = std::move(temp1);
  OnlyMoveableClassWithDestructorCallback temp2(&destructorCallback2);
  either<OnlyMoveableClassWithDestructorCallback, string> var2 = std::move(temp2);
  var1 = std::move(var2);
}

TEST_F(EitherTest_Destructor, RightDestructorIsCalledAfterMoveAssignment) {
  DestructorCallback destructorCallback1;
  DestructorCallback destructorCallback2;
  destructorCallback1.EXPECT_CALLED(2); //Once for the temp1 object, once at the assignment
  destructorCallback2.EXPECT_CALLED(3); //Once for the temp2 object, once in destructor of var2, once in destructor of var1

  OnlyMoveableClassWithDestructorCallback temp1(&destructorCallback1);
  either<string, OnlyMoveableClassWithDestructorCallback> var1 = std::move(temp1);
  OnlyMoveableClassWithDestructorCallback temp2(&destructorCallback2);
  either<string, OnlyMoveableClassWithDestructorCallback> var2 = std::move(temp2);
  var1 = std::move(var2);
}