shared_ptr_access.cpp File Reference

Go to the source code of this file.

Functions
	TEST_CASE ("shared_ptr get returns correctly with nullptr", "[shared_ptr][access][nullptr]")
	TEST_CASE ("shared_ptr get returns correct address", "[shared_ptr][access]")
	TEST_CASE ("shared_ptr dereference via * throws on nullptr", "[shared_ptr][dereference][nullptr]")
	TEST_CASE ("shared_ptr dereference via -> throws on nullptr", "[shared_ptr][dereference][nullptr]")
	TEST_CASE ("type specific shared_ptr exceptions are caught by base exception", "[shared_ptr][exception]")
	TEST_CASE ("type specific shared_ptr exceptions are caught by using correct type", "[shared_ptr][exception]")
	TEST_CASE ("shared_ptr exceptions have non-empty what()", "[shared_ptr][exception]")
	TEST_CASE ("shared_ptr use count works", "[shared_ptr][use count]")
	TEST_CASE ("operator bool works", "[shared_ptr]")

Function Documentation

TEST_CASE() [1/9]

TEST_CASE	(	"shared_ptr get returns correctly with nullptr"	,
		""	[shared_ptr][access][nullptr]
	)

Definition at line 15 of file shared_ptr_access.cpp.

                                           {
    throwing::shared_ptr<int> nothing;
    REQUIRE(nothing.get() == nullptr);

    throwing::shared_ptr<int> nothing_nullptr(nullptr);
    REQUIRE(nothing.get() == nullptr);

    throwing::shared_ptr<int> nothing_null(NULL);
    REQUIRE(nothing.get() == nullptr);
}

TEST_CASE() [2/9]

TEST_CASE	(	"shared_ptr get returns correct address"	,
		""	[shared_ptr][access]
	)

Definition at line 27 of file shared_ptr_access.cpp.

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

TEST_CASE() [3/9]

TEST_CASE	(	"shared_ptr dereference via * throws on nullptr"	,
		""	[shared_ptr][dereference][nullptr]
	)

Definition at line 33 of file shared_ptr_access.cpp.

                                                {
    throwing::shared_ptr<int> nothing;
    REQUIRE_THROWS_AS((*nothing)++, throwing::base_null_ptr_exception);
    REQUIRE_THROWS_AS((*nothing)++, throwing::null_ptr_exception<int>);
}

TEST_CASE() [4/9]

TEST_CASE	(	"shared_ptr dereference via -> throws on nullptr"	,
		""	[shared_ptr][dereference][nullptr]
	)

Definition at line 40 of file shared_ptr_access.cpp.

                                                {
    throwing::shared_ptr<Foo> nothing;
    REQUIRE_THROWS_AS(nothing->foo(), throwing::base_null_ptr_exception);
    REQUIRE_THROWS_AS(nothing->foo(), throwing::null_ptr_exception<Foo>);
}

TEST_CASE() [5/9]

TEST_CASE	(	"type specific shared_ptr exceptions are caught by base exception"	,
		""	[shared_ptr][exception]
	)

Definition at line 47 of file shared_ptr_access.cpp.

                                     {
    throwing::shared_ptr<int> nothing;
    try {
        (*nothing)++;
    } catch (const throwing::null_ptr_exception<float> &) {
        FAIL();
    } catch (const throwing::base_null_ptr_exception &e) {
        REQUIRE(std::string(e.what()) == "Dereference of nullptr");
    }
}

TEST_CASE() [6/9]

TEST_CASE	(	"type specific shared_ptr exceptions are caught by using correct type"	,
		""	[shared_ptr][exception]
	)

Definition at line 59 of file shared_ptr_access.cpp.

                                   {
    throwing::shared_ptr<int> nothing;
    try {
        (*nothing)++;
    } catch (const throwing::null_ptr_exception<float> &) {
        FAIL();
    } catch (const throwing::null_ptr_exception<int> &) {
    }
}

TEST_CASE() [7/9]

TEST_CASE	(	"shared_ptr exceptions have non-empty what()"	,
		""	[shared_ptr][exception]
	)

Definition at line 71 of file shared_ptr_access.cpp.

                                     {
    throwing::shared_ptr<int> nothing;
    try {
        (*nothing)++;
    } catch (const throwing::base_null_ptr_exception &e) {
        std::string what = e.what_type();
        REQUIRE_FALSE(what.empty());
    }
}

TEST_CASE() [8/9]

TEST_CASE	(	"shared_ptr use count works"	,
		""	[shared_ptr][use count]
	)

Definition at line 82 of file shared_ptr_access.cpp.

                                                                   {
    Foo *foo = new Foo;
    throwing::shared_ptr<Foo> ptr;
    REQUIRE(ptr.use_count() == 0l);
    ptr.reset(foo);
    REQUIRE(ptr.use_count() == 1l);
    auto ptr2 = ptr;
    REQUIRE(ptr.use_count() == 2l);
    REQUIRE(ptr2.use_count() == 2l);
    ptr.reset();
    REQUIRE(ptr.use_count() == 0l);
    REQUIRE(ptr2.use_count() == 1l);
    ptr2.reset();
    REQUIRE(ptr.use_count() == 0l);
    REQUIRE(ptr2.use_count() == 0l);
}

TEST_CASE() [9/9]

TEST_CASE	(	"operator bool works"	,
		""	[shared_ptr]
	)

Definition at line 99 of file shared_ptr_access.cpp.

                                                 {
    Foo *foo = new Foo;
    throwing::shared_ptr<Foo> ptr;
    REQUIRE_FALSE(ptr);
    ptr.reset(foo);
    REQUIRE(ptr);
    ptr.reset();
    REQUIRE_FALSE(ptr);
}