/*-------------------------------------------------------------------------
* drawElements Quality Program Test Executor
* ------------------------------------------
*
* 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 Test batch executor.
*//*--------------------------------------------------------------------*/
#include "xeBatchExecutor.hpp"
#include "xeTestResultParser.hpp"
#include <sstream>
#include <cstdio>
namespace xe
{
using std::string;
using std::vector;
enum
{
TEST_LOG_TMP_BUFFER_SIZE = 1024,
INFO_LOG_TMP_BUFFER_SIZE = 256
};
// \todo [2012-11-01 pyry] Update execute set in handler.
static inline bool isExecutedInBatch (const BatchResult* batchResult, const TestCase* testCase)
{
std::string fullPath;
testCase->getFullPath(fullPath);
if (batchResult->hasTestCaseResult(fullPath.c_str()))
{
ConstTestCaseResultPtr data = batchResult->getTestCaseResult(fullPath.c_str());
return data->getStatusCode() != TESTSTATUSCODE_PENDING && data->getStatusCode() != TESTSTATUSCODE_RUNNING;
}
else
return false;
}
// \todo [2012-06-19 pyry] These can be optimized using TestSetIterator (once implemented)
static void computeExecuteSet (TestSet& executeSet, const TestNode* root, const TestSet& testSet, const BatchResult* batchResult)
{
ConstTestNodeIterator iter = ConstTestNodeIterator::begin(root);
ConstTestNodeIterator end = ConstTestNodeIterator::end(root);
for (; iter != end; ++iter)
{
const TestNode* node = *iter;
if (node->getNodeType() == TESTNODETYPE_TEST_CASE && testSet.hasNode(node))
{
const TestCase* testCase = static_cast<const TestCase*>(node);
if (!isExecutedInBatch(batchResult, testCase))
executeSet.addCase(testCase);
}
}
}
static void computeBatchRequest (TestSet& requestSet, const TestSet& executeSet, const TestNode* root, int maxCasesInSet)
{
ConstTestNodeIterator iter = ConstTestNodeIterator::begin(root);
ConstTestNodeIterator end = ConstTestNodeIterator::end(root);
int numCases = 0;
for (; (iter != end) && (numCases < maxCasesInSet); ++iter)
{
const TestNode* node = *iter;
if (node->getNodeType() == TESTNODETYPE_TEST_CASE && executeSet.hasNode(node))
{
const TestCase* testCase = static_cast<const TestCase*>(node);
requestSet.addCase(testCase);
numCases += 1;
}
}
}
static int removeExecuted (TestSet& set, const TestNode* root, const BatchResult* batchResult)
{
TestSet oldSet (set);
ConstTestNodeIterator iter = ConstTestNodeIterator::begin(root);
ConstTestNodeIterator end = ConstTestNodeIterator::end(root);
int numRemoved = 0;
for (; iter != end; ++iter)
{
const TestNode* node = *iter;
if (node->getNodeType() == TESTNODETYPE_TEST_CASE && oldSet.hasNode(node))
{
const TestCase* testCase = static_cast<const TestCase*>(node);
if (isExecutedInBatch(batchResult, testCase))
{
set.removeCase(testCase);
numRemoved += 1;
}
}
}
return numRemoved;
}
BatchExecutorLogHandler::BatchExecutorLogHandler (BatchResult* batchResult)
: m_batchResult(batchResult)
{
}
BatchExecutorLogHandler::~BatchExecutorLogHandler (void)
{
}
void BatchExecutorLogHandler::setSessionInfo (const SessionInfo& sessionInfo)
{
m_batchResult->getSessionInfo() = sessionInfo;
}
TestCaseResultPtr BatchExecutorLogHandler::startTestCaseResult (const char* casePath)
{
// \todo [2012-11-01 pyry] What to do with duplicate results?
if (m_batchResult->hasTestCaseResult(casePath))
return m_batchResult->getTestCaseResult(casePath);
else
return m_batchResult->createTestCaseResult(casePath);
}
void BatchExecutorLogHandler::testCaseResultUpdated (const TestCaseResultPtr&)
{
}
void BatchExecutorLogHandler::testCaseResultComplete (const TestCaseResultPtr& result)
{
// \todo [2012-11-01 pyry] Remove from execute set here instead of updating it between sessions.
printf("%s\n", result->getTestCasePath());
}
BatchExecutor::BatchExecutor (const TargetConfiguration& config, CommLink* commLink, const TestNode* root, const TestSet& testSet, BatchResult* batchResult, InfoLog* infoLog)
: m_config (config)
, m_commLink (commLink)
, m_root (root)
, m_testSet (testSet)
, m_logHandler (batchResult)
, m_batchResult (batchResult)
, m_infoLog (infoLog)
, m_state (STATE_NOT_STARTED)
, m_testLogParser (&m_logHandler)
{
}
BatchExecutor::~BatchExecutor (void)
{
}
void BatchExecutor::run (void)
{
XE_CHECK(m_state == STATE_NOT_STARTED);
// Check commlink state.
{
CommLinkState commState = COMMLINKSTATE_LAST;
std::string stateStr = "";
commState = m_commLink->getState(stateStr);
if (commState == COMMLINKSTATE_ERROR)
{
// Report error.
XE_FAIL((string("CommLink error: '") + stateStr + "'").c_str());
}
else if (commState != COMMLINKSTATE_READY)
XE_FAIL("CommLink is not ready");
}
// Compute initial execute set.
computeExecuteSet(m_casesToExecute, m_root, m_testSet, m_batchResult);
// Register callbacks.
m_commLink->setCallbacks(enqueueStateChanged, enqueueTestLogData, enqueueInfoLogData, this);
try
{
if (!m_casesToExecute.empty())
{
TestSet batchRequest;
computeBatchRequest(batchRequest, m_casesToExecute, m_root, m_config.maxCasesPerSession);
launchTestSet(batchRequest);
m_state = STATE_STARTED;
}
else
m_state = STATE_FINISHED;
// Run handler loop until we are finished.
while (m_state != STATE_FINISHED)
m_dispatcher.callNext();
}
catch (...)
{
m_commLink->setCallbacks(DE_NULL, DE_NULL, DE_NULL, DE_NULL);
throw;
}
// De-register callbacks.
m_commLink->setCallbacks(DE_NULL, DE_NULL, DE_NULL, DE_NULL);
}
void BatchExecutor::cancel (void)
{
m_state = STATE_FINISHED;
m_dispatcher.cancel();
}
void BatchExecutor::onStateChanged (CommLinkState state, const char* message)
{
switch (state)
{
case COMMLINKSTATE_READY:
case COMMLINKSTATE_TEST_PROCESS_LAUNCHING:
case COMMLINKSTATE_TEST_PROCESS_RUNNING:
break; // Ignore.
case COMMLINKSTATE_TEST_PROCESS_FINISHED:
{
// Feed end of string to parser. This terminates open test case if such exists.
{
deUint8 eos = 0;
onTestLogData(&eos, 1);
}
int numExecuted = removeExecuted(m_casesToExecute, m_root, m_batchResult);
// \note No new batch is launched if no cases were executed in last one. Otherwise excutor
// could end up in infinite loop.
if (!m_casesToExecute.empty() && numExecuted > 0)
{
// Reset state and start batch.
m_testLogParser.reset();
m_commLink->reset();
XE_CHECK(m_commLink->getState() == COMMLINKSTATE_READY);
TestSet batchRequest;
computeBatchRequest(batchRequest, m_casesToExecute, m_root, m_config.maxCasesPerSession);
launchTestSet(batchRequest);
}
else
m_state = STATE_FINISHED;
break;
}
case COMMLINKSTATE_TEST_PROCESS_LAUNCH_FAILED:
printf("Failed to start test process: '%s'\n", message);
m_state = STATE_FINISHED;
break;
case COMMLINKSTATE_ERROR:
printf("CommLink error: '%s'\n", message);
m_state = STATE_FINISHED;
break;
default:
XE_FAIL("Unknown state");
}
}
void BatchExecutor::onTestLogData (const deUint8* bytes, size_t numBytes)
{
try
{
m_testLogParser.parse(bytes, numBytes);
}
catch (const ParseError& e)
{
// \todo [2012-07-06 pyry] Log error.
DE_UNREF(e);
}
}
void BatchExecutor::onInfoLogData (const deUint8* bytes, size_t numBytes)
{
if (numBytes > 0 && m_infoLog)
m_infoLog->append(bytes, numBytes);
}
static void writeCaseListNode (std::ostream& str, const TestNode* node, const TestSet& testSet)
{
DE_ASSERT(testSet.hasNode(node));
TestNodeType nodeType = node->getNodeType();
if (nodeType != TESTNODETYPE_ROOT)
str << node->getName();
if (nodeType == TESTNODETYPE_ROOT || nodeType == TESTNODETYPE_GROUP)
{
const TestGroup* group = static_cast<const TestGroup*>(node);
bool isFirst = true;
str << "{";
for (int ndx = 0; ndx < group->getNumChildren(); ndx++)
{
const TestNode* child = group->getChild(ndx);
if (testSet.hasNode(child))
{
if (!isFirst)
str << ",";
writeCaseListNode(str, child, testSet);
isFirst = false;
}
}
str << "}";
}
}
void BatchExecutor::launchTestSet (const TestSet& testSet)
{
std::ostringstream caseList;
XE_CHECK(testSet.hasNode(m_root));
XE_CHECK(m_root->getNodeType() == TESTNODETYPE_ROOT);
writeCaseListNode(caseList, m_root, testSet);
m_commLink->startTestProcess(m_config.binaryName.c_str(), m_config.cmdLineArgs.c_str(), m_config.workingDir.c_str(), caseList.str().c_str());
}
void BatchExecutor::enqueueStateChanged (void* userPtr, CommLinkState state, const char* message)
{
BatchExecutor* executor = static_cast<BatchExecutor*>(userPtr);
CallWriter writer (&executor->m_dispatcher, BatchExecutor::dispatchStateChanged);
writer << executor
<< state
<< message;
writer.enqueue();
}
void BatchExecutor::enqueueTestLogData (void* userPtr, const deUint8* bytes, size_t numBytes)
{
BatchExecutor* executor = static_cast<BatchExecutor*>(userPtr);
CallWriter writer (&executor->m_dispatcher, BatchExecutor::dispatchTestLogData);
writer << executor
<< numBytes;
writer.write(bytes, numBytes);
writer.enqueue();
}
void BatchExecutor::enqueueInfoLogData (void* userPtr, const deUint8* bytes, size_t numBytes)
{
BatchExecutor* executor = static_cast<BatchExecutor*>(userPtr);
CallWriter writer (&executor->m_dispatcher, BatchExecutor::dispatchInfoLogData);
writer << executor
<< numBytes;
writer.write(bytes, numBytes);
writer.enqueue();
}
void BatchExecutor::dispatchStateChanged (CallReader& data)
{
BatchExecutor* executor = DE_NULL;
CommLinkState state = COMMLINKSTATE_LAST;
std::string message;
data >> executor
>> state
>> message;
executor->onStateChanged(state, message.c_str());
}
void BatchExecutor::dispatchTestLogData (CallReader& data)
{
BatchExecutor* executor = DE_NULL;
size_t numBytes;
data >> executor
>> numBytes;
executor->onTestLogData(data.getDataBlock(numBytes), numBytes);
}
void BatchExecutor::dispatchInfoLogData (CallReader& data)
{
BatchExecutor* executor = DE_NULL;
size_t numBytes;
data >> executor
>> numBytes;
executor->onInfoLogData(data.getDataBlock(numBytes), numBytes);
}
} // xe