Add missing API MAC address encode implementation

[vpp.git] / test / run_tests.py

diff --git a/test/run_tests.py b/test/run_tests.py
index aac28d1..76b6a62 100644 (file)
--- a/test/run_tests.py
+++ b/test/run_tests.py
@@ -52,13 +52,14 @@ StreamQueueManager.register('Queue', StreamQueue)
 
 
 def test_runner_wrapper(suite, keep_alive_pipe, result_pipe, stdouterr_queue,
-                        logger):
+                        partial_result_queue, logger):
     sys.stdout = stdouterr_queue
     sys.stderr = stdouterr_queue
     VppTestCase.logger = logger
     result = VppTestRunner(keep_alive_pipe=keep_alive_pipe,
                            descriptions=descriptions,
                            verbosity=verbose,
+                           results_pipe=partial_result_queue,
                            failfast=failfast).run(suite)
     result_pipe.send(result)
     result_pipe.close()
@@ -70,13 +71,15 @@ class TestCaseWrapper(object):
         self.keep_alive_parent_end, self.keep_alive_child_end = Pipe(
             duplex=False)
         self.result_parent_end, self.result_child_end = Pipe(duplex=False)
+        self.partial_result_parent_end, self.partial_result_child_end = Pipe(
+            duplex=False)
         self.testcase_suite = testcase_suite
         self.stdouterr_queue = manager.Queue()
         self.logger = get_parallel_logger(self.stdouterr_queue)
         self.child = Process(target=test_runner_wrapper,
                              args=(testcase_suite, self.keep_alive_child_end,
                                    self.result_child_end, self.stdouterr_queue,
-                                   self.logger)
+                                   self.partial_result_child_end, self.logger)
                              )
         self.child.start()
         self.pid = self.child.pid
@@ -87,12 +90,15 @@ class TestCaseWrapper(object):
         self.last_heard = time.time()
         self.core_detected_at = None
         self.failed_tests = []
+        self.partial_result = None
 
     def close_pipes(self):
         self.keep_alive_child_end.close()
         self.result_child_end.close()
+        self.partial_result_child_end.close()
         self.keep_alive_parent_end.close()
         self.result_parent_end.close()
