← Back to branch summary

~ubuntu-branches/ubuntu/quantal/enigmail/quantal-security

« back to all changes in this revision

Viewing changes to build/pymake/tests/formattingtests.py

  • Committer: Package Import Robot
  • Author(s): Chris Coulson
  • Date: 2013-09-13 16:02:15 UTC
  • mfrom: (0.12.16)
  • Revision ID: package-import@ubuntu.com-20130913160215-u3g8nmwa0pdwagwc
Tags: 2:1.5.2-0ubuntu0.12.10.1
* New upstream release v1.5.2 for Thunderbird 24

* Build enigmail using a stripped down Thunderbird 17 build system, as it's
  now quite difficult to build the way we were doing previously, with the
  latest Firefox build system
* Add debian/patches/no_libxpcom.patch - Don't link against libxpcom, as it
  doesn't exist anymore (but exists in the build system)
* Add debian/patches/use_sdk.patch - Use the SDK version of xpt.py and
  friends
* Drop debian/patches/ipc-pipe_rename.diff (not needed anymore)
* Drop debian/patches/makefile_depth.diff (not needed anymore)

Show diffs side-by-side

added added

removed removed

Lines of Context:
build/pymake/tests/formattingtests.py
1
 
# This file contains test code for the formatting of parsed statements back to
2
 
# make file "source." It essentially verifies to to_source() functions
3
 
# scattered across the tree.
4
 
 
5
 
import glob
6
 
import logging
7
 
import os.path
8
 
import unittest
9
 
 
10
 
from pymake.data import Expansion
11
 
from pymake.data import StringExpansion
12
 
from pymake.functions import BasenameFunction
13
 
from pymake.functions import SubstitutionRef
14
 
from pymake.functions import VariableRef
15
 
from pymake.functions import WordlistFunction
16
 
from pymake.parserdata import Include
17
 
from pymake.parserdata import SetVariable
18
 
from pymake.parser import parsestring
19
 
from pymake.parser import SyntaxError
20
 
 
21
 
class TestBase(unittest.TestCase):
22
 
    pass
23
 
 
24
 
class VariableRefTest(TestBase):
25
 
    def test_string_name(self):
26
 
        e = StringExpansion('foo', None)
27
 
        v = VariableRef(None, e)
28
 
 
29
 
        self.assertEqual(v.to_source(), '$(foo)')
30
 
 
31
 
    def test_special_variable(self):
32
 
        e = StringExpansion('<', None)
33
 
        v = VariableRef(None, e)
34
 
 
35
 
        self.assertEqual(v.to_source(), '$<')
36
 
 
37
 
    def test_expansion_simple(self):
38
 
        e = Expansion()
39
 
        e.appendstr('foo')
40
 
        e.appendstr('bar')
41
 
 
42
 
        v = VariableRef(None, e)
43
 
 
44
 
        self.assertEqual(v.to_source(), '$(foobar)')
45
 
 
46
 
class StandardFunctionTest(TestBase):
47
 
    def test_basename(self):
48
 
        e1 = StringExpansion('foo', None)
49
 
        v = VariableRef(None, e1)
50
 
        e2 = Expansion(None)
51
 
        e2.appendfunc(v)
52
 
 
53
 
        b = BasenameFunction(None)
54
 
        b.append(e2)
55
 
 
56
 
        self.assertEqual(b.to_source(), '$(basename $(foo))')
57
 
 
58
 
    def test_wordlist(self):
59
 
        e1 = StringExpansion('foo', None)
60
 
        e2 = StringExpansion('bar ', None)
61
 
        e3 = StringExpansion(' baz', None)
62
 
 
63
 
        w = WordlistFunction(None)
64
 
        w.append(e1)
65
 
        w.append(e2)
66
 
        w.append(e3)
67
 
 
68
 
        self.assertEqual(w.to_source(), '$(wordlist foo,bar , baz)')
69
 
 
70
 
    def test_curly_brackets(self):
71
 
        e1 = Expansion(None)
72
 
        e1.appendstr('foo')
73
 
 
74
 
        e2 = Expansion(None)
75
 
        e2.appendstr('foo ( bar')
76
 
 
77
 
        f = WordlistFunction(None)
78
 
        f.append(e1)
79
 
        f.append(e2)
80
 
 
81
 
        self.assertEqual(f.to_source(), '${wordlist foo,foo ( bar}')
82
 
 
83
 
class StringExpansionTest(TestBase):
84
 
    def test_simple(self):
85
 
        e = StringExpansion('foobar', None)
86
 
        self.assertEqual(e.to_source(), 'foobar')
