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::onStateChanged (CommLinkState state, const char* message) 228 { 229 switch (state) 230 { 231 case COMMLINKSTATE_READY: 232 case COMMLINKSTATE_TEST_PROCESS_LAUNCHING: 233 case COMMLINKSTATE_TEST_PROCESS_RUNNING: 234 break; // Ignore. 235 236 case COMMLINKSTATE_TEST_PROCESS_FINISHED: 237 { 238 // Feed end of string to parser. This terminates open test case if such exists. 239 { 240 deUint8 eos = 0; 241 onTestLogData(&eos, 1); 242 } 243 244 int numExecuted = removeExecuted(m_casesToExecute, m_root, m_batchResult); 245 246 // \note No new batch is launched if no cases were executed in last one. Otherwise excutor 247 // could end up in infinite loop. 248 if (!m_casesToExecute.empty() && numExecuted > 0) 249 { 250 // Reset state and start batch. 251 m_testLogParser.reset(); 252 253 m_commLink->reset(); 254 XE_CHECK(m_commLink->getState() == COMMLINKSTATE_READY); 255 256 TestSet batchRequest; 257 computeBatchRequest(batchRequest, m_casesToExecute, m_root, m_config.maxCasesPerSession); 258 launchTestSet(batchRequest); 259 } 260 else 261 m_state = STATE_FINISHED; 262 263 break; 264 } 265 266 case COMMLINKSTATE_TEST_PROCESS_LAUNCH_FAILED: 267 printf("Failed to start test process: '%s'\n", message); 268 m_state = STATE_FINISHED; 269 break; 270 271 case COMMLINKSTATE_ERROR: 272 printf("CommLink error: '%s'\n", message); 273 m_state = STATE_FINISHED; 274 break; 275 276 default: 277 XE_FAIL("Unknown state"); 278 } 279 } 280 281 void BatchExecutor::onTestLogData (const deUint8* bytes, int numBytes) 282 { 283 try 284 { 285 m_testLogParser.parse(bytes, numBytes); 286 } 287 catch (const ParseError& e) 288 { 289 // \todo [2012-07-06 pyry] Log error. 290 DE_UNREF(e); 291 } 292 } 293 294 void BatchExecutor::onInfoLogData (const deUint8* bytes, int numBytes) 295 { 296 if (numBytes > 0 && m_infoLog) 297 m_infoLog->append(bytes, numBytes); 298 } 299 300 static void writeCaseListNode (std::ostream& str, const TestNode* node, const TestSet& testSet) 301 { 302 DE_ASSERT(testSet.hasNode(node)); 303 304 TestNodeType nodeType = node->getNodeType(); 305 306 if (nodeType != TESTNODETYPE_ROOT) 307 str << node->getName(); 308 309 if (nodeType == TESTNODETYPE_ROOT || nodeType == TESTNODETYPE_GROUP) 310 { 311 const TestGroup* group = static_cast<const TestGroup*>(node); 312 bool isFirst = true; 313 314 str << "{"; 315 316 for (int ndx = 0; ndx < group->getNumChildren(); ndx++) 317 { 318 const TestNode* child = group->getChild(ndx); 319 320 if (testSet.hasNode(child)) 321 { 322 if (!isFirst) 323 str << ","; 324 325 writeCaseListNode(str, child, testSet); 326 isFirst = false; 327 } 328 } 329 330 str << "}"; 331 } 332 } 333 334 void BatchExecutor::launchTestSet (const TestSet& testSet) 335 { 336 std::ostringstream caseList; 337 XE_CHECK(testSet.hasNode(m_root)); 338 XE_CHECK(m_root->getNodeType() == TESTNODETYPE_ROOT); 339 writeCaseListNode(caseList, m_root, testSet); 340 341 m_commLink->startTestProcess(m_config.binaryName.c_str(), m_config.cmdLineArgs.c_str(), m_config.workingDir.c_str(), caseList.str().c_str()); 342 } 343 344 void BatchExecutor::enqueueStateChanged (void* userPtr, CommLinkState state, const char* message) 345 { 346 BatchExecutor* executor = static_cast<BatchExecutor*>(userPtr); 347 CallWriter writer (&executor->m_dispatcher, BatchExecutor::dispatchStateChanged); 348 349 writer << executor 350 << state 351 << message; 352 353 writer.enqueue(); 354 } 355 356 void BatchExecutor::enqueueTestLogData (void* userPtr, const deUint8* bytes, int numBytes) 357 { 358 BatchExecutor* executor = static_cast<BatchExecutor*>(userPtr); 359 CallWriter writer (&executor->m_dispatcher, BatchExecutor::dispatchTestLogData); 360 361 writer << executor 362 << numBytes; 363 364 writer.write(bytes, numBytes); 365 writer.enqueue(); 366 } 367 368 void BatchExecutor::enqueueInfoLogData (void* userPtr, const deUint8* bytes, int numBytes) 369 { 370 BatchExecutor* executor = static_cast<BatchExecutor*>(userPtr); 371 CallWriter writer (&executor->m_dispatcher, BatchExecutor::dispatchInfoLogData); 372 373 writer << executor 374 << numBytes; 375 376 writer.write(bytes, numBytes); 377 writer.enqueue(); 378 } 379 380 void BatchExecutor::dispatchStateChanged (CallReader data) 381 { 382 BatchExecutor* executor = DE_NULL; 383 CommLinkState state = COMMLINKSTATE_LAST; 384 std::string message; 385 386 data >> executor 387 >> state 388 >> message; 389 390 executor->onStateChanged(state, message.c_str()); 391 } 392 393 void BatchExecutor::dispatchTestLogData (CallReader data) 394 { 395 BatchExecutor* executor = DE_NULL; 396 int numBytes; 397 398 data >> executor 399 >> numBytes; 400 401 executor->onTestLogData(data.getDataBlock(numBytes), numBytes); 402 } 403 404 void BatchExecutor::dispatchInfoLogData (CallReader data) 405 { 406 BatchExecutor* executor = DE_NULL; 407 int numBytes; 408 409 data >> executor 410 >> numBytes; 411 412 executor->onInfoLogData(data.getDataBlock(numBytes), numBytes); 413 } 414 415 } // xe 416
