MetavariableDataTypeTest Class Reference

Inheritance diagram for MetavariableDataTypeTest:

Collaboration diagram for MetavariableDataTypeTest:

Public Member Functions
int	process_file (self, str filepath)
def	test_metavariable_data_types (self)

Static Public Attributes
dictionary	hardcoded
	we have to hardcode some special cases as data types can't be obtained from source code directly More...
	registering_regex
	regex for finding the REGISTER_METAVARIABLE statements. More...
	extract_regex
	regex for extracting the function name and the enum type from REGISTER_METAVARIABLE statements # noqa More...
	lambda_type_regex = re.compile(r"-> (?P<lambdatype>double|bool|int)")
	regex for extracting the type of the lambda function in metavariable function definition # noqa

Detailed Description

Determine metavariable types from source code and assert correctness

Definition at line 41 of file test_variables_meta.py.

Member Function Documentation

process_file()

int process_file	(		self,
		str	filepath
	)

Check all metavariable types for specified file.

Args:
    filepath (str): path to file containing REGISTER_METAVARIABLE

Raises:
    AssertionError: Raised if no expected function definition is found.
    AssertionError: Rased if lambda function has no associated
                    type information, or no lambda function is defined.

Returns:
    int: number of metavariables in file.
    Used for sanity checks of the coverage.

Definition at line 77 of file test_variables_meta.py.

    def process_file(self, filepath: str) -> int:
        """Check all metavariable types for specified file.
 
        Args:
            filepath (str): path to file containing REGISTER_METAVARIABLE
 
        Raises:
            AssertionError: Raised if no expected function definition is found.
            AssertionError: Rased if lambda function has no associated
                            type information, or no lambda function is defined.
 
        Returns:
            int: number of metavariables in file.
            Used for sanity checks of the coverage.
        """
 
        # Read file contents
        with open(filepath) as fp:
            filecontent = fp.read()
 
        # List for all found registering statements
        registering_statements = self.registering_regex.findall(filecontent)
        # Preprocess all statements by removing spaces and newlines
        # This makes extraction of function name and enum type easier
        registering_statements = list(
            map(
                lambda line: line.replace(" ", "").replace("\n", ""),
                registering_statements,
            ),
        )
 
        for statement in registering_statements:
            # Extract enum type and name
            match_content = self.extract_regex.match(statement)
            function_name = match_content.groupdict()["function_name"]
            enumtype = match_content.groupdict()["enumtype"]
 
            if function_name in self.hardcoded:
                self.assertEqual(
                    enumtype,
                    self.hardcoded[function_name],
                    f"Metavariable '{function_name}' in file {filepath}:\n"
                    f"Metavariable function return type and Manager::VariableDataType have to match.\n"  # noqa
                    f"Expected: Manager::VariableDataType::{self.hardcoded[function_name]}, actual: Manager::VariableDataType::{enumtype}",  # noqa
                )
                continue
 
            # compile regex for finding metavariable function definition
            function_definition_regex = re.compile(
                r"Manager::FunctionPtr %s\‍(.*\‍)[^\{]*" % function_name
            )
            # compile regex for regular typed function definition
            regular_definition_regex = re.compile(
                r"(?P<return_type>double|int|bool) %s\‍(.*?\‍)" % function_name
            )
 
            # Find function body start with regex
            definition = function_definition_regex.search(filecontent)
            if definition is not None:
                func_body_start = definition.end()
            else:  # Manager::FunctionPtr definition not found
                # search for a regular typed function
                return_type = (
                    regular_definition_regex.search(filecontent)
                    .groupdict()
                    .get("return_type")
                )  # noqa
                if return_type is not None:
                    self.assertEqual(
                        return_type,
                        enumtype,
                        f"Metavariable '{function_name}' in file {filepath}:\n"
                        "Metavariable function return type and Manager::VariableDataType have to match."  # noqa
                        f"Return type is {return_type} but it is registered as Manager::VariableDataType::c_{enumtype}.\n",  # noqa
                    )
                    continue
                else:
                    raise AssertionError(
                        f"Metavariable '{function_name}' in file {filepath}:\n"
                        "Metavariable function return type and Manager::VariableDataType have to match."  # noqa
                        "Return type of function could not be automatically determined from the source code."  # noqa
                        "You can add an exception by adding the expected return type information to "  # noqa
                        "the 'hardcoded' dictionary of this testcase."
                    )
 
            # grab function body end
            func_body_end = func_body_start + findMatchedParenthesis(
                filecontent[func_body_start:], "{", "}"
            )
            # Get function body slice from filecontent
            func_body = filecontent[func_body_start:func_body_end]
 
            # grab lambda type definition
            lambdatype_match = self.lambda_type_regex.search(func_body)
            if lambdatype_match is not None:
                lambdatype = lambdatype_match.groupdict()["lambdatype"]
                self.assertEqual(
                    lambdatype,
                    enumtype,
                    f"Metavariable '{function_name}' in file {filepath}:\n"
                    f"Lambda function has return type {lambdatype} "
                    f"but is registered with Manager::VariableDataType::c_{enumtype}.\n"  # noqa
                    "VariableDataType and lambda return type have to match.",
                )
            else:  # lambda type or definition not found
                raise AssertionError(
                    f"Metavariable '{function_name}' in {filepath}:\n"
                    "VariableDataType and lambda definition have to match.\n"
                    "Either lambda function is missing return type information"
                    ", or lambda definition could not be found.\n"  # noqa
                    "Please add return type annotation '(const Particle * particle) -> double/int/bool' to lambda.\n"  # noqa
                    "Or add this metavariable as exception, by adding the expected return type information in the 'hardcoded' dictionary of this testcase\n"  # noqa
                    f"{func_body}"
                )
 
        # Return the number of registering statements in this file
        return len(registering_statements)
 