87
 
 
88
 
        e = StringExpansion('$var', None)
89
 
        self.assertEqual(e.to_source(), '$var')
90
 
 
91
 
    def test_escaping(self):
92
 
        e = StringExpansion('$var', None)
93
 
        self.assertEqual(e.to_source(escape_variables=True), '$$var')
94
 
 
95
 
        e = StringExpansion('this is # not a comment', None)
96
 
        self.assertEqual(e.to_source(escape_comments=True),
97
 
                         'this is \# not a comment')
98
 
 
99
 
    def test_empty(self):
100
 
        e = StringExpansion('', None)
101
 
        self.assertEqual(e.to_source(), '')
102
 
 
103
 
        e = StringExpansion(' ', None)
104
 
        self.assertEqual(e.to_source(), ' ')
105
 
 
106
 
class ExpansionTest(TestBase):
107
 
    def test_single_string(self):
108
 
        e = Expansion()
109
 
        e.appendstr('foo')
110
 
 
111
 
        self.assertEqual(e.to_source(), 'foo')
112
 
 
113
 
    def test_multiple_strings(self):
114
 
        e = Expansion()
115
 
        e.appendstr('hello')
116
 
        e.appendstr('world')
117
 
 
118
 
        self.assertEqual(e.to_source(), 'helloworld')
119
 
 
120
 
    def test_string_escape(self):
121
 
        e = Expansion()
122
 
        e.appendstr('$var')
123
 
        self.assertEqual(e.to_source(), '$var')
124
 
        self.assertEqual(e.to_source(escape_variables=True), '$$var')
125
 
 
126
 
        e = Expansion()
127
 
        e.appendstr('foo')
128
 
        e.appendstr(' $bar')
129
 
        self.assertEqual(e.to_source(escape_variables=True), 'foo $$bar')
130
 
 
131
 
class SubstitutionRefTest(TestBase):
132
 
    def test_simple(self):
133
 
        name = StringExpansion('foo', None)
134
 
        c = StringExpansion('%.c', None)
135
 
        o = StringExpansion('%.o', None)
136
 
        s = SubstitutionRef(None, name, c, o)
137
 
 
138
 
        self.assertEqual(s.to_source(), '$(foo:%.c=%.o)')
139
 
 
140
 
class SetVariableTest(TestBase):
141
 
    def test_simple(self):
142
 
        v = SetVariable(StringExpansion('foo', None), '=', 'bar', None, None)
143
 
        self.assertEqual(v.to_source(), 'foo = bar')
144
 
 
145
 
    def test_multiline(self):
146
 
        s = 'hello\nworld'
147
 
        foo = StringExpansion('FOO', None)
148
 
 
149
 
        v = SetVariable(foo, '=', s, None, None)
150
 
 
151
 
        self.assertEqual(v.to_source(), 'define FOO\nhello\nworld\nendef')
152
 
 
153
 
    def test_multiline_immediate(self):
154
 
        source = 'define FOO :=\nhello\nworld\nendef'
155
 
 
156
 
        statements = parsestring(source, 'foo.mk')
157
 
        self.assertEqual(statements.to_source(), source)
158
 
 
159
 
    def test_target_specific(self):
160
 
        foo = StringExpansion('FOO', None)
161
 
        bar = StringExpansion('BAR', None)
162
 
 
163
 
        v = SetVariable(foo, '+=', 'value', None, bar)
164
 
 
165
 
        self.assertEqual(v.to_source(), 'BAR: FOO += value')
166
 
 
167
 
class IncludeTest(TestBase):
168
 
    def test_include(self):
169
 
        e = StringExpansion('rules.mk', None)
170
 
        i = Include(e, True, False)
171
 
        self.assertEqual(i.to_source(), 'include rules.mk')
172
 
 
173
 
        i = Include(e, False, False)
174
 
        self.assertEqual(i.to_source(), '-include rules.mk')
175
 
 
176
 
class IfdefTest(TestBase):
177
 
    def test_simple(self):
178
 
        source = 'ifdef FOO\nbar := $(value)\nendif'
179
 
 
180
 
        statements = parsestring(source, 'foo.mk')
181
 
        self.assertEqual(statements[0].to_source(), source)
182
 
 
183
 
    def test_nested(self):
184
 
        source = 'ifdef FOO\nifdef BAR\nhello = world\nendif\nendif'
185
 
 
186
 
        statements = parsestring(source, 'foo.mk')
187
 
        self.assertEqual(statements[0].to_source(), source)
188
 
 
189
 
    def test_negation(self):
