shared_ptr_construction.cpp File Reference

Go to the source code of this file.

Functions
	TEST_CASE ("shared_ptr constructor from pointer", "[shared_ptr][constructor]")
	TEST_CASE ("shared_ptr constructor from pointer and deleter", "[shared_ptr][constructor]")
	TEST_CASE ("shared_ptr constructor from pointer and lambda deleter", "Construction")
	TEST_CASE ("shared_ptr constructor from pointer to derived class", "[shared_ptr][constructor]")
	TEST_CASE ("shared_ptr constructor from pointer to base type", "[shared_ptr][constructor]")
	TEST_CASE ("shared_ptr constructor from nullptr and deleter", "[shared_ptr][constructor]")
	TEST_CASE ("shared_ptr constructor from nullptr, lambda deleter and allocator", "[shared_ptr][constructor]")
	TEST_CASE ("shared_ptr aliasing constructor", "[shared_ptr][constructor]")
	TEST_CASE ("shared_ptr copy constructor", "[shared_ptr][constructor]")
	TEST_CASE ("shared_ptr copy constructor from derived", "Construction")
	TEST_CASE ("shared_ptr move constructor", "[shared_ptr][constructor]")
	TEST_CASE ("shared_ptr move constructor from derived", "[shared_ptr][constructor]")
	TEST_CASE ("shared_ptr constructor from std::shared_ptr", "[shared_ptr][constructor]")
	TEST_CASE ("shared_ptr constructor from std::shared_ptr to derived", "[shared_ptr][constructor]")
	TEST_CASE ("shared_ptr move constructor from std::shared_ptr", "[shared_ptr][constructor]")
	TEST_CASE ("shared_ptr move constructor from std::shared_ptr to derived", "[shared_ptr][constructor]")
	TEST_CASE ("shared_ptr constructor from derived std::weak_ptr", "[shared_ptr][constructor]")
	TEST_CASE ("shared_ptr move constructor from std::unique_ptr", "[shared_ptr][constructor]")

Function Documentation

TEST_CASE() [1/18]

TEST_CASE	(	"shared_ptr constructor from pointer"	,
		""	[shared_ptr][constructor]
	)

Definition at line 39 of file shared_ptr_construction.cpp.

                                                                              {
    A *ptr1 = new A;
    throwing::shared_ptr<A> t_ptr1(ptr1);
    REQUIRE(t_ptr1.get() == ptr1);
}

TEST_CASE() [2/18]

TEST_CASE	(	"shared_ptr constructor from pointer and deleter"	,
		""	[shared_ptr][constructor]
	)

Definition at line 45 of file shared_ptr_construction.cpp.

                                       {
    A *ptr1 = new A;
    throwing::shared_ptr<A> t_ptr1(ptr1, A_D());
    REQUIRE(t_ptr1.get() == ptr1);
    REQUIRE(throwing::get_deleter<A_D>(t_ptr1) != nullptr);
}

TEST_CASE() [3/18]

TEST_CASE	(	"shared_ptr constructor from pointer and lambda deleter"	,
		"Construction"
	)

Definition at line 53 of file shared_ptr_construction.cpp.

                          {
    A *ptr1 = new A;
    bool lamda_called = false;
    {
        throwing::shared_ptr<A> t_ptr1(ptr1, [&lamda_called](A *p) {
            delete p;
            lamda_called = true;
        });
        REQUIRE(t_ptr1.get() == ptr1);
        REQUIRE_FALSE(lamda_called);
    }
    REQUIRE(lamda_called);
}

TEST_CASE() [4/18]

TEST_CASE	(	"shared_ptr constructor from pointer to derived class"	,
		""	[shared_ptr][constructor]
	)

Definition at line 68 of file shared_ptr_construction.cpp.

                                       {
    B *ptr1 = new B;
    throwing::shared_ptr<A> t_ptr1(ptr1);
    REQUIRE(t_ptr1.get() == ptr1);
}

TEST_CASE() [5/18]

TEST_CASE	(	"shared_ptr constructor from pointer to base type"	,
		""	[shared_ptr][constructor]
	)

