def test_routine_create():
'''Test that the create method correctly creates a Routine instance. '''
symbol_table = SymbolTable()
symbol = DataSymbol("tmp", REAL_TYPE)
symbol_table.add(symbol)
assignment = Assignment.create(Reference(symbol),
Literal("0.0", REAL_TYPE))
kschedule = Routine.create("mod_name", symbol_table, [assignment],
is_program=True, return_symbol=symbol)
assert isinstance(kschedule, Routine)
check_links(kschedule, [assignment])
assert kschedule.symbol_table is symbol_table
assert kschedule.is_program
assert kschedule.return_symbol is symbol
def test_array_create():
'''Test that the create method in the ArrayReference class correctly
creates an ArrayReference instance.
'''
array_type = ArrayType(REAL_SINGLE_TYPE, [10, 10, 10])
symbol_temp = DataSymbol("temp", array_type)
symbol_i = DataSymbol("i", INTEGER_SINGLE_TYPE)
symbol_j = DataSymbol("j", INTEGER_SINGLE_TYPE)
children = [Reference(symbol_i), Reference(symbol_j),
Literal("1", INTEGER_SINGLE_TYPE)]
array = ArrayReference.create(symbol_temp, children)
check_links(array, children)
result = FortranWriter().arrayreference_node(array)
assert result == "temp(i,j,1)"
def test_naryoperation_create():
'''Test that the create method in the NaryOperation class correctly
creates an NaryOperation instance.
'''
children = [
Reference(DataSymbol("tmp1", REAL_SINGLE_TYPE)),
Reference(DataSymbol("tmp2", REAL_SINGLE_TYPE)),
Reference(DataSymbol("tmp3", REAL_SINGLE_TYPE))
]
oper = NaryOperation.Operator.MAX
naryoperation = NaryOperation.create(oper, children)
check_links(naryoperation, children)
result = FortranWriter().naryoperation_node(naryoperation)
assert result == "MAX(tmp1, tmp2, tmp3)"
def test_ifblock_create():
'''Test that the create method in an IfBlock class correctly creates
an IfBlock instance.
'''
# Without an else clause.
if_condition = Literal('true', BOOLEAN_TYPE)
if_body = [
Assignment.create(Reference(DataSymbol("tmp", REAL_SINGLE_TYPE)),
Literal("0.0", REAL_SINGLE_TYPE)),
Assignment.create(Reference(DataSymbol("tmp2", REAL_SINGLE_TYPE)),
Literal("1.0", REAL_SINGLE_TYPE))
]
ifblock = IfBlock.create(if_condition, if_body)
if_schedule = ifblock.children[1]
assert isinstance(if_schedule, Schedule)
check_links(ifblock, [if_condition, if_schedule])
check_links(if_schedule, if_body)
result = FortranWriter().ifblock_node(ifblock)
assert result == ("if (.true.) then\n"
" tmp=0.0\n"
" tmp2=1.0\n"
"end if\n")
# With an else clause.
else_body = [
Assignment.create(Reference(DataSymbol("tmp", REAL_SINGLE_TYPE)),
Literal("1.0", REAL_SINGLE_TYPE)),
Assignment.create(Reference(DataSymbol("tmp2", REAL_SINGLE_TYPE)),
Literal("0.0", REAL_SINGLE_TYPE))
]
ifblock = IfBlock.create(if_condition, if_body, else_body)
if_schedule = ifblock.children[1]
assert isinstance(if_schedule, Schedule)
else_schedule = ifblock.children[2]
assert isinstance(else_schedule, Schedule)
check_links(ifblock, [if_condition, if_schedule, else_schedule])
check_links(if_schedule, if_body)
check_links(else_schedule, else_body)
result = FortranWriter().ifblock_node(ifblock)
assert result == ("if (.true.) then\n"
" tmp=0.0\n"
" tmp2=1.0\n"
"else\n"
" tmp=1.0\n"
" tmp2=0.0\n"
"end if\n")
def test_loop_create():
'''Test that the create method in the Loop class correctly
creates a Loop instance.
'''
start = Literal("0", INTEGER_SINGLE_TYPE)
stop = Literal("1", INTEGER_SINGLE_TYPE)
step = Literal("1", INTEGER_SINGLE_TYPE)
child_node = Assignment.create(
Reference(DataSymbol("tmp", REAL_SINGLE_TYPE)),
Reference(DataSymbol("i", REAL_SINGLE_TYPE)))
loop = Loop.create(DataSymbol("i", INTEGER_SINGLE_TYPE), start, stop, step,
[child_node])
schedule = loop.children[3]
assert isinstance(schedule, Schedule)
check_links(loop, [start, stop, step, schedule])
check_links(schedule, [child_node])
result = FortranWriter().loop_node(loop)
assert result == "do i = 0, 1, 1\n tmp = i\nenddo\n"
def test_type_convert_binaryop_create(operation, op_str):
'''Test that the create method in the BinaryOperation class correctly
creates a BinaryOperation instance for the REAL and INT type-conversion
operations..
'''
sym = DataSymbol("tmp1", REAL_SINGLE_TYPE)
lhs = Reference(sym)
wp_sym = DataSymbol("wp", INTEGER_SINGLE_TYPE)
# Reference to a kind parameter
rhs = Reference(wp_sym)
binaryoperation = BinaryOperation.create(operation, lhs, rhs)
assert binaryoperation._operator is operation
check_links(binaryoperation, [lhs, rhs])
result = FortranWriter().binaryoperation_node(binaryoperation)
assert op_str + "(tmp1, wp)" in result.lower()
# Kind specified with an integer literal
rhs = Literal("4", INTEGER_SINGLE_TYPE)
binaryoperation = BinaryOperation.create(operation, lhs.detach(), rhs)
check_links(binaryoperation, [lhs, rhs])
result = FortranWriter().binaryoperation_node(binaryoperation)
assert op_str + "(tmp1, 4)" in result.lower()
# Kind specified as an arithmetic expression
rhs = BinaryOperation.create(BinaryOperation.Operator.ADD,
Reference(wp_sym),
Literal("2", INTEGER_SINGLE_TYPE))
binaryoperation = BinaryOperation.create(operation, lhs.detach(), rhs)
check_links(binaryoperation, [lhs, rhs])
result = FortranWriter().binaryoperation_node(binaryoperation)
assert op_str + "(tmp1, wp + 2)" in result.lower()
def test_kernelschedule_create():
'''Test that the create method in the KernelSchedule class correctly
creates a KernelSchedule instance.
'''
symbol_table = SymbolTable()
symbol = DataSymbol("tmp", REAL_TYPE)
symbol_table.add(symbol)
assignment = Assignment.create(Reference(symbol),
Literal("0.0", REAL_TYPE))
kschedule = KernelSchedule.create("mod_name", symbol_table, [assignment])
assert isinstance(kschedule, KernelSchedule)
# A KernelSchedule is not a main program and has no return type.
assert not kschedule.is_program
assert kschedule.return_type is None
check_links(kschedule, [assignment])
assert kschedule.symbol_table is symbol_table
result = FortranWriter().routine_node(kschedule)
assert result == ("subroutine mod_name()\n"
" real :: tmp\n\n"
" tmp = 0.0\n\n"
"end subroutine mod_name\n")
def test_container_create():
'''Test that the create method in the Container class correctly
creates a Container instance.
'''
symbol_table = SymbolTable()
symbol_table.add(DataSymbol("tmp", REAL_SINGLE_TYPE))
kernel1 = KernelSchedule.create("mod_1", SymbolTable(), [])
kernel2 = KernelSchedule.create("mod_2", SymbolTable(), [])
container = Container.create("container_name", symbol_table,
[kernel1, kernel2])
check_links(container, [kernel1, kernel2])
assert container.symbol_table is symbol_table
result = FortranWriter().container_node(container)
assert result == ("module container_name\n"
" real :: tmp\n\n"
" contains\n"
" subroutine mod_1()\n\n\n"
" end subroutine mod_1\n"
" subroutine mod_2()\n\n\n"
" end subroutine mod_2\n\n"
"end module container_name\n")
def test_asr_create(component_symbol):
''' Check the create method. '''
int_one = nodes.Literal("1", symbols.INTEGER_TYPE)
# Reference to scalar member of structure in array of structures
asref = nodes.ArrayOfStructuresReference.create(component_symbol,
[int_one], ["nx"])
assert isinstance(asref.children[0], nodes.Member)
assert isinstance(asref.children[1], nodes.Literal)
check_links(asref, asref.children)
# Reference to member of structure member of structure in array of
# structures
asref = nodes.ArrayOfStructuresReference.create(component_symbol,
[int_one],
["region", "startx"])
assert isinstance(asref.children[0], nodes.StructureMember)
assert isinstance(asref.children[0].children[0], nodes.Member)
# Reference to range of structures
lbound = nodes.BinaryOperation.create(
nodes.BinaryOperation.Operator.LBOUND,
nodes.Reference(component_symbol), int_one)
ubound = nodes.BinaryOperation.create(
nodes.BinaryOperation.Operator.UBOUND,
nodes.Reference(component_symbol), int_one)
my_range = nodes.Range.create(lbound, ubound)
asref = nodes.ArrayOfStructuresReference.create(component_symbol,
[my_range], ["nx"])
assert isinstance(asref.children[0], nodes.Member)
assert isinstance(asref.children[1], nodes.Range)
check_links(asref, asref.children)
check_links(asref.children[1], asref.children[1].children)
# Reference to a symbol of DeferredType
ssym = symbols.DataSymbol("grid", symbols.DeferredType())
asref = nodes.ArrayOfStructuresReference.create(ssym, [int_one],
["region", "startx"])
assert isinstance(asref.symbol.datatype, symbols.DeferredType)
assert isinstance(asref.children[0], nodes.StructureMember)
assert isinstance(asref.children[0].children[0], nodes.Member)
def test_struc_ref_create():
''' Tests for the create method. '''
region_type = symbols.StructureType.create([
("startx", symbols.INTEGER_TYPE, symbols.Symbol.Visibility.PUBLIC)])
region_type_symbol = symbols.TypeSymbol("region_type", region_type)
grid_type = symbols.StructureType.create([
("nx", symbols.INTEGER_TYPE, symbols.Symbol.Visibility.PUBLIC),
("region", region_type_symbol, symbols.Symbol.Visibility.PRIVATE),
("sub_grids", symbols.ArrayType(region_type_symbol, [3]),
symbols.Symbol.Visibility.PUBLIC),
("data", symbols.ArrayType(symbols.REAL_TYPE, [10, 10]),
symbols.Symbol.Visibility.PUBLIC)])
grid_type_symbol = symbols.TypeSymbol("grid_type", grid_type)
ssym = symbols.DataSymbol("grid", grid_type_symbol)
# Reference to scalar member of structure
sref = nodes.StructureReference.create(ssym, ["nx"])
assert sref.symbol is ssym
assert len(sref.children) == 1
assert sref.children[0].name == "nx"
check_links(sref, sref.children)
# Reference to scalar member of structure member of structure
rref = nodes.StructureReference.create(ssym, ["region", "startx"])
assert rref.children[0].name == "region"
assert rref.children[0].children[0].name == "startx"
check_links(rref.children[0], rref.children[0].children)
# Reference to an element of an array member of the structure
aref = nodes.StructureReference.create(
ssym,
[("data", [nodes.Literal("1", symbols.INTEGER_TYPE),
nodes.Literal("5", symbols.INTEGER_TYPE)])])
assert isinstance(aref.children[0], nodes.ArrayMember)
assert aref.children[0].name == "data"
assert isinstance(aref.children[0].children[1], nodes.Literal)
assert aref.children[0].children[1].value == "5"
check_links(aref, aref.children)
check_links(aref.children[0], aref.children[0].children)
# Reference to an array of structures within a structure
structarray_ref = nodes.StructureReference.create(
ssym, [("sub_grids", [nodes.Literal("1", symbols.INTEGER_TYPE)])])
assert isinstance(structarray_ref.children[0], nodes.ArrayMember)
# Reference to a scalar member of an element of an array of structures
# contained in a structure
dref = nodes.StructureReference.create(
ssym,
[("sub_grids", [nodes.Literal("2", symbols.INTEGER_TYPE)]), "startx"])
assert isinstance(dref.children[0], nodes.ArrayOfStructuresMember)
assert isinstance(dref.children[0].children[0], nodes.Member)
assert isinstance(dref.children[0].children[1], nodes.Literal)
check_links(dref, dref.children)
check_links(dref.children[0], dref.children[0].children)
