| /*------------------------------------------------------------------------- | |
| * 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 |