threadsafestack.test.cpp File Reference

Implements class CLASS? More...

Include dependency graph for threadsafestack.test.cpp:

Go to the source code of this file.

Classes
class	ThreadSafeStackTest
	Testing AxisItems. More...

Functions
	TEST_F (ThreadSafeStackTest, concurentPushAndPop)
	Push and pop in concurrent mode. More...
	TEST_F (ThreadSafeStackTest, concurentStopWaiting)
	Explicitely terminate waiting (concurrent mode). More...
	TEST_F (ThreadSafeStackTest, initialState)
	Checking stack initial state (single thread mode). More...
	TEST_F (ThreadSafeStackTest, pushAndPop)
	Push and then pop (single thread mode). More...
	TEST_F (ThreadSafeStackTest, updateTop)
	Update top value (single thread mode). More...

Detailed Description

Implements class CLASS?

Homepage:\n http://www.bornagainproject.org

License:\n GNU General Public License v3 or higher (see COPYING)

Copyright

Forschungszentrum Jülich GmbH 2020

Authors

Gennady Pospelov et al, Scientific Computing Group at MLZ (see CITATION, AUTHORS)

Definition in file threadsafestack.test.cpp.

Function Documentation

TEST_F() [1/5]

TEST_F	(	ThreadSafeStackTest	,
		concurentPushAndPop
	)

Push and pop in concurrent mode.

Test is borrowed from Anthony Williams, C++ Concurrency in Action, Second edition.

Definition at line 87 of file threadsafestack.test.cpp.

{
    threadsafe_stack<int> stack;
    std::promise<void> go, push_ready_for_test, pop_ready_for_test;
    std::shared_future<void> ready(go.get_future());
    std::future<void> push_done;
    std::future<std::shared_ptr<int>> pop_done;
 
    try {
        // starting pushing thread
        push_done = std::async(std::launch::async, [&stack, ready, &push_ready_for_test]() {
            push_ready_for_test.set_value();
            ready.wait();
            stack.push(42);
        });
 
        // starting pop thread
        pop_done = std::async(std::launch::async, [&stack, ready, &pop_ready_for_test]() {
            pop_ready_for_test.set_value();
            ready.wait();
            return stack.wait_and_pop();
        });
 
        // waiting for threads being prepared for racing
        push_ready_for_test.get_future().wait();
        pop_ready_for_test.get_future().wait();
 
        // starting concurrent push and pop
        go.set_value();
 
        // checking result
        push_done.get(); // making sure pushing thread has finished
 
        EXPECT_EQ(*pop_done.get(), 42);
        EXPECT_TRUE(stack.empty());
 
    } catch (...) {
        go.set_value();
        throw;
    }
}

References ModelView::threadsafe_stack< T >::empty(), ModelView::threadsafe_stack< T >::push(), and ModelView::threadsafe_stack< T >::wait_and_pop().

Here is the call graph for this function:

TEST_F() [2/5]

TEST_F	(	ThreadSafeStackTest	,
		concurentStopWaiting
	)

Explicitely terminate waiting (concurrent mode).

Definition at line 131 of file threadsafestack.test.cpp.

{
    threadsafe_stack<int> stack;
    std::promise<void> go, pop_ready_for_test;
    std::shared_future<void> ready(go.get_future());
    std::future<std::shared_ptr<int>> pop_done;
 
    try {
        // starting pop thread
        pop_done = std::async(std::launch::async, [&stack, ready, &pop_ready_for_test]() {
            pop_ready_for_test.set_value();
            ready.wait();
            return stack.wait_and_pop();
        });
 
        // waiting for threads being prepared for racing
        pop_ready_for_test.get_future().wait();
 
        // starting waiting on empty stack
        go.set_value();
 
        // stopping waiting
        stack.stop();
 
        // stopping stack will raise exception
        EXPECT_THROW(*pop_done.get(), empty_stack);
        EXPECT_TRUE(stack.empty());
 
    } catch (...) {
        go.set_value();
        throw;
    }
}

References ModelView::threadsafe_stack< T >::empty(), ModelView::threadsafe_stack< T >::stop(), and ModelView::threadsafe_stack< T >::wait_and_pop().

Here is the call graph for this function:

TEST_F() [3/5]

TEST_F	(	ThreadSafeStackTest	,
		initialState
	)

Checking stack initial state (single thread mode).

Definition at line 32 of file threadsafestack.test.cpp.

{
    threadsafe_stack<int> stack;
    EXPECT_TRUE(stack.empty());
    int value;
    EXPECT_FALSE(stack.try_pop(value));
 
    auto sh_value = stack.try_pop();
    EXPECT_FALSE(sh_value);
}

References ModelView::threadsafe_stack< T >::empty(), and ModelView::threadsafe_stack< T >::try_pop().

Here is the call graph for this function:

TEST_F() [4/5]

TEST_F	(	ThreadSafeStackTest	,
		pushAndPop
	)

Push and then pop (single thread mode).

Definition at line 45 of file threadsafestack.test.cpp.

{
    threadsafe_stack<int> stack;
 
    stack.push(42);
    EXPECT_FALSE(stack.empty());
    int value(0);
    EXPECT_TRUE(stack.try_pop(value));
    EXPECT_EQ(value, 42);
 
    stack.push(43);
    auto result = stack.wait_and_pop();
    EXPECT_EQ(*result.get(), 43);
}

References ModelView::threadsafe_stack< T >::empty(), ModelView::threadsafe_stack< T >::push(), ModelView::threadsafe_stack< T >::try_pop(), and ModelView::threadsafe_stack< T >::wait_and_pop().

Here is the call graph for this function:

TEST_F() [5/5]

TEST_F	(	ThreadSafeStackTest	,
		updateTop
	)

Update top value (single thread mode).

Definition at line 62 of file threadsafestack.test.cpp.

{
    threadsafe_stack<int> stack;
 
    // update of empty stack means simple appearance of value
    stack.update_top(42);
    EXPECT_FALSE(stack.empty());
    int value(0);
    EXPECT_TRUE(stack.try_pop(value));
    EXPECT_EQ(value, 42);
 
    // updating value
    stack.push(43);
    stack.update_top(44);
    auto result = stack.wait_and_pop();
    EXPECT_EQ(*result.get(), 44);
 
    // shouldn't be more values
    auto sh_value = stack.try_pop();
    EXPECT_FALSE(sh_value);
}

References ModelView::threadsafe_stack< T >::empty(), ModelView::threadsafe_stack< T >::push(), ModelView::threadsafe_stack< T >::try_pop(), ModelView::threadsafe_stack< T >::update_top(), and ModelView::threadsafe_stack< T >::wait_and_pop().

Here is the call graph for this function: