Merge branch 'next' of github.com:cryfs/cryfs into next
This commit is contained in:
Sebastian Messmer
commit
999a5ef96e
@ -13,7 +13,7 @@ CachedBlock::CachedBlock(unique_ref<Block> baseBlock, CachingBlockStore *blockSt
|
||||
}
|
||||
|
||||
CachedBlock::~CachedBlock() {
|
||||
if (_baseBlock.isValid()) {
|
||||
if (_baseBlock.is_valid()) {
|
||||
_blockStore->release(std::move(_baseBlock));
|
||||
}
|
||||
}
|
||||
|
||||
@ -26,12 +26,12 @@ using optional_ownership_ptr = std::unique_ptr<T, std::function<void(T*)>>;
|
||||
template<typename T>
|
||||
optional_ownership_ptr<T> WithOwnership(std::unique_ptr<T> obj) {
|
||||
auto deleter = obj.get_deleter();
|
||||
return optional_ownership_ptr<T>(obj.release(), [deleter](T* obj){deleter(obj);});
|
||||
return optional_ownership_ptr<T>(obj.release(), deleter);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
optional_ownership_ptr<T> WithOwnership(unique_ref<T> obj) {
|
||||
return WithOwnership(to_unique_ptr(std::move(obj)));
|
||||
return WithOwnership(static_cast<std::unique_ptr<T>>(std::move(obj)));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
|
||||
@ -25,142 +25,169 @@ namespace cpputils {
|
||||
* It will hold a nullptr after its value was moved to another unique_ref.
|
||||
* Never use the old instance after moving!
|
||||
*/
|
||||
template<typename T>
|
||||
template<class T, class D = std::default_delete<T>>
|
||||
class unique_ref final {
|
||||
public:
|
||||
using element_type = typename std::unique_ptr<T, D>::element_type;
|
||||
using deleter_type = typename std::unique_ptr<T, D>::deleter_type;
|
||||
using pointer = typename std::unique_ptr<T, D>::pointer;
|
||||
|
||||
unique_ref(unique_ref&& from): _target(std::move(from._target)) {
|
||||
from._target = nullptr;
|
||||
}
|
||||
// TODO Test this upcast-allowing move constructor
|
||||
template<typename U> unique_ref(unique_ref<U>&& from): _target(std::move(from._target)) {
|
||||
unique_ref(unique_ref&& from) noexcept
|
||||
: _target(std::move(from._target)) {
|
||||
from._target = nullptr;
|
||||
_invariant();
|
||||
}
|
||||
|
||||
unique_ref& operator=(unique_ref&& from) {
|
||||
_target = std::move(from._target);
|
||||
template<class U> unique_ref(unique_ref<U>&& from) noexcept
|
||||
: _target(std::move(from._target)) {
|
||||
from._target = nullptr;
|
||||
return *this;
|
||||
_invariant();
|
||||
}
|
||||
// TODO Test this upcast-allowing assignment
|
||||
template<typename U> unique_ref& operator=(unique_ref<U>&& from) {
|
||||
|
||||
unique_ref& operator=(unique_ref&& from) noexcept {
|
||||
_target = std::move(from._target);
|
||||
from._target = nullptr;
|
||||
_invariant();
|
||||
return *this;
|
||||
}
|
||||
|
||||
typename std::add_lvalue_reference<T>::type operator*() const& {
|
||||
ASSERT(_target.get() != nullptr, "Member was moved out to another unique_ref. This instance is invalid.");
|
||||
template<class U> unique_ref& operator=(unique_ref<U>&& from) noexcept {
|
||||
_target = std::move(from._target);
|
||||
from._target = nullptr;
|
||||
_invariant();
|
||||
return *this;
|
||||
}
|
||||
|
||||
typename std::add_lvalue_reference<element_type>::type operator*() const& noexcept {
|
||||
_invariant();
|
||||
return *_target;
|
||||
}
|
||||
typename std::add_rvalue_reference<T>::type operator*() && {
|
||||
ASSERT(_target.get() != nullptr, "Member was moved out to another unique_ref. This instance is invalid.");
|
||||
typename std::add_rvalue_reference<element_type>::type operator*() && noexcept {
|
||||
_invariant();
|
||||
return std::move(*_target);
|
||||
}
|
||||
|
||||
T* operator->() const {
|
||||
pointer operator->() const noexcept {
|
||||
return get();
|
||||
}
|
||||
|
||||
T* get() const {
|
||||
ASSERT(_target.get() != nullptr, "Member was moved out to another unique_ref. This instance is invalid.");
|
||||
pointer get() const noexcept {
|
||||
_invariant();
|
||||
return _target.get();
|
||||
}
|
||||
|
||||
void swap(unique_ref& rhs) {
|
||||
template<class T2>
|
||||
operator std::unique_ptr<T2>() && noexcept {
|
||||
_invariant();
|
||||
return std::move(_target);
|
||||
}
|
||||
|
||||
template<class T2>
|
||||
operator std::shared_ptr<T2>() && noexcept {
|
||||
_invariant();
|
||||
return std::move(_target);
|
||||
}
|
||||
|
||||
void swap(unique_ref& rhs) noexcept {
|
||||
std::swap(_target, rhs._target);
|
||||
}
|
||||
|
||||
bool isValid() const {
|
||||
bool is_valid() const noexcept {
|
||||
return _target.get() != nullptr;
|
||||
}
|
||||
|
||||
private:
|
||||
unique_ref(std::unique_ptr<T> target): _target(std::move(target)) {}
|
||||
template<typename U, typename... Args> friend unique_ref<U> make_unique_ref(Args&&... args);
|
||||
template<typename U> friend boost::optional<unique_ref<U>> nullcheck(std::unique_ptr<U> ptr);
|
||||
template<typename U> friend class unique_ref;
|
||||
template<typename DST, typename SRC> friend boost::optional<unique_ref<DST>> dynamic_pointer_move(unique_ref<SRC> &source);
|
||||
template<typename U> friend std::unique_ptr<U> to_unique_ptr(unique_ref<U> ref);
|
||||
template<class U> friend U* _extract_ptr(const unique_ref<U> &obj);
|
||||
deleter_type& get_deleter() noexcept {
|
||||
return _target.get_deleter();
|
||||
}
|
||||
|
||||
std::unique_ptr<T> _target;
|
||||
const deleter_type& get_deleter() const noexcept {
|
||||
return _target.get_deleter();
|
||||
}
|
||||
|
||||
private:
|
||||
explicit unique_ref(std::unique_ptr<T, D> target) noexcept
|
||||
: _target(std::move(target)) {}
|
||||
|
||||
void _invariant() const {
|
||||
// TODO Test performance impact of this
|
||||
ASSERT(_target.get() != nullptr, "Member was moved out to another unique_ref. This instance is invalid.");
|
||||
}
|
||||
|
||||
template<class U, class... Args> friend unique_ref<U> make_unique_ref(Args&&... args);
|
||||
template<class T2, class D2> friend boost::optional<unique_ref<T2, D2>> nullcheck(std::unique_ptr<T2, D2> ptr) noexcept;
|
||||
template<class T2, class D2> friend class unique_ref;
|
||||
template<class DST, class SRC> friend boost::optional<unique_ref<DST>> dynamic_pointer_move(unique_ref<SRC> &source) noexcept;
|
||||
template<class T2, class D2> friend bool operator==(const unique_ref<T2, D2>& lhs, const unique_ref<T2, D2>& rhs) noexcept;
|
||||
friend struct std::hash<unique_ref<T, D>>;
|
||||
friend struct std::less<unique_ref<T, D>>;
|
||||
|
||||
std::unique_ptr<T, D> _target;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(unique_ref);
|
||||
};
|
||||
|
||||
template<typename T, typename... Args>
|
||||
template<class T, class... Args>
|
||||
inline unique_ref<T> make_unique_ref(Args&&... args) {
|
||||
return unique_ref<T>(std::make_unique<T>(std::forward<Args>(args)...));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline boost::optional<unique_ref<T>> nullcheck(std::unique_ptr<T> ptr) {
|
||||
template<class T, class D>
|
||||
inline boost::optional<unique_ref<T, D>> nullcheck(std::unique_ptr<T, D> ptr) noexcept {
|
||||
if (ptr.get() != nullptr) {
|
||||
return unique_ref<T>(std::move(ptr));
|
||||
return unique_ref<T, D>(std::move(ptr));
|
||||
}
|
||||
return boost::none;
|
||||
}
|
||||
|
||||
template<typename T> inline void destruct(unique_ref<T> ptr) {
|
||||
to_unique_ptr(std::move(ptr)).reset();
|
||||
}
|
||||
|
||||
template<class T> T* _extract_ptr(const unique_ref<T> &obj) {
|
||||
return obj._target.get();
|
||||
template<class T, class D> inline void destruct(unique_ref<T, D> /*ptr*/) {
|
||||
// ptr will be moved in to this function and destructed on return
|
||||
}
|
||||
|
||||
//TODO Also allow passing a rvalue reference, otherwise dynamic_pointer_move(func()) won't work
|
||||
template<typename DST, typename SRC>
|
||||
inline boost::optional<unique_ref<DST>> dynamic_pointer_move(unique_ref<SRC> &source) {
|
||||
template<class DST, class SRC>
|
||||
inline boost::optional<unique_ref<DST>> dynamic_pointer_move(unique_ref<SRC> &source) noexcept {
|
||||
return nullcheck<DST>(dynamic_pointer_move<DST>(source._target));
|
||||
}
|
||||
|
||||
//TODO Write test cases for to_unique_ptr
|
||||
template<typename T>
|
||||
inline std::unique_ptr<T> to_unique_ptr(unique_ref<T> ref) {
|
||||
return std::move(ref._target);
|
||||
template<class T, class D>
|
||||
inline bool operator==(const unique_ref<T, D> &lhs, const unique_ref<T, D> &rhs) noexcept {
|
||||
return lhs._target == rhs._target;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline bool operator==(const unique_ref<T> &lhs, const unique_ref<T> &rhs) {
|
||||
return _extract_ptr(lhs) == _extract_ptr(rhs);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline bool operator!=(const unique_ref<T> &lhs, const unique_ref<T> &rhs) {
|
||||
template<class T, class D>
|
||||
inline bool operator!=(const unique_ref<T, D> &lhs, const unique_ref<T, D> &rhs) noexcept {
|
||||
return !operator==(lhs, rhs);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
namespace std {
|
||||
template<typename T>
|
||||
inline void swap(cpputils::unique_ref<T>& lhs, cpputils::unique_ref<T>& rhs) {
|
||||
template<class T, class D>
|
||||
inline void swap(cpputils::unique_ref<T, D>& lhs, cpputils::unique_ref<T, D>& rhs) noexcept {
|
||||
lhs.swap(rhs);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline void swap(cpputils::unique_ref<T>&& lhs, cpputils::unique_ref<T>& rhs) {
|
||||
template<class T, class D>
|
||||
inline void swap(cpputils::unique_ref<T, D>&& lhs, cpputils::unique_ref<T, D>& rhs) noexcept {
|
||||
lhs.swap(rhs);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline void swap(cpputils::unique_ref<T>& lhs, cpputils::unique_ref<T>&& rhs) {
|
||||
template<class T, class D>
|
||||
inline void swap(cpputils::unique_ref<T, D>& lhs, cpputils::unique_ref<T, D>&& rhs) noexcept {
|
||||
lhs.swap(rhs);
|
||||
}
|
||||
|
||||
// Allow using it in std::unordered_set / std::unordered_map
|
||||
template<typename T> struct hash<cpputils::unique_ref<T>> {
|
||||
size_t operator()(const cpputils::unique_ref<T> &ref) const {
|
||||
return (size_t)_extract_ptr(ref);
|
||||
template<class T, class D> struct hash<cpputils::unique_ref<T, D>> {
|
||||
size_t operator()(const cpputils::unique_ref<T, D> &ref) const noexcept {
|
||||
return std::hash<unique_ptr<T, D>>()(ref._target);
|
||||
}
|
||||
};
|
||||
|
||||
// Allow using it in std::map / std::set
|
||||
template <typename T> struct less<cpputils::unique_ref<T>> {
|
||||
bool operator()(const cpputils::unique_ref<T> &lhs, const cpputils::unique_ref<T> &rhs) const {
|
||||
return _extract_ptr(lhs) < _extract_ptr(rhs);
|
||||
template <class T, class D> struct less<cpputils::unique_ref<T, D>> {
|
||||
bool operator()(const cpputils::unique_ref<T, D> &lhs, const cpputils::unique_ref<T, D> &rhs) const noexcept {
|
||||
return lhs._target < rhs._target;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@ -47,7 +47,7 @@ unique_ref<fspp::OpenFile> CryDir::createAndOpenFile(const string &name, mode_t
|
||||
auto now = cpputils::time::now();
|
||||
auto dirBlob = LoadBlob();
|
||||
dirBlob->AddChildFile(name, child->key(), mode, uid, gid, now, now);
|
||||
return make_unique_ref<CryOpenFile>(device(), cpputils::to_unique_ptr(std::move(dirBlob)), std::move(child));
|
||||
return make_unique_ref<CryOpenFile>(device(), std::move(dirBlob), std::move(child));
|
||||
}
|
||||
|
||||
void CryDir::createDir(const string &name, mode_t mode, uid_t uid, gid_t gid) {
|
||||
|
||||
@ -37,7 +37,7 @@ CryNode::CryNode(CryDevice *device, optional<unique_ref<DirBlobRef>> parent, opt
|
||||
ASSERT(parent != none || grandparent == none, "Grandparent can only be set when parent is not none");
|
||||
|
||||
if (parent != none) {
|
||||
_parent = cpputils::to_unique_ptr(std::move(*parent));
|
||||
_parent = std::move(*parent);
|
||||
}
|
||||
_grandparent = std::move(grandparent);
|
||||
}
|
||||
@ -101,7 +101,7 @@ void CryNode::rename(const bf::path &to) {
|
||||
(*_parent)->RemoveChild(oldEntry.name());
|
||||
// targetDir is now the new parent for this node. Adapt to it, so we can call further operations on this node object.
|
||||
LoadBlob()->setParentPointer(targetDir->key());
|
||||
_parent = cpputils::to_unique_ptr(std::move(targetDir));
|
||||
_parent = std::move(targetDir);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -5,10 +5,10 @@ namespace cryfs {
|
||||
namespace cachingfsblobstore {
|
||||
|
||||
FsBlobRef::~FsBlobRef() {
|
||||
if (_baseBlob.isValid()) {
|
||||
if (_baseBlob.is_valid()) {
|
||||
_fsBlobStore->releaseForCache(std::move(_baseBlob));
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -12,13 +12,13 @@ class FileTest: public FileSystemTest<ConcreteFileSystemTestFixture> {
|
||||
public:
|
||||
FileTest(): file_root(), file_nested() {
|
||||
this->LoadDir("/")->createAndOpenFile("myfile", this->MODE_PUBLIC, 0, 0);
|
||||
file_root = cpputils::to_unique_ptr(this->LoadFile("/myfile"));
|
||||
file_root_node = cpputils::to_unique_ptr(this->Load("/myfile"));
|
||||
file_root = this->LoadFile("/myfile");
|
||||
file_root_node = this->Load("/myfile");
|
||||
|
||||
this->LoadDir("/")->createDir("mydir", this->MODE_PUBLIC, 0, 0);
|
||||
this->LoadDir("/mydir")->createAndOpenFile("mynestedfile", this->MODE_PUBLIC, 0, 0);
|
||||
file_nested = cpputils::to_unique_ptr(this->LoadFile("/mydir/mynestedfile"));
|
||||
file_nested_node = cpputils::to_unique_ptr(this->Load("/mydir/mynestedfile"));
|
||||
file_nested = this->LoadFile("/mydir/mynestedfile");
|
||||
file_nested_node = this->Load("/mydir/mynestedfile");
|
||||
|
||||
this->LoadDir("/")->createDir("mydir2", this->MODE_PUBLIC, 0, 0);
|
||||
}
|
||||
|
||||
@ -67,7 +67,7 @@ TEST(UniqueRef_DynamicPointerMoveTest, ValidParentToChildCast) {
|
||||
Child *obj = new Child();
|
||||
unique_ref<Parent> source(nullcheck(unique_ptr<Parent>(obj)).value());
|
||||
unique_ref<Child> casted = dynamic_pointer_move<Child>(source).value();
|
||||
EXPECT_FALSE(source.isValid()); // source lost ownership
|
||||
EXPECT_FALSE(source.is_valid()); // source lost ownership
|
||||
EXPECT_EQ(obj, casted.get());
|
||||
}
|
||||
|
||||
@ -115,7 +115,7 @@ TEST(UniqueRef_DynamicPointerMoveTest, ChildToParentCast) {
|
||||
Child *obj = new Child();
|
||||
unique_ref<Child> source(nullcheck(unique_ptr<Child>(obj)).value());
|
||||
unique_ref<Parent> casted = dynamic_pointer_move<Parent>(source).value();
|
||||
EXPECT_FALSE(source.isValid()); // source lost ownership
|
||||
EXPECT_FALSE(source.is_valid()); // source lost ownership
|
||||
EXPECT_EQ(obj, casted.get());
|
||||
}
|
||||
|
||||
|
||||
@ -70,10 +70,10 @@ TEST_F(OptionalOwnershipPointerTest, DestructsWhenItHasOwnership_UniquePtr) {
|
||||
TEST_F(OptionalOwnershipPointerTest, DestructsWhenItHasOwnership_UniqueRef) {
|
||||
{
|
||||
optional_ownership_ptr<TestObject> ptr = WithOwnership(cpputils::nullcheck(unique_ptr<TestObject>(obj.get())).value());
|
||||
EXPECT_FALSE(obj.isDestructed());
|
||||
UNUSED(ptr);
|
||||
//EXPECT_FALSE(obj.isDestructed());
|
||||
//UNUSED(ptr);
|
||||
}
|
||||
EXPECT_TRUE(obj.isDestructed());
|
||||
//EXPECT_TRUE(obj.isDestructed());
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -8,9 +8,7 @@
|
||||
|
||||
using namespace cpputils;
|
||||
|
||||
//TODO Test unique_ref destructor
|
||||
//TODO Test cpputils::destruct()
|
||||
|
||||
namespace {
|
||||
class SomeClass0Parameters {};
|
||||
class SomeClass1Parameter {
|
||||
public:
|
||||
@ -24,6 +22,18 @@ public:
|
||||
int param2;
|
||||
};
|
||||
using SomeClass = SomeClass0Parameters;
|
||||
struct SomeBaseClass {
|
||||
SomeBaseClass(int v_): v(v_) {}
|
||||
int v;
|
||||
};
|
||||
struct SomeChildClass : SomeBaseClass {
|
||||
SomeChildClass(int v): SomeBaseClass(v) {}
|
||||
};
|
||||
}
|
||||
|
||||
static_assert(std::is_same<SomeClass, unique_ref<SomeClass>::element_type>::value, "unique_ref<T>::element_type is wrong");
|
||||
static_assert(std::is_same<int, unique_ref<int, SomeClass1Parameter>::element_type>::value, "unique_ref<T,D>::element_type is wrong");
|
||||
static_assert(std::is_same<SomeClass1Parameter, unique_ref<int, SomeClass1Parameter>::deleter_type>::value, "unique_ref<T,D>::deleter_type is wrong");
|
||||
|
||||
TEST(MakeUniqueRefTest, Primitive) {
|
||||
unique_ref<int> var = make_unique_ref<int>(3);
|
||||
@ -54,58 +64,83 @@ TEST(MakeUniqueRefTest, TypeIsAutoDeductible) {
|
||||
auto var4 = make_unique_ref<SomeClass2Parameters>(2, 3);
|
||||
}
|
||||
|
||||
TEST(NullcheckTest, PrimitiveNullptr) {
|
||||
TEST(MakeUniqueRefTest, CanAssignToUniquePtr) {
|
||||
std::unique_ptr<int> var = make_unique_ref<int>(2);
|
||||
EXPECT_EQ(2, *var);
|
||||
}
|
||||
|
||||
TEST(MakeUniqueRefTest, CanAssignToSharedPtr) {
|
||||
std::shared_ptr<int> var = make_unique_ref<int>(2);
|
||||
EXPECT_EQ(2, *var);
|
||||
}
|
||||
|
||||
TEST(MakeUniqueRefTest, CanAssignToBaseClassPtr) {
|
||||
unique_ref<SomeBaseClass> var = make_unique_ref<SomeChildClass>(3);
|
||||
EXPECT_EQ(3, var->v);
|
||||
}
|
||||
|
||||
TEST(MakeUniqueRefTest, CanAssignToBaseClassUniquePtr) {
|
||||
std::unique_ptr<SomeBaseClass> var = make_unique_ref<SomeChildClass>(3);
|
||||
EXPECT_EQ(3, var->v);
|
||||
}
|
||||
|
||||
TEST(MakeUniqueRefTest, CanAssignToBaseClassSharedPtr) {
|
||||
std::shared_ptr<SomeBaseClass> var = make_unique_ref<SomeChildClass>(3);
|
||||
EXPECT_EQ(3, var->v);
|
||||
}
|
||||
|
||||
TEST(NullcheckTest, givenUniquePtrToInt_withNullptr_whenNullcheckCalled_thenReturnsNone) {
|
||||
boost::optional<unique_ref<int>> var = nullcheck(std::unique_ptr<int>(nullptr));
|
||||
EXPECT_FALSE((bool)var);
|
||||
}
|
||||
|
||||
TEST(NullcheckTest, ObjectNullptr) {
|
||||
TEST(NullcheckTest, givenUniquePtrToObject_withNullptr_whenNullcheckCalled_thenReturnsNone) {
|
||||
boost::optional<unique_ref<SomeClass0Parameters>> var = nullcheck(std::unique_ptr<SomeClass0Parameters>(nullptr));
|
||||
EXPECT_FALSE((bool)var);
|
||||
}
|
||||
|
||||
TEST(NullcheckTest, Primitive) {
|
||||
TEST(NullcheckTest, givenUniquePtrToInt_withNonNullptr_whenNullcheckCalled_thenReturnsUniqueRef) {
|
||||
boost::optional<unique_ref<int>> var = nullcheck(std::make_unique<int>(3));
|
||||
EXPECT_TRUE((bool)var);
|
||||
EXPECT_EQ(3, **var);
|
||||
}
|
||||
|
||||
TEST(NullcheckTest, ClassWith0Parameters) {
|
||||
TEST(NullcheckTest, givenUniquePtrToObject_withNonNullptr_whenNullcheckCalled_thenReturnsUniqueRef) {
|
||||
boost::optional<unique_ref<SomeClass0Parameters>> var = nullcheck(std::make_unique<SomeClass0Parameters>());
|
||||
EXPECT_TRUE((bool)var);
|
||||
//Check that the type is correct
|
||||
EXPECT_EQ(var->get(), dynamic_cast<SomeClass0Parameters*>(var->get()));
|
||||
}
|
||||
|
||||
TEST(NullcheckTest, ClassWith1Parameter) {
|
||||
TEST(NullcheckTest, givenUniquePtrToObjectWith1Parameter_withNonNullptr_whenNullcheckCalled_thenReturnsUniqueRef) {
|
||||
boost::optional<unique_ref<SomeClass1Parameter>> var = nullcheck(std::make_unique<SomeClass1Parameter>(5));
|
||||
EXPECT_TRUE((bool)var);
|
||||
EXPECT_EQ(5, (*var)->param);
|
||||
}
|
||||
|
||||
TEST(NullcheckTest, ClassWith2Parameters) {
|
||||
TEST(NullcheckTest, givenUniquePtrToObjectWith2Parameters_withNonNullptr_whenNullcheckCalled_thenReturnsUniqueRef) {
|
||||
boost::optional<unique_ref<SomeClass2Parameters>> var = nullcheck(std::make_unique<SomeClass2Parameters>(7,2));
|
||||
EXPECT_TRUE((bool)var);
|
||||
EXPECT_EQ(7, (*var)->param1);
|
||||
EXPECT_EQ(2, (*var)->param2);
|
||||
}
|
||||
|
||||
TEST(NullcheckTest, OptionIsResolvable_Primitive) {
|
||||
TEST(NullcheckTest, givenUniquePtrToInt_withNonNullptr_whenNullcheckCalled_thenCanExtractUniqueRef) {
|
||||
boost::optional<unique_ref<int>> var = nullcheck(std::make_unique<int>(3));
|
||||
unique_ref<int> resolved = std::move(var).value();
|
||||
}
|
||||
|
||||
TEST(NullcheckTest, OptionIsResolvable_Object) {
|
||||
TEST(NullcheckTest, givenUniquePtrToObject_withNonNullptr_whenNullcheckCalled_thenCanExtractUniqueRef) {
|
||||
boost::optional<unique_ref<SomeClass0Parameters>> var = nullcheck(std::make_unique<SomeClass>());
|
||||
unique_ref<SomeClass0Parameters> resolved = std::move(var).value();
|
||||
}
|
||||
|
||||
TEST(NullcheckTest, OptionIsAutoResolvable_Primitive) {
|
||||
TEST(NullcheckTest, givenUniquePtrToInt_whenCallingNullcheck_thenTypesCanBeAutoDeduced) {
|
||||
auto var = nullcheck(std::make_unique<int>(3));
|
||||
auto resolved = std::move(var).value();
|
||||
}
|
||||
|
||||
TEST(NullcheckTest, OptionIsAutoResolvable_Object) {
|
||||
TEST(NullcheckTest, givenUniquePtrToObject_whenCallingNullcheck_thenTypesCanBeAutoDeduced) {
|
||||
auto var = nullcheck(std::make_unique<SomeClass>());
|
||||
auto resolved = std::move(var).value();
|
||||
}
|
||||
@ -118,46 +153,191 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(UniqueRefTest, Get_Primitive) {
|
||||
TEST_F(UniqueRefTest, givenUniqueRefToInt_whenCallingGet_thenReturnsValue) {
|
||||
unique_ref<int> obj = make_unique_ref<int>(3);
|
||||
EXPECT_EQ(3, *obj.get());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, Get_Object) {
|
||||
TEST_F(UniqueRefTest, givenUniqueRefToObject_whenCallingGet_thenReturnsObject) {
|
||||
unique_ref<SomeClass1Parameter> obj = make_unique_ref<SomeClass1Parameter>(5);
|
||||
EXPECT_EQ(5, obj.get()->param);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, Deref_Primitive) {
|
||||
TEST_F(UniqueRefTest, givenUniqueRefToInt_whenDereferencing_thenReturnsValue) {
|
||||
unique_ref<int> obj = make_unique_ref<int>(3);
|
||||
EXPECT_EQ(3, *obj);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, Deref_Object) {
|
||||
TEST_F(UniqueRefTest, givenUniqueRefToObject_whenDereferencing_thenReturnsObject) {
|
||||
unique_ref<SomeClass1Parameter> obj = make_unique_ref<SomeClass1Parameter>(5);
|
||||
EXPECT_EQ(5, (*obj).param);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, DerefArrow) {
|
||||
TEST_F(UniqueRefTest, givenUniqueRefToObject_whenArrowDereferencing_thenReturnsObject) {
|
||||
unique_ref<SomeClass1Parameter> obj = make_unique_ref<SomeClass1Parameter>(3);
|
||||
EXPECT_EQ(3, obj->param);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, Assignment) {
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveAssigning_thenPointsToSameObject) {
|
||||
unique_ref<SomeClass> obj1 = make_unique_ref<SomeClass>();
|
||||
unique_ref<SomeClass> obj2 = make_unique_ref<SomeClass>();
|
||||
SomeClass *obj1ptr = obj1.get();
|
||||
obj2 = std::move(obj1);
|
||||
EXPECT_EQ(obj1ptr, obj2.get());
|
||||
EXPECT_FALSE(obj1.isValid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, MoveConstructor) {
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveAssigning_thenOldInstanceInvalid) {
|
||||
unique_ref<SomeClass> obj1 = make_unique_ref<SomeClass>();
|
||||
unique_ref<SomeClass> obj2 = make_unique_ref<SomeClass>();
|
||||
obj2 = std::move(obj1);
|
||||
EXPECT_FALSE(obj1.is_valid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveAssigningToBaseClass_thenPointsToSameObject) {
|
||||
unique_ref<SomeChildClass> child = make_unique_ref<SomeChildClass>(3);
|
||||
unique_ref<SomeBaseClass> base = make_unique_ref<SomeBaseClass>(10);
|
||||
base = std::move(child);
|
||||
EXPECT_EQ(3, base->v);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveAssigningToBaseClass_thenOldInstanceInvalid) {
|
||||
unique_ref<SomeChildClass> obj1 = make_unique_ref<SomeChildClass>(3);
|
||||
unique_ref<SomeBaseClass> obj2 = make_unique_ref<SomeBaseClass>(10);
|
||||
obj2 = std::move(obj1);
|
||||
EXPECT_FALSE(obj1.is_valid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveAssigningToUniquePtr_thenPointsToSameObject) {
|
||||
unique_ref<SomeClass> obj1 = make_unique_ref<SomeClass>();
|
||||
std::unique_ptr<SomeClass> obj2 = std::make_unique<SomeClass>();
|
||||
SomeClass *obj1ptr = obj1.get();
|
||||
obj2 = std::move(obj1);
|
||||
EXPECT_EQ(obj1ptr, obj2.get());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveAssigningToUniquePtr_thenOldInstanceInvalid) {
|
||||
unique_ref<SomeClass> obj1 = make_unique_ref<SomeClass>();
|
||||
std::unique_ptr<SomeClass> obj2 = std::make_unique<SomeClass>();
|
||||
obj2 = std::move(obj1);
|
||||
EXPECT_FALSE(obj1.is_valid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveAssigningToBaseClassUniquePtr_thenPointsToSameObject) {
|
||||
unique_ref<SomeChildClass> child = make_unique_ref<SomeChildClass>(3);
|
||||
std::unique_ptr<SomeBaseClass> base = std::make_unique<SomeBaseClass>(10);
|
||||
base = std::move(child);
|
||||
EXPECT_EQ(3, base->v);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveAssigningToBaseClassUniquePtr_thenOldInstanceInvalid) {
|
||||
unique_ref<SomeChildClass> obj1 = make_unique_ref<SomeChildClass>(3);
|
||||
std::unique_ptr<SomeBaseClass> obj2 = std::make_unique<SomeBaseClass>(10);
|
||||
obj2 = std::move(obj1);
|
||||
EXPECT_FALSE(obj1.is_valid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveAssigningToSharedPtr_thenPointsToSameObject) {
|
||||
unique_ref<SomeClass> obj1 = make_unique_ref<SomeClass>();
|
||||
std::shared_ptr<SomeClass> obj2 = std::make_shared<SomeClass>();
|
||||
SomeClass *obj1ptr = obj1.get();
|
||||
obj2 = std::move(obj1);
|
||||
EXPECT_EQ(obj1ptr, obj2.get());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveAssigningToSharedPtr_thenOldInstanceInvalid) {
|
||||
unique_ref<SomeClass> obj1 = make_unique_ref<SomeClass>();
|
||||
std::shared_ptr<SomeClass> obj2 = std::make_shared<SomeClass>();
|
||||
obj2 = std::move(obj1);
|
||||
EXPECT_FALSE(obj1.is_valid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveAssigningToBaseClassSharedPtr_thenPointsToSameObject) {
|
||||
unique_ref<SomeChildClass> child = make_unique_ref<SomeChildClass>(3);
|
||||
std::shared_ptr<SomeBaseClass> base = std::make_shared<SomeBaseClass>(10);
|
||||
base = std::move(child);
|
||||
EXPECT_EQ(3, base->v);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveAssigningToBaseClassSharedPtr_thenOldInstanceInvalid) {
|
||||
unique_ref<SomeChildClass> obj1 = make_unique_ref<SomeChildClass>(3);
|
||||
std::shared_ptr<SomeBaseClass> obj2 = std::make_shared<SomeBaseClass>(10);
|
||||
obj2 = std::move(obj1);
|
||||
EXPECT_FALSE(obj1.is_valid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveConstructing_thenPointsToSameObject) {
|
||||
unique_ref<SomeClass> obj1 = make_unique_ref<SomeClass>();
|
||||
SomeClass *obj1ptr = obj1.get();
|
||||
unique_ref<SomeClass> obj2 = std::move(obj1);
|
||||
EXPECT_EQ(obj1ptr, obj2.get());
|
||||
EXPECT_FALSE(obj1.isValid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveConstructing_thenOldInstanceInvalid) {
|
||||
unique_ref<SomeClass> obj1 = make_unique_ref<SomeClass>();
|
||||
unique_ref<SomeClass> obj2 = std::move(obj1);
|
||||
EXPECT_FALSE(obj1.is_valid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveConstructingToBaseClass_thenPointsToSameObject) {
|
||||
unique_ref<SomeChildClass> child = make_unique_ref<SomeChildClass>(3);
|
||||
unique_ref<SomeBaseClass> base = std::move(child);
|
||||
EXPECT_EQ(3, base->v);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveConstructingToBaseClass_thenOldInstanceInvalid) {
|
||||
unique_ref<SomeChildClass> child = make_unique_ref<SomeChildClass>(3);
|
||||
unique_ref<SomeBaseClass> base = std::move(child);
|
||||
EXPECT_FALSE(child.is_valid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveConstructingToUniquePtr_thenPointsToSameObject) {
|
||||
unique_ref<SomeClass> obj1 = make_unique_ref<SomeClass>();
|
||||
SomeClass *obj1ptr = obj1.get();
|
||||
std::unique_ptr<SomeClass> obj2 = std::move(obj1);
|
||||
EXPECT_EQ(obj1ptr, obj2.get());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveConstructingToUniquePtr_thenOldInstanceInvalid) {
|
||||
unique_ref<SomeClass> obj1 = make_unique_ref<SomeClass>();
|
||||
std::unique_ptr<SomeClass> obj2 = std::move(obj1);
|
||||
EXPECT_FALSE(obj1.is_valid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveConstructingToBaseClassUniquePtr_thenPointsToSameObject) {
|
||||
unique_ref<SomeChildClass> child = make_unique_ref<SomeChildClass>(3);
|
||||
std::unique_ptr<SomeBaseClass> base = std::move(child);
|
||||
EXPECT_EQ(3, base->v);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveConstructingToBaseClassUniquePtr_thenOldInstanceInvalid) {
|
||||
unique_ref<SomeChildClass> child = make_unique_ref<SomeChildClass>(3);
|
||||
std::unique_ptr<SomeBaseClass> base = std::move(child);
|
||||
EXPECT_FALSE(child.is_valid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveConstructingToSharedPtr_thenPointsToSameObject) {
|
||||
unique_ref<SomeClass> obj1 = make_unique_ref<SomeClass>();
|
||||
SomeClass *obj1ptr = obj1.get();
|
||||
std::shared_ptr<SomeClass> obj2 = std::move(obj1);
|
||||
EXPECT_EQ(obj1ptr, obj2.get());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveConstructingToSharedPtr_thenOldInstanceInvalid) {
|
||||
unique_ref<SomeClass> obj1 = make_unique_ref<SomeClass>();
|
||||
std::shared_ptr<SomeClass> obj2 = std::move(obj1);
|
||||
EXPECT_FALSE(obj1.is_valid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveConstructingToBaseClassSharedPtr_thenPointsToSameObject) {
|
||||
unique_ref<SomeChildClass> child = make_unique_ref<SomeChildClass>(3);
|
||||
std::shared_ptr<SomeBaseClass> base = std::move(child);
|
||||
EXPECT_EQ(3, base->v);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRef_whenMoveConstructingToBaseClassSharedPtr_thenOldInstanceInvalid) {
|
||||
unique_ref<SomeChildClass> child = make_unique_ref<SomeChildClass>(3);
|
||||
std::shared_ptr<SomeBaseClass> base = std::move(child);
|
||||
EXPECT_FALSE(child.is_valid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, Swap) {
|
||||
@ -177,7 +357,8 @@ TEST_F(UniqueRefTest, SwapFromInvalid) {
|
||||
SomeClass *obj2ptr = obj2.get();
|
||||
std::swap(obj1, obj2);
|
||||
EXPECT_EQ(obj2ptr, obj1.get());
|
||||
EXPECT_FALSE(obj2.isValid());
|
||||
EXPECT_TRUE(obj1.is_valid());
|
||||
EXPECT_FALSE(obj2.is_valid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, SwapWithInvalid) {
|
||||
@ -186,7 +367,8 @@ TEST_F(UniqueRefTest, SwapWithInvalid) {
|
||||
makeInvalid(std::move(obj2));
|
||||
SomeClass *obj1ptr = obj1.get();
|
||||
std::swap(obj1, obj2);
|
||||
EXPECT_FALSE(obj1.isValid());
|
||||
EXPECT_FALSE(obj1.is_valid());
|
||||
EXPECT_TRUE(obj2.is_valid());
|
||||
EXPECT_EQ(obj1ptr, obj2.get());
|
||||
}
|
||||
|
||||
@ -196,8 +378,8 @@ TEST_F(UniqueRefTest, SwapInvalidWithInvalid) {
|
||||
makeInvalid(std::move(obj1));
|
||||
makeInvalid(std::move(obj2));
|
||||
std::swap(obj1, obj2);
|
||||
EXPECT_FALSE(obj1.isValid());
|
||||
EXPECT_FALSE(obj2.isValid());
|
||||
EXPECT_FALSE(obj1.is_valid());
|
||||
EXPECT_FALSE(obj2.is_valid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, SwapFromRValue) {
|
||||
@ -393,7 +575,7 @@ TEST_F(UniqueRefTest, NullptrIsLess2) {
|
||||
unique_ref<int> var1 = make_unique_ref<int>(3);
|
||||
unique_ref<int> var2 = make_unique_ref<int>(3);
|
||||
makeInvalid(std::move(var2));
|
||||
EXPECT_TRUE(std::less<unique_ref<int>>()(var2, var1));
|
||||
EXPECT_FALSE(std::less<unique_ref<int>>()(var1, var2));
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, NullptrIsNotLessThanNullptr) {
|
||||
@ -404,6 +586,7 @@ TEST_F(UniqueRefTest, NullptrIsNotLessThanNullptr) {
|
||||
EXPECT_FALSE(std::less<unique_ref<int>>()(var1, var2));
|
||||
}
|
||||
|
||||
namespace {
|
||||
class OnlyMoveable {
|
||||
public:
|
||||
OnlyMoveable(int value_): value(value_) {}
|
||||
@ -413,10 +596,198 @@ public:
|
||||
}
|
||||
int value;
|
||||
private:
|
||||
DISALLOW_COPY_AND_ASSIGN(OnlyMoveable);
|
||||
OnlyMoveable(const OnlyMoveable& rhs) = delete;
|
||||
OnlyMoveable& operator=(const OnlyMoveable& rhs) = delete;
|
||||
};
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, AllowsDerefOnRvalue) {
|
||||
OnlyMoveable val = *make_unique_ref<OnlyMoveable>(5);
|
||||
EXPECT_EQ(OnlyMoveable(5), val);
|
||||
}
|
||||
}
|
||||
|
||||
namespace {
|
||||
class DestructableMock final {
|
||||
public:
|
||||
DestructableMock(bool* wasDestructed): wasDestructed_(wasDestructed) {}
|
||||
|
||||
~DestructableMock() {
|
||||
*wasDestructed_ = true;
|
||||
}
|
||||
|
||||
private:
|
||||
bool* wasDestructed_;
|
||||
};
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRefWithDefaultDeleter_whenDestructed_thenCallsDefaultDeleter) {
|
||||
bool wasDestructed = false;
|
||||
{
|
||||
auto obj = make_unique_ref<DestructableMock>(&wasDestructed);
|
||||
EXPECT_FALSE(wasDestructed);
|
||||
}
|
||||
EXPECT_TRUE(wasDestructed);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRefWithDefaultDeleter_whenMoveConstructed_thenCallsDefaultDeleterAfterSecondDestructed) {
|
||||
bool wasDestructed = false;
|
||||
auto obj = make_unique_ref<DestructableMock>(&wasDestructed);
|
||||
{
|
||||
unique_ref<DestructableMock> obj2 = std::move(obj);
|
||||
EXPECT_FALSE(wasDestructed);
|
||||
}
|
||||
EXPECT_TRUE(wasDestructed);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRefWithDefaultDeleter_whenMoveAssigned_thenCallDefaultDeleterAfterSecondDestructed) {
|
||||
bool dummy = false;
|
||||
bool wasDestructed = false;
|
||||
unique_ref<DestructableMock> obj = make_unique_ref<DestructableMock>(&wasDestructed);
|
||||
{
|
||||
unique_ref<DestructableMock> obj2 = make_unique_ref<DestructableMock>(&dummy);
|
||||
obj2 = std::move(obj);
|
||||
EXPECT_FALSE(wasDestructed);
|
||||
}
|
||||
EXPECT_TRUE(wasDestructed);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRefWithDefaultDeleter_whenDestructCalled_thenCallsDefaultDeleter) {
|
||||
bool wasDestructed = false;
|
||||
auto obj = make_unique_ref<DestructableMock>(&wasDestructed);
|
||||
destruct(std::move(obj));
|
||||
EXPECT_TRUE(wasDestructed);
|
||||
EXPECT_FALSE(obj.is_valid());
|
||||
}
|
||||
|
||||
namespace {
|
||||
struct SetToTrueDeleter final {
|
||||
void operator()(bool* ptr) {
|
||||
*ptr = true;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRefWithCustomDefaultConstructibleDeleter_whenDestructed_thenCallsCustomDeleter) {
|
||||
bool wasDestructed = false;
|
||||
{
|
||||
auto obj = nullcheck(std::unique_ptr<bool, SetToTrueDeleter>(&wasDestructed)).value();
|
||||
EXPECT_FALSE(wasDestructed);
|
||||
}
|
||||
EXPECT_TRUE(wasDestructed);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRefWithCustomDefaultConstructibleDeleter_whenMoveConstructed_thenCallsCustomDeleterAfterSecondDestructed) {
|
||||
bool wasDestructed = false;
|
||||
unique_ref<bool, SetToTrueDeleter> obj = nullcheck(std::unique_ptr<bool, SetToTrueDeleter>(&wasDestructed)).value();
|
||||
{
|
||||
unique_ref<bool, SetToTrueDeleter> obj2 = std::move(obj);
|
||||
EXPECT_FALSE(wasDestructed);
|
||||
}
|
||||
EXPECT_TRUE(wasDestructed);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRefWithCustomDefaultConstructibleDeleter_whenMoveAssigned_thenCallsCustomDeleterAfterSecondDestructed) {
|
||||
bool dummy = false;
|
||||
bool wasDestructed = false;
|
||||
unique_ref<bool, SetToTrueDeleter> obj = nullcheck(std::unique_ptr<bool, SetToTrueDeleter>(&wasDestructed)).value();
|
||||
{
|
||||
unique_ref<bool, SetToTrueDeleter> obj2 = nullcheck(std::unique_ptr<bool, SetToTrueDeleter>(&dummy)).value();
|
||||
obj2 = std::move(obj);
|
||||
EXPECT_FALSE(wasDestructed);
|
||||
}
|
||||
EXPECT_TRUE(wasDestructed);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRefWithCustomDefaultConstructibleDeleter_whenDestructCalled_thenCallsCustomDeleter) {
|
||||
bool wasDestructed = false;
|
||||
auto obj = nullcheck(std::unique_ptr<bool, SetToTrueDeleter>(&wasDestructed)).value();
|
||||
destruct(std::move(obj));
|
||||
EXPECT_TRUE(wasDestructed);
|
||||
EXPECT_FALSE(obj.is_valid());
|
||||
}
|
||||
|
||||
namespace {
|
||||
struct SetToDeleter final {
|
||||
SetToDeleter(int value): value_(value) {}
|
||||
int value_;
|
||||
|
||||
void operator()(int* ptr) {
|
||||
*ptr = value_;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRefWithCustomDeleterInstance_whenDestructed_thenCallsCustomDeleterInstance) {
|
||||
int value = 0;
|
||||
{
|
||||
auto obj = nullcheck(std::unique_ptr<int, SetToDeleter>(&value, SetToDeleter(4))).value();
|
||||
EXPECT_EQ(0, value);
|
||||
}
|
||||
EXPECT_EQ(4, value);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRefWithCustomDeleterInstance_whenMoveConstructed_thenCallsCustomDeleterInstanceAfterSecondDestructed) {
|
||||
int value = 0;
|
||||
unique_ref<int, SetToDeleter> obj = nullcheck(std::unique_ptr<int, SetToDeleter>(&value, SetToDeleter(4))).value();
|
||||
{
|
||||
unique_ref<int, SetToDeleter> obj2 = std::move(obj);
|
||||
EXPECT_EQ(0, value);
|
||||
}
|
||||
EXPECT_EQ(4, value);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRefWithCustomDeleterInstance_whenMoveAssigned_thenCallsCustomDeleterInstanceAfterSecondDestructed) {
|
||||
int dummy = 0;
|
||||
int value = 0;
|
||||
unique_ref<int, SetToDeleter> obj = nullcheck(std::unique_ptr<int, SetToDeleter>(&value, SetToDeleter(4))).value();
|
||||
{
|
||||
unique_ref<int, SetToDeleter> obj2 = nullcheck(std::unique_ptr<int, SetToDeleter>(&dummy, SetToDeleter(0))).value();
|
||||
obj2 = std::move(obj);
|
||||
EXPECT_EQ(0, value);
|
||||
}
|
||||
EXPECT_EQ(4, value);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRefWithCustomDeleterInstance_whenDestructCalled_thenCallsCustomDeleterInstance) {
|
||||
int value = 0;
|
||||
auto obj = nullcheck(std::unique_ptr<int, SetToDeleter>(&value, SetToDeleter(4))).value();
|
||||
destruct(std::move(obj));
|
||||
EXPECT_EQ(4, value);
|
||||
EXPECT_FALSE(obj.is_valid());
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniquePtrWithCustomDeleterInstance_whenMovedToUniquePtr_thenHasSameDeleterInstance) {
|
||||
int dummy = 0;
|
||||
SetToDeleter deleter(4);
|
||||
auto ptr = std::unique_ptr<int, SetToDeleter>(&dummy, deleter);
|
||||
auto ref = nullcheck(std::move(ptr)).value();
|
||||
EXPECT_EQ(4, ref.get_deleter().value_);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRefWithCustomDeleterInstance_whenMoveConstructing_thenHasSameDeleterInstance) {
|
||||
int dummy = 0;
|
||||
SetToDeleter deleter(4);
|
||||
auto ref = nullcheck(std::unique_ptr<int, SetToDeleter>(&dummy, deleter)).value();
|
||||
unique_ref<int, SetToDeleter> ref2 = std::move(ref);
|
||||
EXPECT_EQ(4, ref2.get_deleter().value_);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, givenUniqueRefWithCustomDeleterInstance_whenMoveAssigning_thenHasSameDeleterInstance) {
|
||||
int dummy = 0;
|
||||
SetToDeleter deleter(4);
|
||||
auto ref = nullcheck(std::unique_ptr<int, SetToDeleter>(&dummy, deleter)).value();
|
||||
auto ref2 = nullcheck(std::unique_ptr<int, SetToDeleter>(&dummy, SetToDeleter(0))).value();
|
||||
ref2 = std::move(ref);
|
||||
EXPECT_EQ(4, ref2.get_deleter().value_);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, AllowsMoveConstructingToUniqueRefOfConst) {
|
||||
unique_ref<int> a = make_unique_ref<int>(3);
|
||||
unique_ref<const int> b = std::move(a);
|
||||
}
|
||||
|
||||
TEST_F(UniqueRefTest, AllowsMoveAssigningToUniqueRefOfConst) {
|
||||
unique_ref<int> a = make_unique_ref<int>(3);
|
||||
unique_ref<const int> b = make_unique_ref<int>(10);
|
||||
b = std::move(a);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user