604 lines
27 KiB
C++
604 lines
27 KiB
C++
#pragma once
|
|
|
|
#include "dtcore/inc/dtdefinitions.h"
|
|
#include "dtcore/inc/dtbytebuffer.h"
|
|
#include "dtcore/inc/dtmemory.h"
|
|
#include "dtcore/inc/dterror.h"
|
|
#include "dtcore/inc/dtxmlparser.h"
|
|
#include "dtcore/inc/dtusertoagentmapping.h"
|
|
#include "dtcore/inc/dttestdescriptor.h"
|
|
|
|
#pragma warning(push)
|
|
#include <functional>
|
|
#pragma warning(pop)
|
|
|
|
namespace dt
|
|
{
|
|
// Macro used by test to create a failure
|
|
// Note that the optional additional text *must* start with double quotes, if you need to use a function output do something like:
|
|
// DT_FAIL(my_desc, "" << my_func());
|
|
#define DT_FAIL(header, ...) \
|
|
do { \
|
|
dt::String _header; \
|
|
_header << header; \
|
|
if (*(""#__VA_ARGS__) != '\0') \
|
|
{ \
|
|
_header << " (" << "" __VA_ARGS__ << ")"; \
|
|
} \
|
|
dt::Test::AssertionFailed(dt::AssertionDetails(_header, \
|
|
dt::String::Blank(), \
|
|
dt::String::Blank(), \
|
|
__FILE__, \
|
|
__LINE__)); \
|
|
} while (0)
|
|
|
|
#define DT_FAIL_WITH_CATEGORY(header, category, ...) \
|
|
do { \
|
|
dt::String _header; \
|
|
_header << header; \
|
|
if (*(""#__VA_ARGS__) != '\0') \
|
|
{ \
|
|
_header << " (" << "" __VA_ARGS__ << ")"; \
|
|
} \
|
|
dt::String _category; \
|
|
_category << category; \
|
|
dt::Test::AssertionFailed(dt::AssertionDetails(_header, \
|
|
dt::String::Blank(), \
|
|
_category, \
|
|
__FILE__, \
|
|
__LINE__)); \
|
|
} while (0)
|
|
|
|
#define DT_FAIL_WITH_DETAILS(header, extended, ...) \
|
|
do { \
|
|
dt::String _header; \
|
|
_header << header; \
|
|
if (*(""#__VA_ARGS__) != '\0') \
|
|
{ \
|
|
_header << " (" << "" __VA_ARGS__ << ")"; \
|
|
} \
|
|
dt::String _extended; \
|
|
_extended << extended; \
|
|
dt::Test::AssertionFailed(dt::AssertionDetails(_header, \
|
|
_extended, \
|
|
dt::String::Blank(), \
|
|
__FILE__, \
|
|
__LINE__)); \
|
|
} while (0)
|
|
|
|
#define DT_FAIL_WITH_DETAILS_CATEGORY(header, extended, category, ...) \
|
|
do { \
|
|
dt::String _header; \
|
|
_header << header; \
|
|
if (*(""#__VA_ARGS__) != '\0') \
|
|
{ \
|
|
_header << " (" << "" __VA_ARGS__ << ")"; \
|
|
} \
|
|
dt::String _extended; \
|
|
_extended << extended; \
|
|
dt::String _category; \
|
|
_category << category; \
|
|
dt::Test::AssertionFailed(dt::AssertionDetails(_header, \
|
|
_extended, \
|
|
_category, \
|
|
__FILE__, \
|
|
__LINE__)); \
|
|
} while (0)
|
|
|
|
#define DT_FAIL_WITH_DETAILS_FILE_LINE(header, extended, file, line, ...) \
|
|
do { \
|
|
dt::String _header; \
|
|
_header << header; \
|
|
if (*(""#__VA_ARGS__) != '\0') \
|
|
{ \
|
|
_header << " (" << "" __VA_ARGS__ << ")"; \
|
|
} \
|
|
dt::String _extended; \
|
|
_extended << extended; \
|
|
dt::Test::AssertionFailed(dt::AssertionDetails(_header, \
|
|
_extended, \
|
|
dt::String::Blank(), \
|
|
file, \
|
|
line)); \
|
|
} while (0)
|
|
|
|
#define DT_FAIL_WITH_DETAILS_CATEGORY_FILE_LINE(header, extended, category, file, line, ...) \
|
|
do { \
|
|
dt::String _header; \
|
|
_header << header; \
|
|
if (*(""#__VA_ARGS__) != '\0') \
|
|
{ \
|
|
_header << " (" << "" __VA_ARGS__ << ")"; \
|
|
} \
|
|
dt::String _extended; \
|
|
_extended << extended; \
|
|
dt::String _category; \
|
|
_category << category; \
|
|
dt::Test::AssertionFailed(dt::AssertionDetails(_header, \
|
|
_extended, \
|
|
_category, \
|
|
file, \
|
|
line)); \
|
|
} while (0)
|
|
|
|
// Macro used by test to create a warning
|
|
#define DT_WARNING(header, ...) \
|
|
do { \
|
|
dt::String _header; \
|
|
_header << header; \
|
|
if (*(""#__VA_ARGS__) != '\0') \
|
|
{ \
|
|
_header << " (" << "" __VA_ARGS__ << ")"; \
|
|
} \
|
|
dt::Test::AssertionWarning(dt::AssertionDetails(_header, \
|
|
dt::String::Blank(), \
|
|
dt::String::Blank(), \
|
|
__FILE__, \
|
|
__LINE__)); \
|
|
} while (0)
|
|
|
|
#define DT_WARNING_WITH_DETAILS(header, extended, ...) \
|
|
do { \
|
|
dt::String _header; \
|
|
_header << header; \
|
|
if (*(""#__VA_ARGS__) != '\0') \
|
|
{ \
|
|
_header << " (" << "" __VA_ARGS__ << ")"; \
|
|
} \
|
|
dt::String _extended; \
|
|
_extended << extended; \
|
|
dt::Test::AssertionWarning(dt::AssertionDetails(_header, \
|
|
_extended, \
|
|
dt::String::Blank(), \
|
|
__FILE__, \
|
|
__LINE__)); \
|
|
} while (0)
|
|
|
|
// Macro used by test to verify equality
|
|
#define DT_EXPECT_EQUAL(expression, expectation, ...) \
|
|
do { \
|
|
if ((expression) == (expectation)) \
|
|
{ \
|
|
dt::Test::AssertionSucceeded(); \
|
|
} \
|
|
else \
|
|
{ \
|
|
DT_FAIL_WITH_DETAILS("Given value should match expectation", \
|
|
"Given value (" << (expression) << ") should match expectation (" << \
|
|
(expectation) << ") in expression: " << #expression << " == " << \
|
|
#expectation, __VA_ARGS__); \
|
|
} \
|
|
} while (0)
|
|
|
|
// Macro used by test to verify >
|
|
#define DT_EXPECT_GREATER(expression, expectation, ...) \
|
|
do { \
|
|
if ((expression) > (expectation)) \
|
|
{ \
|
|
dt::Test::AssertionSucceeded(); \
|
|
} \
|
|
else \
|
|
{ \
|
|
DT_FAIL_WITH_DETAILS("Given value should be greater than expectation", \
|
|
"Given value (" << (expression) << ") should be greater than expectation (" << \
|
|
(expectation) << ") in expression: " << #expression << " > " << \
|
|
#expectation, __VA_ARGS__); \
|
|
} \
|
|
} while (0)
|
|
|
|
// Macro used by test to verify >=
|
|
#define DT_EXPECT_GREATER_OR_EQUAL(expression, expectation, ...) \
|
|
do { \
|
|
if ((expression) >= (expectation)) \
|
|
{ \
|
|
dt::Test::AssertionSucceeded(); \
|
|
} \
|
|
else \
|
|
{ \
|
|
DT_FAIL_WITH_DETAILS("Given value should be greater or equal to expectation", \
|
|
"Given value (" << (expression) << ") should be greater or equal to expectation (" << \
|
|
(expectation) << ") in expression: " << #expression << " >= " << \
|
|
#expectation, __VA_ARGS__); \
|
|
} \
|
|
} while (0)
|
|
|
|
// Macro used by test to verify <
|
|
#define DT_EXPECT_SMALLER(expression, expectation, ...) \
|
|
do { \
|
|
if ((expression) < (expectation)) \
|
|
{ \
|
|
dt::Test::AssertionSucceeded(); \
|
|
} \
|
|
else \
|
|
{ \
|
|
DT_FAIL_WITH_DETAILS("Given value should be smaller than expectation", \
|
|
"Given value (" << (expression) << ") should be smaller than expectation (" << \
|
|
(expectation) << ") in expression: " << #expression << " < " << \
|
|
#expectation, __VA_ARGS__); \
|
|
} \
|
|
} while (0)
|
|
|
|
// Macro used by test to verify >=
|
|
#define DT_EXPECT_SMALLER_OR_EQUAL(expression, expectation, ...) \
|
|
do { \
|
|
if ((expression) <= (expectation)) \
|
|
{ \
|
|
dt::Test::AssertionSucceeded(); \
|
|
} \
|
|
else \
|
|
{ \
|
|
DT_FAIL_WITH_DETAILS("Given value should be smaller or equal to expectation", \
|
|
"Given value (" << (expression) << ") should be smaller or equal to expectation (" << \
|
|
(expectation) << ") in expression: " << #expression << " <= " << \
|
|
#expectation, __VA_ARGS__); \
|
|
} \
|
|
} while (0)
|
|
|
|
// Macro used by test to verify equality
|
|
#define DT_EXPECT_UNEQUAL(expression, expectation, ...) \
|
|
do { \
|
|
if ((expression) != (expectation)) \
|
|
{ \
|
|
dt::Test::AssertionSucceeded(); \
|
|
} \
|
|
else \
|
|
{ \
|
|
DT_FAIL_WITH_DETAILS("Given value should not match expectation", \
|
|
"Given value (" << (expression) << ") should not match expectation (" << \
|
|
(expectation) << ") in expression: " << #expression << " != " << \
|
|
#expectation, __VA_ARGS__); \
|
|
} \
|
|
} while (0)
|
|
|
|
// Macro used by test to verify truthfulness
|
|
#define DT_EXPECT_TRUE(expression, ...) \
|
|
do { \
|
|
if ((expression)) \
|
|
{ \
|
|
dt::Test::AssertionSucceeded(); \
|
|
} \
|
|
else \
|
|
{ \
|
|
DT_FAIL_WITH_DETAILS("Given value should match expectation", \
|
|
"Given value should evaluate to TRUE in expression: " << \
|
|
#expression, __VA_ARGS__); \
|
|
} \
|
|
} while (0)
|
|
|
|
// Macro used by test to verify falseness
|
|
#define DT_EXPECT_FALSE(expression, ...) \
|
|
do { \
|
|
if (!(expression)) \
|
|
{ \
|
|
dt::Test::AssertionSucceeded(); \
|
|
} \
|
|
else \
|
|
{ \
|
|
DT_FAIL_WITH_DETAILS("Given value should match expectation", \
|
|
"Given value should evaluate to FALSE in expression: " << \
|
|
#expression, __VA_ARGS__); \
|
|
} \
|
|
} while (0)
|
|
|
|
// Macro used by test to report progress
|
|
#define DT_REPORT_PROGRESS(description) \
|
|
do { \
|
|
dt::String _msg; \
|
|
_msg << description; \
|
|
dt::Test::ReportProgress(_msg, dt::ProgressionType::User); \
|
|
} while (0)
|
|
|
|
// Use this macro to register your test to the TestFactory
|
|
#define DT_REGISTER_TEST(className) \
|
|
do { \
|
|
extern dt::Test* dtCreate##className(); \
|
|
dt::TestFactory::Register(#className, &dtCreate##className); \
|
|
} while (0)
|
|
|
|
// Use this macro to declare a test. The base class should be or derive from dt::Test
|
|
// example: DT_DECLARE_TEST(yourtestname) : public dt::Test
|
|
#define DT_DECLARE_TEST(className, ...) \
|
|
class className; \
|
|
__VA_ARGS__ dt::Test* dtCreate##className() \
|
|
{ \
|
|
return dt::TestFactory::CreateTemplate<className>(); \
|
|
} \
|
|
class __VA_ARGS__ className
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
enum class ProgressionType
|
|
{
|
|
User,
|
|
System
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
// The progression listener interface class can be used to listen to dt::Test::ReportProgress calls.
|
|
class TestProgressionListener
|
|
{
|
|
public:
|
|
DT_CORE_DLL_ENTRY virtual ~TestProgressionListener() {}
|
|
|
|
DT_CORE_DLL_ENTRY virtual void OnProgression(const String& message, ProgressionType progressionType) = 0;
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
class AssertionDetails
|
|
{
|
|
public:
|
|
DT_CORE_DLL_ENTRY AssertionDetails() = default;
|
|
DT_CORE_DLL_ENTRY AssertionDetails(const String& header,
|
|
const String& extended,
|
|
const String& category,
|
|
const char* file,
|
|
int line);
|
|
|
|
DT_CORE_DLL_ENTRY const String& GetHeader() const { return m_Header; }
|
|
DT_CORE_DLL_ENTRY const String& GetExtended() const { return m_Extended; }
|
|
DT_CORE_DLL_ENTRY const String& GetCategory() const { return m_Category; }
|
|
DT_CORE_DLL_ENTRY const char* GetFile() const { return m_File; }
|
|
DT_CORE_DLL_ENTRY int GetLine() const { return m_Line; }
|
|
|
|
private:
|
|
String m_Header;
|
|
String m_Extended;
|
|
String m_Category;
|
|
const char* m_File = nullptr;
|
|
int m_Line = 0;
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
class Test
|
|
{
|
|
public:
|
|
DT_CORE_DLL_ENTRY virtual ~Test() {}
|
|
|
|
// Functions to be overridden in your test
|
|
|
|
// override this method in your test if needed, this base function must no be called from your test
|
|
DT_CORE_DLL_ENTRY virtual void Setup();
|
|
// override this method in your test if needed, this base function must no be called from your test
|
|
DT_CORE_DLL_ENTRY virtual void Execute();
|
|
// override this method in your test if needed, this base function must no be called from your test
|
|
DT_CORE_DLL_ENTRY virtual void TearDown();
|
|
// override this method to add a custom failure when you test timeout. Useful to report what you where exactly doing in the failure reason.
|
|
DT_CORE_DLL_ENTRY virtual void OnTimeout();
|
|
|
|
|
|
// Utility functions
|
|
|
|
// this function will be called by the test assertion macros: DT_EXPECT_EQUAL, DT_EXPECT_TRUE, DT_EXPECT_FALSE, etc
|
|
// when a success is found
|
|
DT_CORE_DLL_ENTRY static void AssertionSucceeded();
|
|
// this function will be called by the test assertion macros: DT_EXPECT_EQUAL, DT_EXPECT_TRUE, DT_EXPECT_FALSE, etc
|
|
// when a failure is found
|
|
DT_CORE_DLL_ENTRY static void AssertionFailed(const AssertionDetails& details);
|
|
DT_CORE_DLL_ENTRY static void AssertionWarning(const AssertionDetails& details);
|
|
// this function is to be called when a crash is detected by external tools, this will trigger a message to the farm to inform user if in interactive mode.
|
|
DT_CORE_DLL_ENTRY static void InteractiveTrigger(bool trap);
|
|
// call this function if your test is in asynchronous mode (see dt::Test::SetExecutionMode())
|
|
DT_CORE_DLL_ENTRY static void SetCompleted();
|
|
// returns true if Test::SetCompleted() was called
|
|
DT_CORE_DLL_ENTRY static bool IsCompleted();
|
|
// function used to override or create a DTEST user variable
|
|
DT_CORE_DLL_ENTRY static void SetUserVariable(const String& name, const String& value);
|
|
// function used to get a DTEST user variable
|
|
DT_CORE_DLL_ENTRY static const Variable& GetUserVariable(const String& name);
|
|
// function used to get a DTEST user variable
|
|
DT_CORE_DLL_ENTRY static bool TryGetUserVariable(const String& name, const Variable** out);
|
|
|
|
// Test Descriptor
|
|
|
|
// get the TestDescriptor of current running test
|
|
// The descriptor will only be valid after TestDescriptorCallback, set when creating ServiceTest_Agent, is called.
|
|
DT_CORE_DLL_ENTRY static const TestDescriptor& GetDescriptor();
|
|
|
|
// get the current agent index running. The indexes starts at 0. If you have 3 agents in your test the indexes will be 0, 1 and 2
|
|
DT_CORE_DLL_ENTRY static int GetAgentIndex();
|
|
DT_CORE_DLL_ENTRY static AgentIndex GetStrongTypeAgentIndex();
|
|
// get the total number of agents necessary to run this test;
|
|
DT_CORE_DLL_ENTRY static int GetTotalAgentCount();
|
|
// get a token of the specified type and return a reservation id; Set only in you test constructor. Your test will fail if you get an unknown token
|
|
DT_CORE_DLL_ENTRY static const String& GetToken(const String& tokenName);
|
|
|
|
// Additional test information
|
|
|
|
// get the batch ID
|
|
DT_CORE_DLL_ENTRY static int GetBatchId();
|
|
DT_CORE_DLL_ENTRY static BatchId GetStrongTypeBatchId();
|
|
// get the test ID (unique in the current database)
|
|
DT_CORE_DLL_ENTRY static int GetTestId();
|
|
DT_CORE_DLL_ENTRY static TestId GetStrongTypeTestId();
|
|
// get the test GUID (globally unique)
|
|
DT_CORE_DLL_ENTRY static const String& GetTestGUID();
|
|
// get the current try of the test
|
|
DT_CORE_DLL_ENTRY static int GetTryId();
|
|
DT_CORE_DLL_ENTRY static TryId GetStrongTypeTryId();
|
|
// get the resource ID
|
|
DT_CORE_DLL_ENTRY static int GetResourceId();
|
|
DT_CORE_DLL_ENTRY static ResourceReservationId GetStrongTypeResourceId();
|
|
|
|
// Returns the ID of the associated TestManagementTool test, if one was associated with this test, INVALID_ID otherwise.
|
|
DT_CORE_DLL_ENTRY static int GetTestManagementToolTestId();
|
|
DT_CORE_DLL_ENTRY static TestManagementToolTestId GetTestManagementToolStrongTypeTestId();
|
|
|
|
// get the shell command ID. The shell command ID is a unique ID of the command that started the executable of this agent.
|
|
DT_CORE_DLL_ENTRY static int GetShellCommandId();
|
|
DT_CORE_DLL_ENTRY static CommandId GetStrongTypeCommandId();
|
|
// get if timeouts should be enabled (this is to ease debugging)
|
|
DT_CORE_DLL_ENTRY static bool IsTimeoutEnabled();
|
|
// get if the script is current paused on a breakpoint
|
|
DT_CORE_DLL_ENTRY static bool IsPausedOnBreakpoint();
|
|
// get if the agent is waiting for user interaction on test end
|
|
DT_CORE_DLL_ENTRY static bool IsWaitInteractionOnEnd();
|
|
// get if the given agent has failed
|
|
DT_CORE_DLL_ENTRY static bool HasAgentFailed(int agentIndex);
|
|
// get the maintainer's name
|
|
DT_CORE_DLL_ENTRY static const String& GetMaintainerName();
|
|
// get the maintainer's email
|
|
DT_CORE_DLL_ENTRY static const String& GetMaintainerEmail();
|
|
// get the current platform name as specified in the DTEST project
|
|
DT_CORE_DLL_ENTRY static const String& GetPlatform();
|
|
// get the current config name as specified in the DTEST project
|
|
DT_CORE_DLL_ENTRY static const String& GetConfig();
|
|
// get the current profile used to run the test
|
|
DT_CORE_DLL_ENTRY static const String& GetProfile();
|
|
// get the current configuration file name (dtproj)
|
|
DT_CORE_DLL_ENTRY static const String& GetProjectFileName();
|
|
// get the current executing script line
|
|
DT_CORE_DLL_ENTRY static bool GetExecutingScriptLine(const ScriptLine** curLine);
|
|
|
|
// get the maximum artefact size allowed to be uploaded to the farm
|
|
DT_CORE_DLL_ENTRY static SizeT GetMaxArtefactSizeInBytes();
|
|
|
|
// return true if this subtest is the first to run in the agent.
|
|
// return false if the current test is not a subtest.
|
|
// This can be used to run setup code that means to be executed before the test can run
|
|
DT_CORE_DLL_ENTRY static bool IsFirstSubTest();
|
|
|
|
// Events
|
|
|
|
// Wait for a specific event
|
|
// eventId: The event type to wait for
|
|
// payload: Optionally pass a pointer to an instance of a ByteBuffer to retrieve a payload
|
|
// returns true if within maxWaitTimeMs an event of type eventId was received
|
|
DT_CORE_DLL_ENTRY static bool WaitForEvent(const String& eventId, ByteBuffer* payload, int maxWaitTimeMs = 0);
|
|
// Wait for any event
|
|
// eventId: Optionally pass a pointer to an instance of a String to retrieve the type of event received
|
|
// payload: Optionally pass a pointer to an instance of a ByteBuffer to retrieve a payload
|
|
// returns true if within maxWaitTimeMs an event was received
|
|
DT_CORE_DLL_ENTRY static bool WaitForAnyEvent(String* eventId, ByteBuffer* payload, int maxWaitTimeMs = 0);
|
|
// Sends an event to all agents within the test
|
|
// eventId: The event type to send
|
|
// payload: Optional custom data to send with the event
|
|
DT_CORE_DLL_ENTRY static void BroadcastEvent(const String& eventId, const ByteBuffer& payload = ByteBuffer());
|
|
// Send an event to the specified agent within the test
|
|
// AgentIndex: The destination agent index to send to event to
|
|
// eventId: The event type to send
|
|
// payload: Optional custom data to send with the event
|
|
DT_CORE_DLL_ENTRY static void UnicastEvent(int AgentIndex, const String& eventId, const ByteBuffer& payload = ByteBuffer());
|
|
|
|
|
|
// Threads
|
|
|
|
// Invoke a call on the foreground thread of the application. This is useful if the tests runs in a
|
|
// background thread (ServiceTest_Agent created with runTestOnForegroundUpdate=false). The call will
|
|
// be performed when ServiceTest_Agent::ForegroundUpdate is called. Invoke will return immediatly and
|
|
// the call will be performed in background. InvokeAndWait will return only afterward the call has been
|
|
// down in the foreground thread.
|
|
DT_CORE_DLL_ENTRY static void Invoke(const std::function<void()>& function);
|
|
DT_CORE_DLL_ENTRY static void InvokeAndWait(const std::function<void()>& function);
|
|
|
|
|
|
// Progression
|
|
|
|
// A test can add progression string to show the big steps of a test as they happen during execution.
|
|
// The progression information will be shown in the DTEST graphical application, in the dtTerminal
|
|
// standard output and on the web site test details. The goal of this is to provide a brief overview
|
|
// of what is happening in your test. It should no be too verbose and is not there to replace logs.
|
|
// It shall be user friendly message that every one can understand like:
|
|
// Player spawned
|
|
// Waiting for friend to join
|
|
// Starting playing with friend
|
|
// Etc.
|
|
// These progression message will also show up in logs, so no need to duplicate them.
|
|
DT_CORE_DLL_ENTRY static void ReportProgress(const String& progression, ProgressionType progressionType);
|
|
|
|
// A progression listener can be registered to intercept any calls to dt::Test::ReportProgress.
|
|
// You are responsible to remove the listener before its deletion.
|
|
DT_CORE_DLL_ENTRY static void AddProgressListener(TestProgressionListener* listener);
|
|
|
|
// Remove a previously registered listener. If the listener is not found, the call does nothing.
|
|
DT_CORE_DLL_ENTRY static void RemoveProgressListener(TestProgressionListener* listener);
|
|
|
|
|
|
// Shell Commands
|
|
|
|
// Starts a global shell command already declared in DTest's config files.
|
|
// globalCommandName: The global command name to be used
|
|
// params: The parameters of the shell command
|
|
// returns the local command ID of the command that was started
|
|
DT_CORE_DLL_ENTRY static int StartGlobalShellCommand(const String& globalCommandName, const ShellCommandParams& params);
|
|
// Starts a custom shell command.
|
|
// command: A string which represents the actual instructions to be executed.
|
|
// params: The parameters of the shell command
|
|
// returns the local command ID of the command that was started
|
|
DT_CORE_DLL_ENTRY static int StartCustomShellCommand(const String& command, const ShellCommandParams& params);
|
|
// Waits for a previously started shell command to be finished.
|
|
// commandId: The ID of the command to wait for
|
|
// exitCode: Returns the exit code of the command that executed
|
|
// output: The string that will receive the output of the shell command. Pass null if you don't care about output
|
|
// maxWaitTimeSec: Maximum wait time for the command to complete, in seconds.
|
|
DT_CORE_DLL_ENTRY static bool WaitForRuntimeShellCommand(int commandId, int* exitCode, String* output = nullptr, int maxWaitTimeSec = 0);
|
|
// Returns the output of the shell command where the ShellCommandParams::SetOutputRequested was defined true
|
|
// commandId: The ID of the command
|
|
// output: The string that will receive the output of the shell command
|
|
// returns True if the shell command output was copied in the string. False if the command has not yet completed or was not found.
|
|
DT_CORE_DLL_ENTRY static bool GetShellCommandOutput(int commandId, String* output);
|
|
// Clears the output of the shell command
|
|
// commandId: The ID of the command
|
|
DT_CORE_DLL_ENTRY static void ClearShellCommandOutput(int commandId);
|
|
|
|
|
|
// Deprecated API
|
|
|
|
// DEPRECATED - This will be removed in the next versions. Please use GetDescriptor() instead.
|
|
DT_DEPRECATED("This will be removed in the next versions. Please use GetDescriptor() instead.")
|
|
DT_CORE_DLL_ENTRY static const String& GetName();
|
|
// DEPRECATED - This will be removed in the next versions. Please use GetDescriptor() instead.
|
|
DT_DEPRECATED("This will be removed in the next versions. Please use GetDescriptor() instead.")
|
|
DT_CORE_DLL_ENTRY static const String& GetClass();
|
|
// DEPRECATED - This will be removed in the next versions. Please use GetDescriptor() instead.
|
|
DT_DEPRECATED("This will be removed in the next versions. Please use GetDescriptor() instead.")
|
|
DT_CORE_DLL_ENTRY static TestExecutionMode GetExecutionMode();
|
|
// DEPRECATED - This will be removed in the next versions. Please use GetDescriptor() instead.
|
|
DT_DEPRECATED("This will be removed in the next versions. Please use GetDescriptor() instead.")
|
|
DT_CORE_DLL_ENTRY static const XmlNode* GetCustomData();
|
|
// DEPRECATED - This will be removed in the next versions. Please use alternate form of StartGlobalShellCommand() instead.
|
|
DT_DEPRECATED("This will be removed in the next versions. Please use alternate form of StartGlobalShellCommand() instead.")
|
|
DT_CORE_DLL_ENTRY static int StartGlobalShellCommand(const String& globalCommandName,
|
|
const ShellCommandArguments& commandArguments,
|
|
const String& commandName);
|
|
// DEPRECATED - This will be removed in the next versions. Please use alternate form of StartCustomShellCommand() instead.
|
|
DT_DEPRECATED("This will be removed in the next versions. Please use alternate form of StartCustomShellCommand() instead.")
|
|
DT_CORE_DLL_ENTRY static int StartCustomShellCommand(const String& command,
|
|
const ShellCommandArguments& commandArguments,
|
|
const String& commandName,
|
|
int commandTimeout = INVALID_VALUE);
|
|
DT_DEPRECATED("This will be removed in the next versions. Please use the GetTestManagementToolTestId() version instead.")
|
|
DT_CORE_DLL_ENTRY static int GetTestRailTestId();
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
// The test factory call is used by the DT_DECLARE_TEST macro to register your test and let the system create
|
|
// it. It shall not be necessary to use it from the test perspective
|
|
class TestFactory
|
|
{
|
|
public:
|
|
typedef Test* (*CreateFunction)();
|
|
|
|
// Register a create function for the specified class name
|
|
DT_CORE_DLL_ENTRY static void Register(const char* name, CreateFunction createFunc);
|
|
// Try a create a test class of the specific type name
|
|
// returns a new instance of the specified class
|
|
// returns true if the class was known and test class created
|
|
DT_CORE_DLL_ENTRY static bool Create(const String& typeName, Test** out);
|
|
// Helper function to create a test
|
|
template <typename T> static Test* CreateTemplate();
|
|
// Returns the complete list of known tests
|
|
DT_CORE_DLL_ENTRY static void GetRegisteredTests(Strings* out);
|
|
|
|
};
|
|
|
|
template <typename T> Test* TestFactory::CreateTemplate()
|
|
{
|
|
return DT_NEW(T);
|
|
}
|
|
|
|
}
|
|
|