test_system.h

Go to the documentation of this file.

#pragma once
 
#include <adtfbase/adtf_runtime.h>
#include <adtfsystemsdk/adtf_system.h>
#include <adtfsystemsdk/services/session_intf.h>
#include <adtfstreaming3/named_graph_object_intf.h>
#include <adtfstreaming3/filtergraph_intf.h>
#include <adtfstreaming3/streaming_graph_intf.h>
#include <string>
 
#ifndef ADTF_TESTING_ADTF_DIR
    #define ADTF_TESTING_ADTF_DIR ""
#endif
 
#ifndef ADTF_TESTING_PLUGIN_DIRECTORIES
    #define ADTF_TESTING_PLUGIN_DIRECTORIES ""
#endif
 
#ifndef ADTF_TESTING_SOURCE_DIR
    #define ADTF_TESTING_SOURCE_DIR ""
#endif
 
#ifndef ADTF_TESTING_MUTABLE_RESOURCES
    #define ADTF_TESTING_MUTABLE_RESOURCES ""
#endif
 
#ifndef ADTF_TESTING_BUILD_DIR
    #define ADTF_TESTING_BUILD_DIR ""
#endif
 
namespace adtf
{
namespace system
{
namespace testing
{
namespace giant
{
 
class cTestResourceCopier
{
public:
    cTestResourceCopier(const std::string& strResources = ADTF_TESTING_MUTABLE_RESOURCES,
                        const std::string& strTargetRootDirectory = ADTF_TESTING_BUILD_DIR);

    ~cTestResourceCopier();
 
public:
    std::string GetResourceTargetDirectory() const;
 
protected:
    class cImplementation;
    std::unique_ptr<cImplementation> m_pImplementation;
};

class cTestSystem
{
public:
    cTestSystem(const std::string& strUrl = "",
                const std::vector<std::string>& oPlugins = {},
                bool bCreateSessionManager = false,
                const std::string& strAdtfDirectory = ADTF_TESTING_ADTF_DIR,
                const std::string& strPluginDirectories = ADTF_TESTING_PLUGIN_DIRECTORIES,
                const std::string& strResources = ADTF_TESTING_MUTABLE_RESOURCES,
                const std::string& strResourcesOutputDirectory = ADTF_TESTING_BUILD_DIR);

    cTestSystem(const std::string& strUrl,
                const std::vector<std::string>& oPlugins,
                bool bCreateSessionManager,
                bool bCreateLoggingService,
                const std::string& strAdtfDirectory = ADTF_TESTING_ADTF_DIR,
                const std::string& strPluginDirectories = ADTF_TESTING_PLUGIN_DIRECTORIES,
                const std::string& strResources = ADTF_TESTING_MUTABLE_RESOURCES,
                const std::string& strResourcesOutputDirectory = ADTF_TESTING_BUILD_DIR);
    ~cTestSystem();

    static void SetCurDirectory(const std::string& strRelativePath,
                                const std::string& strTestSourceDirectory = ADTF_TESTING_SOURCE_DIR);

    static void SetMacro(const std::string& strName, const std::string& strValue);

    void SetRunLevel(base::ant::tADTFRunLevel eRunlevel);

    base::ant::tADTFRunLevel GetRunLevel() const;

    void LoadPlugin(const std::string& strPluginFileName,
                    bool bCreateServices = true,
                    base::ant::tADTFRunLevel nServicesRunlevel = base::tADTFRunLevel::RL_System);

    ucom::ant::object_ptr<ucom::ant::IService>
        CreateService(const std::string& strClassId,
                      const std::string& strObjectId,
                      base::ant::tADTFRunLevel nRunlevel = base::tADTFRunLevel::RL_System);

    ucom::ant::object_ptr<ucom::ant::IService>
        CreateService(const std::string& strPluginFileName,
                      const std::string& strClassId,
                      const std::string& strObjectId,
                      base::ant::tADTFRunLevel nRunlevel = base::tADTFRunLevel::RL_System);

    ucom::ant::object_ptr<ucom::ant::IService> CreateService(const std::string& strClassId,
                                                             const std::string& strObjectId,
                                                             base::ant::tADTFRunLevel nRunlevel,
                                                             const std::map<std::string, std::string>& oProperties);

    ucom::ant::object_ptr<ucom::ant::IService> CreateService(const std::string& strPluginFileName,
                                                             const std::string& strClassId,
                                                             const std::string& strObjectId,
                                                             base::ant::tADTFRunLevel nRunlevel,
                                                             const std::map<std::string, std::string>& oProperties);
 
    enum tProtocolFamily
    {
        TCP_IPv4,
        TCP_IPv6,
        UDP_IPv4,
        UDP_IPv6,
    };

    static uint16_t GetAvailablePort(tProtocolFamily eFamily, const std::string& strInterface = {});

    static std::string GetAvailableTestUrl();

    std::string GetUrl() const;

    std::string GetMutableResourceDirectory() const;
 
protected:
    class cImplementation;
    std::unique_ptr<cImplementation> m_pImplementation;
};

class cSessionTestSystem : public cTestSystem
{
public:
    cSessionTestSystem(const std::string& strUrl = "",
                       const std::string& strAdtfDirectory = ADTF_TESTING_ADTF_DIR,
                       const std::string& strPluginDirectories = ADTF_TESTING_PLUGIN_DIRECTORIES,
                       const std::string& strResources = ADTF_TESTING_MUTABLE_RESOURCES,
                       const std::string& strResourcesOutputDirectory = ADTF_TESTING_BUILD_DIR);

    cSessionTestSystem(const std::string& strUrl,
                       bool bCreateLoggingService,
                       const std::string& strAdtfDirectory = ADTF_TESTING_ADTF_DIR,
                       const std::string& strPluginDirectories = ADTF_TESTING_PLUGIN_DIRECTORIES,
                       const std::string& strResources = ADTF_TESTING_MUTABLE_RESOURCES,
                       const std::string& strResourcesOutputDirectory = ADTF_TESTING_BUILD_DIR);

    void SetEnvironmentFile(const std::string& strFileName, bool bPluginDiscovery = true);

    void CreateSession(const std::string& strFileName);

    void Exec(std::chrono::microseconds tmTimeout);

    void Exec(int8_t nInitialRunlevel, std::function<void()> fnStartup);

    void ExecTest(int8_t nInitialRunlevel, std::function<void()> fnTest);

    void Exec(int8_t nInitialRunlevel, int8_t nAutoQuitLevel, std::function<void()> fnStartup);

    ucom::ant::object_ptr<services::ISession> GetSession();

    ucom::ant::object_ptr<streaming::ant::IStreamingGraph> GetStreamingGraph();

    ucom::ant::object_ptr<streaming::ant::IFilterGraph> GetFilterGraph();

    ucom::ant::object_ptr<streaming::ant::INamedGraphObject> GetGraphObject(const std::string& name);
};
 
} // namespace giant
 
using giant::cTestResourceCopier;
using giant::cTestSystem;
using giant::cSessionTestSystem;
 
} // namespace testing
} // namespace system
} // namespace adtf