Definition at line 75 of file shared_ptr_construction.cpp.

                                       {
    int *ptr1 = new int;
    throwing::shared_ptr<int> t_ptr1(ptr1);
    REQUIRE(t_ptr1.get() == ptr1);
}

TEST_CASE() [6/18]

TEST_CASE	(	"shared_ptr constructor from nullptr and deleter"	,
		""	[shared_ptr][constructor]
	)

Definition at line 82 of file shared_ptr_construction.cpp.

                                       {
    bool lamda_called = false;
    {
        throwing::shared_ptr<A> t_ptr1(nullptr, [&lamda_called](A *p) {
            delete p;
            lamda_called = true;
        });
        REQUIRE(t_ptr1.get() == nullptr);
        REQUIRE_FALSE(lamda_called);
    }
    REQUIRE(lamda_called);
}

TEST_CASE() [7/18]

TEST_CASE	(	"shared_ptr constructor from	nullptr,
		lambda deleter and allocator"	,
		""	[shared_ptr][constructor]
	)

Definition at line 96 of file shared_ptr_construction.cpp.

                                       {
    A *ptr1 = new A;
    std::allocator<void *> allocator;
    bool lamda_called = false;
    {
        throwing::shared_ptr<A> t_ptr1(ptr1,
                                       [&lamda_called](A *p) {
                                           delete p;
                                           lamda_called = true;
                                       },
                                       allocator);
        REQUIRE(t_ptr1.get() == ptr1);
        REQUIRE_FALSE(lamda_called);
    }
    REQUIRE(lamda_called);
}

TEST_CASE() [8/18]

TEST_CASE	(	"shared_ptr aliasing constructor"	,
		""	[shared_ptr][constructor]
	)

Definition at line 114 of file shared_ptr_construction.cpp.

                                                                          {
    Container *ptr1 = new Container;
    bool lamda_called = false;
    {
        throwing::shared_ptr<Container> t_ptr1(ptr1,
                                               [&lamda_called](Container *p) {
                                                   delete p;
                                                   lamda_called = true;
                                               });
        REQUIRE(t_ptr1.get() == ptr1);
        REQUIRE_FALSE(lamda_called);
        auto via_aliasing =
                throwing::shared_ptr<Contained>(t_ptr1, &ptr1->things);
        REQUIRE_FALSE(lamda_called);
        t_ptr1.reset();
        REQUIRE_FALSE(lamda_called);
        via_aliasing.reset();
        REQUIRE(lamda_called);
    }
}

TEST_CASE() [9/18]

TEST_CASE	(	"shared_ptr copy constructor"	,
		""	[shared_ptr][constructor]
	)

Definition at line 135 of file shared_ptr_construction.cpp.

                                                                      {
    A *ptr1 = new A;
    auto t_ptr1 = throwing::shared_ptr<A>(ptr1);
    throwing::shared_ptr<A> t_ptr2(t_ptr1);
    REQUIRE(t_ptr2.get() == t_ptr1.get());
    t_ptr1.reset();
    REQUIRE(t_ptr2.get() == ptr1);
}

TEST_CASE() [10/18]

TEST_CASE	(	"shared_ptr copy constructor from derived"	,
		"Construction"
	)

Definition at line 144 of file shared_ptr_construction.cpp.

                                                                      {
    B *ptr1 = new B;
    auto t_ptr1 = throwing::shared_ptr<B>(ptr1);
    throwing::shared_ptr<A> t_ptr2 = t_ptr1;
    REQUIRE(t_ptr2.get() == t_ptr1.get());
    t_ptr1.reset();
    REQUIRE(t_ptr2.get() == ptr1);
}

TEST_CASE() [11/18]

TEST_CASE	(	"shared_ptr move constructor"	,
		""	[shared_ptr][constructor]
	)

Definition at line 153 of file shared_ptr_construction.cpp.

                                                                      {
    A *ptr1 = new A;
    auto t_ptr1 = throwing::shared_ptr<A>(ptr1);
    throwing::shared_ptr<A> t_ptr2(std::move(t_ptr1));
    REQUIRE(t_ptr1.get() == nullptr);
    REQUIRE(t_ptr2.get() == ptr1);
}