190
 
        source = 'ifndef FOO\nbar += value\nendif'
191
 
 
192
 
        statements = parsestring(source, 'foo.mk')
193
 
        self.assertEqual(statements[0].to_source(), source)
194
 
 
195
 
class IfeqTest(TestBase):
196
 
    def test_simple(self):
197
 
        source = 'ifeq ($(foo),bar)\nhello = $(world)\nendif'
198
 
 
199
 
        statements = parsestring(source, 'foo.mk')
200
 
        self.assertEqual(statements[0].to_source(), source)
201
 
 
202
 
    def test_negation(self):
203
 
        source = 'ifneq (foo,bar)\nhello = world\nendif'
204
 
 
205
 
        statements = parsestring(source, 'foo.mk')
206
 
        self.assertEqual(statements.to_source(), source)
207
 
 
208
 
class ConditionBlocksTest(TestBase):
209
 
    def test_mixed_conditions(self):
210
 
        source = 'ifdef FOO\nifeq ($(FOO),bar)\nvar += $(value)\nendif\nendif'
211
 
 
212
 
        statements = parsestring(source, 'foo.mk')
213
 
        self.assertEqual(statements.to_source(), source)
214
 
 
215
 
    def test_extra_statements(self):
216
 
        source = 'ifdef FOO\nF := 1\nifdef BAR\nB += 1\nendif\nC = 1\nendif'
217
 
 
218
 
        statements = parsestring(source, 'foo.mk')
219
 
        self.assertEqual(statements.to_source(), source)
220
 
 
221
 
    def test_whitespace_preservation(self):
222
 
        source = "ifeq ' x' 'x '\n$(error stripping)\nendif"
223
 
 
224
 
        statements = parsestring(source, 'foo.mk')
225
 
        self.assertEqual(statements.to_source(), source)
226
 
 
227
 
        source = 'ifneq (x , x)\n$(error stripping)\nendif'
228
 
        statements = parsestring(source, 'foo.mk')
229
 
        self.assertEqual(statements.to_source(),
230
 
                'ifneq (x,x)\n$(error stripping)\nendif')
231
 
 
232
 
class MakefileCorupusTest(TestBase):
233
 
    """Runs the make files from the pymake corpus through the formatter.
234
 
 
235
 
    All the above tests are child's play compared to this.
236
 
    """
237
 
 
238
 
    # Our reformatting isn't perfect. We ignore files with known failures until
239
 
    # we make them work.
240
 
    # TODO Address these formatting corner cases.
241
 
    _IGNORE_FILES = [
242
 
        # We are thrown off by backslashes at end of lines.
243
 
        'comment-parsing.mk',
244
 
        'escape-chars.mk',
245
 
        'include-notfound.mk',
246
 
    ]
247
 
 
248
 
    def _get_test_files(self):
249
 
        ourdir = os.path.dirname(os.path.abspath(__file__))
250
 
 
251
 
        for makefile in glob.glob(os.path.join(ourdir, '*.mk')):
252
 
            if os.path.basename(makefile) in self._IGNORE_FILES:
253
 
                continue
254
 
 
255
 
            source = None
256
 
            with open(makefile, 'rU') as fh:
257
 
                source = fh.read()
258
 
 
259
 
            try:
260
 
                yield (makefile, source, parsestring(source, makefile))
261
 
            except SyntaxError:
262
 
                continue
263
 
 
264
 
    def test_reparse_consistency(self):
265
 
        for filename, source, statements in self._get_test_files():
266
 
            reformatted = statements.to_source()
267
 
 
268
 
            # We should be able to parse the reformatted source fine.
269
 
            new_statements = parsestring(reformatted, filename)
270
 
 
271
 
            # If we do the formatting again, the representation shouldn't
272
 
            # change. i.e. the only lossy change should be the original
273
 
            # (whitespace and some semantics aren't preserved).
274
 
            reformatted_again = new_statements.to_source()
275
 
            self.assertEqual(reformatted, reformatted_again,
276
 
                '%s has lossless reformat.' % filename)
277
 
 
278
 
            self.assertEqual(len(statements), len(new_statements))
279
 
 
280
 
            for i in xrange(0, len(statements)):
281
 
                original = statements[i]
282
 
                formatted = new_statements[i]
283
 
 
284
 
                self.assertEqual(original, formatted, '%s %d: %s != %s' % (filename,
285
 
                    i, original, formatted))
286
 
 
287
 
if __name__ == '__main__':
288
 
    logging.basicConfig(level=logging.DEBUG)
289
 
    unittest.main()