1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program Test Executor 3 * ------------------------------------------ 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Test batch executor. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "xeBatchExecutor.hpp" 25 #include "xeTestResultParser.hpp" 26 27 #include <sstream> 28 #include <cstdio> 29 30 namespace xe 31 { 32 33 using std::string; 34 using std::vector; 35 36 enum 37 { 38 TEST_LOG_TMP_BUFFER_SIZE = 1024, 39 INFO_LOG_TMP_BUFFER_SIZE = 256 40 }; 41 42 // \todo [2012-11-01 pyry] Update execute set in handler. 43 44 static inline bool isExecutedInBatch (const BatchResult* batchResult, const TestCase* testCase) 45 { 46 std::string fullPath; 47 testCase->getFullPath(fullPath); 48 49 if (batchResult->hasTestCaseResult(fullPath.c_str())) 50 { 51 ConstTestCaseResultPtr data = batchResult->getTestCaseResult(fullPath.c_str()); 52 return data->getStatusCode() != TESTSTATUSCODE_PENDING && data->getStatusCode() != TESTSTATUSCODE_RUNNING; 53 } 54 else 55 return false; 56 } 57 58 // \todo [2012-06-19 pyry] These can be optimized using TestSetIterator (once implemented) 59 60 static void computeExecuteSet (TestSet& executeSet, const TestNode* root, const TestSet& testSet, const BatchResult* batchResult) 61 { 62 ConstTestNodeIterator iter = ConstTestNodeIterator::begin(root); 63 ConstTestNodeIterator end = ConstTestNodeIterator::end(root); 64 65 for (; iter != end; ++iter) 66 { 67 const TestNode* node = *iter; 68 69 if (node->getNodeType() == TESTNODETYPE_TEST_CASE && testSet.hasNode(node)) 70 { 71 const TestCase* testCase = static_cast<const TestCase*>(node); 72 73 if (!isExecutedInBatch(batchResult, testCase)) 74 executeSet.addCase(testCase); 75 } 76 } 77 } 78 79 static void computeBatchRequest (TestSet& requestSet, const TestSet& executeSet, const TestNode* root, int maxCasesInSet) 80 { 81 ConstTestNodeIterator iter = ConstTestNodeIterator::begin(root); 82 ConstTestNodeIterator end = ConstTestNodeIterator::end(root); 83 int numCases = 0; 84 85 for (; (iter != end) && (numCases < maxCasesInSet); ++iter) 86 { 87 const TestNode* node = *iter; 88 89 if (node->getNodeType() == TESTNODETYPE_TEST_CASE && executeSet.hasNode(node)) 90 { 91 const TestCase* testCase = static_cast<const TestCase*>(node); 92 requestSet.addCase(testCase); 93 numCases += 1; 94 } 95 } 96 } 97 98 static int removeExecuted (TestSet& set, const TestNode* root, const BatchResult* batchResult) 99 { 100 TestSet oldSet (set); 101 ConstTestNodeIterator iter = ConstTestNodeIterator::begin(root); 102 ConstTestNodeIterator end = ConstTestNodeIterator::end(root); 103 int numRemoved = 0; 104 105 for (; iter != end; ++iter) 106 { 107 const TestNode* node = *iter; 108 109 if (node->getNodeType() == TESTNODETYPE_TEST_CASE && oldSet.hasNode(node)) 110 { 111 const TestCase* testCase = static_cast<const TestCase*>(node); 112 113 if (isExecutedInBatch(batchResult, testCase)) 114 { 115 set.removeCase(testCase); 116 numRemoved += 1; 117 } 118 } 119 } 120 121 return numRemoved; 122 } 123 124 BatchExecutorLogHandler::BatchExecutorLogHandler (BatchResult* batchResult) 125 : m_batchResult(batchResult) 126 { 127 } 128 129 BatchExecutorLogHandler::~BatchExecutorLogHandler (void) 130 { 131 } 132 133 void BatchExecutorLogHandler::setSessionInfo (const SessionInfo& sessionInfo) 134 { 135 m_batchResult->getSessionInfo() = sessionInfo; 136 } 137 138 TestCaseResultPtr BatchExecutorLogHandler::startTestCaseResult (const char* casePath) 139 { 140 // \todo [2012-11-01 pyry] What to do with duplicate results? 141 if (m_batchResult->hasTestCaseResult(casePath)) 142 return m_batchResult->getTestCaseResult(casePath); 143 else 144 return m_batchResult->createTestCaseResult(casePath); 145 } 146 147 void BatchExecutorLogHandler::testCaseResultUpdated (const TestCaseResultPtr&) 148 { 149 } 150 151 void BatchExecutorLogHandler::testCaseResultComplete (const TestCaseResultPtr& result) 152 { 153 // \todo [2012-11-01 pyry] Remove from execute set here instead of updating it between sessions. 154 printf("%s\n", result->getTestCasePath()); 155 } 156 157 BatchExecutor::BatchExecutor (const TargetConfiguration& config, CommLink* commLink, const TestNode* root, const TestSet& testSet, BatchResult* batchResult, InfoLog* infoLog) 158 : m_config (config) 159 , m_commLink (commLink) 160 , m_root (root) 161 , m_testSet (testSet) 162 , m_logHandler (batchResult) 163 , m_batchResult (batchResult) 164 , m_infoLog (infoLog) 165 , m_state (STATE_NOT_STARTED) 166 , m_testLogParser (&m_logHandler) 167 { 168 } 169 170 BatchExecutor::~BatchExecutor (void) 171 { 172 } 173 174 void BatchExecutor::run (void) 175 { 176 XE_CHECK(m_state == STATE_NOT_STARTED); 177 178 // Check commlink state. 179 { 180 CommLinkState commState = COMMLINKSTATE_LAST; 181 std::string stateStr = ""; 182 183 commState = m_commLink->getState(stateStr); 184 185 if (commState == COMMLINKSTATE_ERROR) 186 { 187 // Report error. 188 XE_FAIL((string("CommLink error: '") + stateStr + "'").c_str()); 189 } 190 else if (commState != COMMLINKSTATE_READY) 191 XE_FAIL("CommLink is not ready"); 192 } 193 194 // Compute initial execute set. 195 computeExecuteSet(m_casesToExecute, m_root, m_testSet, m_batchResult); 196 197 // Register callbacks. 198 m_commLink->setCallbacks(enqueueStateChanged, enqueueTestLogData, enqueueInfoLogData, this); 199 200 try 201 { 202 if (!m_casesToExecute.empty()) 203 { 204 TestSet batchRequest; 205 computeBatchRequest(batchRequest, m_casesToExecute, m_root, m_config.maxCasesPerSession); 206 launchTestSet(batchRequest); 207 208 m_state = STATE_STARTED; 209 } 210 else 211 m_state = STATE_FINISHED; 212 213 // Run handler loop until we are finished. 214 while (m_state != STATE_FINISHED) 215 m_dispatcher.callNext(); 216 } 217 catch (...) 218 { 219 m_commLink->setCallbacks(DE_NULL, DE_NULL, DE_NULL, DE_NULL); 220 throw; 221 } 222 223 // De-register callbacks. 224 m_commLink->setCallbacks(DE_NULL, DE_NULL, DE_NULL, DE_NULL); 225 } 226 227 void BatchExecutor::cancel (void) 228 { 229 m_state = STATE_FINISHED; 230 m_dispatcher.cancel(); 231 } 232 233 void BatchExecutor::onStateChanged (CommLinkState state, const char* message) 234 { 235 switch (state) 236 { 237 case COMMLINKSTATE_READY: 238 case COMMLINKSTATE_TEST_PROCESS_LAUNCHING: 239 case COMMLINKSTATE_TEST_PROCESS_RUNNING: 240 break; // Ignore. 241 242 case COMMLINKSTATE_TEST_PROCESS_FINISHED: 243 { 244 // Feed end of string to parser. This terminates open test case if such exists. 245 { 246 deUint8 eos = 0; 247 onTestLogData(&eos, 1); 248 } 249 250 int numExecuted = removeExecuted(m_casesToExecute, m_root, m_batchResult); 251 252 // \note No new batch is launched if no cases were executed in last one. Otherwise excutor 253 // could end up in infinite loop. 254 if (!m_casesToExecute.empty() && numExecuted > 0) 255 { 256 // Reset state and start batch. 257 m_testLogParser.reset(); 258 259 m_commLink->reset(); 260 XE_CHECK(m_commLink->getState() == COMMLINKSTATE_READY); 261 262 TestSet batchRequest; 263 computeBatchRequest(batchRequest, m_casesToExecute, m_root, m_config.maxCasesPerSession); 264 launchTestSet(batchRequest); 265 } 266 else 267 m_state = STATE_FINISHED; 268 269 break; 270 } 271 272 case COMMLINKSTATE_TEST_PROCESS_LAUNCH_FAILED: 273 printf("Failed to start test process: '%s'\n", message); 274 m_state = STATE_FINISHED; 275 break; 276 277 case COMMLINKSTATE_ERROR: 278 printf("CommLink error: '%s'\n", message); 279 m_state = STATE_FINISHED; 280 break; 281 282 default: 283 XE_FAIL("Unknown state"); 284 } 285 } 286 287 void BatchExecutor::onTestLogData (const deUint8* bytes, size_t numBytes) 288 { 289 try 290 { 291 m_testLogParser.parse(bytes, numBytes); 292 } 293 catch (const ParseError& e) 294 { 295 // \todo [2012-07-06 pyry] Log error. 296 DE_UNREF(e); 297 } 298 } 299 300 void BatchExecutor::onInfoLogData (const deUint8* bytes, size_t numBytes) 301 { 302 if (numBytes > 0 && m_infoLog) 303 m_infoLog->append(bytes, numBytes); 304 } 305 306 static void writeCaseListNode (std::ostream& str, const TestNode* node, const TestSet& testSet) 307 { 308 DE_ASSERT(testSet.hasNode(node)); 309 310 TestNodeType nodeType = node->getNodeType(); 311 312 if (nodeType != TESTNODETYPE_ROOT) 313 str << node->getName(); 314 315 if (nodeType == TESTNODETYPE_ROOT || nodeType == TESTNODETYPE_GROUP) 316 { 317 const TestGroup* group = static_cast<const TestGroup*>(node); 318 bool isFirst = true; 319 320 str << "{"; 321 322 for (int ndx = 0; ndx < group->getNumChildren(); ndx++) 323 { 324 const TestNode* child = group->getChild(ndx); 325 326 if (testSet.hasNode(child)) 327 { 328 if (!isFirst) 329 str << ","; 330 331 writeCaseListNode(str, child, testSet); 332 isFirst = false; 333 } 334 } 335 336 str << "}"; 337 } 338 } 339 340 void BatchExecutor::launchTestSet (const TestSet& testSet) 341 { 342 std::ostringstream caseList; 343 XE_CHECK(testSet.hasNode(m_root)); 344 XE_CHECK(m_root->getNodeType() == TESTNODETYPE_ROOT); 345 writeCaseListNode(caseList, m_root, testSet); 346 347 m_commLink->startTestProcess(m_config.binaryName.c_str(), m_config.cmdLineArgs.c_str(), m_config.workingDir.c_str(), caseList.str().c_str()); 348 } 349 350 void BatchExecutor::enqueueStateChanged (void* userPtr, CommLinkState state, const char* message) 351 { 352 BatchExecutor* executor = static_cast<BatchExecutor*>(userPtr); 353 CallWriter writer (&executor->m_dispatcher, BatchExecutor::dispatchStateChanged); 354 355 writer << executor 356 << state 357 << message; 358 359 writer.enqueue(); 360 } 361 362 void BatchExecutor::enqueueTestLogData (void* userPtr, const deUint8* bytes, size_t numBytes) 363 { 364 BatchExecutor* executor = static_cast<BatchExecutor*>(userPtr); 365 CallWriter writer (&executor->m_dispatcher, BatchExecutor::dispatchTestLogData); 366 367 writer << executor 368 << numBytes; 369 370 writer.write(bytes, numBytes); 371 writer.enqueue(); 372 } 373 374 void BatchExecutor::enqueueInfoLogData (void* userPtr, const deUint8* bytes, size_t numBytes) 375 { 376 BatchExecutor* executor = static_cast<BatchExecutor*>(userPtr); 377 CallWriter writer (&executor->m_dispatcher, BatchExecutor::dispatchInfoLogData); 378 379 writer << executor 380 << numBytes; 381 382 writer.write(bytes, numBytes); 383 writer.enqueue(); 384 } 385 386 void BatchExecutor::dispatchStateChanged (CallReader& data) 387 { 388 BatchExecutor* executor = DE_NULL; 389 CommLinkState state = COMMLINKSTATE_LAST; 390 std::string message; 391 392 data >> executor 393 >> state 394 >> message; 395 396 executor->onStateChanged(state, message.c_str()); 397 } 398 399 void BatchExecutor::dispatchTestLogData (CallReader& data) 400 { 401 BatchExecutor* executor = DE_NULL; 402 size_t numBytes; 403 404 data >> executor 405 >> numBytes; 406 407 executor->onTestLogData(data.getDataBlock(numBytes), numBytes); 408 } 409 410 void BatchExecutor::dispatchInfoLogData (CallReader& data) 411 { 412 BatchExecutor* executor = DE_NULL; 413 size_t numBytes; 414 415 data >> executor 416 >> numBytes; 417 418 executor->onInfoLogData(data.getDataBlock(numBytes), numBytes); 419 } 420 421 } // xe 422
