зеркало из https://github.com/mozilla/gecko-dev.git
315 строки
11 KiB
Python
315 строки
11 KiB
Python
import pymake.data, pymake.parser, pymake.parserdata, pymake.functions
|
|
import unittest
|
|
import logging
|
|
|
|
from cStringIO import StringIO
|
|
|
|
def multitest(cls):
|
|
for name in cls.testdata.iterkeys():
|
|
def m(self, name=name):
|
|
return self.runSingle(*self.testdata[name])
|
|
|
|
setattr(cls, 'test_%s' % name, m)
|
|
return cls
|
|
|
|
class TestBase(unittest.TestCase):
|
|
def assertEqual(self, a, b, msg=""):
|
|
"""Actually print the values which weren't equal, if things don't work out!"""
|
|
unittest.TestCase.assertEqual(self, a, b, "%s got %r expected %r" % (msg, a, b))
|
|
|
|
class DataTest(TestBase):
|
|
testdata = {
|
|
'oneline':
|
|
("He\tllo", "f", 1, 0,
|
|
((0, "f", 1, 0), (2, "f", 1, 2), (3, "f", 1, 4))),
|
|
'twoline':
|
|
("line1 \n\tl\tine2", "f", 1, 4,
|
|
((0, "f", 1, 4), (5, "f", 1, 9), (6, "f", 1, 10), (7, "f", 2, 0), (8, "f", 2, 4), (10, "f", 2, 8), (13, "f", 2, 11))),
|
|
}
|
|
|
|
def runSingle(self, data, filename, line, col, results):
|
|
d = pymake.parser.Data(data, 0, len(data), pymake.parserdata.Location(filename, line, col))
|
|
for pos, file, lineno, col in results:
|
|
loc = d.getloc(pos)
|
|
self.assertEqual(loc.path, file, "data file offset %i" % pos)
|
|
self.assertEqual(loc.line, lineno, "data line offset %i" % pos)
|
|
self.assertEqual(loc.column, col, "data col offset %i" % pos)
|
|
multitest(DataTest)
|
|
|
|
class LineEnumeratorTest(TestBase):
|
|
testdata = {
|
|
'simple': (
|
|
'Hello, world', [
|
|
('Hello, world', 1),
|
|
]
|
|
),
|
|
'multi': (
|
|
'Hello\nhappy \n\nworld\n', [
|
|
('Hello', 1),
|
|
('happy ', 2),
|
|
('', 3),
|
|
('world', 4),
|
|
('', 5),
|
|
]
|
|
),
|
|
'continuation': (
|
|
'Hello, \\\n world\nJellybeans!', [
|
|
('Hello, \\\n world', 1),
|
|
('Jellybeans!', 3),
|
|
]
|
|
),
|
|
'multislash': (
|
|
'Hello, \\\\\n world', [
|
|
('Hello, \\\\', 1),
|
|
(' world', 2),
|
|
]
|
|
)
|
|
}
|
|
|
|
def runSingle(self, s, lines):
|
|
gotlines = [(d.s[d.lstart:d.lend], d.loc.line) for d in pymake.parser.enumeratelines(s, 'path')]
|
|
self.assertEqual(gotlines, lines)
|
|
|
|
multitest(LineEnumeratorTest)
|
|
|
|
class IterTest(TestBase):
|
|
testdata = {
|
|
'plaindata': (
|
|
pymake.parser.iterdata,
|
|
"plaindata # test\n",
|
|
"plaindata # test\n"
|
|
),
|
|
'makecomment': (
|
|
pymake.parser.itermakefilechars,
|
|
"VAR = val # comment",
|
|
"VAR = val "
|
|
),
|
|
'makeescapedcomment': (
|
|
pymake.parser.itermakefilechars,
|
|
"VAR = val \# escaped hash",
|
|
"VAR = val # escaped hash"
|
|
),
|
|
'makeescapedslash': (
|
|
pymake.parser.itermakefilechars,
|
|
"VAR = val\\\\",
|
|
"VAR = val\\\\",
|
|
),
|
|
'makecontinuation': (
|
|
pymake.parser.itermakefilechars,
|
|
"VAR = VAL \\\n continuation # comment \\\n continuation",
|
|
"VAR = VAL continuation "
|
|
),
|
|
'makecontinuation2': (
|
|
pymake.parser.itermakefilechars,
|
|
"VAR = VAL \\ \\\n continuation",
|
|
"VAR = VAL \\ continuation"
|
|
),
|
|
'makeawful': (
|
|
pymake.parser.itermakefilechars,
|
|
"VAR = VAL \\\\# comment\n",
|
|
"VAR = VAL \\"
|
|
),
|
|
'command': (
|
|
pymake.parser.itercommandchars,
|
|
"echo boo # comment",
|
|
"echo boo # comment",
|
|
),
|
|
'commandcomment': (
|
|
pymake.parser.itercommandchars,
|
|
"echo boo \# comment",
|
|
"echo boo \# comment",
|
|
),
|
|
'commandcontinue': (
|
|
pymake.parser.itercommandchars,
|
|
"echo boo # \\\n\t command 2",
|
|
"echo boo # \\\n command 2"
|
|
),
|
|
}
|
|
|
|
def runSingle(self, ifunc, idata, expected):
|
|
d = pymake.parser.Data.fromstring(idata, 'IterTest data')
|
|
|
|
it = pymake.parser._alltokens.finditer(d.s, 0, d.lend)
|
|
actual = ''.join( [c for c, t, o, oo in ifunc(d, 0, ('dummy-token',), it)] )
|
|
self.assertEqual(actual, expected)
|
|
|
|
if ifunc == pymake.parser.itermakefilechars:
|
|
print "testing %r" % expected
|
|
self.assertEqual(pymake.parser.flattenmakesyntax(d, 0), expected)
|
|
|
|
multitest(IterTest)
|
|
|
|
|
|
# 'define': (
|
|
# pymake.parser.iterdefinechars,
|
|
# "endef",
|
|
# ""
|
|
# ),
|
|
# 'definenesting': (
|
|
# pymake.parser.iterdefinechars,
|
|
# """define BAR # comment
|
|
#random text
|
|
#endef not what you think!
|
|
#endef # comment is ok\n""",
|
|
# """define BAR # comment
|
|
#random text
|
|
#endef not what you think!"""
|
|
# ),
|
|
# 'defineescaped': (
|
|
# pymake.parser.iterdefinechars,
|
|
# """value \\
|
|
#endef
|
|
#endef\n""",
|
|
# "value endef"
|
|
# ),
|
|
|
|
class MakeSyntaxTest(TestBase):
|
|
# (string, startat, stopat, stopoffset, expansion
|
|
testdata = {
|
|
'text': ('hello world', 0, (), None, ['hello world']),
|
|
'singlechar': ('hello $W', 0, (), None,
|
|
['hello ',
|
|
{'type': 'VariableRef',
|
|
'.vname': ['W']}
|
|
]),
|
|
'stopat': ('hello: world', 0, (':', '='), 6, ['hello']),
|
|
'funccall': ('h $(flavor FOO)', 0, (), None,
|
|
['h ',
|
|
{'type': 'FlavorFunction',
|
|
'[0]': ['FOO']}
|
|
]),
|
|
'escapedollar': ('hello$$world', 0, (), None, ['hello$world']),
|
|
'varref': ('echo $(VAR)', 0, (), None,
|
|
['echo ',
|
|
{'type': 'VariableRef',
|
|
'.vname': ['VAR']}
|
|
]),
|
|
'dynamicvarname': ('echo $($(VARNAME):.c=.o)', 0, (':',), None,
|
|
['echo ',
|
|
{'type': 'SubstitutionRef',
|
|
'.vname': [{'type': 'VariableRef',
|
|
'.vname': ['VARNAME']}
|
|
],
|
|
'.substfrom': ['.c'],
|
|
'.substto': ['.o']}
|
|
]),
|
|
'substref': (' $(VAR:VAL) := $(VAL)', 0, (':=', '+=', '=', ':'), 15,
|
|
[' ',
|
|
{'type': 'VariableRef',
|
|
'.vname': ['VAR:VAL']},
|
|
' ']),
|
|
'vadsubstref': (' $(VAR:VAL) = $(VAL)', 15, (), None,
|
|
[{'type': 'VariableRef',
|
|
'.vname': ['VAL']},
|
|
]),
|
|
}
|
|
|
|
def compareRecursive(self, actual, expected, path):
|
|
self.assertEqual(len(actual), len(expected),
|
|
"compareRecursive: %s %r" % (path, actual))
|
|
for i in xrange(0, len(actual)):
|
|
ipath = path + [i]
|
|
|
|
a, isfunc = actual[i]
|
|
e = expected[i]
|
|
if isinstance(e, str):
|
|
self.assertEqual(a, e, "compareRecursive: %s" % (ipath,))
|
|
else:
|
|
self.assertEqual(type(a), getattr(pymake.functions, e['type']),
|
|
"compareRecursive: %s" % (ipath,))
|
|
for k, v in e.iteritems():
|
|
if k == 'type':
|
|
pass
|
|
elif k[0] == '[':
|
|
item = int(k[1:-1])
|
|
proppath = ipath + [item]
|
|
self.compareRecursive(a[item], v, proppath)
|
|
elif k[0] == '.':
|
|
item = k[1:]
|
|
proppath = ipath + [item]
|
|
self.compareRecursive(getattr(a, item), v, proppath)
|
|
else:
|
|
raise Exception("Unexpected property at %s: %s" % (ipath, k))
|
|
|
|
def runSingle(self, s, startat, stopat, stopoffset, expansion):
|
|
d = pymake.parser.Data.fromstring(s, pymake.parserdata.Location('testdata', 1, 0))
|
|
|
|
a, t, offset = pymake.parser.parsemakesyntax(d, startat, stopat, pymake.parser.itermakefilechars)
|
|
self.compareRecursive(a, expansion, [])
|
|
self.assertEqual(offset, stopoffset)
|
|
|
|
multitest(MakeSyntaxTest)
|
|
|
|
class VariableTest(TestBase):
|
|
testdata = """
|
|
VAR = value
|
|
VARNAME = TESTVAR
|
|
$(VARNAME) = testvalue
|
|
$(VARNAME:VAR=VAL) = moretesting
|
|
IMM := $(VARNAME) # this is a comment
|
|
MULTIVAR = val1 \\
|
|
val2
|
|
VARNAME = newname
|
|
"""
|
|
expected = {'VAR': 'value',
|
|
'VARNAME': 'newname',
|
|
'TESTVAR': 'testvalue',
|
|
'TESTVAL': 'moretesting',
|
|
'IMM': 'TESTVAR ',
|
|
'MULTIVAR': 'val1 val2',
|
|
'UNDEF': None}
|
|
|
|
def runTest(self):
|
|
stmts = pymake.parser.parsestring(self.testdata, 'VariableTest')
|
|
|
|
m = pymake.data.Makefile()
|
|
stmts.execute(m)
|
|
for k, v in self.expected.iteritems():
|
|
flavor, source, val = m.variables.get(k)
|
|
if val is None:
|
|
self.assertEqual(val, v, 'variable named %s' % k)
|
|
else:
|
|
self.assertEqual(val.resolvestr(m, m.variables), v, 'variable named %s' % k)
|
|
|
|
class SimpleRuleTest(TestBase):
|
|
testdata = """
|
|
VAR = value
|
|
TSPEC = dummy
|
|
all: TSPEC = myrule
|
|
all:: test test2 $(VAR)
|
|
echo "Hello, $(TSPEC)"
|
|
|
|
%.o: %.c
|
|
$(CC) -o $@ $<
|
|
"""
|
|
|
|
def runTest(self):
|
|
stmts = pymake.parser.parsestring(self.testdata, 'SimpleRuleTest')
|
|
|
|
m = pymake.data.Makefile()
|
|
stmts.execute(m)
|
|
self.assertEqual(m.defaulttarget, 'all', "Default target")
|
|
|
|
self.assertTrue(m.hastarget('all'), "Has 'all' target")
|
|
target = m.gettarget('all')
|
|
rules = target.rules
|
|
self.assertEqual(len(rules), 1, "Number of rules")
|
|
prereqs = rules[0].prerequisites
|
|
self.assertEqual(prereqs, ['test', 'test2', 'value'], "Prerequisites")
|
|
commands = rules[0].commands
|
|
self.assertEqual(len(commands), 1, "Number of commands")
|
|
expanded = commands[0].resolvestr(m, target.variables)
|
|
self.assertEqual(expanded, 'echo "Hello, myrule"')
|
|
|
|
irules = m.implicitrules
|
|
self.assertEqual(len(irules), 1, "Number of implicit rules")
|
|
|
|
irule = irules[0]
|
|
self.assertEqual(len(irule.targetpatterns), 1, "%.o target pattern count")
|
|
self.assertEqual(len(irule.prerequisites), 1, "%.o prerequisite count")
|
|
self.assertEqual(irule.targetpatterns[0].match('foo.o'), 'foo', "%.o stem")
|
|
|
|
if __name__ == '__main__':
|
|
logging.basicConfig(level=logging.DEBUG)
|
|
unittest.main()
|