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
 
namespace adtf
{
namespace system
{
namespace testing
{
namespace giant
{
 
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);
 
        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);
        ~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);
 
    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);
 
        cSessionTestSystem(const std::string& strUrl,
                           bool bCreateLoggingService,
                           const std::string& strAdtfDirectory = ADTF_TESTING_ADTF_DIR,
                           const std::string& strPluginDirectories = ADTF_TESTING_PLUGIN_DIRECTORIES);
 
        void SetEnvironmentFile(const std::string& strFileName);
 
        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);
 
        ucom::ant::object_ptr<services::ant::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);
};
 
}
 
using giant::cTestSystem;
using giant::cSessionTestSystem;
 
}
}
}