← Back to branch summary

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

« back to all changes in this revision

Viewing changes to mozilla/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:
mozilla/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()