Core/Utilities/CloneablePtrTests.cpp

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 CERN for the benefit of the ACTS project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
0008
0009 #include <boost/test/unit_test.hpp>
0010
0011 #include "Acts/Utilities/CloneablePtr.hpp"
0012
0013 #include <memory>
0014 #include <string>
0015 #include <utility>
0016
0017 using namespace Acts;
0018
0019 namespace {
0020
0021 struct Base {
0022   virtual ~Base() = default;
0023   virtual int value() const = 0;
0024   virtual std::unique_ptr<Base> clone() const = 0;
0025 };
0026
0027 struct Derived : Base {
0028   int m_val;
0029   explicit Derived(int v) : m_val(v) {}
0030   int value() const override { return m_val; }
0031   std::unique_ptr<Base> clone() const override {
0032     return std::make_unique<Derived>(m_val);
0033   }
0034 };
0035
0036 }  // namespace
0037
0038 BOOST_AUTO_TEST_SUITE(UtilitiesCloneablePtr)
0039
0040 BOOST_AUTO_TEST_CASE(DefaultConstruction) {
0041   CloneablePtr<int> p;
0042   BOOST_CHECK(!p);
0043   BOOST_CHECK(p.get() == nullptr);
0044 }
0045
0046 BOOST_AUTO_TEST_CASE(ConstructFromUniquePtr) {
0047   CloneablePtr<int> p(std::make_unique<int>(42));
0048   BOOST_CHECK(p);
0049   BOOST_CHECK_EQUAL(*p, 42);
0050 }
0051
0052 BOOST_AUTO_TEST_CASE(ConstructFromRawPtr) {
0053   CloneablePtr<int> p(new int(7));
0054   BOOST_CHECK(p);
0055   BOOST_CHECK_EQUAL(*p, 7);
0056 }
0057
0058 BOOST_AUTO_TEST_CASE(CopyConstruction) {
0059   CloneablePtr<int> a(std::make_unique<int>(10));
0060   CloneablePtr<int> b(a);
0061   BOOST_CHECK(a);
0062   BOOST_CHECK(b);
0063   BOOST_CHECK_EQUAL(*a, 10);
0064   BOOST_CHECK_EQUAL(*b, 10);
0065   BOOST_CHECK(a.get() != b.get());
0066 }
0067
0068 BOOST_AUTO_TEST_CASE(CopyAssignment) {
0069   CloneablePtr<int> a(std::make_unique<int>(20));
0070   CloneablePtr<int> b;
0071   b = a;
0072   BOOST_CHECK(b);
0073   BOOST_CHECK_EQUAL(*b, 20);
0074   BOOST_CHECK(a.get() != b.get());
0075 }
0076
0077 BOOST_AUTO_TEST_CASE(MoveConstruction) {
0078   CloneablePtr<int> a(std::make_unique<int>(30));
0079   int* raw = a.get();
0080   CloneablePtr<int> b(std::move(a));
0081   BOOST_CHECK(b);
0082   BOOST_CHECK_EQUAL(b.get(), raw);
0083   BOOST_CHECK(!a);  // NOLINT(bugprone-use-after-move)
0084 }
0085
0086 BOOST_AUTO_TEST_CASE(MoveAssignment) {
0087   CloneablePtr<int> a(std::make_unique<int>(40));
0088   int* raw = a.get();
0089   CloneablePtr<int> b;
0090   b = std::move(a);
0091   BOOST_CHECK(b);
0092   BOOST_CHECK_EQUAL(b.get(), raw);
0093   BOOST_CHECK(!a);  // NOLINT(bugprone-use-after-move)
0094 }
0095
0096 BOOST_AUTO_TEST_CASE(NullCopy) {
0097   CloneablePtr<int> a;
0098   CloneablePtr<int> b(a);
0099   BOOST_CHECK(!a);
0100   BOOST_CHECK(!b);
0101 }
0102
0103 BOOST_AUTO_TEST_CASE(Release) {
0104   CloneablePtr<int> p(std::make_unique<int>(50));
0105   std::unique_ptr<int> raw = p.release();
0106   BOOST_CHECK(!p);
0107   BOOST_CHECK_EQUAL(*raw, 50);
0108 }
0109
0110 BOOST_AUTO_TEST_CASE(Reset) {
0111   CloneablePtr<int> p(std::make_unique<int>(60));
0112   p.reset();
0113   BOOST_CHECK(!p);
0114
0115   p.reset(new int(70));
0116   BOOST_CHECK(p);
0117   BOOST_CHECK_EQUAL(*p, 70);
0118 }
0119
0120 BOOST_AUTO_TEST_CASE(ArrowOperator) {
0121   CloneablePtr<std::string> p(std::make_unique<std::string>("hello"));
0122   BOOST_CHECK_EQUAL(p->size(), 5u);
0123 }
0124
0125 BOOST_AUTO_TEST_CASE(CustomCloner) {
0126   auto cloner = [](const Base& b) { return b.clone(); };
0127
0128   CloneablePtr<Base> a(std::make_unique<Derived>(99), std::move(cloner));
0129   BOOST_CHECK(a);
0130   BOOST_CHECK_EQUAL(a->value(), 99);
0131
0132   CloneablePtr<Base> b(a);
0133   BOOST_CHECK(b);
0134   BOOST_CHECK_EQUAL(b->value(), 99);
0135   BOOST_CHECK(a.get() != b.get());
0136 }
0137
0138 BOOST_AUTO_TEST_CASE(NullptrComparison) {
0139   CloneablePtr<int> null;
0140   CloneablePtr<int> nonNull(std::make_unique<int>(1));
0141
0142   BOOST_CHECK(null == nullptr);
0143   BOOST_CHECK(nullptr == null);
0144   BOOST_CHECK(!(null != nullptr));
0145
0146   BOOST_CHECK(nonNull != nullptr);
0147   BOOST_CHECK(nullptr != nonNull);
0148   BOOST_CHECK(!(nonNull == nullptr));
0149 }
0150
0151 BOOST_AUTO_TEST_CASE(SelfAssignment) {
0152   CloneablePtr<int> p(std::make_unique<int>(5));
0153   auto* addr = p.get();
0154   auto& ref = p;
0155   p = ref;
0156   BOOST_CHECK(p);
0157   BOOST_CHECK_EQUAL(*p, 5);
0158   BOOST_CHECK_EQUAL(p.get(), addr);
0159 }
0160
0161 BOOST_AUTO_TEST_SUITE_END()