ADTF  3.18.2
Test for Non-ADTF Sinks and Sources Plugin
Description
This examples test the UDP/TCP Receiver/Sender From/To Non-ADTF Application Plugin
Location
./src/examples/src/remote/foreign_application/test
Build Environment
To see how to set up the build environment have a look at ADTF CMake Environment
this implementation shows:
Implementation
#include <adtftesting/adtf_testing.h>
#include <adtfsystemsdk/testing/test_system.h>
#include <adtfsystemsdk/testing/test_logger.h>
#include <adtffiltersdk/adtf_filtersdk.h>
// this is auto-generated
#include <serialization.h>
#ifdef CreateService
#undef CreateService
#endif
using namespace adtf::util;
using namespace adtf::ucom;
using namespace adtf::base;
using namespace adtf::streaming;
using namespace adtf::filter::testing;
constexpr char CID_TCP_SOURCE[] = "demo_foreign_application_tcp_receiver.streaming_source.adtf.cid";
constexpr char CID_TCP_SINK[] = "demo_foreign_application_tcp_sender.streaming_sink.adtf.cid";
constexpr char CID_UDP_SOURCE[] = "demo_foreign_application_udp_receiver.streaming_source.adtf.cid";
constexpr char CID_UDP_SINK[] = "demo_foreign_application_udp_sender.streaming_sink.adtf.cid";
#ifdef _DEBUG
static const cString TEST_PORT{"54300"};
#else
static const cString TEST_PORT{"54301"};
#endif
struct cMyTestSystem: adtf::system::testing::cTestSystem
{
cMyTestSystem(bool bWithLogging = false): cTestSystem({}, {}, false, bWithLogging)
{
LoadPlugin("adtf_clock.adtfplugin");
LoadPlugin("adtf_kernel.adtfplugin");
CreateService("adtf_media_description.adtfplugin",
CID_ADTF_MEDIA_DESCRIPTION_SERVICE,
"mds",
tADTFRunLevel::RL_System,
{{"media_description_files", ADTF_TESTING_SOURCE_DIR "/test_serialization.description"}});
configure_media_description_service();
LoadPlugin("foreign_application_udp.adtfplugin");
LoadPlugin("foreign_application_tcp.adtfplugin");
SetRunLevel(tADTFRunLevel::RL_Session);
}
~cMyTestSystem()
{
}
void configure_media_description_service()
{
object_ptr<adtf::services::IMediaDescriptionService> pService;
REQUIRE_OK(_runtime->GetObject(pService));
IConfiguration* pConfig = ucom_cast<IConfiguration*>(pService.Get());
set_property<cString>(*pConfig, "media_description_files", ADTF_TESTING_SOURCE_DIR "/serialization.description");
}
};
struct cMyTestSystemWithLog : public cMyTestSystem
{
cMyTestSystemWithLog(): cMyTestSystem(true)
{
}
};
struct tTestGraph
{
object_ptr<cStreamingGraph> pStreamingGraph;
std::unique_ptr<cOutputRecorder> pSourceOutput;
std::unique_ptr<cTestWriter> pSinkInput;
};
class cTestApplication
{
public:
cTestApplication(const cString& strArguments)
{
REQUIRE_OK(adtf::util::cSystem::ChildExecute(&m_nPID, DEMO_APPLICATION, strArguments));
std::this_thread::sleep_for(std::chrono::seconds(1));
}
~cTestApplication()
{
adtf::util::cSystem::ChildTerminate(m_nPID);
}
private:
uint64_t m_nPID;
};
tTestGraph create_graph(const cString& strSourceCid,
const std::map<cString, cString>& oSourceConfig,
const cString& strSinkCid,
const std::map<cString, cString>& oSinkConfig,
const adtf::filter::cStreamTypeHelper& oType = stream_meta_type_anonymous(),
bool bConnectSockets = true)
{
auto pGraph = make_object_ptr<cStreamingGraph>();
object_ptr<IObject> pSource;
REQUIRE_OK(add_graph_object(*pGraph, strSourceCid, "source", oSourceConfig, 0, pSource));
object_ptr<IObject> pSink;
REQUIRE_OK(add_graph_object(*pGraph, strSinkCid, "sink", oSinkConfig, 0, pSink));
if (bConnectSockets)
{
REQUIRE_OK(add_binding_proxy(*pGraph, "socket"));
REQUIRE_OK(pGraph->AddConnection("connection1", "source", "socket", "socket", "", 0, true));
REQUIRE_OK(pGraph->AddConnection("connection2", "socket", "", "sink", "socket", 0, true));
}
REQUIRE_OK(pGraph->SetState(IStreamingGraph::tStreamingState::State_Initialized));
return { pGraph, std::make_unique<cOutputRecorder>(pSource, "output"), std::make_unique<cTestWriter>(pSink, "input", oType) };
}
void test_raw(tTestGraph& oGraph)
{
REQUIRE_OK(oGraph.pStreamingGraph->SetState(IStreamingGraph::tStreamingState::State_Streaming));
for (uint64_t nCounter = 123456789; nCounter < 123456789 + 100; ++nCounter)
{
oGraph.pSinkInput->Write(std::chrono::seconds(0), nCounter, true);
INFO("WaitForTrigger on counter = " + std::to_string(nCounter));
REQUIRE(oGraph.pSourceOutput->WaitForTrigger(std::chrono::seconds(1)));
auto oOutput = oGraph.pSourceOutput->GetCurrentOutput();
REQUIRE(!oOutput.GetSamples().empty());
{
sample_data<uint64_t> oData(oOutput.GetSamples().front());
REQUIRE(oData == nCounter);
}
}
}
void test_serialization(tTestGraph& oGraph)
{
REQUIRE_OK(oGraph.pStreamingGraph->SetState(IStreamingGraph::tStreamingState::State_Streaming));
tTestSerialization sTest{ 1, 2 };
oGraph.pSinkInput->Write(std::chrono::seconds(0), sTest, true);
REQUIRE(oGraph.pSourceOutput->WaitForTrigger(std::chrono::seconds(1)));
auto oOutput = oGraph.pSourceOutput->GetCurrentOutput();
REQUIRE(!oOutput.GetSamples().empty());
{
sample_data<tTestSerialization> oData(oOutput.GetSamples().front());
// the values should be flipped, see serialized/deserialized representation in test.description
REQUIRE(oData->nValue1 == sTest.nValue2);
REQUIRE(oData->nValue2 == sTest.nValue1);
}
}
TEST_CASE_METHOD(cMyTestSystem, "Test Raw TCP / IPv4", "[req:ACORE-8868][req:ACORE-10086]")
{
cTestApplication oApplication("-p=" + TEST_PORT + " -tcp");
auto oGraph = create_graph(
CID_TCP_SOURCE,
{
{"remote_host", "127.0.0.1"},
{"remote_port", TEST_PORT},
},
CID_TCP_SINK,
{
// interface and port can be used from the source
});
test_raw(oGraph);
}
TEST_CASE_METHOD(cMyTestSystem, "Test Raw UDP / IPv4", "[req:ACORE-8868][req:ACORE-10086]")
{
cTestApplication oApplication("-p=" + TEST_PORT);
auto oGraph = create_graph(
CID_UDP_SOURCE, {},
CID_UDP_SINK,
{
{"remote_host", "127.0.0.1"},
{"port", TEST_PORT},
});
test_raw(oGraph);
}
TEST_CASE_METHOD(cMyTestSystemWithLog, "Test Raw receive buffer size set", "[req:gitlab-#2939]")
{
adtf::system::testing::cTestLogger oTestLogger;
cTestApplication oApplication("-p=" + TEST_PORT);
auto oGraph = create_graph(CID_UDP_SOURCE,
{
{"socket_receive_buffer_size", std::to_string(2 * 1024 * 1024).c_str()}
},
CID_UDP_SINK,
{
{"remote_host", "127.0.0.1"},
{"port", TEST_PORT}
});
test_raw(oGraph);
auto oMessages = oTestLogger.GetCurrentMessages();
CHECK(oMessages.ContainsMessage("Sockets buffersize set from"));
CHECK(oMessages.ContainsMessage("to " + std::to_string(2 * 1024 * 1024) + " bytes"));
}
TEST_CASE_METHOD(cMyTestSystem, "Test Raw UDP Multicast / IPv4", "[req:ACORE-11192]")
{
cTestApplication oApplication("-p=" + TEST_PORT + " -m=224.0.0.4");
auto oGraph = create_graph(
CID_UDP_SOURCE, {},
CID_UDP_SINK,
{
{"remote_host", "224.0.0.4"},
{"port", TEST_PORT},
});
test_raw(oGraph);
}
TEST_CASE_METHOD(cMyTestSystem, "Test Raw TCP / IPv6", "[req:ACORE-8868][req:ACORE-10086]")
{
cTestApplication oApplication("-p=" + TEST_PORT + " -tcp -ipv6");
auto oGraph = create_graph(
CID_TCP_SOURCE,
{
{"remote_host", "::1"},
{"remote_port", TEST_PORT},
},
CID_TCP_SINK, {});
test_raw(oGraph);
}
TEST_CASE_METHOD(cMyTestSystem, "Test Raw UDP / IPv6", "[req:ACORE-8868][req:ACORE-10086]")
{
cTestApplication oApplication("-p=" + TEST_PORT + " -ipv6");
auto oGraph = create_graph(
CID_UDP_SOURCE,
{
{"interface", "::1"}
},
CID_UDP_SINK,
{
{"remote_host", "::1"},
{"port", TEST_PORT},
});
test_raw(oGraph);
}
TEST_CASE_METHOD(cMyTestSystem, "Test Source Deserialization TCP / IPv4", "[req:ACORE-8868][req:ACORE-10086]")
{
cTestApplication oApplication("-p=" + TEST_PORT + " -tcp");
auto oGraph = create_graph(
CID_TCP_SOURCE,
{
{"remote_host", "127.0.0.1"},
{"remote_port", TEST_PORT},
{"ddl_struct_name", "tTestSerialization"},
{"deserialize_via_media_description", "true"}
},
CID_TCP_SINK, {},
adtf::mediadescription::description<tTestSerialization>());
test_serialization(oGraph);
}
TEST_CASE_METHOD(cMyTestSystem, "Test Source Deserialization TCP / IPv6", "[req:ACORE-8868][req:ACORE-10086]")
{
cTestApplication oApplication("-p=" + TEST_PORT + " -tcp -ipv6");
auto oGraph = create_graph(
CID_TCP_SOURCE,
{
{"remote_host", "::1"},
{"remote_port", TEST_PORT},
{"ddl_struct_name", "tTestSerialization"},
{"deserialize_via_media_description", "true"}
},
CID_TCP_SINK, {},
adtf::mediadescription::description<tTestSerialization>());
test_serialization(oGraph);
}
TEST_CASE_METHOD(cMyTestSystem, "Test Source Deserialization UDP / IPv4", "[req:ACORE-8868][req:ACORE-10086]")
{
cTestApplication oApplication("-p=" + TEST_PORT);
auto oGraph = create_graph(
CID_UDP_SOURCE,
{
{"ddl_struct_name", "tTestSerialization"},
{"deserialize_via_media_description", "true"}
},
CID_UDP_SINK,
{
{"remote_host", "127.0.0.1"},
{"port", TEST_PORT},
});
test_serialization(oGraph);
}
TEST_CASE_METHOD(cMyTestSystem, "Test Source Deserialization UDP / IPv6", "[req:ACORE-8868][req:ACORE-10086]")
{
cTestApplication oApplication("-p=" + TEST_PORT + " -ipv6");
auto oGraph = create_graph(
CID_UDP_SOURCE,
{
{"interface", "::1"},
{"ddl_struct_name", "tTestSerialization"},
{"deserialize_via_media_description", "true"}
},
CID_UDP_SINK,
{
{"remote_host", "::1"},
{"port", TEST_PORT},
});
test_serialization(oGraph);
}
TEST_CASE_METHOD(cMyTestSystem, "Test Sink Serialization TCP / IPv4", "[req:ACORE-10086]")
{
cTestApplication oApplication("-p=" + TEST_PORT + " -tcp");
auto oGraph = create_graph(
CID_TCP_SOURCE,
{
{"remote_host", "127.0.0.1"},
{"remote_port", TEST_PORT},
{"ddl_struct_name", "tTestSerialization"}
},
CID_TCP_SINK,
{
{"serialize_via_media_description", "true"}
},
adtf::mediadescription::description<tTestSerialization>());
test_serialization(oGraph);
}
TEST_CASE_METHOD(cMyTestSystem, "Test Sink Serialization TCP / IPv6", "[req:ACORE-10086]")
{
cTestApplication oApplication("-p=" + TEST_PORT + " -tcp -ipv6");
auto oGraph = create_graph(
CID_TCP_SOURCE,
{
{"remote_host", "::1"},
{"remote_port", TEST_PORT},
{"ddl_struct_name", "tTestSerialization"}
},
CID_TCP_SINK,
{
{"serialize_via_media_description", "true"}
},
adtf::mediadescription::description<tTestSerialization>());
test_serialization(oGraph);
}
TEST_CASE_METHOD(cMyTestSystem, "Test Sink Serialization UDP / IPv4", "[req:ACORE-10086]")
{
cTestApplication oApplication("-p=" + TEST_PORT);
auto oGraph = create_graph(
CID_UDP_SOURCE,
{
{"ddl_struct_name", "tTestSerialization"}
},
CID_UDP_SINK,
{
{"serialize_via_media_description", "true"},
{"remote_host", "127.0.0.1"},
{"port", TEST_PORT},
},
adtf::mediadescription::description<tTestSerialization>());
test_serialization(oGraph);
}
TEST_CASE_METHOD(cMyTestSystem, "Test Sink Serialization UDP / IPv6", "[req:ACORE-10086]")
{
cTestApplication oApplication("-p=" + TEST_PORT + " -ipv6");
auto oGraph = create_graph(
CID_UDP_SOURCE,
{
{"interface", "::1"},
{"ddl_struct_name", "tTestSerialization"}
},
CID_UDP_SINK,
{
{"serialize_via_media_description", "true"},
{"remote_host", "::1"},
{"port", TEST_PORT},
},
adtf::mediadescription::description<tTestSerialization>());
test_serialization(oGraph);
}
TEST_CASE_METHOD(cMyTestSystem, "Test TCP Source Fixed Packet Size", "[req:ACORE-10086]")
{
cTestApplication oApplication("-p=" + TEST_PORT + " -tcp");
auto oGraph = create_graph(
CID_TCP_SOURCE,
{
{"remote_host", "127.0.0.1"},
{"remote_port", TEST_PORT},
{"fixed_packet_size", "8"},
},
CID_TCP_SINK, {});
REQUIRE_OK(oGraph.pStreamingGraph->SetState(IStreamingGraph::tStreamingState::State_Streaming));
uint32_t nValue1 = 1;
uint32_t nValue2 = 2;
oGraph.pSinkInput->Write(std::chrono::seconds(0), nValue1, true);
REQUIRE(!oGraph.pSourceOutput->WaitForTrigger(std::chrono::seconds(1)));
oGraph.pSinkInput->Write(std::chrono::seconds(0), nValue2, true);
REQUIRE(oGraph.pSourceOutput->WaitForTrigger(std::chrono::seconds(1)));
auto oOutput = oGraph.pSourceOutput->GetCurrentOutput();
REQUIRE(!oOutput.GetSamples().empty());
{
sample_data<uint32_t[2]> oData(oOutput.GetSamples().front());
REQUIRE((*oData)[0] == nValue1);
REQUIRE((*oData)[1] == nValue2);
}
}
TEST_CASE_METHOD(cMyTestSystem, "Independent UDP Source and Sink Sockets", "[req:ACORE-10086]")
{
auto oGraph = create_graph(
CID_UDP_SOURCE,
{
{"port", TEST_PORT},
},
CID_UDP_SINK,
{
{"remote_host", "127.0.0.1"},
{"port", TEST_PORT},
},
stream_meta_type_anonymous(),
false);
REQUIRE_OK(oGraph.pStreamingGraph->SetState(IStreamingGraph::tStreamingState::State_Streaming));
uint32_t nValue1 = 1;
oGraph.pSinkInput->Write(std::chrono::seconds(0), nValue1, true);
REQUIRE(oGraph.pSourceOutput->WaitForTrigger(std::chrono::seconds(1)));
auto oOutput = oGraph.pSourceOutput->GetCurrentOutput();
REQUIRE(!oOutput.GetSamples().empty());
{
sample_data<uint32_t> oData(oOutput.GetSamples().front());
REQUIRE(oData == nValue1);
}
}
TEST_CASE_METHOD(cMyTestSystem, "Independent UDP Source and Sink Sockets Multicast", "[req:ACORE-11192]")
{
auto oGraph = create_graph(
CID_UDP_SOURCE,
{
{"port", TEST_PORT},
{"multicast_group", "224.0.0.2"},
},
CID_UDP_SINK,
{
{"remote_host", "224.0.0.2"},
{"port", TEST_PORT},
},
stream_meta_type_anonymous(),
false);
REQUIRE_OK(oGraph.pStreamingGraph->SetState(IStreamingGraph::tStreamingState::State_Streaming));
uint32_t nValue1 = 1;
oGraph.pSinkInput->Write(std::chrono::seconds(0), nValue1, true);
REQUIRE(oGraph.pSourceOutput->WaitForTrigger(std::chrono::seconds(1)));
auto oOutput = oGraph.pSourceOutput->GetCurrentOutput();
REQUIRE(!oOutput.GetSamples().empty());
{
sample_data<uint32_t> oData(oOutput.GetSamples().front());
REQUIRE(oData == nValue1);
}
}
void tcp_server(std::promise<void> oListening)
{
cServerSocket oServer;
THROW_IF_FAILED(oServer.Open(cString(TEST_PORT).AsUInt32()));
THROW_IF_FAILED(oServer.Listen(2));
oListening.set_value();
cStreamSocket oClient1;
cStreamSocket oClient2;
THROW_IF_FAILED(oServer.Accept(oClient1));
THROW_IF_FAILED(oServer.Accept(oClient2));
uint8_t nBuffer;
THROW_IF_FAILED(oClient1.Read(&nBuffer, sizeof(nBuffer)));
THROW_IF_FAILED(oClient2.Write(&nBuffer, sizeof(nBuffer)));
}
TEST_CASE_METHOD(cMyTestSystem, "Independent TCP Source and Sink Sockets", "[req:ACORE-10086]")
{
auto oGraph = create_graph(
CID_TCP_SOURCE,
{
{"remote_host", "127.0.0.1"},
{"remote_port", TEST_PORT},
},
CID_TCP_SINK,
{
{"remote_host", "127.0.0.1"},
{"remote_port", TEST_PORT},
},
stream_meta_type_anonymous(),
false);
std::promise<void> oListening;
auto oListeningStarted = oListening.get_future();
auto oServerResult = std::async(std::launch::async, tcp_server, std::move(oListening));
oListeningStarted.get();
REQUIRE_OK(oGraph.pStreamingGraph->SetState(IStreamingGraph::tStreamingState::State_Streaming));
uint8_t nValue1 = 123;
oGraph.pSinkInput->Write(std::chrono::seconds(0), nValue1, true);
REQUIRE(oGraph.pSourceOutput->WaitForTrigger(std::chrono::seconds(1)));
auto oOutput = oGraph.pSourceOutput->GetCurrentOutput();
REQUIRE(!oOutput.GetSamples().empty());
{
sample_data<uint8_t> oData(oOutput.GetSamples().front());
REQUIRE(oData == nValue1);
}
oServerResult.get();
}
void tcp_server_source(std::promise<void> oListening)
{
cServerSocket oServer;
THROW_IF_FAILED(oServer.Open(cString(TEST_PORT).AsUInt32()));
THROW_IF_FAILED(oServer.Listen(2));
LOG_INFO("Starting to accept");
oListening.set_value();
cStreamSocket oClient1;
THROW_IF_FAILED(oServer.Accept(oClient1));
LOG_INFO("Accepted client");
uint8_t nBuffer = 123;
THROW_IF_FAILED(oClient1.Write(&nBuffer, sizeof(nBuffer)));
LOG_INFO("Wrote data");
}
TEST_CASE_METHOD(cMyTestSystem, "Test TCP Source Reconnection", "[req:ACORE-11249]")
{
object_ptr<IStreamingSource> pSource;
REQUIRE_OK(_runtime->CreateInstance(CID_TCP_SOURCE, pSource));
auto pConfiguration = ucom_cast<IConfiguration*>(pSource.Get());
set_property(*pConfiguration, "remote_host", "127.0.0.1");
set_property(*pConfiguration, "remote_port", TEST_PORT);
SECTION("disabled reconnection")
{
set_property(*pConfiguration, "enable_automatic_reconnection", false);
REQUIRE_OK(pSource->SetState(IStreamingService::tStreamingState::State_Initialized));
REQUIRE_FAILED(pSource->SetState(IStreamingService::tStreamingState::State_Streaming));
}
SECTION("enabled reconnection")
{
set_property(*pConfiguration, "enable_automatic_reconnection", true);
REQUIRE_OK(pSource->SetState(IStreamingService::tStreamingState::State_Initialized));
cOutputRecorder oRecorder(pSource, "output");
REQUIRE_OK(pSource->SetState(IStreamingService::tStreamingState::State_Streaming));
for (size_t nCounter = 0; nCounter < 5; ++ nCounter)
{
REQUIRE(!oRecorder.WaitForTrigger(std::chrono::milliseconds(500)));
std::promise<void> oListening;
auto oListeningStarted = oListening.get_future();
auto oServerResult = std::async(std::launch::async, tcp_server_source, std::move(oListening));
oListeningStarted.get();
REQUIRE(oRecorder.WaitForTrigger(std::chrono::seconds(5)));
REQUIRE(oRecorder.GetCurrentOutput().GetSamples().size() == 1);
oServerResult.get();
}
}
}
void tcp_server_sink(std::promise<void> oListening, std::promise<void> oRecievedData)
{
cServerSocket oServer;
THROW_IF_FAILED(oServer.Open(cString(TEST_PORT).AsUInt32()));
THROW_IF_FAILED(oServer.Listen(2));
LOG_INFO("Starting to accept");
oListening.set_value();
cStreamSocket oClient1;
THROW_IF_FAILED(oServer.Accept(oClient1));
LOG_INFO("Accepted client");
uint8_t nBuffer = 123;
THROW_IF_FAILED(oClient1.Read(&nBuffer, sizeof(nBuffer)));
oRecievedData.set_value();
LOG_INFO("Recieved data %d", nBuffer);
}
TEST_CASE_METHOD(cMyTestSystem, "Test TCP Sink Reconnection", "[req:ACORE-11249]")
{
object_ptr<IStreamingSink> pSink;
REQUIRE_OK(_runtime->CreateInstance(CID_TCP_SINK, pSink));
auto pConfiguration = ucom_cast<IConfiguration*>(pSink.Get());
set_property(*pConfiguration, "remote_host", "127.0.0.1");
set_property(*pConfiguration, "remote_port", TEST_PORT);
SECTION("disabled reconnection")
{
set_property(*pConfiguration, "enable_automatic_reconnection", false);
REQUIRE_OK(pSink->SetState(IStreamingService::tStreamingState::State_Initialized));
REQUIRE_FAILED(pSink->SetState(IStreamingService::tStreamingState::State_Streaming));
}
SECTION("enabled reconnection")
{
set_property(*pConfiguration, "enable_automatic_reconnection", true);
REQUIRE_OK(pSink->SetState(IStreamingService::tStreamingState::State_Initialized));
cTestWriter oWriter(pSink, "input");
REQUIRE_OK(pSink->SetState(IStreamingService::tStreamingState::State_Streaming));
for (uint8_t nCounter = 0; nCounter < 5; ++ nCounter)
{
std::promise<void> oListening;
auto oListeningStarted = oListening.get_future();
std::promise<void> oRecievedData;
auto oReceivedDataDone = oRecievedData.get_future();
auto oServerResult = std::async(std::launch::async, tcp_server_sink, std::move(oListening), std::move(oRecievedData));
oListeningStarted.get();
do
{
oWriter.Write(nCounter, true);
}
while (oReceivedDataDone.wait_for(std::chrono::milliseconds(100)) == std::future_status::timeout);
oServerResult.get();
}
}
}
adtf_testing.h
Copyright © Audi Electronics Venture GmbH.
adtf_filtersdk.h
Copyright © Audi Electronics Venture GmbH.
LOG_INFO
#define LOG_INFO(...)
Logs an info message.
Definition: builds/digitalwerk/solutions/adtf_content/adtf_base/adtf_core/src/libraries/a_utils/include/a_utils/std/log.h:130
adtf::filter::flash::cStreamTypeHelper
Helper class that wraps different objects into an adtf::streaming::ant::IStreamType.
Definition: stream_type_helper.h:30
adtf::system::testing::giant::cTestSystem
This class enables you to setup an ADTF system where you can test your filters and services.
Definition: test_system.h:67
adtf::system::testing::lucky::cTestLogger
Utility class to record all log messages in an ADTF system during tests.
Definition: test_logger.h:28
adtf::system::testing::lucky::cTestLogger::GetCurrentMessages
tMessages GetCurrentMessages(bool bClear=true)
Returns all messages currently received.
adtf::ucom::ant::IRuntime::CreateInstance
virtual tResult CreateInstance(const char *strCID, iobject_ptr< IObject > &pObject, const tChar *strNameOfObject="") const =0
Creates a new instance of an object.
adtf::ucom::ant::IRuntime::GetObject
virtual tResult GetObject(iobject_ptr< IObject > &pObject, const char *strNameOID) const =0
Get registered object from object registry.
CID_ADTF_MEDIA_DESCRIPTION_SERVICE
#define CID_ADTF_MEDIA_DESCRIPTION_SERVICE
The default Class id of the media description service.
Definition: media_description_service_intf.h:13
A_UTILS_NS::to_string
cString to_string(const tResult &i_oResult, eResultFormatFlags i_eFormatFlags=eResultFormatFlags::RFF_DisableNone, const tChar *i_strFormat=nullptr)
Copy all information of an assigned result object to a (formatted) string.
A_UTILS_NS::cString
string_base< cStackString > cString
cString implementation for a stack string which works on stack if string is lower than A_UTILS_DEFAUL...
Definition: string.h:2778
a_util::chrono::seconds
std::chrono::seconds seconds
Compatibility to C++11 std::chrono::seconds
Definition: workspace/conan/dev_essential/1.3.3/dw/stable/package/37682420cd166e229516a41c8d6a139a0b13e1e1/include/a_util/concurrency/chrono.h:62
a_util::chrono::milliseconds
std::chrono::milliseconds milliseconds
Compatibility to C++11 std::chrono::milliseconds
Definition: workspace/conan/dev_essential/1.3.3/dw/stable/package/37682420cd166e229516a41c8d6a139a0b13e1e1/include/a_util/concurrency/chrono.h:55
adtf::base::ant::RL_Session
@ RL_Session
The session level.
Definition: adtf_runtime.h:30
adtf::base::ant::set_property
tResult set_property(IConfiguration &oConfiguration, const char *strNameOfValue, VALUETYPE oValue)
Set the property.
Definition: configuration.h:307
adtf::base
Namespace for the ADTF Base SDK.
Definition: page_base_namespaces.dox:11
adtf::filter::testing
Namespace for all testing functionality of the ADTF Filter SDK.
Definition: mainpage_filtersdk.dox:49
adtf::streaming::devil::add_binding_proxy
tResult add_binding_proxy(ant::cGraph &oGraph, const util::cString &strName, int32_t nOrderNumber, ucom::iobject_ptr< ucom::IObject > &pBindingProxy)
adds a Binding Proxy to a graph and return the created proxy.
Definition: graph_utils.h:117
adtf::streaming::devil::add_graph_object
tResult add_graph_object(ant::cGraph &oGraph, const util::cString &strCID, const util::cString &strName, const std::map< util::cString, util::cString > &oProperties, int32_t nOrderNumber, ucom::iobject_ptr< ucom::IObject > &pObject)
Convenience functionality to create and add add graph object to a existing graph.
Definition: graph_utils.h:39
adtf::streaming
Namespace for the ADTF Streaming SDK.
Definition: mainpage_streaming.dox:10
adtf::ucom
Namespace for the ADTF uCOM3 SDK.
Definition: testing/include/adtftesting/test_runtime.h:12
adtf::util
alias namespace for the A_UTILS Library.
Definition: page_a_utils.dox:15
_runtime
adtf::ucom::IRuntime * _runtime
Global Runtime Pointer to reference to the current runtime.
adtf::mediadescription::osborn::description
Template to provide struct name and definition for a generated struct.
Definition: md_sample_data.h:52
test_logger.h
Copyright © Audi Electronics Venture GmbH.
test_system.h
Copyright © Audi Electronics Venture GmbH.
THROW_IF_FAILED
#define THROW_IF_FAILED(s)
throws if the expression returns a failed tResult
Definition: ucom3/include/adtfucom3/exception_handling.h:180