/*-------------------------------------------------------------------------
* drawElements Quality Program Tester Core
* ----------------------------------------
*
* Copyright 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*//*!
* \file
* \brief Command line parsing.
*//*--------------------------------------------------------------------*/
#include "tcuCommandLine.hpp"
#include "tcuPlatform.hpp"
#include "deFilePath.hpp"
#include "deStringUtil.hpp"
#include "deString.h"
#include "deInt32.h"
#include "deCommandLine.h"
#include "qpTestLog.h"
#include "qpDebugOut.h"
#include <string>
#include <vector>
#include <sstream>
#include <fstream>
#include <iostream>
using std::string;
using std::vector;
// OOM tests are enabled by default only on platforms that don't do memory overcommit (Win32)
#if (DE_OS == DE_OS_WIN32)
# define TEST_OOM_DEFAULT "enable"
#else
# define TEST_OOM_DEFAULT "disable"
#endif
namespace tcu
{
namespace opt
{
DE_DECLARE_COMMAND_LINE_OPT(CasePath, std::string);
DE_DECLARE_COMMAND_LINE_OPT(CaseList, std::string);
DE_DECLARE_COMMAND_LINE_OPT(CaseListFile, std::string);
DE_DECLARE_COMMAND_LINE_OPT(StdinCaseList, bool);
DE_DECLARE_COMMAND_LINE_OPT(LogFilename, std::string);
DE_DECLARE_COMMAND_LINE_OPT(RunMode, tcu::RunMode);
DE_DECLARE_COMMAND_LINE_OPT(WatchDog, bool);
DE_DECLARE_COMMAND_LINE_OPT(CrashHandler, bool);
DE_DECLARE_COMMAND_LINE_OPT(BaseSeed, int);
DE_DECLARE_COMMAND_LINE_OPT(TestIterationCount, int);
DE_DECLARE_COMMAND_LINE_OPT(Visibility, WindowVisibility);
DE_DECLARE_COMMAND_LINE_OPT(SurfaceWidth, int);
DE_DECLARE_COMMAND_LINE_OPT(SurfaceHeight, int);
DE_DECLARE_COMMAND_LINE_OPT(SurfaceType, tcu::SurfaceType);
DE_DECLARE_COMMAND_LINE_OPT(ScreenRotation, tcu::ScreenRotation);
DE_DECLARE_COMMAND_LINE_OPT(GLContextType, std::string);
DE_DECLARE_COMMAND_LINE_OPT(GLConfigID, int);
DE_DECLARE_COMMAND_LINE_OPT(GLConfigName, std::string);
DE_DECLARE_COMMAND_LINE_OPT(GLContextFlags, std::string);
DE_DECLARE_COMMAND_LINE_OPT(CLPlatformID, int);
DE_DECLARE_COMMAND_LINE_OPT(CLDeviceIDs, std::vector<int>);
DE_DECLARE_COMMAND_LINE_OPT(CLBuildOptions, std::string);
DE_DECLARE_COMMAND_LINE_OPT(EGLDisplayType, std::string);
DE_DECLARE_COMMAND_LINE_OPT(EGLWindowType, std::string);
DE_DECLARE_COMMAND_LINE_OPT(EGLPixmapType, std::string);
DE_DECLARE_COMMAND_LINE_OPT(LogImages, bool);
DE_DECLARE_COMMAND_LINE_OPT(TestOOM, bool);
static void parseIntList (const char* src, std::vector<int>* dst)
{
std::istringstream str (src);
std::string val;
while (std::getline(str, val, ','))
{
int intVal = 0;
de::cmdline::parseType(val.c_str(), &intVal);
dst->push_back(intVal);
}
}
void registerOptions (de::cmdline::Parser& parser)
{
using de::cmdline::Option;
using de::cmdline::NamedValue;
static const NamedValue<bool> s_enableNames[] =
{
{ "enable", true },
{ "disable", false }
};
static const NamedValue<tcu::RunMode> s_runModes[] =
{
{ "execute", RUNMODE_EXECUTE },
{ "xml-caselist", RUNMODE_DUMP_XML_CASELIST },
{ "txt-caselist", RUNMODE_DUMP_TEXT_CASELIST }
};
static const NamedValue<WindowVisibility> s_visibilites[] =
{
{ "windowed", WINDOWVISIBILITY_WINDOWED },
{ "fullscreen", WINDOWVISIBILITY_FULLSCREEN },
{ "hidden", WINDOWVISIBILITY_HIDDEN }
};
static const NamedValue<tcu::SurfaceType> s_surfaceTypes[] =
{
{ "window", SURFACETYPE_WINDOW },
{ "pixmap", SURFACETYPE_OFFSCREEN_NATIVE },
{ "pbuffer", SURFACETYPE_OFFSCREEN_GENERIC },
{ "fbo", SURFACETYPE_FBO }
};
static const NamedValue<tcu::ScreenRotation> s_screenRotations[] =
{
{ "0", SCREENROTATION_0 },
{ "90", SCREENROTATION_90 },
{ "180", SCREENROTATION_180 },
{ "270", SCREENROTATION_270 }
};
parser
<< Option<CasePath> ("n", "deqp-case", "Test case(s) to run, supports wildcards (e.g. dEQP-GLES2.info.*)")
<< Option<CaseList> (DE_NULL, "deqp-caselist", "Case list to run in trie format (e.g. {dEQP-GLES2{info{version,renderer}}})")
<< Option<CaseListFile> (DE_NULL, "deqp-caselist-file", "Read case list (in trie format) from given file")
<< Option<StdinCaseList> (DE_NULL, "deqp-stdin-caselist", "Read case list (in trie format) from stdin")
<< Option<LogFilename> (DE_NULL, "deqp-log-filename", "Write test results to given file", "TestResults.qpa")
<< Option<RunMode> (DE_NULL, "deqp-runmode", "Execute tests, or write list of test cases into a file",
s_runModes, "execute")
<< Option<WatchDog> (DE_NULL, "deqp-watchdog", "Enable test watchdog", s_enableNames, "disable")
<< Option<CrashHandler> (DE_NULL, "deqp-crashhandler", "Enable crash handling", s_enableNames, "disable")
<< Option<BaseSeed> (DE_NULL, "deqp-base-seed", "Base seed for test cases that use randomization")
<< Option<TestIterationCount> (DE_NULL, "deqp-test-iteration-count", "Iteration count for cases that support variable number of iterations")
<< Option<Visibility> (DE_NULL, "deqp-visibility", "Default test window visibility", s_visibilites, "windowed")
<< Option<SurfaceWidth> (DE_NULL, "deqp-surface-width", "Use given surface width if possible", "-1")
<< Option<SurfaceHeight> (DE_NULL, "deqp-surface-height", "Use given surface height if possible", "-1")
<< Option<SurfaceType> (DE_NULL, "deqp-surface-type", "Use given surface type", s_surfaceTypes, "window")
<< Option<ScreenRotation> (DE_NULL, "deqp-screen-rotation", "Screen rotation for platforms that support it", s_screenRotations, "0")
<< Option<GLContextType> (DE_NULL, "deqp-gl-context-type", "OpenGL context type for platforms that support multiple")
<< Option<GLConfigID> (DE_NULL, "deqp-gl-config-id", "OpenGL (ES) render config ID (EGL config id on EGL platforms)", "-1")
<< Option<GLConfigName> (DE_NULL, "deqp-gl-config-name", "Symbolic OpenGL (ES) render config name")
<< Option<GLContextFlags> (DE_NULL, "deqp-gl-context-flags", "OpenGL context flags (comma-separated, supports debug and robust)")
<< Option<CLPlatformID> (DE_NULL, "deqp-cl-platform-id", "Execute tests on given OpenCL platform (IDs start from 1)", "1")
<< Option<CLDeviceIDs> (DE_NULL, "deqp-cl-device-ids", "Execute tests on given CL devices (comma-separated, IDs start from 1)", parseIntList)
<< Option<CLBuildOptions> (DE_NULL, "deqp-cl-build-options", "Extra build options for OpenCL compiler")
<< Option<EGLDisplayType> (DE_NULL, "deqp-egl-display-type", "EGL native display type")
<< Option<EGLWindowType> (DE_NULL, "deqp-egl-window-type", "EGL native window type")
<< Option<EGLPixmapType> (DE_NULL, "deqp-egl-pixmap-type", "EGL native pixmap type")
<< Option<LogImages> (DE_NULL, "deqp-log-images", "Enable or disable logging of result images", s_enableNames, "enable")
<< Option<TestOOM> (DE_NULL, "deqp-test-oom", "Run tests that exhaust memory on purpose", s_enableNames, TEST_OOM_DEFAULT);
}
void registerLegacyOptions (de::cmdline::Parser& parser)
{
using de::cmdline::Option;
parser
<< Option<GLConfigID> (DE_NULL, "deqp-egl-config-id", "Legacy name for --deqp-gl-config-id", "-1")
<< Option<GLConfigName> (DE_NULL, "deqp-egl-config-name", "Legacy name for --deqp-gl-config-name");
}
} // opt
// \todo [2014-02-13 pyry] This could be useful elsewhere as well.
class DebugOutStreambuf : public std::streambuf
{
public:
DebugOutStreambuf (void);
~DebugOutStreambuf (void);
protected:
std::streamsize xsputn (const char* s, std::streamsize count);
int overflow (int ch = -1);
private:
void flushLine (void);
std::ostringstream m_curLine;
};
DebugOutStreambuf::DebugOutStreambuf (void)
{
}
DebugOutStreambuf::~DebugOutStreambuf (void)
{
if (m_curLine.tellp() != std::streampos(0))
flushLine();
}
std::streamsize DebugOutStreambuf::xsputn (const char* s, std::streamsize count)
{
for (std::streamsize pos = 0; pos < count; pos++)
{
m_curLine.put(s[pos]);
if (s[pos] == '\n')
flushLine();
}
return count;
}
int DebugOutStreambuf::overflow (int ch)
{
if (ch == -1)
return -1;
else
{
DE_ASSERT((ch & 0xff) == ch);
const char chVal = (char)(deUint8)(ch & 0xff);
return xsputn(&chVal, 1) == 1 ? ch : -1;
}
}
void DebugOutStreambuf::flushLine (void)
{
qpPrint(m_curLine.str().c_str());
m_curLine.str("");
}
class CaseTreeNode
{
public:
CaseTreeNode (const std::string& name) : m_name(name) {}
~CaseTreeNode (void);
void addChild (CaseTreeNode* child) { m_children.push_back(child); }
const std::string& getName (void) const { return m_name; }
const std::vector<CaseTreeNode*>& getChildren (void) const { return m_children; }
private:
CaseTreeNode (const CaseTreeNode&);
CaseTreeNode& operator= (const CaseTreeNode&);
std::string m_name;
std::vector<CaseTreeNode*> m_children;
};
CaseTreeNode::~CaseTreeNode (void)
{
for (vector<CaseTreeNode*>::const_iterator i = m_children.begin(); i != m_children.end(); ++i)
delete *i;
}
static CaseTreeNode* parseCaseTree (std::istream& in)
{
vector<CaseTreeNode*> nodeStack;
string curName;
if (in.get() != '{')
throw std::invalid_argument("Malformed case tree");
nodeStack.reserve(1);
nodeStack.push_back(new CaseTreeNode(""));
try
{
for (;;)
{
const int curChr = in.get();
if (curChr == std::char_traits<char>::eof() || curChr == 0)
break;
if (nodeStack.empty())
throw std::invalid_argument("Trailing characters at end of case tree");
if (!curName.empty() && (curChr == '{' || curChr == ',' || curChr == '}'))
{
// Create child and push to stack.
nodeStack.reserve(nodeStack.size()+1);
nodeStack.push_back(new CaseTreeNode(curName));
curName.clear();
}
if (curChr == ',' || curChr == '}')
{
// Attach to parent
if (nodeStack.size() < 2)
throw std::invalid_argument("Malformed case tree");
(*(nodeStack.end()-2))->addChild(nodeStack.back());
nodeStack.pop_back();
}
else if (curChr != '{')
curName += (char)curChr;
}
if (nodeStack.size() != 1 || nodeStack[0]->getName() != "")
throw std::invalid_argument("Unterminated case tree");
}
catch (...)
{
// Nodes in stack are not attached to any parents and must be deleted individually.
for (vector<CaseTreeNode*>::const_iterator i = nodeStack.begin(); i != nodeStack.end(); ++i)
delete *i;
throw;
}
return nodeStack[0];
}
class CasePaths
{
public:
CasePaths (const string& pathList);
bool matches (const string& caseName, bool allowPrefix=false) const;
private:
const vector<string> m_casePatterns;
};
CasePaths::CasePaths (const string& pathList)
: m_casePatterns(de::splitString(pathList, ','))
{
}
// Match a single path component against a pattern component that may contain *-wildcards.
static bool matchWildcards(string::const_iterator patternStart,
string::const_iterator patternEnd,
string::const_iterator pathStart,
string::const_iterator pathEnd,
bool allowPrefix)
{
string::const_iterator pattern = patternStart;
string::const_iterator path = pathStart;
while (pattern != patternEnd && path != pathEnd && *pattern == *path)
{
++pattern;
++path;
}
if (pattern == patternEnd)
return (path == pathEnd);
else if (*pattern == '*')
{
for (; path != pathEnd; ++path)
{
if (matchWildcards(pattern + 1, patternEnd, path, pathEnd, allowPrefix))
return true;
}
if (matchWildcards(pattern + 1, patternEnd, pathEnd, pathEnd, allowPrefix))
return true;
}
else if (path == pathEnd && allowPrefix)
return true;
return false;
}
#if defined(TCU_HIERARCHICAL_CASEPATHS)
// Match a list of pattern components to a list of path components. A pattern
// component may contain *-wildcards. A pattern component "**" matches zero or
// more whole path components.
static bool patternMatches(vector<string>::const_iterator patternStart,
vector<string>::const_iterator patternEnd,
vector<string>::const_iterator pathStart,
vector<string>::const_iterator pathEnd,
bool allowPrefix)
{
vector<string>::const_iterator pattern = patternStart;
vector<string>::const_iterator path = pathStart;
while (pattern != patternEnd && path != pathEnd && *pattern != "**" &&
(*pattern == *path || matchWildcards(pattern->begin(), pattern->end(),
path->begin(), path->end(), false)))
{
++pattern;
++path;
}
if (path == pathEnd && (allowPrefix || pattern == patternEnd))
return true;
else if (pattern != patternEnd && *pattern == "**")
{
for (; path != pathEnd; ++path)
if (patternMatches(pattern + 1, patternEnd, path, pathEnd, allowPrefix))
return true;
if (patternMatches(pattern + 1, patternEnd, path, pathEnd, allowPrefix))
return true;
}
return false;
}
#endif
bool CasePaths::matches (const string& caseName, bool allowPrefix) const
{
const vector<string> components = de::splitString(caseName, '.');
for (size_t ndx = 0; ndx < m_casePatterns.size(); ++ndx)
{
#if defined(TCU_HIERARCHICAL_CASEPATHS)
const vector<string> patternComponents = de::splitString(m_casePatterns[ndx], '.');
if (patternMatches(patternComponents.begin(), patternComponents.end(),
components.begin(), components.end(), allowPrefix))
return true;
#else
if (matchWildcards(m_casePatterns[ndx].begin(), m_casePatterns[ndx].end(),
caseName.begin(), caseName.end(), allowPrefix))
return true;
#endif
}
return false;
}
/*--------------------------------------------------------------------*//*!
* \brief Construct command line
* \note CommandLine is not fully initialized until parse() has been called.
*//*--------------------------------------------------------------------*/
CommandLine::CommandLine (void)
: m_logFlags (0)
, m_caseTree (DE_NULL)
{
}
/*--------------------------------------------------------------------*//*!
* \brief Construct command line from standard argc, argv pair.
*
* Calls parse() with given arguments
* \param argc Number of arguments
* \param argv Command line arguments
*//*--------------------------------------------------------------------*/
CommandLine::CommandLine (int argc, const char* const* argv)
: m_logFlags (0)
, m_caseTree (DE_NULL)
{
if (!parse(argc, argv))
throw Exception("Failed to parse command line");
}
/*--------------------------------------------------------------------*//*!
* \brief Construct command line from string.
*
* Calls parse() with given argument.
* \param cmdLine Full command line string.
*//*--------------------------------------------------------------------*/
CommandLine::CommandLine (const std::string& cmdLine)
: m_logFlags (0)
, m_caseTree (DE_NULL)
{
if (!parse(cmdLine))
throw Exception("Failed to parse command line");
}
CommandLine::~CommandLine (void)
{
delete m_caseTree;
}
void CommandLine::clear (void)
{
m_cmdLine.clear();
m_logFlags = 0;
delete m_caseTree;
m_caseTree = DE_NULL;
}
/*--------------------------------------------------------------------*//*!
* \brief Parse command line from standard argc, argv pair.
* \note parse() must be called exactly once.
* \param argc Number of arguments
* \param argv Command line arguments
*//*--------------------------------------------------------------------*/
bool CommandLine::parse (int argc, const char* const* argv)
{
DebugOutStreambuf sbuf;
std::ostream debugOut (&sbuf);
de::cmdline::Parser parser;
opt::registerOptions(parser);
opt::registerLegacyOptions(parser);
clear();
if (!parser.parse(argc-1, argv+1, &m_cmdLine, std::cerr))
{
debugOut << "\n" << de::FilePath(argv[0]).getBaseName() << " [options]\n\n";
parser.help(debugOut);
clear();
return false;
}
if (!m_cmdLine.getOption<opt::LogImages>())
m_logFlags |= QP_TEST_LOG_EXCLUDE_IMAGES;
if ((m_cmdLine.getOption<opt::CasePath>().empty()?0:1) +
(m_cmdLine.getOption<opt::CaseList>().empty()?0:1) +
(m_cmdLine.getOption<opt::CaseListFile>().empty()?0:1) +
(m_cmdLine.getOption<opt::StdinCaseList>()?1:0) > 1)
{
debugOut << "ERROR: multiple test case list options given!\n" << std::endl;
clear();
return false;
}
try
{
if (!m_cmdLine.getOption<opt::CaseList>().empty())
{
std::istringstream str(m_cmdLine.getOption<opt::CaseList>());
m_caseTree = parseCaseTree(str);
}
else if (!m_cmdLine.getOption<opt::CaseListFile>().empty())
{
std::ifstream in(m_cmdLine.getOption<opt::CaseListFile>().c_str(), std::ios_base::binary);
if (!in.is_open() || !in.good())
throw Exception("Failed to open case list file '" + m_cmdLine.getOption<opt::CaseListFile>() + "'");
m_caseTree = parseCaseTree(in);
}
else if (m_cmdLine.getOption<opt::StdinCaseList>())
{
m_caseTree = parseCaseTree(std::cin);
}
else if (!m_cmdLine.getOption<opt::CasePath>().empty())
m_casePaths = de::MovePtr<const CasePaths>(new CasePaths(m_cmdLine.getOption<opt::CasePath>()));
}
catch (const std::exception& e)
{
debugOut << "ERROR: Failed to parse test case list: " << e.what() << "\n";
clear();
return false;
}
return true;
}
/*--------------------------------------------------------------------*//*!
* \brief Parse command line from string.
* \note parse() must be called exactly once.
* \param cmdLine Full command line string.
*//*--------------------------------------------------------------------*/
bool CommandLine::parse (const std::string& cmdLine)
{
deCommandLine* parsedCmdLine = deCommandLine_parse(cmdLine.c_str());
if (!parsedCmdLine)
throw std::bad_alloc();
bool isOk = false;
try
{
isOk = parse(parsedCmdLine->numArgs, parsedCmdLine->args);
}
catch (...)
{
deCommandLine_destroy(parsedCmdLine);
throw;
}
deCommandLine_destroy(parsedCmdLine);
return isOk;
}
const char* CommandLine::getLogFileName (void) const { return m_cmdLine.getOption<opt::LogFilename>().c_str(); }
deUint32 CommandLine::getLogFlags (void) const { return m_logFlags; }
RunMode CommandLine::getRunMode (void) const { return m_cmdLine.getOption<opt::RunMode>(); }
WindowVisibility CommandLine::getVisibility (void) const { return m_cmdLine.getOption<opt::Visibility>(); }
bool CommandLine::isWatchDogEnabled (void) const { return m_cmdLine.getOption<opt::WatchDog>(); }
bool CommandLine::isCrashHandlingEnabled (void) const { return m_cmdLine.getOption<opt::CrashHandler>(); }
int CommandLine::getBaseSeed (void) const { return m_cmdLine.getOption<opt::BaseSeed>(); }
int CommandLine::getTestIterationCount (void) const { return m_cmdLine.getOption<opt::TestIterationCount>(); }
int CommandLine::getSurfaceWidth (void) const { return m_cmdLine.getOption<opt::SurfaceWidth>(); }
int CommandLine::getSurfaceHeight (void) const { return m_cmdLine.getOption<opt::SurfaceHeight>(); }
SurfaceType CommandLine::getSurfaceType (void) const { return m_cmdLine.getOption<opt::SurfaceType>(); }
ScreenRotation CommandLine::getScreenRotation (void) const { return m_cmdLine.getOption<opt::ScreenRotation>(); }
int CommandLine::getGLConfigId (void) const { return m_cmdLine.getOption<opt::GLConfigID>(); }
int CommandLine::getCLPlatformId (void) const { return m_cmdLine.getOption<opt::CLPlatformID>(); }
const std::vector<int>& CommandLine::getCLDeviceIds (void) const { return m_cmdLine.getOption<opt::CLDeviceIDs>(); }
const char* CommandLine::getEGLDisplayType (void) const { return m_cmdLine.getOption<opt::EGLDisplayType>().c_str(); }
const char* CommandLine::getEGLWindowType (void) const { return m_cmdLine.getOption<opt::EGLWindowType>().c_str(); }
const char* CommandLine::getEGLPixmapType (void) const { return m_cmdLine.getOption<opt::EGLPixmapType>().c_str(); }
bool CommandLine::isOutOfMemoryTestEnabled (void) const { return m_cmdLine.getOption<opt::TestOOM>(); }
const char* CommandLine::getGLContextType (void) const
{
if (!m_cmdLine.getOption<opt::GLContextType>().empty())
return m_cmdLine.getOption<opt::GLContextType>().c_str();
else
return DE_NULL;
}
const char* CommandLine::getGLConfigName (void) const
{
if (!m_cmdLine.getOption<opt::GLConfigName>().empty())
return m_cmdLine.getOption<opt::GLConfigName>().c_str();
else
return DE_NULL;
}
const char* CommandLine::getGLContextFlags (void) const
{
if (!m_cmdLine.getOption<opt::GLContextFlags>().empty())
return m_cmdLine.getOption<opt::GLContextFlags>().c_str();
else
return DE_NULL;
}
const char* CommandLine::getCLBuildOptions (void) const
{
if (!m_cmdLine.getOption<opt::CLBuildOptions>().empty())
return m_cmdLine.getOption<opt::CLBuildOptions>().c_str();
else
return DE_NULL;
}
static bool checkTestGroupName (const CaseTreeNode* node, const char* groupName)
{
for (vector<CaseTreeNode*>::const_iterator childIter = node->getChildren().begin(); childIter != node->getChildren().end(); ++childIter)
{
const CaseTreeNode* const child = *childIter;
if (deStringBeginsWith(groupName, child->getName().c_str()))
{
const int prefixLen = (int)child->getName().length();
if (groupName[prefixLen] == 0)
return true;
else if (groupName[prefixLen] == '.')
return checkTestGroupName(child, groupName + prefixLen + 1);
}
}
return false;
}
static bool checkTestCaseName (const CaseTreeNode* node, const char* caseName)
{
for (vector<CaseTreeNode*>::const_iterator childIter = node->getChildren().begin(); childIter != node->getChildren().end(); ++childIter)
{
const CaseTreeNode* const child = *childIter;
if (deStringBeginsWith(caseName, child->getName().c_str()))
{
const int prefixLen = (int)child->getName().length();
if (caseName[prefixLen] == 0 && child->getChildren().empty())
return true;
else if (caseName[prefixLen] == '.')
return checkTestCaseName(child, caseName + prefixLen + 1);
}
}
return false;
}
bool CommandLine::checkTestGroupName (const char* groupName) const
{
if (m_casePaths)
return m_casePaths->matches(groupName, true);
else if (m_caseTree)
return groupName[0] == 0 || tcu::checkTestGroupName(m_caseTree, groupName);
else
return true;
}
bool CommandLine::checkTestCaseName (const char* caseName) const
{
if (m_casePaths)
return m_casePaths->matches(caseName, false);
else if (m_caseTree)
return tcu::checkTestCaseName(m_caseTree, caseName);
else
return true;
}
} // tcu