test_metavariable_data_types()

def test_metavariable_data_types

(

self

)

Metavariables have to be registered with the correct Manager::Variable::VariableDataType enum value. This test makes sure Metavariable definition and variable registration are correct.

Definition at line 195 of file test_variables_meta.py.

Member Data Documentation

extract_regex

extract_regex

static

Initial value:

=  re.compile(
        r'REGISTER_METAVARIABLE\‍(".*?",(?P<function_name>[^,]*),.*?Manager::VariableDataType::c_(?P<enumtype>double|bool|int)'  # noqa
    )

regex for extracting the function name and the enum type from REGISTER_METAVARIABLE statements # noqa

Definition at line 71 of file test_variables_meta.py.

hardcoded

dictionary hardcoded

static

Initial value:

=  {
        "softwareTriggerResult": "double",
        "formula": "double",
        "softwareTriggerResultNonPrescaled": "double",
        "isDaughterOfList": "bool",
        "isGrandDaughterOfList": "bool",
        "daughterDiffOf": "double",
        "daughterDiffOfPhi": "double",
        "daughterDiffOfClusterPhi": "double",
        "mcDaughterDiffOfPhi": "double",
        "grandDaughterDiffOf": 'double',
        "grandDaughterDiffOfPhi": "double",
        "grandDaughterDiffOfClusterPhi": "double",
        "daughterDiffOfPhiCMS": "double",
        "daughterDiffOfClusterPhiCMS": "double",
    }

we have to hardcode some special cases as data types can't be obtained from source code directly

Definition at line 48 of file test_variables_meta.py.

registering_regex

registering_regex

static

Initial value:

=  re.compile(
        r"(?s)REGISTER_METAVARIABLE.*?Manager::VariableDataType::(?:c_double|c_int|c_bool)"  # noqa
    )

regex for finding the REGISTER_METAVARIABLE statements.

Definition at line 67 of file test_variables_meta.py.

---

The documentation for this class was generated from the following file:

• analysis/tests/test_variables_meta.py