1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

import copy, sys, unittest

def reporting(assertion, _self=None):
    def wrapper(*args, **kwargs):
        if _self is None:
            self, args = args[0], args[1:]
        else:
            self = _self

        try:
            args_str = ", ".join([str(arg) for arg in args] + ["%s=%s" % (k, v) for k, v in kwargs.items()])
            ret = assertion(self, *args, **kwargs)
            self._reporting_assertion_successes.append((self,))
            return ret
        except self.failureException:
            selfcopy = copy.copy(self)
            testname, rest = str(self).split(None, 1)
            selfcopy._testMethodDoc = "%s.%s(%s) %s" % (testname, assertion.func_name, args_str, rest)
            self._reporting_assertion_failures.append((selfcopy, self._exc_info()))
            exctype, value, tb = self._exc_info()
        except KeyboardInterrupt:
            raise
        except:
            self._reporting_assertion_errors.append((self, self._exc_info()))
    return wrapper
        

class TestCase(unittest.TestCase):

    def __init__(self, *args, **kwargs):
        super(TestCase, self).__init__(*args, **kwargs)
        self._reporting_assertion_failures = []
        self._reporting_assertion_errors = []
        self._reporting_assertion_successes = []

    def run(self, result=None):

        if result is None: result = self.defaultTestResult()
        result.startTest(self)
        testMethod = getattr(self, self._testMethodName)
        try:
            try:
                self.setUp()
            except KeyboardInterrupt:
                raise
            except:
                result.addError(self, self._exc_info())
                return

            ok = False
            try:
                testMethod()
                ok = not self._reporting_assertion_failures and not self._reporting_assertion_errors

                for failure_args in self._reporting_assertion_failures:
                    result.addFailure(*failure_args)

                for error_args in self._reporting_assertion_errors:
                    result.addError(*error_args)

                for success in self._reporting_assertion_successes:
                    result.addSuccess(self)

            except self.failureException:
                result.addFailure(self, self._exc_info())
            except KeyboardInterrupt:
                raise
            except:
                result.addError(self, self._exc_info())

            try:
                self.tearDown()
            except KeyboardInterrupt:
                raise
            except:
                result.addError(self, self._exc_info())
                ok = False
            if ok: result.addSuccess(self)
        finally:
            result.stopTest(self)