def test_index_scope_ok(self):
self.ast_description = """
file: TestTemplate
#def test_function
#set $foo = {}
#if True
#set $foo[1] = 1
#end if
#end def
"""
ast_root, function_node = self._build_function_template()
assign_node1 = ast.AssignNode(
ast.IdentifierNode('foo'), ast.DictLiteralNode())
function_node.append(assign_node1)
if_node = ast.IfNode(ast.LiteralNode(True))
assign_node2 = ast.AssignNode(
ast.SliceNode(
ast.IdentifierNode('foo'), ast.LiteralNode(1)),
ast.LiteralNode(1))
if_node.append(assign_node2)
function_node.append(if_node)
optimization_analyzer = self._get_analyzer(ast_root)
try:
optimization_analyzer.visit_ast(ast_root)
except analyzer.SemanticAnalyzerError:
self.fail('visit_ast raised SemanticAnalyzerError unexpectedly.')
def assign_after_filter_fails(self):
self.ast_description = """
file: TestTemplate
#def test_function
#set $foo = 'foo'
$foo
#set $foo = 'bar'
$foo
#end def
"""
ast_root, function_node = self._build_function_template()
first_assign = ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode('foo'))
function_node.append(first_assign)
first_use = ast.FilterNode(ast.IdentifierNode('foo'))
function_node.append(first_use)
second_assign = ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode('bar'))
function_node.append(second_assign)
second_use = ast.FilterNode(ast.IdentifierNode('foo'))
function_node.append(second_use)
optimization_analyzer = optimizer.OptimizationAnalyzer(
ast_root, self.compiler.analyzer_options, self.compiler)
optimization_analyzer.visit_ast = test_util.RecordedFunction(
optimization_analyzer.visit_ast)
self.assertRaises(compiler.Warning, optimization_analyzer.visit_ast,
ast_root)
def test_nested_else(self):
self.ast_description = """
file: TestTemplate
#def test_function
#if True
#set $foo = 1
#else
#if
#set $foo = 2
#else
#set $foo = 3
#end if
#end if
$foo
#end def
"""
ast_root, function_node, if_node = self._build_if_template()
if_node.append(ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode(1)))
if_node_2 = ast.IfNode(ast.LiteralNode(True))
if_node_2.append(ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode(2)))
if_node_2.else_.append(ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode(3)))
if_node.else_.append(if_node_2)
function_node.append(ast.PlaceholderNode('foo'))
optimization_analyzer = self._get_analyzer(ast_root)
try:
optimization_analyzer.visit_ast(ast_root)
except analyzer.SemanticAnalyzerError:
self.fail('visit_ast raised SemanticAnalyzerError unexpectedly.')
def build_conditional_body(node):
node.append(ast.AssignNode(
ast.IdentifierNode('_rph_foo'), ast.PlaceholderNode('foo')))
node.append(ast.AssignNode(
ast.IdentifierNode('_fph123'), ast.FilterNode(
ast.IdentifierNode('_rph_foo'))))
node.append(ast.BufferWrite(ast.IdentifierNode('_fph123')))
def double_assign_ok(self):
self.ast_description = """
file: TestTemplate
#def test_function
#set $foo = 'foo'
#set $foo = 'bar'
$foo
#end def
"""
ast_root, function_node = self._build_function_template()
first_assign = ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode('foo'))
function_node.append(first_assign)
second_assign = ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode('bar'))
function_node.append(second_assign)
first_use = ast.FilterNode(ast.IdentifierNode('foo'))
function_node.append(first_use)
optimization_analyzer = optimizer.OptimizationAnalyzer(
ast_root, self.compiler.analyzer_options, self.compiler)
optimization_analyzer.visit_ast = test_util.RecordedFunction(
optimization_analyzer.visit_ast)
try:
optimization_analyzer.visit_ast(ast_root)
except compiler.Warning:
self.fail('visit_ast raised WarningError unexpectedly.')
def test_partial_nested_else_if(self):
self.ast_description = """
file: TestTemplate
#def test_function
#if True
#set $foo = 1
#else
#if True
#set $foo = 2
#end if
#end if
$foo
#end def
"""
ast_root, function_node, if_node = self._build_if_template()
if_node.append(ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode(1)))
if_node_2 = ast.IfNode(ast.LiteralNode(True))
if_node_2.append(ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode(2)))
if_node.else_.append(if_node_2)
function_node.append(ast.PlaceholderNode('foo'))
optimization_analyzer = self._get_analyzer(ast_root)
self.assertRaises(analyzer.SemanticAnalyzerError,
optimization_analyzer.visit_ast, ast_root)
def test_duplicate_node_collect(self):
self.ast_description = """
file: TestTemplate
#def test_function
foo
bar
#if True
#set $foo = 1
#end if
baz
boo
#if True
#set $foo = 1
#end if
#end def
NOTE: This test will break if collect_writes is written
using ast.ASTNode.insert_before.
"""
ast_root, function_node = self._build_function_template()
function_node.append(ast.BufferWrite(ast.LiteralNode('foo')))
function_node.append(ast.BufferWrite(ast.LiteralNode('bar')))
if_node = ast.IfNode()
if_node.append(ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode(1)))
function_node.append(if_node)
function_node.append(ast.BufferWrite(ast.LiteralNode('baz')))
function_node.append(ast.BufferWrite(ast.LiteralNode('boo')))
if_node = ast.IfNode()
if_node.append(ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode(1)))
optimization_analyzer = self._get_analyzer(ast_root)
ast_root, function_node = self._build_function_template()
tuple_node = ast.TupleLiteralNode()
tuple_node.append(ast.LiteralNode('foo'))
tuple_node.append(ast.LiteralNode('bar'))
function_node.append(ast.BufferExtend(tuple_node))
if_node = ast.IfNode()
if_node.append(ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode(1)))
function_node.append(if_node)
tuple_node = ast.TupleLiteralNode()
tuple_node.append(ast.LiteralNode('baz'))
tuple_node.append(ast.LiteralNode('boo'))
function_node.append(ast.BufferExtend(tuple_node))
if_node = ast.IfNode()
if_node.append(ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode(1)))
expected_hash = hash(ast_root)
got_hash = hash(optimization_analyzer.optimize_ast())
self.assertEqual(expected_hash, got_hash)
def test_collect_writes_join_if(self):
self.ast_description = """
file: TestTemplate
#def test_function
foo
bar
#if True
#set $foo = 1
#end if
baz
boo
#end def
"""
ast_root, function_node = self._build_function_template()
function_node.append(ast.BufferWrite(ast.LiteralNode('foo')))
function_node.append(ast.BufferWrite(ast.LiteralNode('bar')))
if_node = ast.IfNode()
if_node.append(ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode(1)))
function_node.append(if_node)
function_node.append(ast.BufferWrite(ast.LiteralNode('baz')))
function_node.append(ast.BufferWrite(ast.LiteralNode('boo')))
optimization_analyzer = self._get_analyzer(ast_root)
ast_root, function_node = self._build_function_template()
tuple_node = ast.TupleLiteralNode()
tuple_node.append(ast.LiteralNode('foo'))
tuple_node.append(ast.LiteralNode('bar'))
function_node.append(ast.BufferExtend(tuple_node))
if_node = ast.IfNode()
if_node.append(ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode(1)))
function_node.append(if_node)
tuple_node = ast.TupleLiteralNode()
tuple_node.append(ast.LiteralNode('baz'))
tuple_node.append(ast.LiteralNode('boo'))
function_node.append(ast.BufferExtend(tuple_node))
expected_hash = hash(ast_root)
got_hash = hash(optimization_analyzer.optimize_ast())
self.assertEqual(expected_hash, got_hash)
def test_index_before_assign_error(self):
self.ast_description = """
file: TestTemplate
#def test_function
#set $foo[1] = 1
#end def
"""
ast_root, function_node = self._build_function_template()
assign_node = ast.AssignNode(
ast.SliceNode(
ast.IdentifierNode('foo'), ast.LiteralNode(1)),
ast.LiteralNode(1))
function_node.append(assign_node)
optimization_analyzer = self._get_analyzer(ast_root)
self.assertRaises(analyzer.SemanticAnalyzerError,
optimization_analyzer.visit_ast, ast_root)
def test_slice_non_identifier_error(self):
self.ast_description = """
file: TestTemplate
#def test_function
#set 1[1] = 1
#end def
"""
ast_root, def_node = self._build_function_template()
assign_node = ast.AssignNode(
ast.SliceNode(
ast.LiteralNode(1), ast.LiteralNode(1)), ast.LiteralNode(1))
def_node.append(assign_node)
semantic_analyzer = self._get_analyzer(ast_root)
self.assertRaises(analyzer.SemanticAnalyzerError,
semantic_analyzer.get_ast)
def test_set_error(self):
self.ast_description = """
file: TestTemplate
#implements library
#set $foo = True
#def test_function
#end def
"""
ast_root, def_node = self._build_function_template_library()
assign_node = ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode(True))
ast_root.insert_before(def_node, assign_node)
semantic_analyzer = self._get_analyzer(ast_root)
self.assertRaises(analyzer.SemanticAnalyzerError,
semantic_analyzer.get_ast)
def test_empty_if_full_else_fails(self):
self.ast_description = """
file: TestTemplate
#def test_function
#if True
#else
#set $foo = true
#end if
#end def
"""
ast_root, def_node, if_node = self._build_if_template()
assign_node = ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode(True))
if_node.else_.append(assign_node)
semantic_analyzer = self._get_analyzer(ast_root)
self.assertRaises(analyzer.SemanticAnalyzerError,
semantic_analyzer.get_ast)
def test_hoists_both_from_plus(self):
self.ast_description = """
file: TestTemplate
#global $foo
#def test_function
#set $bar = $foo + $foo
#end def
"""
ast_root, function_node = self._build_function_template()
ast_root.global_placeholders.add('foo')
function_node.append(ast.AssignNode(
ast.IdentifierNode('bar'), ast.BinOpNode('+', ast.PlaceholderNode(
'foo'), ast.PlaceholderNode('foo'))))
optimization_analyzer = self._get_analyzer_and_visit(ast_root)
self.assertEqual(
optimization_analyzer._placeholdernode_replacement.GetResults(),
[True, True])
def test_slice_identifier_ok(self):
self.ast_description = """
file: TestTemplate
#def test_function
#set $foo[1] = 1
#end def
"""
ast_root, def_node = self._build_function_template()
assign_node = ast.AssignNode(
ast.SliceNode(
ast.IdentifierNode('foo'), ast.LiteralNode(1)),
ast.LiteralNode(1))
def_node.append(assign_node)
semantic_analyzer = self._get_analyzer(ast_root)
try:
semantic_analyzer.get_ast()
except analyzer.SemanticAnalyzerError:
self.fail('get_ast raised SemanticAnalyzerError unexpectedly.')
def test_non_empty_for_ok(self):
self.ast_description = """
file: TestTemplate
#def test_function
#for $i in []
#set $foo = True
#end for
#end def
"""
ast_root, def_node, for_node = self._build_for_template()
assign_node = ast.AssignNode(
ast.IdentifierNode('foo'), ast.LiteralNode(True))
for_node.append(assign_node)
semantic_analyzer = self._get_analyzer(ast_root)
try:
semantic_analyzer.get_ast()
except analyzer.SemanticAnalyzerError:
self.fail('get_ast raised SemanticAnalyzerError unexpectedly.')
