The Tor Browser: build/pymake/tests/formattingtests.py@141e0f1194b1 (annotated)

build/pymake/tests/formattingtests.py@141e0f1194b1 (annotated)

build/pymake/tests/formattingtests.py

Wed, 31 Dec 2014 07:16:47 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:16:47 +0100
branch: TOR_BUG_9701
changeset 3: 141e0f1194b1
permissions: -rw-r--r--

Revert simplistic fix pending revisit of Mozilla integration attempt.

 # This file contains test code for the formatting of parsed statements back to
 # make file "source." It essentially verifies to to_source() functions
 # scattered across the tree.
 import glob
 import logging
 import os.path
 import unittest
 from pymake.data import Expansion
 from pymake.data import StringExpansion
 from pymake.functions import BasenameFunction
 from pymake.functions import SubstitutionRef
 from pymake.functions import VariableRef
 from pymake.functions import WordlistFunction
 from pymake.parserdata import Include
 from pymake.parserdata import SetVariable
 from pymake.parser import parsestring
 from pymake.parser import SyntaxError
 class TestBase(unittest.TestCase):
     pass
 class VariableRefTest(TestBase):
     def test_string_name(self):
         e = StringExpansion('foo', None)
         v = VariableRef(None, e)
         self.assertEqual(v.to_source(), '$(foo)')
     def test_special_variable(self):
         e = StringExpansion('<', None)
         v = VariableRef(None, e)
         self.assertEqual(v.to_source(), '$<')
     def test_expansion_simple(self):
         e = Expansion()
         e.appendstr('foo')
         e.appendstr('bar')
         v = VariableRef(None, e)
         self.assertEqual(v.to_source(), '$(foobar)')
 class StandardFunctionTest(TestBase):
     def test_basename(self):
         e1 = StringExpansion('foo', None)
         v = VariableRef(None, e1)
         e2 = Expansion(None)
         e2.appendfunc(v)
         b = BasenameFunction(None)
         b.append(e2)
         self.assertEqual(b.to_source(), '$(basename $(foo))')
     def test_wordlist(self):
         e1 = StringExpansion('foo', None)
         e2 = StringExpansion('bar ', None)
         e3 = StringExpansion(' baz', None)
         w = WordlistFunction(None)
         w.append(e1)
         w.append(e2)
         w.append(e3)
         self.assertEqual(w.to_source(), '$(wordlist foo,bar , baz)')
     def test_curly_brackets(self):
         e1 = Expansion(None)
         e1.appendstr('foo')
         e2 = Expansion(None)
         e2.appendstr('foo ( bar')
         f = WordlistFunction(None)
         f.append(e1)
         f.append(e2)
         self.assertEqual(f.to_source(), '${wordlist foo,foo ( bar}')
 class StringExpansionTest(TestBase):
     def test_simple(self):
         e = StringExpansion('foobar', None)
         self.assertEqual(e.to_source(), 'foobar')
         e = StringExpansion('$var', None)
         self.assertEqual(e.to_source(), '$var')
     def test_escaping(self):
         e = StringExpansion('$var', None)
         self.assertEqual(e.to_source(escape_variables=True), '$$var')
         e = StringExpansion('this is # not a comment', None)
         self.assertEqual(e.to_source(escape_comments=True),
                          'this is \# not a comment')
     def test_empty(self):
         e = StringExpansion('', None)
         self.assertEqual(e.to_source(), '')
         e = StringExpansion(' ', None)
         self.assertEqual(e.to_source(), ' ')
 class ExpansionTest(TestBase):
     def test_single_string(self):
         e = Expansion()
         e.appendstr('foo')
         self.assertEqual(e.to_source(), 'foo')
     def test_multiple_strings(self):
         e = Expansion()
         e.appendstr('hello')
         e.appendstr('world')
         self.assertEqual(e.to_source(), 'helloworld')
     def test_string_escape(self):
         e = Expansion()
         e.appendstr('$var')
         self.assertEqual(e.to_source(), '$var')
         self.assertEqual(e.to_source(escape_variables=True), '$$var')
         e = Expansion()
         e.appendstr('foo')
         e.appendstr(' $bar')
         self.assertEqual(e.to_source(escape_variables=True), 'foo $$bar')
 class SubstitutionRefTest(TestBase):
     def test_simple(self):
         name = StringExpansion('foo', None)
         c = StringExpansion('%.c', None)
         o = StringExpansion('%.o', None)
         s = SubstitutionRef(None, name, c, o)
         self.assertEqual(s.to_source(), '$(foo:%.c=%.o)')
 class SetVariableTest(TestBase):
     def test_simple(self):
         v = SetVariable(StringExpansion('foo', None), '=', 'bar', None, None)
         self.assertEqual(v.to_source(), 'foo = bar')
     def test_multiline(self):
         s = 'hello\nworld'
         foo = StringExpansion('FOO', None)
         v = SetVariable(foo, '=', s, None, None)
         self.assertEqual(v.to_source(), 'define FOO\nhello\nworld\nendef')
     def test_multiline_immediate(self):
         source = 'define FOO :=\nhello\nworld\nendef'
         statements = parsestring(source, 'foo.mk')
         self.assertEqual(statements.to_source(), source)
     def test_target_specific(self):
         foo = StringExpansion('FOO', None)
         bar = StringExpansion('BAR', None)
         v = SetVariable(foo, '+=', 'value', None, bar)
         self.assertEqual(v.to_source(), 'BAR: FOO += value')
 class IncludeTest(TestBase):
     def test_include(self):
         e = StringExpansion('rules.mk', None)
         i = Include(e, True, False)
         self.assertEqual(i.to_source(), 'include rules.mk')
         i = Include(e, False, False)
         self.assertEqual(i.to_source(), '-include rules.mk')
 class IfdefTest(TestBase):
     def test_simple(self):
         source = 'ifdef FOO\nbar := $(value)\nendif'
         statements = parsestring(source, 'foo.mk')
         self.assertEqual(statements[0].to_source(), source)
     def test_nested(self):
         source = 'ifdef FOO\nifdef BAR\nhello = world\nendif\nendif'
         statements = parsestring(source, 'foo.mk')
         self.assertEqual(statements[0].to_source(), source)
     def test_negation(self):
         source = 'ifndef FOO\nbar += value\nendif'
         statements = parsestring(source, 'foo.mk')
         self.assertEqual(statements[0].to_source(), source)
 class IfeqTest(TestBase):
     def test_simple(self):
         source = 'ifeq ($(foo),bar)\nhello = $(world)\nendif'
         statements = parsestring(source, 'foo.mk')
         self.assertEqual(statements[0].to_source(), source)
     def test_negation(self):
         source = 'ifneq (foo,bar)\nhello = world\nendif'
         statements = parsestring(source, 'foo.mk')
         self.assertEqual(statements.to_source(), source)
 class ConditionBlocksTest(TestBase):
     def test_mixed_conditions(self):
         source = 'ifdef FOO\nifeq ($(FOO),bar)\nvar += $(value)\nendif\nendif'
         statements = parsestring(source, 'foo.mk')
         self.assertEqual(statements.to_source(), source)
     def test_extra_statements(self):
         source = 'ifdef FOO\nF := 1\nifdef BAR\nB += 1\nendif\nC = 1\nendif'
         statements = parsestring(source, 'foo.mk')
         self.assertEqual(statements.to_source(), source)
     def test_whitespace_preservation(self):
         source = "ifeq ' x' 'x '\n$(error stripping)\nendif"
         statements = parsestring(source, 'foo.mk')
         self.assertEqual(statements.to_source(), source)
         source = 'ifneq (x , x)\n$(error stripping)\nendif'
         statements = parsestring(source, 'foo.mk')
         self.assertEqual(statements.to_source(),
                 'ifneq (x,x)\n$(error stripping)\nendif')
 class MakefileCorupusTest(TestBase):
     """Runs the make files from the pymake corpus through the formatter.
     All the above tests are child's play compared to this.
     """
     # Our reformatting isn't perfect. We ignore files with known failures until
     # we make them work.
     # TODO Address these formatting corner cases.
     _IGNORE_FILES = [
         # We are thrown off by backslashes at end of lines.
         'comment-parsing.mk',
         'escape-chars.mk',
         'include-notfound.mk',
     ]
     def _get_test_files(self):
         ourdir = os.path.dirname(os.path.abspath(__file__))
         for makefile in glob.glob(os.path.join(ourdir, '*.mk')):
             if os.path.basename(makefile) in self._IGNORE_FILES:
                 continue
             source = None
             with open(makefile, 'rU') as fh:
                 source = fh.read()
             try:
                 yield (makefile, source, parsestring(source, makefile))
             except SyntaxError:
                 continue
     def test_reparse_consistency(self):
         for filename, source, statements in self._get_test_files():
             reformatted = statements.to_source()
             # We should be able to parse the reformatted source fine.
             new_statements = parsestring(reformatted, filename)
             # If we do the formatting again, the representation shouldn't
             # change. i.e. the only lossy change should be the original
             # (whitespace and some semantics aren't preserved).
             reformatted_again = new_statements.to_source()
             self.assertEqual(reformatted, reformatted_again,
                 '%s has lossless reformat.' % filename)
             self.assertEqual(len(statements), len(new_statements))
             for i in xrange(0, len(statements)):
                 original = statements[i]
                 formatted = new_statements[i]
                 self.assertEqual(original, formatted, '%s %d: %s != %s' % (filename,
                     i, original, formatted))
 if __name__ == '__main__':
     logging.basicConfig(level=logging.DEBUG)
     unittest.main()

The Tor Browser / annotate

build/pymake/tests/formattingtests.py@141e0f1194b1 (annotated)

build/pymake/tests/formattingtests.py