forked from microsoft/GSL
Move from unittest-cpp to catch for unit testing. (#533)
Many thanks to @rianquinn. This should fix #495, #494 and #529.
This commit is contained in:
Neil MacIntosh
GitHub
+172
-182
@@ -14,7 +14,7 @@
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <UnitTest++/UnitTest++.h>
|
||||
#include <catch/catch.hpp>
|
||||
|
||||
#include <gsl/gsl>
|
||||
|
||||
@@ -104,192 +104,182 @@ struct NonCopyableNonMovable
|
||||
NonCopyableNonMovable& operator=(NonCopyableNonMovable&&) = delete;
|
||||
};
|
||||
|
||||
bool helper(not_null<int*> p) { return *p == 12; }
|
||||
|
||||
SUITE(NotNullTests)
|
||||
TEST_CASE("TestNotNullConstructors")
|
||||
{
|
||||
|
||||
bool helper(not_null<int*> p) { return *p == 12; }
|
||||
|
||||
TEST(TestNotNullConstructors)
|
||||
{
|
||||
#ifdef CONFIRM_COMPILATION_ERRORS
|
||||
not_null<int*> p = nullptr; // yay...does not compile!
|
||||
not_null<std::vector<char>*> p = 0; // yay...does not compile!
|
||||
not_null<int*> p; // yay...does not compile!
|
||||
std::unique_ptr<int> up = std::make_unique<int>(120);
|
||||
not_null<int*> p = up;
|
||||
not_null<int*> p = nullptr; // yay...does not compile!
|
||||
not_null<std::vector<char>*> p = 0; // yay...does not compile!
|
||||
not_null<int*> p; // yay...does not compile!
|
||||
std::unique_ptr<int> up = std::make_unique<int>(120);
|
||||
not_null<int*> p = up;
|
||||
|
||||
// Forbid non-nullptr assignable types
|
||||
not_null<std::vector<int>> f(std::vector<int>{1});
|
||||
not_null<int> z(10);
|
||||
not_null<std::vector<int>> y({1, 2});
|
||||
// Forbid non-nullptr assignable types
|
||||
not_null<std::vector<int>> f(std::vector<int>{1});
|
||||
not_null<int> z(10);
|
||||
not_null<std::vector<int>> y({1, 2});
|
||||
#endif
|
||||
int i = 12;
|
||||
auto rp = RefCounted<int>(&i);
|
||||
not_null<int*> p(rp);
|
||||
CHECK(p.get() == &i);
|
||||
int i = 12;
|
||||
auto rp = RefCounted<int>(&i);
|
||||
not_null<int*> p(rp);
|
||||
CHECK(p.get() == &i);
|
||||
|
||||
not_null<std::shared_ptr<int>> x(
|
||||
std::make_shared<int>(10)); // shared_ptr<int> is nullptr assignable
|
||||
}
|
||||
|
||||
TEST(TestNotNullCasting)
|
||||
{
|
||||
MyBase base;
|
||||
MyDerived derived;
|
||||
Unrelated unrelated;
|
||||
not_null<Unrelated*> u = &unrelated;
|
||||
(void) u;
|
||||
not_null<MyDerived*> p = &derived;
|
||||
not_null<MyBase*> q = &base;
|
||||
q = p; // allowed with heterogeneous copy ctor
|
||||
CHECK(q == p);
|
||||
|
||||
#ifdef CONFIRM_COMPILATION_ERRORS
|
||||
q = u; // no viable conversion possible between MyBase* and Unrelated*
|
||||
p = q; // not possible to implicitly convert MyBase* to MyDerived*
|
||||
|
||||
not_null<Unrelated*> r = p;
|
||||
not_null<Unrelated*> s = reinterpret_cast<Unrelated*>(p);
|
||||
#endif
|
||||
not_null<Unrelated*> t = reinterpret_cast<Unrelated*>(p.get());
|
||||
CHECK(reinterpret_cast<void*>(p.get()) == reinterpret_cast<void*>(t.get()));
|
||||
}
|
||||
|
||||
TEST(TestNotNullAssignment)
|
||||
{
|
||||
int i = 12;
|
||||
not_null<int*> p = &i;
|
||||
CHECK(helper(p));
|
||||
|
||||
int* q = nullptr;
|
||||
CHECK_THROW(p = q, fail_fast);
|
||||
}
|
||||
|
||||
TEST(TestNotNullRawPointerComparison)
|
||||
{
|
||||
int ints[2] = {42, 43};
|
||||
int* p1 = &ints[0];
|
||||
const int* p2 = &ints[1];
|
||||
|
||||
using NotNull1 = not_null<decltype(p1)>;
|
||||
using NotNull2 = not_null<decltype(p2)>;
|
||||
|
||||
CHECK((NotNull1(p1) == NotNull1(p1)) == true);
|
||||
CHECK((NotNull1(p1) == NotNull2(p2)) == false);
|
||||
|
||||
CHECK((NotNull1(p1) != NotNull1(p1)) == false);
|
||||
CHECK((NotNull1(p1) != NotNull2(p2)) == true);
|
||||
|
||||
CHECK((NotNull1(p1) < NotNull1(p1)) == false);
|
||||
CHECK((NotNull1(p1) < NotNull2(p2)) == (p1 < p2));
|
||||
CHECK((NotNull2(p2) < NotNull1(p1)) == (p2 < p1));
|
||||
|
||||
CHECK((NotNull1(p1) > NotNull1(p1)) == false);
|
||||
CHECK((NotNull1(p1) > NotNull2(p2)) == (p1 > p2));
|
||||
CHECK((NotNull2(p2) > NotNull1(p1)) == (p2 > p1));
|
||||
|
||||
CHECK((NotNull1(p1) <= NotNull1(p1)) == true);
|
||||
CHECK((NotNull1(p1) <= NotNull2(p2)) == (p1 <= p2));
|
||||
CHECK((NotNull2(p2) <= NotNull1(p1)) == (p2 <= p1));
|
||||
|
||||
CHECK((NotNull1(p1) >= NotNull1(p1)) == true);
|
||||
CHECK((NotNull1(p1) >= NotNull2(p2)) == (p1 >= p2));
|
||||
CHECK((NotNull2(p2) >= NotNull1(p1)) == (p2 >= p1));
|
||||
}
|
||||
|
||||
TEST(TestNotNullSharedPtrComparison)
|
||||
{
|
||||
auto sp1 = std::make_shared<int>(42);
|
||||
auto sp2 = std::make_shared<const int>(43);
|
||||
|
||||
using NotNullSp1 = not_null<decltype(sp1)>;
|
||||
using NotNullSp2 = not_null<decltype(sp2)>;
|
||||
|
||||
CHECK((NotNullSp1(sp1) == NotNullSp1(sp1)) == true);
|
||||
CHECK((NotNullSp1(sp1) == NotNullSp2(sp2)) == false);
|
||||
|
||||
CHECK((NotNullSp1(sp1) != NotNullSp1(sp1)) == false);
|
||||
CHECK((NotNullSp1(sp1) != NotNullSp2(sp2)) == true);
|
||||
|
||||
CHECK((NotNullSp1(sp1) < NotNullSp1(sp1)) == false);
|
||||
CHECK((NotNullSp1(sp1) < NotNullSp2(sp2)) == (sp1 < sp2));
|
||||
CHECK((NotNullSp2(sp2) < NotNullSp1(sp1)) == (sp2 < sp1));
|
||||
|
||||
CHECK((NotNullSp1(sp1) > NotNullSp1(sp1)) == false);
|
||||
CHECK((NotNullSp1(sp1) > NotNullSp2(sp2)) == (sp1 > sp2));
|
||||
CHECK((NotNullSp2(sp2) > NotNullSp1(sp1)) == (sp2 > sp1));
|
||||
|
||||
CHECK((NotNullSp1(sp1) <= NotNullSp1(sp1)) == true);
|
||||
CHECK((NotNullSp1(sp1) <= NotNullSp2(sp2)) == (sp1 <= sp2));
|
||||
CHECK((NotNullSp2(sp2) <= NotNullSp1(sp1)) == (sp2 <= sp1));
|
||||
|
||||
CHECK((NotNullSp1(sp1) >= NotNullSp1(sp1)) == true);
|
||||
CHECK((NotNullSp1(sp1) >= NotNullSp2(sp2)) == (sp1 >= sp2));
|
||||
CHECK((NotNullSp2(sp2) >= NotNullSp1(sp1)) == (sp2 >= sp1));
|
||||
}
|
||||
|
||||
TEST(TestNotNullCustomPtrComparison)
|
||||
{
|
||||
int ints[2] = {42, 43};
|
||||
CustomPtr<int> p1(&ints[0]);
|
||||
CustomPtr<const int> p2(&ints[1]);
|
||||
|
||||
using NotNull1 = not_null<decltype(p1)>;
|
||||
using NotNull2 = not_null<decltype(p2)>;
|
||||
|
||||
CHECK((NotNull1(p1) == NotNull1(p1)) == "true");
|
||||
CHECK((NotNull1(p1) == NotNull2(p2)) == "false");
|
||||
|
||||
CHECK((NotNull1(p1) != NotNull1(p1)) == "false");
|
||||
CHECK((NotNull1(p1) != NotNull2(p2)) == "true");
|
||||
|
||||
CHECK((NotNull1(p1) < NotNull1(p1)) == "false");
|
||||
CHECK((NotNull1(p1) < NotNull2(p2)) == (p1 < p2));
|
||||
CHECK((NotNull2(p2) < NotNull1(p1)) == (p2 < p1));
|
||||
|
||||
CHECK((NotNull1(p1) > NotNull1(p1)) == "false");
|
||||
CHECK((NotNull1(p1) > NotNull2(p2)) == (p1 > p2));
|
||||
CHECK((NotNull2(p2) > NotNull1(p1)) == (p2 > p1));
|
||||
|
||||
CHECK((NotNull1(p1) <= NotNull1(p1)) == "true");
|
||||
CHECK((NotNull1(p1) <= NotNull2(p2)) == (p1 <= p2));
|
||||
CHECK((NotNull2(p2) <= NotNull1(p1)) == (p2 <= p1));
|
||||
|
||||
CHECK((NotNull1(p1) >= NotNull1(p1)) == "true");
|
||||
CHECK((NotNull1(p1) >= NotNull2(p2)) == (p1 >= p2));
|
||||
CHECK((NotNull2(p2) >= NotNull1(p1)) == (p2 >= p1));
|
||||
}
|
||||
|
||||
TEST(TestNotNullDereferenceOperator)
|
||||
{
|
||||
{
|
||||
auto sp1 = std::make_shared<NonCopyableNonMovable>();
|
||||
|
||||
using NotNullSp1 = not_null<decltype(sp1)>;
|
||||
CHECK(typeid(*sp1) == typeid(*NotNullSp1(sp1)));
|
||||
CHECK(std::addressof(*NotNullSp1(sp1)) == std::addressof(*sp1));
|
||||
}
|
||||
|
||||
{
|
||||
int ints[1] = { 42 };
|
||||
CustomPtr<int> p1(&ints[0]);
|
||||
|
||||
using NotNull1 = not_null<decltype(p1)>;
|
||||
CHECK(typeid(*NotNull1(p1)) == typeid(*p1));
|
||||
CHECK(*NotNull1(p1) == 42);
|
||||
*NotNull1(p1) = 43;
|
||||
CHECK(ints[0] == 43);
|
||||
}
|
||||
|
||||
{
|
||||
int v = 42;
|
||||
gsl::not_null<int*> p(&v);
|
||||
CHECK(typeid(*p) == typeid(*(&v)));
|
||||
*p = 43;
|
||||
CHECK(v == 43);
|
||||
}
|
||||
}
|
||||
not_null<std::shared_ptr<int>> x(
|
||||
std::make_shared<int>(10)); // shared_ptr<int> is nullptr assignable
|
||||
}
|
||||
|
||||
int main(int, const char* []) { return UnitTest::RunAllTests(); }
|
||||
TEST_CASE("TestNotNullCasting")
|
||||
{
|
||||
MyBase base;
|
||||
MyDerived derived;
|
||||
Unrelated unrelated;
|
||||
not_null<Unrelated*> u = &unrelated;
|
||||
(void) u;
|
||||
not_null<MyDerived*> p = &derived;
|
||||
not_null<MyBase*> q = &base;
|
||||
q = p; // allowed with heterogeneous copy ctor
|
||||
CHECK(q == p);
|
||||
|
||||
#ifdef CONFIRM_COMPILATION_ERRORS
|
||||
q = u; // no viable conversion possible between MyBase* and Unrelated*
|
||||
p = q; // not possible to implicitly convert MyBase* to MyDerived*
|
||||
|
||||
not_null<Unrelated*> r = p;
|
||||
not_null<Unrelated*> s = reinterpret_cast<Unrelated*>(p);
|
||||
#endif
|
||||
not_null<Unrelated*> t = reinterpret_cast<Unrelated*>(p.get());
|
||||
CHECK(reinterpret_cast<void*>(p.get()) == reinterpret_cast<void*>(t.get()));
|
||||
}
|
||||
|
||||
TEST_CASE("TestNotNullAssignment")
|
||||
{
|
||||
int i = 12;
|
||||
not_null<int*> p = &i;
|
||||
CHECK(helper(p));
|
||||
|
||||
int* q = nullptr;
|
||||
CHECK_THROWS_AS(p = q, fail_fast);
|
||||
}
|
||||
|
||||
TEST_CASE("TestNotNullRawPointerComparison")
|
||||
{
|
||||
int ints[2] = {42, 43};
|
||||
int* p1 = &ints[0];
|
||||
const int* p2 = &ints[1];
|
||||
|
||||
using NotNull1 = not_null<decltype(p1)>;
|
||||
using NotNull2 = not_null<decltype(p2)>;
|
||||
|
||||
CHECK((NotNull1(p1) == NotNull1(p1)) == true);
|
||||
CHECK((NotNull1(p1) == NotNull2(p2)) == false);
|
||||
|
||||
CHECK((NotNull1(p1) != NotNull1(p1)) == false);
|
||||
CHECK((NotNull1(p1) != NotNull2(p2)) == true);
|
||||
|
||||
CHECK((NotNull1(p1) < NotNull1(p1)) == false);
|
||||
CHECK((NotNull1(p1) < NotNull2(p2)) == (p1 < p2));
|
||||
CHECK((NotNull2(p2) < NotNull1(p1)) == (p2 < p1));
|
||||
|
||||
CHECK((NotNull1(p1) > NotNull1(p1)) == false);
|
||||
CHECK((NotNull1(p1) > NotNull2(p2)) == (p1 > p2));
|
||||
CHECK((NotNull2(p2) > NotNull1(p1)) == (p2 > p1));
|
||||
|
||||
CHECK((NotNull1(p1) <= NotNull1(p1)) == true);
|
||||
CHECK((NotNull1(p1) <= NotNull2(p2)) == (p1 <= p2));
|
||||
CHECK((NotNull2(p2) <= NotNull1(p1)) == (p2 <= p1));
|
||||
|
||||
}
|
||||
|
||||
TEST_CASE("TestNotNullDereferenceOperator")
|
||||
{
|
||||
{
|
||||
auto sp1 = std::make_shared<NonCopyableNonMovable>();
|
||||
|
||||
using NotNullSp1 = not_null<decltype(sp1)>;
|
||||
CHECK(typeid(*sp1) == typeid(*NotNullSp1(sp1)));
|
||||
CHECK(std::addressof(*NotNullSp1(sp1)) == std::addressof(*sp1));
|
||||
}
|
||||
|
||||
{
|
||||
int ints[1] = { 42 };
|
||||
CustomPtr<int> p1(&ints[0]);
|
||||
|
||||
using NotNull1 = not_null<decltype(p1)>;
|
||||
CHECK(typeid(*NotNull1(p1)) == typeid(*p1));
|
||||
CHECK(*NotNull1(p1) == 42);
|
||||
*NotNull1(p1) = 43;
|
||||
CHECK(ints[0] == 43);
|
||||
}
|
||||
|
||||
{
|
||||
int v = 42;
|
||||
gsl::not_null<int*> p(&v);
|
||||
CHECK(typeid(*p) == typeid(*(&v)));
|
||||
*p = 43;
|
||||
CHECK(v == 43);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("TestNotNullSharedPtrComparison")
|
||||
{
|
||||
auto sp1 = std::make_shared<int>(42);
|
||||
auto sp2 = std::make_shared<const int>(43);
|
||||
|
||||
using NotNullSp1 = not_null<decltype(sp1)>;
|
||||
using NotNullSp2 = not_null<decltype(sp2)>;
|
||||
|
||||
CHECK((NotNullSp1(sp1) == NotNullSp1(sp1)) == true);
|
||||
CHECK((NotNullSp1(sp1) == NotNullSp2(sp2)) == false);
|
||||
|
||||
CHECK((NotNullSp1(sp1) != NotNullSp1(sp1)) == false);
|
||||
CHECK((NotNullSp1(sp1) != NotNullSp2(sp2)) == true);
|
||||
|
||||
CHECK((NotNullSp1(sp1) < NotNullSp1(sp1)) == false);
|
||||
CHECK((NotNullSp1(sp1) < NotNullSp2(sp2)) == (sp1 < sp2));
|
||||
CHECK((NotNullSp2(sp2) < NotNullSp1(sp1)) == (sp2 < sp1));
|
||||
|
||||
CHECK((NotNullSp1(sp1) > NotNullSp1(sp1)) == false);
|
||||
CHECK((NotNullSp1(sp1) > NotNullSp2(sp2)) == (sp1 > sp2));
|
||||
CHECK((NotNullSp2(sp2) > NotNullSp1(sp1)) == (sp2 > sp1));
|
||||
|
||||
CHECK((NotNullSp1(sp1) <= NotNullSp1(sp1)) == true);
|
||||
CHECK((NotNullSp1(sp1) <= NotNullSp2(sp2)) == (sp1 <= sp2));
|
||||
CHECK((NotNullSp2(sp2) <= NotNullSp1(sp1)) == (sp2 <= sp1));
|
||||
|
||||
CHECK((NotNullSp1(sp1) >= NotNullSp1(sp1)) == true);
|
||||
CHECK((NotNullSp1(sp1) >= NotNullSp2(sp2)) == (sp1 >= sp2));
|
||||
CHECK((NotNullSp2(sp2) >= NotNullSp1(sp1)) == (sp2 >= sp1));
|
||||
}
|
||||
|
||||
TEST_CASE("TestNotNullCustomPtrComparison")
|
||||
{
|
||||
int ints[2] = {42, 43};
|
||||
CustomPtr<int> p1(&ints[0]);
|
||||
CustomPtr<const int> p2(&ints[1]);
|
||||
|
||||
using NotNull1 = not_null<decltype(p1)>;
|
||||
using NotNull2 = not_null<decltype(p2)>;
|
||||
|
||||
CHECK((NotNull1(p1) == NotNull1(p1)) == "true");
|
||||
CHECK((NotNull1(p1) == NotNull2(p2)) == "false");
|
||||
|
||||
CHECK((NotNull1(p1) != NotNull1(p1)) == "false");
|
||||
CHECK((NotNull1(p1) != NotNull2(p2)) == "true");
|
||||
|
||||
CHECK((NotNull1(p1) < NotNull1(p1)) == "false");
|
||||
CHECK((NotNull1(p1) < NotNull2(p2)) == (p1 < p2));
|
||||
CHECK((NotNull2(p2) < NotNull1(p1)) == (p2 < p1));
|
||||
|
||||
CHECK((NotNull1(p1) > NotNull1(p1)) == "false");
|
||||
CHECK((NotNull1(p1) > NotNull2(p2)) == (p1 > p2));
|
||||
CHECK((NotNull2(p2) > NotNull1(p1)) == (p2 > p1));
|
||||
|
||||
CHECK((NotNull1(p1) <= NotNull1(p1)) == "true");
|
||||
CHECK((NotNull1(p1) <= NotNull2(p2)) == (p1 <= p2));
|
||||
CHECK((NotNull2(p2) <= NotNull1(p1)) == (p2 <= p1));
|
||||
|
||||
CHECK((NotNull1(p1) >= NotNull1(p1)) == "true");
|
||||
CHECK((NotNull1(p1) >= NotNull2(p2)) == (p1 >= p2));
|
||||
CHECK((NotNull2(p2) >= NotNull1(p1)) == (p2 >= p1));
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user