Fix local server for multiple applications
[anna.git] / testing / TestManager.cpp
1 // ANNA - Anna is Not Nothingness Anymore                                                         //
2 //                                                                                                //
3 // (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
4 //                                                                                                //
5 // See project site at http://redmine.teslayout.com/projects/anna-suite                           //
6 // See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
7
8 // Standard
9 #include <climits>
10 #include <cmath>
11
12 // Project
13 #include <anna/testing/TestManager.hpp>
14
15 #include <anna/xml/Compiler.hpp>
16 #include <anna/xml/Node.hpp>
17 #include <anna/core/tracing/Logger.hpp>
18 #include <anna/app/functions.hpp>
19 #include <anna/timex/Engine.hpp>
20 #include <anna/diameter/helpers/base/functions.hpp>
21 #include <anna/diameter/helpers/dcca/functions.hpp>
22 #include <anna/comm/functions.hpp>
23 #include <anna/core/functions.hpp>
24 #include <anna/diameter.comm/ClientSession.hpp>
25 #include <anna/diameter.comm/ServerSession.hpp>
26 #include <anna/testing/TestStep.hpp>
27 #include <anna/testing/TestClock.hpp>
28 #include <anna/diameter/codec/Message.hpp>
29
30
31 //class TestTimer;
32
33
34 using namespace anna::testing;
35
36
37 ///////////////////////////////////////////////////////////////////////////////////////////////////
38 void TestManager::StatSummary::newTCState(const TestCase::State::_v beginState, const TestCase::State::_v endState) throw() {
39
40   if ((beginState == TestCase::State::Initialized)&&(endState == TestCase::State::Initialized)) { // special case (new test case provisioning)
41     a_initializedTcs++;
42     return;
43   }
44
45   switch (beginState) {
46   case TestCase::State::Initialized: a_initializedTcs--; break;
47   case TestCase::State::InProgress: a_inprogressTcs--; break;
48   case TestCase::State::Failed: a_failedTcs--; break;
49   case TestCase::State::Success: a_sucessTcs--; break;
50   default: break;
51   }
52   switch (endState) {
53   case TestCase::State::Initialized: a_initializedTcs++; break;
54   case TestCase::State::InProgress: a_inprogressTcs++; break;
55   case TestCase::State::Failed: a_failedTcs++; break;
56   case TestCase::State::Success: a_sucessTcs++; break;
57   default: break;
58   }
59 }
60
61 void TestManager::StatSummary::clear() throw() {
62   a_initializedTcs = 0;
63   a_inprogressTcs = 0;
64   a_failedTcs = 0;
65   a_sucessTcs = 0;
66 }
67
68 anna::xml::Node *TestManager::StatSummary::asXML(anna::xml::Node* parent) const throw() {
69   anna::xml::Node* result = parent->createChild("StatSummary");
70
71   anna::xml::Node* tcs = result->createChild("TestCasesCounts");
72   tcs->createAttribute("Total", a_initializedTcs + a_inprogressTcs + a_failedTcs + a_sucessTcs);
73   tcs->createAttribute("Initialized", a_initializedTcs);
74   tcs->createAttribute("InProgress", a_inprogressTcs);
75   tcs->createAttribute("Failed", a_failedTcs);
76   tcs->createAttribute("Success", a_sucessTcs);
77
78   return result;
79 }
80 ///////////////////////////////////////////////////////////////////////////////////////////////////
81
82
83
84 TestManager::TestManager() :
85       anna::timex::TimeEventObserver("TestManager") {
86   a_timeController = NULL;
87   a_reportsDirectory = "./";
88
89   a_dumpInProgressReports = false;
90   a_dumpInitializedReports = false;
91   a_dumpFailedReports = false;
92   a_dumpSuccessReports = false;
93
94   a_dumpHexMessages = false;
95   a_dumpStdout = false;
96   a_synchronousAmount = 1;
97   a_poolRepeats = 0; // repeat disabled by default
98   a_poolCycle = 1;
99   a_inProgressLimit = UINT_MAX; // no limit
100   a_clock = NULL;
101   //a_testPool.clear();
102   //a_statSummary.clear();
103
104   a_autoResetHard = false;
105
106   a_currentTestIt = a_testPool.end();
107 }
108
109 void TestManager::registerKey1(const std::string &key, const TestCase *testCase)  throw(anna::RuntimeException) {
110
111   auto it = a_key1TestCaseMap.find(key);
112   if (it != a_key1TestCaseMap.end()) { // found
113     unsigned int id = it->second->getId();
114     if (id != testCase->getId()) {
115       throw anna::RuntimeException(anna::functions::asString("There is another test case (id = %llu) which registered such key1: %s", id, key.c_str()), ANNA_FILE_LOCATION);
116     }
117   }
118   else {
119     a_key1TestCaseMap[key] = const_cast<TestCase*>(testCase);
120     LOGDEBUG(anna::Logger::debug(anna::functions::asString("TestManager::registerKey1 for test case (id = %llu): %s)", testCase->getId(), key.c_str()), ANNA_FILE_LOCATION));
121   }
122 }
123
124 void TestManager::registerKey2(const std::string &key, const TestCase *testCase)  throw(anna::RuntimeException) {
125
126   auto it = a_key2TestCaseMap.find(key);
127   if (it != a_key2TestCaseMap.end()) { // found
128     unsigned int id = it->second->getId();
129     if (id != testCase->getId()) {
130       throw anna::RuntimeException(anna::functions::asString("There is another test case (id = %llu) which registered such key2: %s", id, key.c_str()), ANNA_FILE_LOCATION);
131     }
132   }
133   else {
134     a_key2TestCaseMap[key] = const_cast<TestCase*>(testCase);
135     LOGDEBUG(anna::Logger::debug(anna::functions::asString("TestManager::registerKey2 for test case (id = %llu): %s)", testCase->getId(), key.c_str()), ANNA_FILE_LOCATION));
136   }
137 }
138
139 TestTimer* TestManager::createTimer(TestCaseStep* testCaseStep, const anna::Millisecond &timeout, const TestTimer::Type::_v type)
140 throw(anna::RuntimeException) {
141   TestTimer* result(NULL);
142
143   if(a_timeController == NULL)
144     throw anna::RuntimeException("You must invoke 'setTimerController' with a not NULL timex engine", ANNA_FILE_LOCATION);
145
146   anna::Guard guard(a_timeController, "TestManager::createTimer");              // avoid interblocking
147   result = a_timers.create();
148   result->setType(type);
149   result->setId((anna::timex::TimeEvent::Id) testCaseStep);
150   result->setObserver(this);
151   result->setContext(testCaseStep);
152   result->setTimeout(timeout);
153
154   LOGDEBUG(
155       std::string msg("TestManager::createTimer | ");
156   msg += result->asString();
157   anna::Logger::debug(msg, ANNA_FILE_LOCATION);
158   );
159
160   a_timeController->activate(result);
161   return result;
162 }
163
164 void TestManager::cancelTimer(TestTimer* timer)
165 throw() {
166   if(timer == NULL)
167     return;
168
169   LOGDEBUG(
170       std::string msg("TestManager::cancel | ");
171   msg += timer->asString();
172   anna::Logger::debug(msg, ANNA_FILE_LOCATION);
173   );
174
175   try {
176     if(a_timeController == NULL)
177       a_timeController = anna::app::functions::component <anna::timex::Engine> (ANNA_FILE_LOCATION);
178
179     a_timeController->cancel(timer);
180   } catch(anna::RuntimeException& ex) {
181     ex.trace();
182   }
183 }
184
185 //------------------------------------------------------------------------------------------
186 // Se invoca automaticamente desde anna::timex::Engine
187 //------------------------------------------------------------------------------------------
188 void TestManager::release(anna::timex::TimeEvent* timeEvent)
189 throw() {
190   TestTimer* timer = static_cast <TestTimer*>(timeEvent);
191   timer->setContext(NULL);
192   a_timers.release(timer);
193 }
194
195 bool TestManager::configureTTPS(int testTicksPerSecond) throw() {
196
197   if (testTicksPerSecond == 0) {
198     if (a_clock) {
199       a_timeController->cancel(a_clock);
200       LOGDEBUG(anna::Logger::debug("Testing timer clock stopped !", ANNA_FILE_LOCATION));
201     }
202     else {
203       LOGDEBUG(anna::Logger::debug("No testing timer started yet !", ANNA_FILE_LOCATION));
204     }
205     return true;
206   }
207   else if (testTicksPerSecond  < 0) {
208     LOGWARNING(anna::Logger::warning("Invalid 'ttps' provided", ANNA_FILE_LOCATION));
209     return false;
210   }
211
212   anna::Millisecond applicationTimeInterval = anna::Millisecond(1000 / testTicksPerSecond);
213   a_synchronousAmount = 1;
214
215   if (applicationTimeInterval < anna::Millisecond(1)) {
216     LOGWARNING(anna::Logger::warning("Not allowed to configure more than 1000 events per second for for triggering testing system", ANNA_FILE_LOCATION));
217     return false;
218   }
219
220   if (applicationTimeInterval < a_timeController->getResolution()) {
221     int maximumObtained = 1000 / (int)(a_timeController->getResolution());
222     a_synchronousAmount = ceil((double)testTicksPerSecond/maximumObtained);
223     // calculate again:
224     applicationTimeInterval = anna::Millisecond(a_synchronousAmount * 1000 / testTicksPerSecond);
225   }
226
227   if (a_synchronousAmount > 1) {
228     LOGWARNING(
229         std::string msg = anna::functions::asString("Desired testing time trigger rate (%d events per second) requires more than one sending per event (%d every %lld milliseconds). Consider launch more instances with lower rate (for example %d ADML processes with %d ttps), or configure %d or more sockets to the remote endpoints to avoid burst sendings",
230             testTicksPerSecond,
231             a_synchronousAmount,
232             applicationTimeInterval.getValue(),
233             a_synchronousAmount,
234             1000/applicationTimeInterval,
235             a_synchronousAmount);
236
237     anna::Logger::warning(msg, ANNA_FILE_LOCATION);
238     );
239   }
240
241   if (a_clock) {
242     a_clock->setTimeout(applicationTimeInterval);
243   }
244   else {
245     a_clock = new TestClock("Testing clock", applicationTimeInterval, this); // clock
246   }
247
248   if (!a_clock->isActive()) a_timeController->activate(a_clock);
249
250   return true;
251 }
252
253 bool TestManager::gotoTestCase(unsigned int id) throw() {
254   test_pool_it it = a_testPool.find(id);
255   if (it != a_testPool.end()) {
256     a_currentTestIt = it;
257     return true;
258   }
259
260   return false;
261 }
262
263 bool TestManager::runTestCase(unsigned int id) throw() {
264   test_pool_it it = a_testPool.find(id);
265   if (it != a_testPool.end()) {
266     a_currentTestIt = it;
267
268     // execTestCases will get the next one, we must return 1 position:
269     if (a_currentTestIt == a_testPool.begin())
270       a_currentTestIt = a_testPool.end();
271     else
272       a_currentTestIt--;
273
274     return execTestCases(1);
275   }
276
277   return false;
278 }
279
280 TestCase *TestManager::findTestCase(unsigned int id) const throw() { // id = -1 provides current test case triggered
281
282   if (!tests()) return NULL;
283   test_pool_it it = ((id != -1) ? a_testPool.find(id) : a_currentTestIt);
284   if (it != a_testPool.end()) return const_cast<TestCase*>(it->second);
285   return NULL;
286 }
287
288 TestCase *TestManager::getTestCase(unsigned int id, const std::string &description) throw() {
289
290   test_pool_nc_it it = a_testPool.find(id);
291   if (it != a_testPool.end()) return it->second;
292
293   TestCase *result = new TestCase(id, description);
294   a_testPool[id] = result;
295   return result;
296 }
297
298 bool TestManager::clearPool() throw() {
299   if (!tests()) return false;
300   for (test_pool_it it = a_testPool.begin(); it != a_testPool.end(); it++) delete it->second;
301   // TODO: stop the possible command threads or there will be a core dump
302
303   a_testPool.clear();
304   a_key1TestCaseMap.clear();
305   a_key2TestCaseMap.clear();
306   a_currentTestIt = a_testPool.end();
307   a_poolCycle = 1;
308   configureTTPS(0); // stop
309   a_statSummary.clear();
310   return true;
311 }
312
313 bool TestManager::resetPool(bool hard) throw() {
314   bool result = false; // any reset
315
316   if (!tests()) return result;
317   for (test_pool_nc_it it = a_testPool.begin(); it != a_testPool.end(); it++) {
318     if (it->second->reset(hard))
319       result = true;
320   }
321   //a_key1TestCaseMap.clear();
322   //a_key2TestCaseMap.clear();
323   return result;
324 }
325
326 bool TestManager::tick() throw() {
327   LOGDEBUG(anna::Logger::debug("New test clock tick !", ANNA_FILE_LOCATION));
328   return execTestCases(a_synchronousAmount);
329 }
330
331 bool TestManager::execTestCases(int sync_amount) throw() {
332
333   if (!tests()) {
334     LOGWARNING(anna::Logger::warning("Testing pool is empty. You need programming", ANNA_FILE_LOCATION));
335     return false;
336   }
337
338   // Synchronous sendings per tick:
339   int count = sync_amount;
340   while (count > 0) {
341     if (!nextTestCase()) return false; // stop the clock
342     count--;
343   }
344
345   return true;
346 }
347
348 bool TestManager::nextTestCase() throw() {
349
350   while (true) {
351
352     // Limit for in-progress test cases:
353     if (getInProgressCount() >= a_inProgressLimit) {
354       LOGDEBUG(anna::Logger::debug(anna::functions::asString("TestManager next case ignored (over in-progress count limit: %llu)", a_inProgressLimit), ANNA_FILE_LOCATION));
355       return true; // wait next tick to release OTA test cases
356     }
357
358     // Next test case:
359     if (a_currentTestIt == a_testPool.end())
360       a_currentTestIt = a_testPool.begin();
361     else
362       a_currentTestIt++;
363
364     // Completed:
365     if (a_currentTestIt == a_testPool.end()) {
366       if ((a_poolCycle > a_poolRepeats) && (a_poolRepeats != -1)) {
367         LOGWARNING(anna::Logger::warning("Testing pool cycle completed. No remaining repeat cycles left. Suspending", ANNA_FILE_LOCATION));
368         a_poolCycle = 1;
369         return false;
370       }
371       else {
372         LOGWARNING(
373             std::string nolimit = (a_poolRepeats != -1) ? "":" [no limit]";
374         anna::Logger::warning(anna::functions::asString("Testing pool cycle %d completed (repeats configured: %d%s). Restarting for the %s cycle", a_poolCycle, a_poolRepeats, nolimit.c_str(), (a_poolRepeats == a_poolCycle) ? "last":"next"), ANNA_FILE_LOCATION);
375         );
376         a_poolCycle++;
377         //a_currentTestIt = a_testPool.begin();
378         return true; // avoids infinite loop: if the cycle takes less time than test cases completion, below reset never will turns state
379         // into Initialized and this while will be infinite. It is preferable to wait one tick when the cycle is completed.
380       }
381     }
382
383     // Hard reset or soft reset to initialize already finished (in previous cycle) test cases:
384     a_currentTestIt->second->reset(a_autoResetHard);
385
386     // Process test case:
387     LOGDEBUG(anna::Logger::debug(anna::functions::asString("Processing test case id = %llu, currently '%s' state", a_currentTestIt->first, TestCase::asText(a_currentTestIt->second->getState())), ANNA_FILE_LOCATION));
388     if (a_currentTestIt->second->getState() != TestCase::State::InProgress) {
389       a_currentTestIt->second->process();
390       return true; // is not probably to reach still In-Progress test cases from previous cycles due to the whole
391       //  time for complete the test cases pool regarding the single test case lifetime. You shouldn't
392       //  forget to programm a test case timeout with a reasonable value
393     }
394   }
395 }
396
397 TestCase *TestManager::getDiameterTestCaseFromSessionId(const anna::DataBlock &message, std::string &sessionId) throw() {
398   try {
399     sessionId = anna::diameter::helpers::base::functions::getSessionId(message);
400   }
401   catch (anna::RuntimeException &ex) {
402     //ex.trace();
403     LOGDEBUG(anna::Logger::debug("Cannot get the Session-Id from received DataBlock in order to identify the Test Case", ANNA_FILE_LOCATION));
404     return NULL;
405   }
406   auto sessionIdIt = a_key1TestCaseMap.find(sessionId);
407   if (sessionIdIt != a_key1TestCaseMap.end())
408     return sessionIdIt->second;
409
410   LOGDEBUG(anna::Logger::debug(anna::functions::asString("Cannot identify the Test Case for received Session-Id: %s", sessionId.c_str()), ANNA_FILE_LOCATION));
411   return NULL;
412 }
413
414 TestCase *TestManager::getDiameterTestCaseFromSubscriberId(const anna::DataBlock &message, std::string &subscriberId) throw() {
415   try {
416     subscriberId = anna::diameter::helpers::dcca::functions::getSubscriptionIdData(message, anna::diameter::helpers::dcca::AVPVALUES__Subscription_Id_Type::END_USER_E164);
417     if (subscriberId == "") // try with IMSI
418       subscriberId = anna::diameter::helpers::dcca::functions::getSubscriptionIdData(message, anna::diameter::helpers::dcca::AVPVALUES__Subscription_Id_Type::END_USER_IMSI);
419   }
420   catch (anna::RuntimeException &ex) {
421     //ex.trace();
422     LOGDEBUG(anna::Logger::debug("Cannot get the Subscriber-Id from received DataBlock in order to identify the Test Case", ANNA_FILE_LOCATION));
423     return NULL;
424   }
425   auto subscriberIdIt = a_key2TestCaseMap.find(subscriberId);
426   if (subscriberIdIt != a_key2TestCaseMap.end())
427     return subscriberIdIt->second;
428
429   LOGDEBUG(anna::Logger::debug(anna::functions::asString("Cannot identify the Test Case for received Subscriber-Id: %s", subscriberId.c_str()), ANNA_FILE_LOCATION));
430   return NULL;
431 }
432
433 void TestManager::receiveDiameterMessage(const anna::DataBlock &message, const anna::diameter::comm::ClientSession *clientSession) throw(anna::RuntimeException) {
434
435   // Testing disabled:
436   if (!tests()) return;
437
438   // Identify the test case:
439   std::string sessionId, subscriberId;
440   TestCase *tc;
441   tc = getDiameterTestCaseFromSessionId(message, sessionId);
442   if (!tc)
443     tc = getDiameterTestCaseFromSubscriberId(message, subscriberId);
444   if (!tc) {
445     LOGWARNING(anna::Logger::warning(anna::comm::functions::asText("Cannot identify the Test Case for the message received from server: ", message), ANNA_FILE_LOCATION)); // this should not appear
446     return;
447   }
448
449   // Work with Test case:
450   TestStepWaitDiameter *tsw = tc->searchNextWaitConditionFulfilled(message, true /* comes from entity */);
451   if (!tsw) { // store as 'uncovered'
452     std::string hint = "Uncovered condition for received message from entity over Session-Id '"; hint += sessionId; hint += "'; ";
453
454     try {
455       static anna::diameter::codec::Message codecMsg;
456       codecMsg.decode(message);
457       hint += "HEX Message: '"; hint += anna::functions::asHexString(message);
458       hint += "'; XML Message:\n"; hint += codecMsg.asXMLString();
459     }
460     catch (anna::RuntimeException &ex) {
461       ex.trace();
462       hint += ex.asString();
463     }
464     hint += "\nClient Session: "; hint += clientSession->asString();
465
466     tc->addDebugSummaryHint(hint);
467   }
468   else {
469     tsw->setClientSession(const_cast<anna::diameter::comm::ClientSession*>(clientSession));
470     tc->process();
471   }
472 }
473
474 void TestManager::receiveDiameterMessage(const anna::DataBlock &message, const anna::diameter::comm::ServerSession *serverSession) throw(anna::RuntimeException) {
475
476   // Testing disabled:
477   if (!tests()) return;
478
479   // Identify the test case:
480   std::string sessionId, subscriberId;
481   TestCase *tc;
482   tc = getDiameterTestCaseFromSessionId(message, sessionId);
483   if (!tc)
484     tc = getDiameterTestCaseFromSubscriberId(message, subscriberId);
485   if (!tc) {
486     LOGWARNING(anna::Logger::warning(anna::comm::functions::asText("Cannot identify the Test Case for the message received from client: ", message), ANNA_FILE_LOCATION)); // this should not appear
487     return;
488   }
489
490   // Work with Test case:
491   TestStepWaitDiameter *tsw = tc->searchNextWaitConditionFulfilled(message, false /* comes from client */);
492   if (!tsw) { // store as 'uncovered'
493     std::string hint = "Uncovered condition for received message from client over Session-Id '"; hint += sessionId; hint += "'; ";
494
495     try {
496       static anna::diameter::codec::Message codecMsg;
497       codecMsg.decode(message);
498       hint += "HEX Message: '"; hint += anna::functions::asHexString(message);
499       hint += "'; XML Message:\n"; hint += codecMsg.asXMLString();
500     }
501     catch (anna::RuntimeException &ex) {
502       ex.trace();
503       hint += ex.asString();
504     }
505     hint += "\nServer Session: "; hint += serverSession->asString();
506
507     tc->addDebugSummaryHint(hint);
508   }
509   else {
510     tsw->setServerSession(const_cast<anna::diameter::comm::ServerSession*>(serverSession));
511     tc->process();
512   }
513 }
514
515 anna::xml::Node* TestManager::asXML(anna::xml::Node* parent) const
516 throw() {
517   anna::xml::Node* result = parent->createChild("TestManager");
518
519   int poolSize = a_testPool.size();
520   result->createAttribute("NumberOfTestCases", poolSize);
521   if (a_poolRepeats) result->createAttribute("PoolRepeats", a_poolRepeats);
522   else result->createAttribute("PoolRepeats", "disabled");
523   result->createAttribute("PoolCycle", a_poolCycle);
524   a_statSummary.asXML(result);
525   if (a_inProgressLimit == UINT_MAX)
526     result->createAttribute("InProgressLimit", "<no limit>");
527   else
528     result->createAttribute("InProgressLimit", a_inProgressLimit);
529   result->createAttribute("DumpInitializedReports", (a_dumpInitializedReports ? "yes":"no"));
530   result->createAttribute("DumpInProgressReports", (a_dumpInProgressReports ? "yes":"no"));
531   result->createAttribute("DumpFailedReports", (a_dumpFailedReports ? "yes":"no"));
532   result->createAttribute("DumpSuccessReports", (a_dumpSuccessReports ? "yes":"no"));
533   result->createAttribute("DumpHexMessages", (a_dumpHexMessages ? "yes":"no"));
534   result->createAttribute("DumpStdout", (a_dumpStdout ? "yes":"no"));
535   result->createAttribute("AutoResetHard", (a_autoResetHard ? "yes":"no"));
536   result->createAttribute("ReportsDirectory", a_reportsDirectory);
537   if (a_clock) {
538     result->createAttribute("AsynchronousSendings", a_synchronousAmount);
539     int ticksPerSecond = (a_synchronousAmount * 1000) / a_clock->getTimeout();
540     result->createAttribute("TicksPerSecond", ticksPerSecond);
541   }
542   if (a_currentTestIt != a_testPool.end()) {
543     result->createAttribute("CurrentTestCaseId", (*a_currentTestIt).first);
544   }
545   if (poolSize != 0) {
546     anna::xml::Node* testCases = result->createChild("TestCases");
547     for (test_pool_it it = a_testPool.begin(); it != a_testPool.end(); it++) {
548       if (((*it).second->getState() == TestCase::State::Initialized) && (!getDumpInitializedReports())) continue;
549       if (((*it).second->getState() == TestCase::State::InProgress) && (!getDumpInProgressReports())) continue;
550       if (((*it).second->getState() == TestCase::State::Failed) && (!getDumpFailedReports())) continue;
551       if (((*it).second->getState() == TestCase::State::Success) && (!getDumpSuccessReports())) continue;
552       (*it).second->asXML(testCases);
553     }
554   }
555
556   return result;
557 }
558
559 anna::xml::Node* TestManager::junitAsXML(anna::xml::Node* parent) const
560 throw() {
561   // if only a single testsuite element is present, the testsuites element can be omitted
562   //anna::xml::Node* result = parent->createChild("testsuites");
563   anna::xml::Node* result = parent->createChild("testsuite");
564
565 /*
566 https://stackoverflow.com/questions/4922867/what-is-the-junit-xml-format-specification-that-hudson-supports
567
568 JUnit XSD file
569 ==============
570 https://windyroad.com.au/dl/Open%20Source/JUnit.xsd
571
572 EXAMPLES
573 ========
574 <?xml version="1.0" encoding="UTF-8"?>
575 <testsuites disabled="" errors="" failures="" name="" tests="" time="">
576     <testsuite disabled="" errors="" failures="" hostname="" id=""
577                name="" package="" skipped="" tests="" time="" timestamp="">
578         <properties>
579             <property name="" value=""/>
580         </properties>
581         <testcase assertions="" classname="" name="" status="" time="">
582             <skipped/>
583             <error message="" type=""/>
584             <failure message="" type=""/>
585             <system-out/>
586             <system-err/>
587         </testcase>
588         <system-out/>
589         <system-err/>
590     </testsuite>
591 </testsuites>
592
593 Some of these items can occur multiple times:
594
595 There can only be one testsuites element, since that's how XML works, but there can be multiple testsuite elements within the testsuites element.
596 Each properties element can have multiple property children.
597 Each testsuite element can have multiple testcase children.
598 Each testcase element can have multiple error, failure, system-out, or system-err children:
599
600 <testsuite tests="3">
601     <testcase classname="foo1" name="ASuccessfulTest"/>
602     <testcase classname="foo2" name="AnotherSuccessfulTest"/>
603     <testcase classname="foo3" name="AFailingTest">
604         <failure type="NotEnoughFoo"> details about failure </failure>
605     </testcase>
606 </testsuite>
607
608 */
609
610 /*
611   <testsuite name=""      <!-- Full (class) name of the test for non-aggregated testsuite documents.
612                                Class name without the package for aggregated testsuites documents. Required -->
613          tests=""     <!-- The total number of tests in the suite, required. -->
614
615          disabled=""  <!-- the total number of disabled tests in the suite. optional -->
616              errors=""    <!-- The total number of tests in the suite that errored. An errored test is one that had an unanticipated problem,
617                                for example an unchecked throwable; or a problem with the implementation of the test. optional -->
618              failures=""  <!-- The total number of tests in the suite that failed. A failure is a test which the code has explicitly failed
619                                by using the mechanisms for that purpose. e.g., via an assertEquals. optional -->
620              hostname=""  <!-- Host on which the tests were executed. 'localhost' should be used if the hostname cannot be determined. optional -->
621          id=""        <!-- Starts at 0 for the first testsuite and is incremented by 1 for each following testsuite -->
622          package=""   <!-- Derived from testsuite/@name in the non-aggregated documents. optional -->
623          skipped=""   <!-- The total number of skipped tests. optional -->
624          time=""      <!-- Time taken (in seconds) to execute the tests in the suite. optional -->
625          timestamp="" <!-- when the test was executed in ISO 8601 format (2014-01-21T16:17:18). Timezone may not be specified. optional -->
626          >
627 */
628   result->createAttribute("name", "ADML Testing Main Testsuite");
629   int poolSize = a_testPool.size();
630   result->createAttribute("tests", poolSize);
631
632   result->createAttribute("errors", 0);
633   result->createAttribute("failures", a_statSummary.getFailedCount());
634   result->createAttribute("hostname", anna::functions::getHostname());
635   result->createAttribute("skipped", a_statSummary.getInitializedCount());
636
637   // Testcases:
638
639 /*
640     <!-- testcase can appear multiple times, see /testsuites/testsuite@tests -->
641     <testcase name=""       <!-- Name of the test method, required. -->
642           assertions="" <!-- number of assertions in the test case. optional -->
643           classname=""  <!-- Full class name for the class the test method is in. required -->
644           status=""
645           time=""       <!-- Time taken (in seconds) to execute the test. optional -->
646           >
647
648 */
649   int testcasesLapseMs = 0;
650   int startTimestampMs = 0;
651   double secs;
652   if (poolSize != 0) {
653     test_pool_it it_min = a_testPool.begin();
654     test_pool_it it_max = a_testPool.end();
655     startTimestampMs = (int)((*it_min).second->getStartTimestamp());
656     std::string debugSummary;
657
658     for (test_pool_it it = it_min; it != it_max; it++) {
659       anna::xml::Node* testcase = result->createChild("testcase");
660       auto tc = (*it).second;
661
662       testcasesLapseMs = (int)(tc->getLapseMs());
663       testcase->createAttribute("classname", "adml_testcase");
664       testcase->createAttribute("description", tc->getDescription());
665       testcase->createAttribute("status", TestCase::asText(tc->getState()));
666
667       secs = testcasesLapseMs / 1000.0;
668       testcase->createAttribute("time", anna::functions::asString(secs, "%.2f"));
669
670       if (tc->isFailed()) {
671         anna::xml::Node* failure = testcase->createChild("failure");
672         std::string text = "";
673         debugSummary = tc->getDebugSummary().asString();
674         if (debugSummary != "") {
675           text += "[Testcase debug summary]";
676           text += "<!--";
677           text += debugSummary;
678           text += "-->";
679         }
680         text += "[Testcase information (xml dump)]";
681         text += "<!--";
682         text += tc->asXMLString();
683         text += "-->";
684         failure->createText(text);
685       }
686     }
687   }
688
689   time_t startTimestamp = startTimestampMs/1000;
690   time(&startTimestamp);
691   char buf[sizeof "2011-10-08T07:07:09Z"];
692   strftime(buf, sizeof buf, "%FT%TZ", gmtime(&startTimestamp));
693   // this will work too, if your compiler doesn't support %F or %T:
694   //     //strftime(buf, sizeof buf, "%Y-%m-%dT%H:%M:%SZ", gmtime(&now));
695   //         std::cout << buf << "\n";
696   result->createAttribute("timestamp", buf);
697
698
699   return result;
700 }
701
702 std::string TestManager::asXMLString() const throw() {
703   anna::xml::Node root("root");
704   return anna::xml::Compiler().apply(asXML(&root));
705 }
706
707 std::string TestManager::junitAsXMLString() const throw() {
708   anna::xml::Node root("root");
709   return anna::xml::Compiler().apply(junitAsXML(&root));
710 }
711
712 std::string TestManager::summaryCounts() const throw() {
713
714   std::string result= "\nSummary Counts:\n";
715   unsigned int total = a_statSummary.getTotal();
716   result += "\nTotal:       " + anna::functions::asString(total);
717   result += "\nInitialized: " + anna::functions::asString(a_statSummary.getInitializedCount());
718   result += "\nIn Progress: " + anna::functions::asString(a_statSummary.getInProgressCount());
719   unsigned int failed = a_statSummary.getFailedCount();
720   unsigned int success = a_statSummary.getSuccessCount();
721   result += "\nFailed:      " + anna::functions::asString(failed);
722   result += "\nSuccess:     " + anna::functions::asString(success);
723   std::string verdict = ((failed == 0) && (success > 0) && (total == success)) ? "PASS":"FAIL";
724   if (total != 0) {
725     result += std::string("\n\nVERDICT:     ") + verdict;
726   }
727
728   return result;
729 }
730
731 std::string TestManager::summaryStates() const throw() {
732
733   std::string result = "\nSummary States:\n";
734   const char *literal = "\n[%s] %s";
735   const char *secsLiteral = " (%.2f secs)";
736
737   int testcasesLapseMs = 0;
738   int startTimestampMs = 0;
739   double secs;
740   int poolSize = a_testPool.size();
741   if (poolSize != 0) {
742     test_pool_it it_min = a_testPool.begin();
743     test_pool_it it_max = a_testPool.end();
744     startTimestampMs = (int)((*it_min).second->getStartTimestamp());
745
746     for (test_pool_it it = it_min; it != it_max; it++) {
747       auto tc = (*it).second;
748
749       testcasesLapseMs = (int)(tc->getLapseMs());
750
751       result += anna::functions::asString(literal, TestCase::asText(tc->getState()), tc->getDescription().c_str());
752
753       if (testcasesLapseMs >= 0) {
754         secs = testcasesLapseMs / 1000.0;
755         result += anna::functions::asString(secsLiteral, secs);
756       }
757     }
758   }
759   else {
760     result +="\nNo test cases programmed !";
761   }
762
763   return result;
764 }
765