LUMIERA.clone/tests/lib/thread-wrapper-join-test.cpp
Ichthyostega 3caa5cfb03 Tests: reorganise test folders
This resolves a long-standing issue:
we could not use proper include paths for test-helper code that was defined alongside the tests.

Since some test-helper code must now be relocated into the »Vault«-Layer,
I took the opportunity to finally resolve this annoyance. The solution is two-fold
 * introduce a dedicated test-support library
 * remove the quirks that were necessary to support some plain-C tests
Together, this allows to raise the include-directory by one level,
and then to adjust all folder names so that they match the namespace
2026-03-07 00:56:19 +01:00

144 lines
3.8 KiB
C++
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
ThreadWrapperJoin(Test) - wait blocking on termination of a thread
Copyright (C)
2008, Hermann Vosseler <Ichthyostega@web.de>
  **Lumiera** is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the
  Free Software Foundation; either version 2 of the License, or (at your
  option) any later version. See the file COPYING for further details.
* *****************************************************************/
/** @file thread-wrapper-join-test.cpp
** unit test \ref ThreadWrapperJoin_test
*/
#include "test/run.hpp"
#include "test/test-helper.hpp"
#include "lib/thread.hpp"
#include "lib/error.hpp"
#include <chrono>
using test::Test;
using std::this_thread::sleep_for;
using namespace std::chrono_literals;
namespace lib {
namespace test {
using error::LUMIERA_ERROR_LOGIC;
namespace {
const int DESTRUCTION_CODE = -23;
LUMIERA_ERROR_DEFINE(SPECIAL, "007 exception");
#define Type(_EXPR_) ::test::showType<decltype(_EXPR_)>()
}
/***********************************************************************//**
* @test verify the special flavour of the thread-wrapper, allowing to block
* waiting on thread end and then pass result or error state.
* @see thread.hpp
* @see Result_test
* @see ThreadWrapper_test
* @see SyncLocking_test
*/
class ThreadWrapperJoin_test : public Test
{
virtual void
run (Arg)
{
seedRand();
simpleUse();
returnValue();
detectFailure();
joinOnceOnly();
}
void
simpleUse()
{
ThreadJoinable theThread{"test join-1"
,[]{ sleep_for (10ms); }};
CHECK (theThread);
theThread.join(); // blocks until thread-function has terminated
CHECK (not theThread);
}
int
theAction (int secretValue) ///< to be run in a new thread...
{
sleep_for (100ms); // pause 100ms prior to modifying
if (DESTRUCTION_CODE == secretValue)
throw error::External{"special agent detected"
, LUMIERA_ERROR_SPECIAL};
else
return secretValue+42;
}
void
returnValue()
{
int mySecret = rani(1000);
ThreadJoinable theThread{"test join-2"
,&ThreadWrapperJoin_test::theAction
, this, mySecret};
// Note: join() passes the result value captured in the thread
CHECK (mySecret+42 == theThread.join());
}
void
detectFailure()
{
ThreadJoinable theThread{"test join-3"
,&ThreadWrapperJoin_test::theAction
, this, DESTRUCTION_CODE};
// join() actually returns a proxy...
auto res = theThread.join();
CHECK (Type(res) == "Result<int>"_expect);
// can detect that the thread was aborted with an exception
CHECK (not res.isValid());
VERIFY_ERROR(SPECIAL, res.maybeThrow() );
VERIFY_ERROR(SPECIAL, (int)res );
}
void
joinOnceOnly()
{
ThreadJoinable theThread{"test join-4"
,[]{ sleep_for (10ms); }};
theThread.join();
VERIFY_ERROR(LOGIC, theThread.join() );
VERIFY_ERROR(LOGIC, theThread.join() );
}
};
/** Register this test class... */
LAUNCHER (ThreadWrapperJoin_test, "function common");
}} // namespace lib::test