cppcore/test/cppcore/misc/nullable_tests.cpp

#include <gtest/gtest.h>
#include <cppcore/misc/nullable.h>

struct TestData
{
    static int ctorCount;
    static int dtorCount;

    TestData()
        { ++ctorCount; }

     ~TestData()
        { ++dtorCount; }
};

struct NonCopyableTestData
{
    int value;

    NonCopyableTestData(int v) :
        value(v)
        { }

    NonCopyableTestData(NonCopyableTestData&& other) :
        value(0)
        { std::swap(value, other.value); }

    NonCopyableTestData(const NonCopyableTestData&) = delete;
};

using NullableInt                 = ::cppcore::nullable<int>;
using NullableIntRef              = ::cppcore::nullable<int&>;
using NullableString              = ::cppcore::nullable<std::string>;
using NullableTestData            = ::cppcore::nullable<TestData>;
using NullableNonCopyableTestData = ::cppcore::nullable<NonCopyableTestData>;

int TestData::ctorCount = 0;
int TestData::dtorCount = 0;

using namespace ::cppcore;
using namespace ::testing;

TEST(nullable_tests, ctor_empty)
{
    NullableInt    n1;
    NullableIntRef n2;
    EXPECT_FALSE(static_cast<bool>(n1));
    EXPECT_FALSE(static_cast<bool>(n2));
}

TEST(nullable_tests, ctor_value)
{
    int i = 5;
    NullableInt    n1(i);
    NullableIntRef n2(i);
    EXPECT_TRUE(static_cast<bool>(n1));
    EXPECT_TRUE(static_cast<bool>(n2));
    EXPECT_EQ  (5,   n1());
    EXPECT_EQ  (&i, &n2());
}

TEST(nullable_tests, ctor_copy)
{
    int i = 5;
    NullableInt    i1(i);
    NullableIntRef i2(i);
    NullableInt    n1(i1);
    NullableIntRef n2(i2);
    EXPECT_TRUE(static_cast<bool>(n1));
    EXPECT_TRUE(static_cast<bool>(n2));
    EXPECT_EQ  (5,   n1());
    EXPECT_EQ  (&i, &n2());
}

TEST(nullable_tests, ctor_move)
{
    NullableString i1("test");
    NullableString n1(std::move(i1));
    EXPECT_FALSE(static_cast<bool>(i1));
    ASSERT_TRUE (static_cast<bool>(n1));
    EXPECT_EQ   (std::string("test"), n1());
}

TEST(nullable_tests, move_assignment)
{
    NullableString i1("test");
    NullableString n1;
    n1 = std::move(i1);
    EXPECT_FALSE(static_cast<bool>(i1));
    ASSERT_TRUE (static_cast<bool>(n1));
    EXPECT_EQ   (std::string("test"), n1());
}

TEST(nullable_tests, movable_object)
{
    NonCopyableTestData data(5);
    NullableNonCopyableTestData tmp;
    tmp = std::move(data);
    ASSERT_TRUE ( tmp.has_value() );
    ASSERT_EQ   ( 5, tmp.value().value );
    ASSERT_EQ   ( 0, data.value );
}

TEST(nullable_tests, hasValue_operatorBool)
{
    EXPECT_FALSE(static_cast<bool>(NullableInt()));
    EXPECT_FALSE(NullableInt().has_value());
    EXPECT_TRUE (static_cast<bool>(NullableInt(5)));
    EXPECT_TRUE (NullableInt(5).has_value());
}

TEST(nullable_tests, reset)
{
    NullableTestData n(TestData{});
    EXPECT_TRUE (n.has_value());
    int tmp = TestData::dtorCount;
    n.reset();
    EXPECT_FALSE(n.has_value());
    EXPECT_EQ   (tmp + 1, TestData::dtorCount);
}

TEST(nullable_tests, value_functor)
{
    NullableInt n1(5);
    NullableInt n2;

    EXPECT_EQ       (5, n1());
    EXPECT_EQ       (5, n1.value());
    EXPECT_ANY_THROW(n2());
    EXPECT_ANY_THROW(n2.value());
}

TEST(nullable_tests, equalityCompareOperator)
{
    NullableInt n1(5);
    NullableInt n2(7);
    NullableInt n3;

    EXPECT_FALSE(n2 == n1);
    EXPECT_TRUE ( 5 == n1);
    EXPECT_FALSE(n3 == n1);

    EXPECT_FALSE(n1 == n2);
    EXPECT_FALSE( 5 == n2);
    EXPECT_FALSE(n3 == n2);

    EXPECT_TRUE (n1 == 5);
    EXPECT_FALSE(n2 == 5);
    EXPECT_FALSE(n3 == 5);

    EXPECT_FALSE(n1 == n3);
    EXPECT_FALSE(n2 == n3);
    EXPECT_FALSE( 5 == n3);
}

TEST(nullable_tests, unequalityCompareOperator)
{
    NullableInt n1(5);
    NullableInt n2(7);
    NullableInt n3;

    EXPECT_TRUE (n2 != n1);
    EXPECT_FALSE( 5 != n1);
    EXPECT_FALSE(n3 != n1);

    EXPECT_TRUE (n1 != n2);
    EXPECT_TRUE ( 5 != n2);
    EXPECT_FALSE(n3 != n2);

    EXPECT_FALSE(n1 != 5);
    EXPECT_TRUE (n2 != 5);
    EXPECT_FALSE(n3 != 5);

    EXPECT_FALSE(n1 != n3);
    EXPECT_FALSE(n2 != n3);
    EXPECT_FALSE( 5 != n3);
}

TEST(nullable_tests, lessCompareOperator)
{
    NullableInt n1(5);
    NullableInt n2(7);
    NullableInt n3;

    EXPECT_FALSE(n2 < n1);
    EXPECT_FALSE( 5 < n1);
    EXPECT_FALSE(n3 < n1);

    EXPECT_TRUE (n1 < n2);
    EXPECT_TRUE ( 5 < n2);
    EXPECT_FALSE(n3 < n2);

    EXPECT_FALSE(n1 < 5);
    EXPECT_FALSE(n2 < 5);
    EXPECT_FALSE(n3 < 5);

    EXPECT_FALSE(n1 < n3);
    EXPECT_FALSE(n2 < n3);
    EXPECT_FALSE( 5 < n3);
}

TEST(nullable_tests, lessEqualCompareOperator)
{
    NullableInt n1(5);
    NullableInt n2(7);
    NullableInt n3;

    EXPECT_FALSE(n2 <= n1);
    EXPECT_TRUE ( 5 <= n1);
    EXPECT_FALSE(n3 <= n1);

    EXPECT_TRUE (n1 <= n2);
    EXPECT_TRUE ( 5 <= n2);
    EXPECT_FALSE(n3 <= n2);

    EXPECT_TRUE (n1 <= 5);
    EXPECT_FALSE(n2 <= 5);
    EXPECT_FALSE(n3 <= 5);

    EXPECT_FALSE(n1 <= n3);
    EXPECT_FALSE(n2 <= n3);
    EXPECT_FALSE( 5 <= n3);
}

TEST(nullable_tests, greaterCompareOperator)
{
    NullableInt n1(5);
    NullableInt n2(7);
    NullableInt n3;

    EXPECT_TRUE (n2 > n1);
    EXPECT_FALSE( 5 > n1);
    EXPECT_FALSE(n3 > n1);

    EXPECT_FALSE(n1 > n2);
    EXPECT_FALSE( 5 > n2);
    EXPECT_FALSE(n3 > n2);

    EXPECT_FALSE(n1 > 5);
    EXPECT_TRUE (n2 > 5);
    EXPECT_FALSE(n3 > 5);

    EXPECT_FALSE(n1 > n3);
    EXPECT_FALSE(n2 > n3);
    EXPECT_FALSE( 5 > n3);
}

TEST(nullable_tests, greaterEqualCompareOperator)
{
    NullableInt n1(5);
    NullableInt n2(7);
    NullableInt n3;

    EXPECT_TRUE (n2 >= n1);
    EXPECT_TRUE ( 5 >= n1);
    EXPECT_FALSE(n3 >= n1);

    EXPECT_FALSE(n1 >= n2);
    EXPECT_FALSE( 5 >= n2);
    EXPECT_FALSE(n3 >= n2);

    EXPECT_TRUE (n1 >= 5);
    EXPECT_TRUE (n2 >= 5);
    EXPECT_FALSE(n3 >= 5);

    EXPECT_FALSE(n1 >= n3);
    EXPECT_FALSE(n2 >= n3);
    EXPECT_FALSE( 5 >= n3);
}