~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_source.py

  • Committer: Andrew Bennetts
  • Date: 2010-01-12 03:53:21 UTC
  • mfrom: (4948 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4964.
  • Revision ID: andrew.bennetts@canonical.com-20100112035321-hofpz5p10224ryj3
Merge lp:bzr, resolving conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2008 Canonical Ltd
2
 
#   Authors: Robert Collins <robert.collins@canonical.com>
3
 
#            and others
 
1
# Copyright (C) 2005, 2006, 2008, 2009 Canonical Ltd
4
2
#
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
14
12
#
15
13
# You should have received a copy of the GNU General Public License
16
14
# along with this program; if not, write to the Free Software
17
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
16
 
19
17
"""These tests are tests about the source code of bzrlib itself.
20
18
 
25
23
import os
26
24
import parser
27
25
import re
28
 
from cStringIO import StringIO
29
26
import symbol
30
27
import sys
31
28
import token
32
29
 
33
30
#import bzrlib specific imports here
34
31
from bzrlib import (
35
 
    diff,
36
32
    osutils,
37
 
    patiencediff,
38
 
    textfile,
39
33
    )
40
34
import bzrlib.branch
41
35
from bzrlib.tests import (
42
 
    KnownFailure,
43
36
    TestCase,
44
37
    TestSkipped,
45
38
    )
46
 
from bzrlib.workingtree import WorkingTree
47
39
 
48
40
 
49
41
# Files which are listed here will be skipped when testing for Copyright (or
50
42
# GPL) statements.
51
 
COPYRIGHT_EXCEPTIONS = ['bzrlib/lsprof.py']
 
43
COPYRIGHT_EXCEPTIONS = ['bzrlib/lsprof.py', 'bzrlib/_bencode_py.py',
 
44
    'bzrlib/doc_generate/sphinx_conf.py']
52
45
 
53
 
LICENSE_EXCEPTIONS = ['bzrlib/lsprof.py']
 
46
LICENSE_EXCEPTIONS = ['bzrlib/lsprof.py', 'bzrlib/_bencode_py.py',
 
47
    'bzrlib/doc_generate/sphinx_conf.py']
54
48
# Technically, 'bzrlib/lsprof.py' should be 'bzrlib/util/lsprof.py',
55
49
# (we do not check bzrlib/util/, since that is code bundled from elsewhere)
56
50
# but for compatibility with previous releases, we don't want to move it.
57
 
 
58
 
 
59
 
def check_coding_style(old_filename, oldlines, new_filename, newlines, to_file,
60
 
                  allow_binary=False, sequence_matcher=None,
61
 
                  path_encoding='utf8'):
62
 
    """text_differ to be passed to diff.DiffText, which checks code style """
63
 
    if allow_binary is False:
64
 
        textfile.check_text_lines(oldlines)
65
 
        textfile.check_text_lines(newlines)
66
 
 
67
 
    if sequence_matcher is None:
68
 
        sequence_matcher = patiencediff.PatienceSequenceMatcher
69
 
 
70
 
    started = [False] #trick to access parent scoped variable
71
 
    def start_if_needed():
72
 
        if not started[0]:
73
 
            to_file.write('+++ %s\n' % new_filename)
74
 
            started[0] = True
75
 
 
76
 
    def check_newlines(j1, j2):
77
 
        for i, line in enumerate(newlines[j1:j2]):
78
 
            bad_ws_match = re.match(r'^(([\t]*)(.*?)([\t ]*))(\r?\n)?$', line)
79
 
            if bad_ws_match:
80
 
                line_content = bad_ws_match.group(1)
81
 
                has_leading_tabs = bool(bad_ws_match.group(2))
82
 
                has_trailing_whitespace = bool(bad_ws_match.group(4))
83
 
                if has_leading_tabs:
84
 
                    start_if_needed()
85
 
                    to_file.write('line %i has leading tabs: "%s"\n'% (
86
 
                        i+1+j1, line_content))
87
 
                if has_trailing_whitespace:
88
 
                    start_if_needed()
89
 
                    to_file.write('line %i has trailing whitespace: "%s"\n'% (
90
 
                        i+1+j1, line_content))
91
 
                if len(line_content) > 79:
92
 
                    print (
93
 
                        '\nFile %s\nline %i is longer than 79 characters:'
94
 
                        '\n"%s"'% (new_filename, i+1+j1, line_content))
95
 
 
96
 
    for group in sequence_matcher(None, oldlines, newlines
97
 
            ).get_grouped_opcodes(0):
98
 
        for tag, i1, i2, j1, j2 in group:
99
 
            if tag == 'replace' or tag == 'insert':
100
 
                check_newlines(j1, j2)
101
 
 
102
 
    if len(newlines) == j2 and not newlines[j2-1].endswith('\n'):
103
 
        start_if_needed()
104
 
        to_file.write("\\ No newline at end of file\n")
 
51
#
 
52
# sphinx_conf is semi-autogenerated.
105
53
 
106
54
 
107
55
class TestSourceHelper(TestCase):
135
83
        # do not even think of increasing this number. If you think you need to
136
84
        # increase it, then you almost certainly are doing something wrong as
137
85
        # the relationship from working_tree to branch is one way.
138
 
        # Note that this is an exact equality so that when the number drops, 
 
86
        # Note that this is an exact equality so that when the number drops,
139
87
        #it is not given a buffer but rather has this test updated immediately.
140
88
        self.assertEqual(0, occurences)
141
89
 
163
111
                              % source_dir)
164
112
        return source_dir
165
113
 
166
 
    def get_source_files(self):
 
114
    def get_source_files(self, extensions=None):
167
115
        """Yield all source files for bzr and bzrlib
168
 
        
 
116
 
169
117
        :param our_files_only: If true, exclude files from included libraries
170
118
            or plugins.
171
119
        """
172
120
        bzrlib_dir = self.get_bzrlib_dir()
 
121
        if extensions is None:
 
122
            extensions = ('.py',)
173
123
 
174
124
        # This is the front-end 'bzr' script
175
125
        bzr_path = self.get_bzr_path()
180
130
                if d.endswith('.tmp'):
181
131
                    dirs.remove(d)
182
132
            for f in files:
183
 
                if not f.endswith('.py'):
 
133
                for extension in extensions:
 
134
                    if f.endswith(extension):
 
135
                        break
 
136
                else:
 
137
                    # Did not match the accepted extensions
184
138
                    continue
185
139
                yield osutils.pathjoin(root, f)
186
140
 
187
 
    def get_source_file_contents(self):
188
 
        for fname in self.get_source_files():
 
141
    def get_source_file_contents(self, extensions=None):
 
142
        for fname in self.get_source_files(extensions=extensions):
189
143
            f = open(fname, 'rb')
190
144
            try:
191
145
                text = f.read()
229
183
                          % filename)
230
184
 
231
185
    def test_copyright(self):
232
 
        """Test that all .py files have a valid copyright statement"""
233
 
        # These are files which contain a different copyright statement
234
 
        # and that is okay.
 
186
        """Test that all .py and .pyx files have a valid copyright statement"""
235
187
        incorrect = []
236
188
 
237
189
        copyright_re = re.compile('#\\s*copyright.*(?=\n)', re.I)
241
193
            r'.*Canonical Ltd' # And containing 'Canonical Ltd'
242
194
            )
243
195
 
244
 
        for fname, text in self.get_source_file_contents():
 
196
        for fname, text in self.get_source_file_contents(
 
197
                extensions=('.py', '.pyx')):
245
198
            if self.is_copyright_exception(fname):
246
199
                continue
247
200
            match = copyright_canonical_re.search(text)
276
229
            self.fail('\n'.join(help_text))
277
230
 
278
231
    def test_gpl(self):
279
 
        """Test that all .py files have a GPL disclaimer"""
 
232
        """Test that all .py and .pyx files have a GPL disclaimer."""
280
233
        incorrect = []
281
234
 
282
235
        gpl_txt = """
292
245
#
293
246
# You should have received a copy of the GNU General Public License
294
247
# along with this program; if not, write to the Free Software
295
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
248
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
296
249
"""
297
250
        gpl_re = re.compile(re.escape(gpl_txt), re.MULTILINE)
298
251
 
299
 
        for fname, text in self.get_source_file_contents():
 
252
        for fname, text in self.get_source_file_contents(
 
253
                extensions=('.py', '.pyx')):
300
254
            if self.is_license_exception(fname):
301
255
                continue
302
256
            if not gpl_re.search(text):
316
270
 
317
271
            self.fail('\n'.join(help_text))
318
272
 
319
 
    def test_no_tabs(self):
320
 
        """bzrlib source files should not contain any tab characters."""
321
 
        incorrect = []
322
 
 
323
 
        for fname, text in self.get_source_file_contents():
324
 
            if not self.is_our_code(fname):
325
 
                continue
326
 
            if '\t' in text:
327
 
                incorrect.append(fname)
328
 
 
329
 
        if incorrect:
330
 
            self.fail('Tab characters were found in the following source files.'
331
 
              '\nThey should either be replaced by "\\t" or by spaces:'
332
 
              '\n\n    %s'
333
 
              % ('\n    '.join(incorrect)))
 
273
    def _push_file(self, dict_, fname, line_no):
 
274
        if fname not in dict_:
 
275
            dict_[fname] = [line_no]
 
276
        else:
 
277
            dict_[fname].append(line_no)
 
278
 
 
279
    def _format_message(self, dict_, message):
 
280
        files = ["%s: %s" % (f, ', '.join([str(i+1) for i in lines]))
 
281
                for f, lines in dict_.items()]
 
282
        files.sort()
 
283
        return message + '\n\n    %s' % ('\n    '.join(files))
334
284
 
335
285
    def test_coding_style(self):
336
 
        """ Check if bazaar code conforms to some coding style conventions.
 
286
        """Check if bazaar code conforms to some coding style conventions.
337
287
 
338
 
        Currently we check all .py files for:
339
 
         * new trailing white space
340
 
         * new leading tabs
341
 
         * new long lines (give warning only)
 
288
        Currently we assert that the following is not present:
 
289
         * any tab characters
 
290
         * non-unix newlines
342
291
         * no newline at end of files
 
292
 
 
293
        Print how many files have
 
294
         * trailing white space
 
295
         * lines longer than 79 chars
343
296
        """
344
 
        bzr_dir = osutils.dirname(self.get_bzrlib_dir())
345
 
        try:
346
 
            wt = WorkingTree.open(bzr_dir)
347
 
        except:
348
 
            raise TestSkipped(
349
 
                'Could not open bazaar working tree %s'
350
 
                % bzr_dir)
351
 
        diff_output = StringIO()
352
 
        wt.lock_read()
353
 
        try:
354
 
            new_tree = wt
355
 
            old_tree = new_tree.basis_tree()
356
 
 
357
 
            old_tree.lock_read()
358
 
            new_tree.lock_read()
359
 
            try:
360
 
                iterator = new_tree.iter_changes(old_tree)
361
 
                for (file_id, paths, changed_content, versioned, parent,
362
 
                    name, kind, executable) in iterator:
363
 
                    if (changed_content and paths[1].endswith('.py')):
364
 
                        if kind == ('file', 'file'):
365
 
                            diff_text = diff.DiffText(old_tree, new_tree,
366
 
                                to_file=diff_output,
367
 
                                text_differ=check_coding_style)
368
 
                            diff_text.diff(file_id, paths[0], paths[1],
369
 
                                kind[0], kind[1])
370
 
                        else:
371
 
                            check_coding_style(name[0], (), name[1],
372
 
                                new_tree.get_file(file_id).readlines(),
373
 
                                diff_output)
374
 
            finally:
375
 
                old_tree.unlock()
376
 
                new_tree.unlock()
377
 
        finally:
378
 
            wt.unlock()
379
 
        if len(diff_output.getvalue()) > 0:
380
 
            self.fail("Unacceptable coding style:\n" + diff_output.getvalue())
 
297
        tabs = {}
 
298
        trailing_ws = {}
 
299
        illegal_newlines = {}
 
300
        long_lines = {}
 
301
        no_newline_at_eof = []
 
302
        for fname, text in self.get_source_file_contents(
 
303
                extensions=('.py', '.pyx')):
 
304
            if not self.is_our_code(fname):
 
305
                continue
 
306
            lines = text.splitlines(True)
 
307
            last_line_no = len(lines) - 1
 
308
            for line_no, line in enumerate(lines):
 
309
                if '\t' in line:
 
310
                    self._push_file(tabs, fname, line_no)
 
311
                if not line.endswith('\n') or line.endswith('\r\n'):
 
312
                    if line_no != last_line_no: # not no_newline_at_eof
 
313
                        self._push_file(illegal_newlines, fname, line_no)
 
314
                if line.endswith(' \n'):
 
315
                    self._push_file(trailing_ws, fname, line_no)
 
316
                if len(line) > 80:
 
317
                    self._push_file(long_lines, fname, line_no)
 
318
            if not lines[-1].endswith('\n'):
 
319
                no_newline_at_eof.append(fname)
 
320
        problems = []
 
321
        if tabs:
 
322
            problems.append(self._format_message(tabs,
 
323
                'Tab characters were found in the following source files.'
 
324
                '\nThey should either be replaced by "\\t" or by spaces:'))
 
325
        if trailing_ws:
 
326
            print ("There are %i lines with trailing white space in %i files."
 
327
                % (sum([len(lines) for f, lines in trailing_ws.items()]),
 
328
                    len(trailing_ws)))
 
329
        if illegal_newlines:
 
330
            problems.append(self._format_message(illegal_newlines,
 
331
                'Non-unix newlines were found in the following source files:'))
 
332
        if long_lines:
 
333
            print ("There are %i lines longer than 79 characters in %i files."
 
334
                % (sum([len(lines) for f, lines in long_lines.items()]),
 
335
                    len(long_lines)))
 
336
        if no_newline_at_eof:
 
337
            no_newline_at_eof.sort()
 
338
            problems.append("The following source files doesn't have a "
 
339
                "newline at the end:"
 
340
               '\n\n    %s'
 
341
               % ('\n    '.join(no_newline_at_eof)))
 
342
        if problems:
 
343
            self.fail('\n\n'.join(problems))
381
344
 
382
345
    def test_no_asserts(self):
383
346
        """bzr shouldn't use the 'assert' statement."""
396
359
                    return True
397
360
            return False
398
361
        badfiles = []
 
362
        assert_re = re.compile(r'\bassert\b')
399
363
        for fname, text in self.get_source_file_contents():
400
364
            if not self.is_our_code(fname):
401
365
                continue
402
 
            ast = parser.ast2tuple(parser.suite(''.join(text)))
 
366
            if not assert_re.search(text):
 
367
                continue
 
368
            ast = parser.ast2tuple(parser.suite(text))
403
369
            if search(ast):
404
370
                badfiles.append(fname)
405
371
        if badfiles:
406
372
            self.fail(
407
373
                "these files contain an assert statement and should not:\n%s"
408
374
                % '\n'.join(badfiles))
 
375
 
 
376
    def test_extension_exceptions(self):
 
377
        """Extension functions should propagate exceptions.
 
378
 
 
379
        Either they should return an object, have an 'except' clause, or have a
 
380
        "# cannot_raise" to indicate that we've audited them and defined them as not
 
381
        raising exceptions.
 
382
        """
 
383
        both_exc_and_no_exc = []
 
384
        missing_except = []
 
385
        class_re = re.compile(r'^(cdef\s+)?(public\s+)?(api\s+)?class (\w+).*:',
 
386
                              re.MULTILINE)
 
387
        except_re = re.compile(r'cdef\s+' # start with cdef
 
388
                               r'([\w *]*?)\s*' # this is the return signature
 
389
                               r'(\w+)\s*\(' # the function name
 
390
                               r'[^)]*\)\s*' # parameters
 
391
                               r'(.*)\s*:' # the except clause
 
392
                               r'\s*(#\s*cannot[- _]raise)?' # cannot raise comment
 
393
                              )
 
394
        for fname, text in self.get_source_file_contents(
 
395
                extensions=('.pyx',)):
 
396
            known_classes = set([m[-1] for m in class_re.findall(text)])
 
397
            cdefs = except_re.findall(text)
 
398
            for sig, func, exc_clause, no_exc_comment in cdefs:
 
399
                if sig.startswith('api '):
 
400
                    sig = sig[4:]
 
401
                if not sig or sig in known_classes:
 
402
                    sig = 'object'
 
403
                if 'nogil' in exc_clause:
 
404
                    exc_clause = exc_clause.replace('nogil', '').strip()
 
405
                if exc_clause and no_exc_comment:
 
406
                    both_exc_and_no_exc.append((fname, func))
 
407
                if sig != 'object' and not (exc_clause or no_exc_comment):
 
408
                    missing_except.append((fname, func))
 
409
        error_msg = []
 
410
        if both_exc_and_no_exc:
 
411
            error_msg.append('The following functions had "cannot raise" comments'
 
412
                             ' but did have an except clause set:')
 
413
            for fname, func in both_exc_and_no_exc:
 
414
                error_msg.append('%s:%s' % (fname, func))
 
415
            error_msg.extend(('', ''))
 
416
        if missing_except:
 
417
            error_msg.append('The following functions have fixed return types,'
 
418
                             ' but no except clause.')
 
419
            error_msg.append('Either add an except or append "# cannot_raise".')
 
420
            for fname, func in missing_except:
 
421
                error_msg.append('%s:%s' % (fname, func))
 
422
            error_msg.extend(('', ''))
 
423
        if error_msg:
 
424
            self.fail('\n'.join(error_msg))