def test_Literal(self):
"""Test the Literal() function."""
input_list = [ '$FOO', Literal('$BAR') ]
gvars = { 'FOO' : 'BAZ', 'BAR' : 'BLAT' }
def escape_func(cmd):
return '**' + cmd + '**'
cmd_list = scons_subst_list(input_list, None, gvars=gvars)
cmd_list = escape_list(cmd_list[0], escape_func)
assert cmd_list == ['BAZ', '**$BAR**'], cmd_list
def test_LiteralEqualsTest(self):
"""Test that Literals compare for equality properly"""
assert Literal('a literal') == Literal('a literal')
assert Literal('a literal') != Literal('b literal')
class SubstTestCase(unittest.TestCase):
class MyNode(DummyNode):
"""Simple node work-alike with some extra stuff for testing."""
def __init__(self, name):
DummyNode.__init__(self, name)
class Attribute:
pass
self.attribute = Attribute()
self.attribute.attr1 = 'attr$1-' + os.path.basename(name)
self.attribute.attr2 = 'attr$2-' + os.path.basename(name)
def get_stuff(self, extra):
return self.name + extra
foo = 1
class TestLiteral:
def __init__(self, literal):
self.literal = literal
def __str__(self):
return self.literal
def is_literal(self):
return 1
class TestCallable:
def __init__(self, value):
self.value = value
def __call__(self):
pass
def __str__(self):
return self.value
# only use of this is currently commented out below
#def function_foo(arg):
# pass
target = [ MyNode("./foo/bar.exe"),
MyNode("/bar/baz with spaces.obj"),
MyNode("../foo/baz.obj") ]
source = [ MyNode("./foo/blah with spaces.cpp"),
MyNode("/bar/ack.cpp"),
MyNode("../foo/ack.c") ]
callable_object_1 = TestCallable('callable-1')
callable_object_2 = TestCallable('callable-2')
def _defines(defs):
l = []
for d in defs:
if SCons.Util.is_List(d) or isinstance(d, tuple):
l.append(str(d[0]) + '=' + str(d[1]))
else:
l.append(str(d))
return l
loc = {
'xxx' : None,
'NEWLINE' : 'before\nafter',
'null' : '',
'zero' : 0,
'one' : 1,
'BAZ' : 'baz',
'ONE' : '$TWO',
'TWO' : '$THREE',
'THREE' : 'four',
'AAA' : 'a',
'BBB' : 'b',
'CCC' : 'c',
'DO' : DummyNode('do something'),
'FOO' : DummyNode('foo.in'),
'BAR' : DummyNode('bar with spaces.out'),
'CRAZY' : DummyNode('crazy\nfile.in'),
# $XXX$HHH should expand to GGGIII, not BADNEWS.
'XXX' : '$FFF',
'FFF' : 'GGG',
'HHH' : 'III',
'FFFIII' : 'BADNEWS',
'THING1' : "$(STUFF$)",
'THING2' : "$THING1",
'LITERAL' : TestLiteral("$XXX"),
# Test that we can expand to and return a function.
#'FUNCTION' : function_foo,
'CMDGEN1' : CmdGen1,
'CMDGEN2' : CmdGen2,
'CallableWithDefault': CallableWithDefault,
'PartialCallable' : PartialCallable,
'PartialCallableNoDefault' : PartialCallableNoDefault,
'LITERALS' : [ Literal('foo\nwith\nnewlines'),
Literal('bar\nwith\nnewlines') ],
'NOTHING' : "",
'NONE' : None,
# Test various combinations of strings, lists and functions.
'N' : None,
'X' : 'x',
'Y' : '$X',
'R' : '$R',
'S' : 'x y',
'LS' : ['x y'],
'L' : ['x', 'y'],
'TS' : ('x y',),
'T' : ('x', 'y'),
'CS' : cs,
'CL' : cl,
'US' : collections.UserString('us'),
# Test function calls within ${}.
'FUNCCALL' : '${FUNC1("$AAA $FUNC2 $BBB")}',
'FUNC1' : lambda x: x,
'FUNC2' : lambda target, source, env, for_signature: ['x$CCC'],
# Various tests refactored from ActionTests.py.
'LIST' : [["This", "is", "$(", "$a", "$)", "test"]],
# Test recursion.
'RECURSE' : 'foo $RECURSE bar',
'RRR' : 'foo $SSS bar',
'SSS' : '$RRR',
# Test callables that don't match the calling arguments.
'CALLABLE1' : callable_object_1,
'CALLABLE2' : callable_object_2,
'_defines' : _defines,
'DEFS' : [ ('Q1', '"q1"'), ('Q2', '"$AAA"') ],
}
def basic_comparisons(self, function, convert):
env = DummyEnv(self.loc)
cases = self.basic_cases[:]
kwargs = {'target' : self.target, 'source' : self.source,
'gvars' : env.Dictionary()}
failed = 0
case_count = 0
while cases:
input, expect = cases[:2]
expect = convert(expect)
try:
result = function(input, env, **kwargs)
except Exception as e:
fmt = " input %s generated %s (%s)"
print(fmt % (repr(input), e.__class__.__name__, repr(e)))
failed = failed + 1
else:
if result != expect:
if failed == 0: print()
print("[%4d] input %s => \n%s did not match \n%s" % (case_count, repr(input), repr(result), repr(expect)))
failed = failed + 1
del cases[:2]
case_count += 1
fmt = "%d %s() cases failed"
assert failed == 0, fmt % (failed, function.__name__)