Revert ymake build from ydb oss export

1 files changed, 0 insertions, 397 deletions

diff --git a/contrib/tools/cython/Cython/Tests/xmlrunner.py b/contrib/tools/cython/Cython/Tests/xmlrunner.py
deleted file mode 100644
index d6838aa22ec..00000000000
--- a/contrib/tools/cython/Cython/Tests/xmlrunner.py
+++ /dev/null
@@ -1,397 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""unittest-xml-reporting is a PyUnit-based TestRunner that can export test
-results to XML files that can be consumed by a wide range of tools, such as
-build systems, IDEs and Continuous Integration servers.
-
-This module provides the XMLTestRunner class, which is heavily based on the
-default TextTestRunner. This makes the XMLTestRunner very simple to use.
-
-The script below, adapted from the unittest documentation, shows how to use
-XMLTestRunner in a very simple way. In fact, the only difference between this
-script and the original one is the last line:
-
-import random
-import unittest
-import xmlrunner
-
-class TestSequenceFunctions(unittest.TestCase):
-    def setUp(self):
-        self.seq = range(10)
-
-    def test_shuffle(self):
-        # make sure the shuffled sequence does not lose any elements
-        random.shuffle(self.seq)
-        self.seq.sort()
-        self.assertEqual(self.seq, range(10))
-
-    def test_choice(self):
-        element = random.choice(self.seq)
-        self.assertTrue(element in self.seq)
-
-    def test_sample(self):
-        self.assertRaises(ValueError, random.sample, self.seq, 20)
-        for element in random.sample(self.seq, 5):
-            self.assertTrue(element in self.seq)
-
-if __name__ == '__main__':
-    unittest.main(testRunner=xmlrunner.XMLTestRunner(output='test-reports'))
-"""
-
-from __future__ import absolute_import
-
-import os
-import sys
-import time
-from unittest import TestResult, TextTestResult, TextTestRunner
-import xml.dom.minidom
-try:
-    from StringIO import StringIO
-except ImportError:
-    from io import StringIO  # doesn't accept 'str' in Py2
-
-
-class XMLDocument(xml.dom.minidom.Document):
-    def createCDATAOrText(self, data):
-        if ']]>' in data:
-            return self.createTextNode(data)
-        return self.createCDATASection(data)
-
-
-class _TestInfo(object):
-    """This class is used to keep useful information about the execution of a
-    test method.
-    """
-
-    # Possible test outcomes
-    (SUCCESS, FAILURE, ERROR) = range(3)
-
-    def __init__(self, test_result, test_method, outcome=SUCCESS, err=None):
-        "Create a new instance of _TestInfo."
-        self.test_result = test_result
-        self.test_method = test_method
-        self.outcome = outcome
-        self.err = err
-        self.stdout = test_result.stdout and test_result.stdout.getvalue().strip() or ''
-        self.stderr = test_result.stdout and test_result.stderr.getvalue().strip() or ''
-
-    def get_elapsed_time(self):
-        """Return the time that shows how long the test method took to
-        execute.
-        """
-        return self.test_result.stop_time - self.test_result.start_time
-
-    def get_description(self):
-        "Return a text representation of the test method."
-        return self.test_result.getDescription(self.test_method)
-
-    def get_error_info(self):
-        """Return a text representation of an exception thrown by a test
-        method.
-        """
-        if not self.err:
-            return ''
-        return self.test_result._exc_info_to_string(
-            self.err, self.test_method)
-
-
-class _XMLTestResult(TextTestResult):
-    """A test result class that can express test results in a XML report.
-
-    Used by XMLTestRunner.
-    """
-    def __init__(self, stream=sys.stderr, descriptions=1, verbosity=1,
-                 elapsed_times=True):
-        "Create a new instance of _XMLTestResult."
-        TextTestResult.__init__(self, stream, descriptions, verbosity)
-        self.successes = []
-        self.callback = None
-        self.elapsed_times = elapsed_times
-        self.output_patched = False
-
-    def _prepare_callback(self, test_info, target_list, verbose_str,
-        short_str):
-        """Append a _TestInfo to the given target list and sets a callback
-        method to be called by stopTest method.
-        """
-        target_list.append(test_info)
-        def callback():
-            """This callback prints the test method outcome to the stream,
-            as well as the elapsed time.
-            """
-
-            # Ignore the elapsed times for a more reliable unit testing
-            if not self.elapsed_times:
-                self.start_time = self.stop_time = 0
-
-            if self.showAll:
-                self.stream.writeln('(%.3fs) %s' % \
-                    (test_info.get_elapsed_time(), verbose_str))
-            elif self.dots:
-                self.stream.write(short_str)
-        self.callback = callback
-
-    def _patch_standard_output(self):
-        """Replace the stdout and stderr streams with string-based streams
-        in order to capture the tests' output.
-        """
-        if not self.output_patched:
-            (self.old_stdout, self.old_stderr) = (sys.stdout, sys.stderr)
-            self.output_patched = True
-        (sys.stdout, sys.stderr) = (self.stdout, self.stderr) = \
-            (StringIO(), StringIO())
-
-    def _restore_standard_output(self):
-        "Restore the stdout and stderr streams."
-        (sys.stdout, sys.stderr) = (self.old_stdout, self.old_stderr)
-        self.output_patched = False
-
-    def startTest(self, test):
-        "Called before execute each test method."
-        self._patch_standard_output()
-        self.start_time = time.time()
-        TestResult.startTest(self, test)
-
-        if self.showAll:
-            self.stream.write('  ' + self.getDescription(test))
-            self.stream.write(" ... ")
-
-    def stopTest(self, test):
-        "Called after execute each test method."
-        self._restore_standard_output()
-        TextTestResult.stopTest(self, test)
-        self.stop_time = time.time()
-
-        if self.callback and callable(self.callback):
-            self.callback()
-            self.callback = None
-
-    def addSuccess(self, test):
-        "Called when a test executes successfully."
-        self._prepare_callback(_TestInfo(self, test),
-                               self.successes, 'OK', '.')
-
-    def addFailure(self, test, err):
-        "Called when a test method fails."
-        self._prepare_callback(_TestInfo(self, test, _TestInfo.FAILURE, err),
-                               self.failures, 'FAIL', 'F')
-
-    def addError(self, test, err):
-        "Called when a test method raises an error."
-        self._prepare_callback(_TestInfo(self, test, _TestInfo.ERROR, err),
-                               self.errors, 'ERROR', 'E')
-
-    def printErrorList(self, flavour, errors):
-        "Write some information about the FAIL or ERROR to the stream."
-        for test_info in errors:
-            if isinstance(test_info, tuple):
-                test_info, exc_info = test_info
-
-            try:
-                t = test_info.get_elapsed_time()
-            except AttributeError:
-                t = 0
-            try:
-                descr = test_info.get_description()
-            except AttributeError:
-                try:
-                    descr = test_info.getDescription()
-                except AttributeError:
-                    descr = str(test_info)
-            try:
-                err_info = test_info.get_error_info()
-            except AttributeError:
-                err_info = str(test_info)
-
-            self.stream.writeln(self.separator1)
-            self.stream.writeln('%s [%.3fs]: %s' % (flavour, t, descr))
-            self.stream.writeln(self.separator2)
-            self.stream.writeln('%s' % err_info)
-
-    def _get_info_by_testcase(self):
-        """This method organizes test results by TestCase module. This
-        information is used during the report generation, where a XML report
-        will be generated for each TestCase.
-        """
-        tests_by_testcase = {}
-
-        for tests in (self.successes, self.failures, self.errors):
-            for test_info in tests:
-                if not isinstance(test_info, _TestInfo):
-                    print("Unexpected test result type: %r" % (test_info,))
-                    continue
-                testcase = type(test_info.test_method)
-
-                # Ignore module name if it is '__main__'
-                module = testcase.__module__ + '.'
-                if module == '__main__.':
-                    module = ''
-                testcase_name = module + testcase.__name__
-
-                if testcase_name not in tests_by_testcase:
-                    tests_by_testcase[testcase_name] = []
-                tests_by_testcase[testcase_name].append(test_info)
-
-        return tests_by_testcase
-
-    def _report_testsuite(suite_name, tests, xml_document):
-        "Appends the testsuite section to the XML document."
-        testsuite = xml_document.createElement('testsuite')
-        xml_document.appendChild(testsuite)
-
-        testsuite.setAttribute('name', str(suite_name))
-        testsuite.setAttribute('tests', str(len(tests)))
-
-        testsuite.setAttribute('time', '%.3f' %
-            sum([e.get_elapsed_time() for e in tests]))
-
-        failures = len([1 for e in tests if e.outcome == _TestInfo.FAILURE])
-        testsuite.setAttribute('failures', str(failures))
-
-        errors = len([1 for e in tests if e.outcome == _TestInfo.ERROR])
-        testsuite.setAttribute('errors', str(errors))
-
-        return testsuite
-
-    _report_testsuite = staticmethod(_report_testsuite)
-
-    def _report_testcase(suite_name, test_result, xml_testsuite, xml_document):
-        "Appends a testcase section to the XML document."
-        testcase = xml_document.createElement('testcase')
-        xml_testsuite.appendChild(testcase)
-
-        testcase.setAttribute('classname', str(suite_name))
-        testcase.setAttribute('name', test_result.test_method.shortDescription()
-                              or getattr(test_result.test_method, '_testMethodName',
-                                         str(test_result.test_method)))
-        testcase.setAttribute('time', '%.3f' % test_result.get_elapsed_time())
-
-        if (test_result.outcome != _TestInfo.SUCCESS):
-            elem_name = ('failure', 'error')[test_result.outcome-1]
-            failure = xml_document.createElement(elem_name)
-            testcase.appendChild(failure)
-
-            failure.setAttribute('type', str(test_result.err[0].__name__))
-            failure.setAttribute('message', str(test_result.err[1]))
-
-            error_info = test_result.get_error_info()
-            failureText = xml_document.createCDATAOrText(error_info)
-            failure.appendChild(failureText)
-
-    _report_testcase = staticmethod(_report_testcase)
-
-    def _report_output(test_runner, xml_testsuite, xml_document, stdout, stderr):
-        "Appends the system-out and system-err sections to the XML document."
-        systemout = xml_document.createElement('system-out')
-        xml_testsuite.appendChild(systemout)
-
-        systemout_text = xml_document.createCDATAOrText(stdout)
-        systemout.appendChild(systemout_text)
-
-        systemerr = xml_document.createElement('system-err')
-        xml_testsuite.appendChild(systemerr)
-
-        systemerr_text = xml_document.createCDATAOrText(stderr)
-        systemerr.appendChild(systemerr_text)
-
-    _report_output = staticmethod(_report_output)
-
-    def generate_reports(self, test_runner):
-        "Generates the XML reports to a given XMLTestRunner object."
-        all_results = self._get_info_by_testcase()
-
-        if type(test_runner.output) == str and not \
-            os.path.exists(test_runner.output):
-            os.makedirs(test_runner.output)
-
-        for suite, tests in all_results.items():
-            doc = XMLDocument()
-
-            # Build the XML file
-            testsuite = _XMLTestResult._report_testsuite(suite, tests, doc)
-            stdout, stderr = [], []
-            for test in tests:
-                _XMLTestResult._report_testcase(suite, test, testsuite, doc)
-                if test.stdout:
-                    stdout.extend(['*****************', test.get_description(), test.stdout])
-                if test.stderr:
-                    stderr.extend(['*****************', test.get_description(), test.stderr])
-            _XMLTestResult._report_output(test_runner, testsuite, doc,
-                                          '\n'.join(stdout), '\n'.join(stderr))
-            xml_content = doc.toprettyxml(indent='\t')
-
-            if type(test_runner.output) is str:
-                report_file = open('%s%sTEST-%s.xml' % \
-                    (test_runner.output, os.sep, suite), 'w')
-                try:
-                    report_file.write(xml_content)
-                finally:
-                    report_file.close()
-            else:
-                # Assume that test_runner.output is a stream
-                test_runner.output.write(xml_content)
-
-
-class XMLTestRunner(TextTestRunner):
-    """A test runner class that outputs the results in JUnit like XML files.
-    """
-    def __init__(self, output='.', stream=None, descriptions=True, verbose=False, elapsed_times=True):
-        "Create a new instance of XMLTestRunner."
-        if stream is None:
-            stream = sys.stderr
-        verbosity = (1, 2)[verbose]
-        TextTestRunner.__init__(self, stream, descriptions, verbosity)
-        self.output = output
-        self.elapsed_times = elapsed_times
-
-    def _make_result(self):
-        """Create the TestResult object which will be used to store
-        information about the executed tests.
-        """
-        return _XMLTestResult(self.stream, self.descriptions, \
-            self.verbosity, self.elapsed_times)
-
-    def run(self, test):
-        "Run the given test case or test suite."
-        # Prepare the test execution
-        result = self._make_result()
-
-        # Print a nice header
-        self.stream.writeln()
-        self.stream.writeln('Running tests...')
-        self.stream.writeln(result.separator2)
-
-        # Execute tests
-        start_time = time.time()
-        test(result)
-        stop_time = time.time()
-        time_taken = stop_time - start_time
-
-        # Generate reports
-        self.stream.writeln()
-        self.stream.writeln('Generating XML reports...')
-        result.generate_reports(self)
-
-        # Print results
-        result.printErrors()
-        self.stream.writeln(result.separator2)
-        run = result.testsRun
-        self.stream.writeln("Ran %d test%s in %.3fs" %
-            (run, run != 1 and "s" or "", time_taken))
-        self.stream.writeln()
-
-        # Error traces
-        if not result.wasSuccessful():
-            self.stream.write("FAILED (")
-            failed, errored = (len(result.failures), len(result.errors))
-            if failed:
-                self.stream.write("failures=%d" % failed)
-            if errored:
-                if failed:
-                    self.stream.write(", ")
-                self.stream.write("errors=%d" % errored)
-            self.stream.writeln(")")
-        else:
-            self.stream.writeln("OK")
-
-        return result