shared_ptr_atomic.cpp File Reference

Go to the source code of this file.

Functions
	TEST_CASE ("atomic_is_lock_free std::shared_ptr compatibility", "[shared_ptr][atomic]")
	TEST_CASE ("atomic_load works in the same thread", "[shared_ptr][atomic]")
	TEST_CASE ("atomic_load_explicit works in the same thread", "[shared_ptr][atomic]")
	TEST_CASE ("atomic_store works in the same thread", "[shared_ptr][atomic]")
	TEST_CASE ("atomic_store_explicit works in the same thread", "[shared_ptr][atomic]")
	TEST_CASE ("atomic_exchange works in the same thread", "[shared_ptr][atomic]")
	TEST_CASE ("atomic_exchange_explicit works in the same thread", "[shared_ptr][atomic]")
	TEST_CASE ("atomic_compare_exchange_weak works in the same thread", "[shared_ptr][atomic]")
	TEST_CASE ("atomic_compare_exchange_weak works in the same thread, compares " "pointer, not value", "[shared_ptr][atomic]")
	TEST_CASE ("atomic_compare_exchange_strong works in the same thread", "[shared_ptr][atomic]")
	TEST_CASE ("atomic_compare_exchange_strong works in the same thread, compares " "pointer, not value", "[shared_ptr][atomic]")
	TEST_CASE ("atomic_compare_exchange_weak_explicit works in the same thread", "[shared_ptr][atomic]")
	TEST_CASE ("atomic_compare_exchange_strong_explicit works in the same thread, " "compares pointer, not value", "[shared_ptr][atomic]")

Function Documentation

TEST_CASE() [1/13]

TEST_CASE	(	"atomic_is_lock_free std::shared_ptr compatibility"	,
		""	[shared_ptr][atomic]
	)

Definition at line 9 of file shared_ptr_atomic.cpp.

                                  {
    const auto std_p = std::make_shared<int>(42);
    const auto p = throwing::make_shared<int>(42);
    REQUIRE(atomic_is_lock_free(&p) == atomic_is_lock_free(&std_p));
}

TEST_CASE() [2/13]

TEST_CASE	(	"atomic_load works in the same thread"	,
		""	[shared_ptr][atomic]
	)

Definition at line 16 of file shared_ptr_atomic.cpp.

                                                                          {
    const auto p = throwing::make_shared<int>(42);
    auto p2 = atomic_load(&p);
    REQUIRE(*p2 == 42);
}

TEST_CASE() [3/13]

TEST_CASE	(	"atomic_load_explicit works in the same thread"	,
		""	[shared_ptr][atomic]
	)

Definition at line 22 of file shared_ptr_atomic.cpp.

                                  {
    const auto p = throwing::make_shared<int>(42);
    auto p2 = atomic_load_explicit(&p, std::memory_order_seq_cst);
    REQUIRE(*p2 == 42);
}

TEST_CASE() [4/13]

TEST_CASE	(	"atomic_store works in the same thread"	,
		""	[shared_ptr][atomic]
	)

Definition at line 29 of file shared_ptr_atomic.cpp.

                                                                           {
    const auto p1 = throwing::make_shared<int>(1);
    auto p2 = throwing::make_shared<int>(2);

    atomic_store(&p2, p1);
    REQUIRE(*p2 == 1);
}

TEST_CASE() [5/13]

TEST_CASE	(	"atomic_store_explicit works in the same thread"	,
		""	[shared_ptr][atomic]
	)

Definition at line 37 of file shared_ptr_atomic.cpp.

                                  {
    const auto p1 = throwing::make_shared<int>(1);
    auto p2 = throwing::make_shared<int>(2);

    atomic_store_explicit(&p2, p1, std::memory_order_seq_cst);
    REQUIRE(*p2 == 1);
}

TEST_CASE() [6/13]

TEST_CASE	(	"atomic_exchange works in the same thread"	,
		""	[shared_ptr][atomic]
	)

Definition at line 46 of file shared_ptr_atomic.cpp.

                                                                              {
    const auto p1 = throwing::make_shared<int>(1);
    auto p2 = throwing::make_shared<int>(2);
    auto p3 = atomic_exchange(&p2, p1);
    REQUIRE(*p2 == 1);
    REQUIRE(*p3 == 2);
}

