File: run-tests

package info (click to toggle)
libgnatcoll-python 21.0.0-2
  • links: PTS, VCS
  • area: main
  • in suites: sid
  • size: 2,088 kB
  • sloc: ada: 14,431; python: 1,493; ansic: 1,378; makefile: 173; sh: 94
file content (123 lines) | stat: -rwxr-xr-x 4,754 bytes parent folder | download | duplicates (4)
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#!/usr/bin/python2
from drivers import make_gnatcoll, TESTSUITE_ROOT_DIR
from drivers.basic import BasicTestDriver
from drivers.json_validation import JSONValidationDriver
from drivers.data_validation import DataValidationDriver
from e3.testsuite import Testsuite
from e3.fs import mkdir, ls, find
from e3.os.process import Run
import re
import os
import logging


class MyTestsuite(Testsuite):
    CROSS_SUPPORT = True
    TEST_SUBDIR = 'tests'
    DRIVERS = {
        'json_validation': JSONValidationDriver,
        'data_validation': DataValidationDriver,
        'default': BasicTestDriver}

    def add_options(self):
        self.main.argument_parser.add_argument(
            '--gcov',
            help="compute testsuite coverage of gnatcoll",
            default=False,
            action="store_true")
        self.main.argument_parser.add_argument(
            '--valgrind',
            help="check memory usage with Valgrind (memcheck tool)",
            action="store_true")
        self.main.argument_parser.add_argument(
            '--recompile',
            help="recompile production version of gnatcoll for testing",
            default=False,
            action="store_true")

    def tear_up(self):
        self.env.gcov = self.main.args.gcov
        self.env.valgrind = self.main.args.valgrind
        self.env.enable_cleanup = self.main.args.enable_cleanup
        if self.main.args.gcov:
            work_dir = os.path.join(TESTSUITE_ROOT_DIR, 'gcov')
            gpr_dir, src_dir, obj_dir = make_gnatcoll(work_dir, gcov=True)
            self.env.gnatcoll_gpr_dir = gpr_dir
            self.env.gnatcoll_src_dir = src_dir
            self.env.gnatcoll_obj_dir = obj_dir
        else:
            self.env.gnatcoll_gpr_dir = None

        if self.main.args.recompile:
            work_dir = os.path.join(TESTSUITE_ROOT_DIR, 'prod')
            gpr_dir, _, _ = make_gnatcoll(work_dir, gcov=False)
            self.env.gnatcoll_prod_gpr_dir = gpr_dir
            if self.env.gnatcoll_gpr_dir is None:
                self.env.gnatcoll_gpr_dir = gpr_dir
        else:
            self.env.gnatcoll_prod_gpr_dir = None

    def tear_down(self):
        if self.main.args.gcov:
            wd = TESTSUITE_ROOT_DIR

            # We need to call gcov on gcda present both in gnatcoll itself and
            # tests (for generics coverage).
            gcda_files = \
                find(os.path.join(self.env.gnatcoll_obj_dir), '*.gcda') + \
                find(os.path.join(self.env.working_dir), '*.gcda')
            mkdir(os.path.join(wd, 'gcov', 'results'))
            gcr = os.path.join(wd, 'gcov', 'results')
            Run(['gcov'] + gcda_files,
                cwd=os.path.join(wd, 'gcov', 'results'))
            total_sources = 0
            total_covered = 0

            for source_file in ls(
                    os.path.join(self.env.gnatcoll_src_dir, '*', '*')):
                base_file = os.path.basename(source_file)
                if not os.path.isfile(os.path.join(gcr, base_file + '.gcov')):
                    total = 1
                    covered = 0
                    with open(source_file) as fd:
                        total = len([line for line in fd
                                     if line.strip() and
                                     not re.match(r' *--', line)])
                else:
                    with open(os.path.join(gcr, base_file + '.gcov')) as fd:
                        total = 0
                        covered = 0
                        for line in fd:
                            if re.match(r' *-:', line):
                                pass
                            elif re.match(r' *[#=]{5}:', line):
                                total += 1
                            else:
                                total += 1
                                covered += 1
                total_sources += total
                total_covered += covered

                logging.info('%6.2f %% %8d/%-8d %s',
                             float(covered) * 100.0 / float(total),
                             covered,
                             total,
                             os.path.basename(source_file))

            logging.info('%6.2f %% %8d/%-8d %s',
                         float(total_covered) * 100.0 / float(total_sources),
                         total_covered,
                         total_sources,
                         'TOTAL')
        super(MyTestsuite, self).tear_down()

    @property
    def default_driver(self):
        return 'default'


if __name__ == '__main__':
    suite = MyTestsuite(os.path.dirname(__file__))
    suite.testsuite_main()
    for k, v in suite.test_status_counters.iteritems():
        print '%-24s: %d' % (k, v)