+        self.partial_result_parent_end.close()
 
 
 def stdouterr_reader_wrapper(unread_testcases, finished_unread_testcases,
@@ -148,7 +154,8 @@ def run_forked(testcases):
         for wrapped_testcase_suite in wrapped_testcase_suites:
             readable = select.select(
                 [wrapped_testcase_suite.keep_alive_parent_end.fileno(),
-                 wrapped_testcase_suite.result_parent_end.fileno()],
+                 wrapped_testcase_suite.result_parent_end.fileno(),
+                 wrapped_testcase_suite.partial_result_parent_end.fileno()],
                 [], [], 1)[0]
             if wrapped_testcase_suite.result_parent_end.fileno() in readable:
                 results.append(
@@ -157,6 +164,13 @@ def run_forked(testcases):
                 finished_testcase_suites.add(wrapped_testcase_suite)
                 continue
 
+            if wrapped_testcase_suite.partial_result_parent_end.fileno() \
+                    in readable:
+                while wrapped_testcase_suite.partial_result_parent_end.poll():
+                    wrapped_testcase_suite.partial_result = \
+                        wrapped_testcase_suite.partial_result_parent_end.recv()
+                    wrapped_testcase_suite.last_heard = time.time()
+
             if wrapped_testcase_suite.keep_alive_parent_end.fileno() \
                     in readable:
                 while wrapped_testcase_suite.keep_alive_parent_end.poll():
@@ -256,7 +270,8 @@ def run_forked(testcases):
                 except OSError:
                     # already dead
                     pass
-                results.append((wrapped_testcase_suite.testcase_suite, None))
+                results.append((wrapped_testcase_suite.testcase_suite,
+                                wrapped_testcase_suite.partial_result))
                 finished_testcase_suites.add(wrapped_testcase_suite)
 
         for finished_testcase in finished_testcase_suites:
@@ -395,9 +410,9 @@ class NonPassedResults(dict):
         self.expectedFailures_id = 'expectedFailures'
         self.unexpectedSuccesses_id = 'unexpectedSuccesses'
         self.rerun = []
+        self.passed = 0
         self[self.failures_id] = 0
         self[self.errors_id] = 0
-        self[self.crashes_id] = 0
         self[self.skipped_id] = 0
         self[self.expectedFailures_id] = 0
         self[self.unexpectedSuccesses_id] = 0
@@ -413,7 +428,6 @@ class NonPassedResults(dict):
                     self.results_per_suite[tc_class] = \
                         {self.failures_id: [],
                          self.errors_id: [],
-                         self.crashes_id: [],
                          self.skipped_id: [],
                          self.expectedFailures_id: [],
                          self.unexpectedSuccesses_id: []}
@@ -421,39 +435,28 @@ class NonPassedResults(dict):
                 return True
         return False
 
-    def add_results(self, testcases, testcase_result,
-                    duplicates=None):
+    def add_results(self, testcases, testcase_result_id):
         for failed_testcase, _ in testcases:
-            if self._add_result(failed_testcase, testcase_result):
-                if duplicates:
-                    if failed_testcase not in duplicates:
-                        self[testcase_result] += 1
-                else:
-                    self[testcase_result] += 1
+            if self._add_result(failed_testcase, testcase_result_id):
+                self[testcase_result_id] += 1
 
     def add_result(self, testcase_suite, result):
         retval = 0
-        self.all_testcases += testcase_suite.countTestCases()
+        self.all_testcases += result.testsRun
+        self.passed += result.passed
         if result:
             # suite finished properly
             if not result.wasSuccessful():
                 retval = 1
 
             self.add_results(result.failures, self.failures_id)
-            self.add_results(result.errors, self.errors_id,
-                             result.failures + result.errors)
+            self.add_results(result.errors, self.errors_id)
             self.add_results(result.skipped, self.skipped_id)
             self.add_results(result.expectedFailures,
                              self.expectedFailures_id)
             self.add_results(result.unexpectedSuccesses,
                              self.unexpectedSuccesses_id)
 
-        else:
-            # suite crashed
-            retval = -1
-            self.add_results([(x, None) for x in testcase_suite],
-                             self.crashes_id)
-
         if retval != 0:
             if concurrent_tests == 1:
                 if result:
@@ -476,17 +479,13 @@ class NonPassedResults(dict):
         print('TEST RESULTS:')
         print('        Executed tests: {}'.format(self.all_testcases))
         print('          Passed tests: {}'.format(
-            colorize(str(self.all_testcases -
-                         self.all_nonpassed), GREEN)))
+            colorize(str(self.passed), GREEN)))
         if self[self.failures_id] > 0:
-            print('          Failed tests: {}'.format(
+            print('              Failures: {}'.format(
                 colorize(str(self[self.failures_id]), RED)))
         if self[self.errors_id] > 0:
-            print('         Errored tests: {}'.format(
+            print('                Errors: {}'.format(
                 colorize(str(self[self.errors_id]), RED)))
-        if self[self.crashes_id] > 0:
-            print('         Crashed tests: {}'.format(
-                colorize(str(self[self.crashes_id]), RED)))
         if self[self.skipped_id] > 0:
             print('         Skipped tests: {}'.format(
                 colorize(str(self[self.skipped_id]), YELLOW)))
@@ -505,10 +504,7 @@ class NonPassedResults(dict):
                     self.failures_id]
                 errored_testcases = suite_results[
                     self.errors_id]
-                crashed_testcases = suite_results[
-                    self.crashes_id]
-                if len(failed_testcases) or len(errored_testcases) \
-                        or len(crashed_testcases):
+                if len(failed_testcases) or len(errored_testcases):
                     print('  Testcase name: {}'.format(
                         colorize(testcase_class, RED)))
                     for failed_test in failed_testcases:
@@ -519,25 +515,13 @@ class NonPassedResults(dict):
                         print('    ERRORED: {}'.format(
                             colorize(get_test_description(
                                 descriptions, failed_test), RED)))
-                    for failed_test in crashed_testcases:
-                        print('    CRASHED: {}'.format(
-                            colorize(get_test_description(
-                                descriptions, failed_test), RED)))
 
         print(double_line_delim)
         print('')
 
-    @property
-    def all_nonpassed(self):
-        return self[self.failures_id] + self[self.errors_id] + \
-               self[self.crashes_id] + self[self.skipped_id] + \
-               self[self.expectedFailures_id] + \
-               self[self.unexpectedSuccesses_id]
-
     @property
     def all_failed(self):
-        return self[self.failures_id] + self[self.errors_id] + \
-               self[self.crashes_id]
+        return self[self.failures_id] + self[self.errors_id]
 
 
 def parse_results(results):