def test_hierarchies(self): """Verify the class and file hierarchies.""" # verify the file hierarchy and file declaration relationships file_hierarchy_dict = { directory("include"): { file("c_maths.h"): { function("int", "cm_add"): parameters("int", "int"), function("int", "cm_sub"): parameters("int", "int") } } } compare_file_hierarchy(self, file_hierarchy(file_hierarchy_dict)) compare_class_hierarchy(self, class_hierarchy({}))
def test_hierarchies(self): """Verify the class and file hierarchies.""" # verify the file hierarchy and file declaration relationships file_hierarchy_dict = { directory("include"): { file("main.h"): { function("int", "add"): signature("int a", "int b"), function("int", "sub"): signature("int a", "int b") } } } compare_file_hierarchy(self, file_hierarchy(file_hierarchy_dict)) compare_class_hierarchy(self, class_hierarchy({}))
class CPPWithSpaces(ExhaleTestCase): """ Primary test class for project ``cpp with spaces``. """ test_project = "cpp with spaces" """.. testproject:: cpp with spaces""" file_hierarchy_dict = { directory("include"): { directory("with spaces"): { file("with spaces.hpp"): { namespace("with_spaces"): { function("int", "value"): parameters() } } } } } """The file hierarchy for this project.""" def test_hierarchies(self): """ Verify the class and file hierarchies. .. todo:: Class hierarchy not tested here, need to revisit that part of the testing framework **as well as** stop emitting a "Class Hierarchy" on the root api page when it is empty. """ compare_file_hierarchy(self, file_hierarchy(self.file_hierarchy_dict)) @no_cleanup def test_build(self): """Verify that the sphinx build (with spaces in filenames) succeeds.""" self.app.build()
class CPPFuncOverloads(ExhaleTestCase): """ Primary test class for project ``cpp_func_overloads``. """ test_project = "cpp_func_overloads" """.. testproject:: cpp_func_overloads""" file_hierarchy_dict = { directory("include"): { directory("overload"): { file("overload.hpp"): { function("int", "blargh"): parameters("int"), namespace("overload"): { # No args function("void", "blargh"): parameters(), # "pure" int overloads function("int", "blargh"): parameters("int"), function("int", "blargh"): parameters("int", "int"), function("int", "blargh"): parameters("int", "int", "int"), # "pure" float overloads function("float", "blargh"): parameters("float"), function("float", "blargh"): parameters("float", "float"), function("float", "blargh"): parameters("float", "float", "float"), # "pure" std::string overloads function("std::string", "blargh"): parameters("const std::string&"), function("std::string", "blargh"): parameters( "const std::string&", "const std::string&" ), function("std::string", "blargh"): parameters( "const std::string&", "const std::string&", "const std::string&" ), # absurd mixtures function("std::size_t", "blargh"): parameters("std::size_t", "const std::string&"), function("std::size_t", "blargh"): parameters( "std::size_t", "const float&", "double", "const std::string&" ), # vector overloads function("void", "blargh"): parameters("std::vector<std::string>&"), function("void", "blargh"): parameters("std::vector<std::vector<int>>&"), # pointer style (spaces matter...) function("void", "blargh"): parameters( "const float *", "const float *", "float *", "std::size_t" ), # templates function("C::type", "blargh", template=["class C"]): parameters("typename C::type"), # SFINAE is really pretty yeah? function( "std::enable_if<std::is_convertible<typename C::type, T>::value, T>::type", "blargh", template=["class C", "typename T"] ): parameters("typename C::type"), function( "std::enable_if<!std::is_convertible<typename C::type, T>::value, T>::type", "blargh", template=["class C", "typename T"] ): parameters("typename C::type") } } } } } @no_cleanup def test_builds(self): """Test deliberately kept to serve as a perpetual reminder this is still broken.""" self.app.build() def test_file_hierarchy(self): """Verify the file hierarchy.""" compare_file_hierarchy(self, file_hierarchy(self.file_hierarchy_dict))
class CPPPimpl(ExhaleTestCase): """ Primary test class for project ``cpp_pimpl``. """ test_project = "cpp_pimpl" """.. testproject:: cpp_pimpl""" file_hierarchy_dict = { directory("include"): { directory("pimpl"): { file("planet.hpp"): { namespace("pimpl"): { clike("class", "Planet"): {} } }, file("earth.hpp"): { namespace("pimpl"): { clike("class", "Earth"): {}, clike("class", "EarthImpl"): {}, clike("class", "Earth_v2"): {}, namespace("detail"): { clike("class", "EarthImpl"): {} } } }, file("jupiter.hpp"): { namespace("pimpl"): { clike("class", "Jupiter"): {}, clike("class", "JupiterImpl"): {}, clike("class", "Jupiter_v2"): {}, namespace("detail"): { clike("class", "JupiterImpl"): {} } } } } } } """The file hierarchy for this test.""" class_hierarchy_dict = { namespace("pimpl"): { clike("class", "Planet"): {}, clike("class", "Earth"): {}, clike("class", "EarthImpl"): {}, clike("class", "Earth_v2"): {}, clike("class", "Jupiter"): {}, clike("class", "JupiterImpl"): {}, clike("class", "Jupiter_v2"): {}, namespace("detail"): { clike("class", "EarthImpl"): {}, clike("class", "JupiterImpl"): {} } } } """The class hierarchy for this test.""" def impl_link_names(self): """Link names for ``pimpl::{Earth,Jupiter}Impl``.""" links = self.link_name_format_dict() return { "- :ref:`{pimpl_EarthImpl}`".format(**links), "- :ref:`{pimpl_JupiterImpl}`".format(**links) } def detail_impl_link_names(self): """Link names for ``pimpl::detail::{Earth,Jupiter}Impl``.""" links = self.link_name_format_dict() return { "- :ref:`{pimpl_detail_EarthImpl}`".format(**links), "- :ref:`{pimpl_detail_JupiterImpl}`".format(**links), } def earth_hpp_link_names(self): """Link names for ``earth.hpp``.""" links = self.link_name_format_dict() return { "- :ref:`{pimpl_Earth}`".format(**links), "- :ref:`{pimpl_Earth_v2}`".format(**links), "- :ref:`{pimpl_EarthImpl}`".format(**links), "- :ref:`{pimpl_detail_EarthImpl}`".format(**links) } def jupiter_hpp_link_names(self): """Link names for ``jupiter.hpp``.""" links = self.link_name_format_dict() return { "- :ref:`{pimpl_Jupiter}`".format(**links), "- :ref:`{pimpl_Jupiter_v2}`".format(**links), "- :ref:`{pimpl_JupiterImpl}`".format(**links), "- :ref:`{pimpl_detail_JupiterImpl}`".format(**links) } def nspace_pimpl_link_names(self): """Link names for ``namespace pimpl``.""" links = self.link_name_format_dict() return { "- :ref:`{pimpl_detail}`".format(**links), "- :ref:`{pimpl_Earth}`".format(**links), "- :ref:`{pimpl_Earth_v2}`".format(**links), "- :ref:`{pimpl_EarthImpl}`".format(**links), "- :ref:`{pimpl_Jupiter}`".format(**links), "- :ref:`{pimpl_Jupiter_v2}`".format(**links), "- :ref:`{pimpl_JupiterImpl}`".format(**links), "- :ref:`{pimpl_Planet}`".format(**links) } def nspace_pimpl_detail_link_names(self): """Link names for ``namespace pimpl::detail``.""" links = self.link_name_format_dict() return { "- :ref:`{pimpl_detail_EarthImpl}`".format(**links), "- :ref:`{pimpl_detail_JupiterImpl}`".format(**links) } def link_name_format_dict(self): """ Return a dictionary suitable for using with :any:`python:str.format`. Since Doxygen will behave differently on different platforms with respect to what the specific ``refid`` of a given node is, which affect the generated ``link_name`` for a given :class:`~exhale.graph.ExhaleNode`, they must be searched for after exhale runs for the given test function. **Return** (:class:`python:dict`) A dictionary with string keys and string values is returned, the key-value pairs are ``{name}``: ``{compound.link_name}``: +--------------------------------+--------------------------------------+ | Key | C++ Compound ``link_name`` | +================================+======================================+ | ``"pimpl"`` | ``namespace pimpl`` | +--------------------------------+--------------------------------------+ | ``"pimpl_detail"`` | ``namespace detail::pimpl`` | +--------------------------------+--------------------------------------+ | ``"pimpl_detail_EarthImpl"`` | ``class pimpl::detail::EarthImpl`` | +--------------------------------+--------------------------------------+ | ``"pimpl_detail_JupiterImpl"`` | ``class pimpl::detail::JupiterImpl`` | +--------------------------------+--------------------------------------+ | ``"pimpl_Earth"`` | ``class pimpl::Earth`` | +--------------------------------+--------------------------------------+ | ``"pimpl_Earth_v2"`` | ``class pimpl::Earth_v2`` | +--------------------------------+--------------------------------------+ | ``"pimpl_EarthImpl"`` | ``class pimpl::EarthImpl`` | +--------------------------------+--------------------------------------+ | ``"pimpl_Jupiter"`` | ``class pimpl::Jupiter`` | +--------------------------------+--------------------------------------+ | ``"pimpl_Jupiter_v2"`` | ``class pimpl::Jupiter_v2`` | +--------------------------------+--------------------------------------+ | ``"pimpl_JupiterImpl"`` | ``class pimpl::JupiterImpl`` | +--------------------------------+--------------------------------------+ | ``"pimpl_Planet"`` | ``class pimpl::Planet`` | +--------------------------------+--------------------------------------+ """ pimpl = None pimpl_detail = None pimpl_detail_EarthImpl = None pimpl_detail_JupiterImpl = None pimpl_Earth = None pimpl_Earth_v2 = None pimpl_EarthImpl = None pimpl_Jupiter = None pimpl_Jupiter_v2 = None pimpl_JupiterImpl = None pimpl_Planet = None exhale_root = get_exhale_root(self) for node in exhale_root.all_nodes: if node.kind == "namespace": if node.name == "pimpl": pimpl = node elif node.name == "pimpl::detail": pimpl_detail = node elif node.kind == "class": if node.name == "pimpl::Earth": pimpl_Earth = node elif node.name == "pimpl::Earth_v2": pimpl_Earth_v2 = node elif node.name == "pimpl::EarthImpl": pimpl_EarthImpl = node elif node.name == "pimpl::detail::EarthImpl": pimpl_detail_EarthImpl = node elif node.name == "pimpl::Jupiter": pimpl_Jupiter = node elif node.name == "pimpl::Jupiter_v2": pimpl_Jupiter_v2 = node elif node.name == "pimpl::JupiterImpl": pimpl_JupiterImpl = node elif node.name == "pimpl::detail::JupiterImpl": pimpl_detail_JupiterImpl = node elif node.name == "pimpl::Planet": pimpl_Planet = node # NOTE: test will crash if one is not found, which we want. return { "pimpl": pimpl.link_name, "pimpl_detail": pimpl_detail.link_name, "pimpl_detail_EarthImpl": pimpl_detail_EarthImpl.link_name, "pimpl_detail_JupiterImpl": pimpl_detail_JupiterImpl.link_name, "pimpl_Earth": pimpl_Earth.link_name, "pimpl_Earth_v2": pimpl_Earth_v2.link_name, "pimpl_EarthImpl": pimpl_EarthImpl.link_name, "pimpl_Jupiter": pimpl_Jupiter.link_name, "pimpl_Jupiter_v2": pimpl_Jupiter_v2.link_name, "pimpl_JupiterImpl": pimpl_JupiterImpl.link_name, "pimpl_Planet": pimpl_Planet.link_name } def expected_class_hierarchy(self, exclusions): """ Return expected rst class hiearchy listing based on specified ``exclusions``. Helper method for :func:`validate_class_hierarchy`. **Parameters** ``exclusions`` (:class:`TestedExclusionTypes`) The exclusion that is currently being tested. **Return** (:class:`python:str`) The expected rst class listing. If ``exclusions`` is invalid, then the string ``"INTERNAL TESTING ERROR"`` is returned. """ full_class_hierarchy_lines = textwrap.dedent('''\ - :ref:`{pimpl}` - :ref:`{pimpl_detail}` - :ref:`{pimpl_detail_EarthImpl}` - :ref:`{pimpl_detail_JupiterImpl}` - :ref:`{pimpl_Earth}` - :ref:`{pimpl_Earth_v2}` - :ref:`{pimpl_EarthImpl}` - :ref:`{pimpl_Jupiter}` - :ref:`{pimpl_Jupiter_v2}` - :ref:`{pimpl_JupiterImpl}` - :ref:`{pimpl_Planet}` ''').format(**self.link_name_format_dict()).splitlines() if exclusions == TestedExclusionTypes.NoExclusions: return "\n".join(full_class_hierarchy_lines) elif exclusions == TestedExclusionTypes.AllImpl: return "\n".join([ line for line in full_class_hierarchy_lines if "detail" not in line and "impl" not in line.lower() ]) elif exclusions == TestedExclusionTypes.DetailImpl: return "\n".join([ line for line in full_class_hierarchy_lines if "detail" not in line ]) return "INTERNAL TESTING ERROR" def validate_class_hierarchy(self, exclusions): """ Validate generated class hierarchy rst list is correct based on ``exclusions``. **Parameters** ``exclusions`` (:class:`TestedExclusionTypes`) The exclusion that is currently being tested. """ class_hierarchy_path = os.path.join(self.getAbsContainmentFolder(), "class_view_hierarchy.rst") expected_class_hierarchy = self.expected_class_hierarchy(exclusions) with open(class_hierarchy_path) as class_hierarchy: class_hierarchy_contents = class_hierarchy.read() self.assertTrue( expected_class_hierarchy in class_hierarchy_contents, textwrap.dedent('''\ Expected class hierarchy not in generated class hierarchy. Expected class hierarchy: {vsep} {expected} {vsep} Generated class hierarchy: {vsep} {generated} ''').format(vsep=('-' * 44), expected=expected_class_hierarchy, generated=class_hierarchy_contents)) def validate_namespace_listings(self, exclusions): """ Validate generated namespace rst listings are correct based on ``exclusions``. This project contains two namespaces that are tested: ``namespace pimpl`` and ``namespace pimpl::detail``. **Parameters** ``exclusions`` (:class:`TestedExclusionTypes`) The exclusion that is currently being tested. """ # First gather the two namespace nodes for this project so we can read in the # generated file's contents. exhale_root = get_exhale_root(self) # TODO: this may break if you un-do the reparenting stuff # There's only one top-level namespace pimpl = exhale_root.namespaces[0] pimpl_detail = None for child in pimpl.children: if child.kind == "namespace" and child.name == "pimpl::detail": pimpl_detail = child break # Make sure required / forbidden items check out for namespace pimpl pimpl_contents = self.contents_for_node(pimpl) if exclusions in { TestedExclusionTypes.NoExclusions, TestedExclusionTypes.DetailImpl }: pimpl_required = self.nspace_pimpl_link_names() pimpl_forbidden = None elif exclusions == TestedExclusionTypes.AllImpl: pimpl_required = self.nspace_pimpl_link_names( ) - self.impl_link_names() pimpl_forbidden = self.impl_link_names() self.cross_validate(pimpl_contents, required=pimpl_required, forbidden=pimpl_forbidden) # Make sure required / forbidden items check out for namespace pimpl::detail pimpl_detail_contents = self.contents_for_node(pimpl_detail) if exclusions == TestedExclusionTypes.NoExclusions: pimpl_detail_required = self.nspace_pimpl_detail_link_names() pimpl_detail_forbidden = None elif exclusions in { TestedExclusionTypes.AllImpl, TestedExclusionTypes.DetailImpl }: pimpl_detail_required = None pimpl_detail_forbidden = self.nspace_pimpl_detail_link_names() self.cross_validate(pimpl_detail_contents, required=pimpl_detail_required, forbidden=pimpl_detail_forbidden) def validate_file_listings(self): """ Validate ``{earth,jupiter}.hpp`` link to all items (regardless of ``"listingExclude"``). """ # Gather the exhale nodes for the two files we care about. exhale_root = get_exhale_root(self) earth_hpp = None jupiter_hpp = None for f in exhale_root.files: if "earth.hpp" in f.name: earth_hpp = f elif "jupiter.hpp" in f.name: jupiter_hpp = f # Make sure the "excluded" items are always included on file pages. self.cross_validate(self.contents_for_node(earth_hpp), required=self.earth_hpp_link_names(), forbidden=None) self.cross_validate(self.contents_for_node(jupiter_hpp), required=self.jupiter_hpp_link_names(), forbidden=None) def test_hierarchies(self): """Verify the class and file hierarchies.""" compare_file_hierarchy(self, file_hierarchy(self.file_hierarchy_dict)) compare_class_hierarchy(self, class_hierarchy(self.class_hierarchy_dict)) # TODO: once config objects are in this override is not necessary, but currently # the tests in tests/configs.py populate a listingExclude.... @confoverrides(exhale_args={"listingExclude": []}) def test_no_listing_exclusions(self): """Verify empty listing exclude results in no change in listed API.""" self.validate_class_hierarchy(TestedExclusionTypes.NoExclusions) self.validate_namespace_listings(TestedExclusionTypes.NoExclusions) self.validate_file_listings() self.checkAllFilesIncluded() @confoverrides(exhale_args={"listingExclude": [r".*Impl$"]}) def test_impl_exclude(self): """Verify ``r".*Impl$"`` excludes ``*Impl`` class names.""" self.validate_class_hierarchy(TestedExclusionTypes.AllImpl) self.validate_namespace_listings(TestedExclusionTypes.AllImpl) self.validate_file_listings() self.checkAllFilesIncluded() @confoverrides( exhale_args={"listingExclude": [(r".*impl$", re.IGNORECASE)]}) def test_impl_exclude_ignorecase(self): """ Verify ``r".*impl$`` with :data:`python:re.IGNORECASE` excludes ``*Impl`` items. """ self.validate_class_hierarchy(TestedExclusionTypes.AllImpl) self.validate_namespace_listings(TestedExclusionTypes.AllImpl) self.validate_file_listings() self.checkAllFilesIncluded() @confoverrides(exhale_args={"listingExclude": [r".*detail::.*Impl$"]}) def test_detail_impl_exclude(self): """ Verify ``r".*detail::.*Impl$`` excludes ``*detail::*Impl`` items. """ self.validate_class_hierarchy(TestedExclusionTypes.DetailImpl) self.validate_namespace_listings(TestedExclusionTypes.DetailImpl) self.validate_file_listings() self.checkAllFilesIncluded() @confoverrides(exhale_args={ "listingExclude": [(r".*detail::.*impl$", re.IGNORECASE)] }) def test_detail_impl_exclude_ignorecase(self): """ Verify ``r".*detail::.*impl$`` with |I| excludes ``*detail::*Impl`` items. .. |I| replace:: :data:`python:re.IGNORECASE` """ self.validate_class_hierarchy(TestedExclusionTypes.DetailImpl) self.validate_namespace_listings(TestedExclusionTypes.DetailImpl) self.validate_file_listings() self.checkAllFilesIncluded()
def make_file_hierarchy_dict(): """ Return the :class:`python:dict` representing the file hierarchy. If :data:`RUN_ABSURD_TEST` is ``True``, :data:`ABSURD_DIRECTORY_PATH` will be incorporated in the returned dictionary. """ absurdly_long_names_hpp_contents = { define("MAKE_IT_BIG"): {}, clike("class", make_it_big("class")): {}, clike("struct", make_it_big("struct")): {}, function("std::string", make_it_big("function")): parameters(), enum(make_it_big("enum")): {}, # TODO: values("first", "second", "third"), namespace(make_it_big("namespace")): { variable("int", "value"): {} }, define(make_it_big("define").upper()): {}, variable("int", make_it_big("variable")): {}, typedef(make_it_big("typedef"), "float"): {}, union(make_it_big("union")): {} } if RUN_ABSURD_TEST: absurd_directory_structure = { directory("structure"): { directory("that"): { directory("is"): { directory("longer"): { directory("than"): { directory("two"): { directory("hundred"): { directory("and"): { directory("fifty"): { directory("five"): { directory("characters"): { directory("long"): { directory("which"): { directory("is"): { directory("an"): { directory("absolutely"): { directory("and"): { directory("completely"): { directory("ridiculous"): { directory("thing"): { directory("to"): { directory("do"): { # noqa: E501 directory("and"): { # noqa: E501 directory("if"): { # noqa: E501 directory("you"): { # noqa: E501 directory("did"): { # noqa: E501 directory("this"): { # noqa: E501 directory("in"): { # noqa: E501 directory("the"): { # noqa: E501 directory("real"): { # noqa: E501 directory("world"): { # noqa: E501 directory("you"): { # noqa: E501 directory("put"): { # noqa: E501 directory("yourself"): { # noqa: E501 directory("comfortably"): { # noqa: E501 directory("in"): { # noqa: E501 directory("a"): { # noqa: E501 directory("position"): { # noqa: E501 directory("to"): { # noqa: E501 directory("be"): { # noqa: E501 directory("downsized"): { # noqa: E501 directory("and"): { # noqa: E501 directory("outta"): { # noqa: E501 directory("here"): { # noqa: E501 directory("as"): { # noqa: E501 directory("soul"): { # noqa: E501 directory("position"): { # noqa: E501 directory("would"): { # noqa: E501 directory("explain"): { # noqa: E501 directory("to"): { # noqa: E501 directory("you"): { # noqa: E501 file("a_file.hpp"): { # noqa: E501 function("std::string", "extremely_nested"): parameters() # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } # noqa: E501 } } } } } } } } } } } } } } } } } } } } } } } } } } return { directory("include"): { file("absurdly_long_names.hpp"): absurdly_long_names_hpp_contents, directory("directory"): absurd_directory_structure } } else: return { directory("include"): { file("absurdly_long_names.hpp"): absurdly_long_names_hpp_contents } }
class CPPNesting(ExhaleTestCase): """ Primary test class for project ``cpp_nesting``. """ test_project = "cpp_nesting" """.. testproject:: cpp_nesting""" file_hierarchy_dict = { directory("include"): { file("top_level.hpp"): { clike("struct", "top_level"): {} }, directory("nested"): { directory("one"): { file("one.hpp"): { namespace("nested"): { clike("struct", "one"): { clike("struct", "params"): { union("four_bytes"): {} } } } }, }, directory("two"): { file("two.hpp"): { namespace("nested"): { clike("struct", "two"): { clike("struct", "params"): { union("four_bytes"): {} } }, union("four_bytes"): {} } } }, directory("dual_nested"): { directory("one"): { file("one.hpp"): { namespace("nested"): { namespace("dual_nested"): { clike("struct", "one"): { clike("struct", "params"): { union("four_bytes"): {} } } } } } }, directory("two"): { file("two.hpp"): { namespace("nested"): { namespace("dual_nested"): { clike("struct", "two"): { clike("struct", "params"): { union("four_bytes"): {} } } } } } } } } } } class_hierarchy_dict = { clike("struct", "top_level"): {}, namespace("nested"): { clike("struct", "one"): { clike("struct", "params"): { union("four_bytes"): {} } }, clike("struct", "two"): { clike("struct", "params"): { union("four_bytes"): {} } }, union("four_bytes"): {}, namespace("dual_nested"): { clike("struct", "one"): { clike("struct", "params"): { union("four_bytes"): {} } }, clike("struct", "two"): { clike("struct", "params"): { union("four_bytes"): {} } } } } } def test_hierarchies(self): """Verify the class and file hierarchies.""" compare_file_hierarchy(self, file_hierarchy(self.file_hierarchy_dict)) compare_class_hierarchy(self, class_hierarchy(self.class_hierarchy_dict)) @confoverrides(exhale_args={"doxygenStripFromPath": "../include"}) def test_hierarchies_stripped(self): """ Verify the class and file hierarchies with ``doxygenStripFromPath=../include``. .. todo:: this test is not supported yet """ return # TODO: Exhale should remove the include/ directory # dirty hack to pop off the first include/ directory without needing to know # the actual object that is the first and only key for key in self.file_hierarchy_dict: no_include = self.file_hierarchy_dict[key] break compare_file_hierarchy(self, file_hierarchy(no_include)) compare_class_hierarchy(self, class_hierarchy(self.class_hierarchy_dict))
class CPPFortranMixed(ExhaleTestCase): """ Primary test class for project ``cpp_fortran_mixed``. This test class exists to test explicit language lexer mappings via :data:`~exhale.configs.lexerMapping`. Note that the C++ code and namespace ``convert`` is definitively chosen to be different than the name of the fortran module name (``conversions``). If they are the same, some interesting things happen on the Doxygen side, because Doxygen will combine the namespaces. .. todo:: These tests are incomplete (``from __future__ import config_objects``). The module level storage creates conflicts between the test cases when specifying the regular expressions :/ Currently there is only one test for a custom lexer mapping, and it only actually works because the name is alphabetically sorted after the default test (meaning pytest will run it after). .. todo:: The full function validation does not support templates (yet). Templates at large in the testing framework need to be reworked, currently it is all boiler plate code with no actual validation... """ test_project = "cpp_fortran_mixed" """.. testproject:: cpp_fortran_mixed""" file_hierarchy_dict = { directory("include"): { directory("convert"): { file("convert.hpp"): { namespace("convert"): { function("T", "to_degrees", template=["typename T"]): parameters("T"), function("T", "to_radians", template=["typename T"]): parameters("T") } } } }, directory("src"): { file("conversions.f90"): { namespace("conversions"): { variable("real(c_float)", "pi_s"): {}, variable("real(c_double)", "pi_d"): {}, variable("real(c_float)", "s_180"): {}, variable("real(c_double)", "d_180"): {}, # NOTE: function parameters in fortran are a little weird. # 1. <type> has 'function', e.g. 'real(c_float) function' # 2. Parameters are names, not types? function("real(c_float) function", "degrees_to_radians_s"): parameters("degrees_s"), function("real(c_double) function", "degrees_to_radians_d"): parameters("degrees_d"), function("real(c_float) function", "radians_to_degrees_s"): parameters("radians_s"), function("real(c_double) function", "radians_to_degrees_d"): parameters("radians_d") } } } } """The file hierarchy for this project.""" def test_hierarchies(self): """ Validate the class and file hierarchies. **Not tested on Windows**, maybe I'll care to fix it one day. `But it is not this day`__! __ https://youtu.be/EXGUNvIFTQw .. todo:: Too much shared code in hierarchy comparisons, the class hierarchy for this project should be **empty**. Need to enable asserting this fact (same for the ``cpp_nesting`` project). """ if platform.system() != "Windows": compare_file_hierarchy(self, file_hierarchy(self.file_hierarchy_dict)) # compare_class_hierarchy(self, class_hierarchy({})) def validate_pygments_lexers(self, exhale_root, node_map): """ Validate nodes have the expected pygments lexer in their program listing file. **Parameters** ``exhale_root`` (:class:`exhale.graph.ExhaleRoot`) The graph root object for this project. ``node_map`` (:class:`python:dict`) A map of :class:`exhale.graph.ExhaleNode` objects to string values. The keys must be the nodes extracted from the ``exhale_root`` (as opposed to a testing type). Each value should be a pygments lexer, such as ``"cpp"`` or ``"fortran"``. The generated program listing file will be parsed and an assert statement performed for equality to these specified values. """ lexer_regex = re.compile(r"^.. code-block:: (.*)$") for file_node in node_map: expected_lexer = node_map[file_node] program_listing_file_path = os.path.join( exhale_root.root_directory, file_node.program_file) lexer_was_asserted = False with open(program_listing_file_path) as program_listing_file: for line in program_listing_file: lexer_match = lexer_regex.match(line) if lexer_match: lexer = lexer_match.groups()[0] self.assertTrue( lexer == expected_lexer, "{0}: expected '{1}' but got '{2}' language lexer." .format(file_node.location, expected_lexer, lexer)) lexer_was_asserted = True break # Make sure we actually ran a check for this file. self.assertTrue( lexer_was_asserted, "Did not find '.. code-block:: xxxx' in [{0}]".format( program_listing_file_path)) def get_hpp_and_f90_nodes(self, exhale_root): """ Return the two :class:`~exhale.graph.ExhaleNode` objects for this project. **Parameters** ``exhale_root`` (:class:`~exhale.graph.ExhaleRoot`) The graph root object for this project. **Returns** :class:`python:tuple` A length two tuple of :class:`~exhale.graph.ExhaleNode` objects, ordered as ``(convert_hpp, conversions_f90)``. These represent the files ``include/convert/convert.hpp`` and ``src/conversions.f90``, respectively. """ convert_hpp = None convert_hpp_path = os.path.join("include", "convert", "convert.hpp") conversions_f90 = None conversions_f90_path = os.path.join("src", "conversions.f90") for f in exhale_root.files: if f.location == convert_hpp_path: convert_hpp = f continue elif f.location == conversions_f90_path: conversions_f90 = f continue self.assertTrue( convert_hpp is not None, "Could not find ExhaleNode with file location 'include/convert/convert.hpp'." ) self.assertTrue( conversions_f90 is not None, "Could not find ExhaleNode with file location 'src/conversions.f90'." ) return (convert_hpp, conversions_f90) def test_default_lexers(self): """ Verify ``convert.hpp`` maps to ``"cpp"`` and ``conversions.f90`` to ``"fortran"``. """ exhale_root = get_exhale_root(self) convert_hpp, conversions_f90 = self.get_hpp_and_f90_nodes(exhale_root) self.validate_pygments_lexers(exhale_root, { convert_hpp: "cpp", conversions_f90: "fortran" }) @confoverrides(exhale_args={"lexerMapping": {r".*\.f90": "python"}}) def test_modified_fortran(self): """ Verify regular expression overload of ``*.f90`` files map to ``"python"``. """ exhale_root = get_exhale_root(self) convert_hpp, conversions_f90 = self.get_hpp_and_f90_nodes(exhale_root) self.validate_pygments_lexers(exhale_root, { convert_hpp: "cpp", conversions_f90: "python" })