TEST_CASE() [12/18]

TEST_CASE	(	"shared_ptr move constructor from derived"	,
		""	[shared_ptr][constructor]
	)

Definition at line 161 of file shared_ptr_construction.cpp.

                                       {
    B *ptr1 = new B;
    auto t_ptr1 = throwing::shared_ptr<B>(ptr1);
    throwing::shared_ptr<A> t_ptr2(std::move(t_ptr1));
    REQUIRE(t_ptr1.get() == nullptr);
    REQUIRE(t_ptr2.get() == ptr1);
}

TEST_CASE() [13/18]

TEST_CASE	(	"shared_ptr constructor from std::shared_ptr"	,
		""	[shared_ptr][constructor]
	)

Definition at line 170 of file shared_ptr_construction.cpp.

                                       {
    A *ptr1 = new A;
    auto t_ptr1 = std::shared_ptr<A>(ptr1);
    throwing::shared_ptr<A> t_ptr2(t_ptr1);
    REQUIRE(t_ptr2.get() == t_ptr1.get());
    t_ptr1.reset();
    REQUIRE(t_ptr2.get() == ptr1);
}

TEST_CASE() [14/18]

TEST_CASE	(	"shared_ptr constructor from std::shared_ptr to derived"	,
		""	[shared_ptr][constructor]
	)

Definition at line 180 of file shared_ptr_construction.cpp.

                                       {
    B *ptr1 = new B;
    auto t_ptr1 = std::shared_ptr<B>(ptr1);
    throwing::shared_ptr<A> t_ptr2(t_ptr1);
    REQUIRE(t_ptr2.get() == t_ptr1.get());
    t_ptr1.reset();
    REQUIRE(t_ptr2.get() == ptr1);
}

TEST_CASE() [15/18]

TEST_CASE	(	"shared_ptr move constructor from std::shared_ptr"	,
		""	[shared_ptr][constructor]
	)

Definition at line 190 of file shared_ptr_construction.cpp.

                                       {
    A *ptr1 = new A;
    auto t_ptr1 = std::shared_ptr<A>(ptr1);
    throwing::shared_ptr<A> t_ptr2(std::move(t_ptr1));
    REQUIRE(t_ptr1.get() == nullptr);
    REQUIRE(t_ptr2.get() == ptr1);
}

TEST_CASE() [16/18]

TEST_CASE	(	"shared_ptr move constructor from std::shared_ptr to derived"	,
		""	[shared_ptr][constructor]
	)

Definition at line 199 of file shared_ptr_construction.cpp.

                                       {
    B *ptr1 = new B;
    auto t_ptr1 = std::shared_ptr<B>(ptr1);
    throwing::shared_ptr<A> t_ptr2(std::move(t_ptr1));
    REQUIRE(t_ptr1.get() == nullptr);
    REQUIRE(t_ptr2.get() == ptr1);
}

TEST_CASE() [17/18]

TEST_CASE	(	"shared_ptr constructor from derived std::weak_ptr"	,
		""	[shared_ptr][constructor]
	)

Definition at line 208 of file shared_ptr_construction.cpp.

                                       {
    B *ptr1 = new B;
    auto t_ptr1 = std::shared_ptr<B>(ptr1);
    std::weak_ptr<B> weak = t_ptr1;
    throwing::shared_ptr<A> t_ptr2(weak);
    REQUIRE(t_ptr2.get() == t_ptr1.get());
    t_ptr1.reset();
    REQUIRE(t_ptr2.get() == ptr1);
}

TEST_CASE() [18/18]

TEST_CASE	(	"shared_ptr move constructor from std::unique_ptr"	,
		""	[shared_ptr][constructor]
	)

Definition at line 219 of file shared_ptr_construction.cpp.

                                       {
    B *ptr1 = new B;
    auto u_ptr1 = std::unique_ptr<B>(ptr1);
    throwing::shared_ptr<A> t_ptr2(std::move(u_ptr1));
    REQUIRE(u_ptr1.get() == nullptr);
    REQUIRE(t_ptr2.get() == ptr1);
}