TEST_CASE() [7/13]

TEST_CASE	(	"atomic_exchange_explicit works in the same thread"	,
		""	[shared_ptr][atomic]
	)

Definition at line 54 of file shared_ptr_atomic.cpp.

                                  {
    const auto p1 = throwing::make_shared<int>(1);
    auto p2 = throwing::make_shared<int>(2);
    auto p3 = atomic_exchange_explicit(&p2, p1, std::memory_order_seq_cst);
    REQUIRE(*p2 == 1);
    REQUIRE(*p3 == 2);
}

TEST_CASE() [8/13]

TEST_CASE	(	"atomic_compare_exchange_weak works in the same thread"	,
		""	[shared_ptr][atomic]
	)

Definition at line 63 of file shared_ptr_atomic.cpp.

                                  {
    auto p = throwing::make_shared<int>(1);
    auto expected = p;
    auto desired = throwing::make_shared<int>(2);

    REQUIRE(atomic_compare_exchange_weak(&p, &expected, desired));
    REQUIRE(*p == 2);
}

TEST_CASE() [9/13]

TEST_CASE	(	"atomic_compare_exchange_weak works in the same	thread,
		compares " "	pointer,
		not value"	,
		""	[shared_ptr][atomic]
	)

Definition at line 73 of file shared_ptr_atomic.cpp.

                                  {
    auto p = throwing::make_shared<int>(1);
    auto expected = throwing::make_shared<int>(1);
    auto desired = throwing::make_shared<int>(3);

    REQUIRE_FALSE(atomic_compare_exchange_weak(&p, &expected, desired));
    REQUIRE(*expected == 1);
}

TEST_CASE() [10/13]

TEST_CASE	(	"atomic_compare_exchange_strong works in the same thread"	,
		""	[shared_ptr][atomic]
	)

Definition at line 84 of file shared_ptr_atomic.cpp.

                                  {
    auto p = throwing::make_shared<int>(1);
    auto expected = p;
    auto desired = throwing::make_shared<int>(2);

    REQUIRE(atomic_compare_exchange_strong(&p, &expected, desired));
    REQUIRE(*p == 2);
}

TEST_CASE() [11/13]

TEST_CASE	(	"atomic_compare_exchange_strong works in the same	thread,
		compares " "	pointer,
		not value"	,
		""	[shared_ptr][atomic]
	)

Definition at line 94 of file shared_ptr_atomic.cpp.

                                  {
    auto p = throwing::make_shared<int>(1);
    auto expected = throwing::make_shared<int>(1);
    auto desired = throwing::make_shared<int>(3);

    REQUIRE_FALSE(atomic_compare_exchange_strong(&p, &expected, desired));
    REQUIRE(*expected == 1);
}

TEST_CASE() [12/13]

TEST_CASE	(	"atomic_compare_exchange_weak_explicit works in the same thread"	,
		""	[shared_ptr][atomic]
	)

Definition at line 105 of file shared_ptr_atomic.cpp.

                                  {
    auto p = throwing::make_shared<int>(1);
    auto expected = p;
    auto desired = throwing::make_shared<int>(2);

    REQUIRE(atomic_compare_exchange_weak_explicit(&p, &expected, desired,
                                                  std::memory_order_seq_cst,
                                                  std::memory_order_seq_cst));
    REQUIRE(*p == 2);
}

TEST_CASE() [13/13]

TEST_CASE	(	"atomic_compare_exchange_strong_explicit works in the same	thread,
		" "compares	pointer,
		not value"	,
		""	[shared_ptr][atomic]
	)

Definition at line 117 of file shared_ptr_atomic.cpp.

                                  {
    auto p = throwing::make_shared<int>(1);
    auto expected = throwing::make_shared<int>(1);
    auto desired = throwing::make_shared<int>(3);

    REQUIRE_FALSE(atomic_compare_exchange_strong_explicit(
            &p, &expected, desired, std::memory_order_seq_cst,
            std::memory_order_seq_cst));
    REQUIRE(*expected == 1);
}