def test_get_int_array(): ''' Tests for the KernelType.get_integer_array() method. ''' ast = fpapi.parse(MDATA, ignore_comments=False) ktype = KernelType(ast) targets = ktype.get_integer_array("gh_evaluator_targets") assert targets == ["w0", "w1"] mdata = MDATA.replace("[W0, W1]", "(/W0, W1/)") ast = fpapi.parse(mdata, ignore_comments=False) ktype = KernelType(ast) targets = ktype.get_integer_array("gh_evaluator_targets") assert targets == ["w0", "w1"]
def test_get_int_array_err1(monkeypatch): ''' Tests that we raise the correct error if there is something wrong with the assignment statement obtained from fparser2. ''' from fparser.two import Fortran2003 # This is difficult as we have to break the result returned by fparser2. # We therefore create a valid KernelType object ast = fpapi.parse(MDATA, ignore_comments=False) ktype = KernelType(ast) # Next we create a valid fparser2 result my_assign = Fortran2003.Assignment_Stmt("my_array(2) = [1, 2]") # Break its `items` property by replacing the Name object with a string # (tuples are immutable so make a new one) broken_items = tuple(["invalid"] + list(my_assign.items[1:])) # Use monkeypatch to ensure that that the Assignment_Stmt that # is returned when we attempt to use fparser2 from within the # routine under test now has the broken tuple of items. def my_init(self, _): self.items = broken_items monkeypatch.setattr(Fortran2003.Assignment_Stmt, "__init__", my_init) with pytest.raises(InternalError) as err: _ = ktype.get_integer_array("gh_evaluator_targets") assert "Unsupported assignment statement: 'invalid = [1, 2]'" in str(err)
def test_kernel_binding_not_code(): ''' Check that we raise the expected error when Kernel meta-data uses a specific binding but does not have 'code' as the generic name. ''' mdata = MDATA.replace("code => test", "my_code => test") ast = fpapi.parse(mdata) with pytest.raises(ParseError) as err: _ = KernelType(ast) assert ("binds to a specific procedure but does not use 'code' as the " "generic name" in str(err))
def test_get_int_err(): ''' Tests that we raise the expected error if the meta-data contains an integer literal instead of a name. ''' mdata = MDATA.replace("= cells", "= 1") ast = fpapi.parse(mdata, ignore_comments=False) with pytest.raises(ParseError) as err: _ = KernelType(ast) assert ("RHS of assignment is not a variable name: 'iterates_over = 1'" in str(err))
def test_kernel_binding_missing(): ''' Check that we raise the correct error when the Kernel meta-data is missing the type-bound procedure giving the name of the subroutine. ''' mdata = MDATA.replace( "contains\n procedure, nopass :: code => testkern_eval_code\n", "") ast = fpapi.parse(mdata) with pytest.raises(RuntimeError) as err: _ = KernelType(ast) assert ("Kernel type testkern_eval_type does not bind a specific " "procedure" in str(err))
def test_get_int_array_not_array(): ''' Test that get_integer_array returns the expected error if the requested variable is not an array. ''' ast = fpapi.parse(MDATA, ignore_comments=False) ktype = KernelType(ast) # Erroneously call get_integer_array with the name of a scalar meta-data # entry with pytest.raises(ParseError) as err: _ = ktype.get_integer_array("iterates_over") assert ("RHS of assignment is not an array constructor: 'iterates_over = " "cells'" in str(err))
def test_empty_kernel_name(monkeypatch): ''' Check that we raise the correct error when we get a blank string for the name of the Kernel subroutine. ''' import fparser mdata = MDATA.replace("procedure, nopass :: code => testkern_eval_code", "procedure, nopass :: testkern_eval_code") ast = fpapi.parse(mdata) # Break the AST for statement, _ in fpapi.walk(ast, -1): if isinstance(statement, fparser.one.statements.SpecificBinding): monkeypatch.setattr(statement, "name", "") break with pytest.raises(InternalError) as err: _ = KernelType(ast) assert ("Empty Kernel name returned for Kernel type testkern_eval_type" in str(err))
def test_get_int_array_err2(monkeypatch): ''' Check that we raise the appropriate error if we fail to parse the array constructor expression. ''' from fparser.two import Fortran2003 # First create a valid KernelType object ast = fpapi.parse(MDATA, ignore_comments=False) ktype = KernelType(ast) # Create a valid fparser2 result assign = Fortran2003.Assignment_Stmt("gh_evaluator_targets(2) = [1, 2]") # Break the array constructor expression (tuples are immutable so make a # new one) assign.items[2].items[1].items = tuple(["hello", "goodbye"]) # Use monkeypatch to ensure that that's the result that is returned # when we attempt to use fparser2 from within the routine under test def my_init(self, _): self.items = assign.items monkeypatch.setattr(Fortran2003.Assignment_Stmt, "__init__", my_init) with pytest.raises(InternalError) as err: _ = ktype.get_integer_array("gh_evaluator_targets") assert "Failed to parse array constructor: '[hello, goodbye]'" in str(err)
def test_get_int(): ''' Tests for the KernelType.get_integer(). method ''' ast = fpapi.parse(MDATA, ignore_comments=False) ktype = KernelType(ast) iter_val = ktype.get_integer_variable("iterates_over") assert iter_val == "cells"