Esempio n. 1
0
    def test_get_output_path_on_windows(self):
        output_path = "output_path"
        report = TestReport()
        runner = TestRunner(report, output_path)

        with mock.patch("sys.platform", new="win32"):
            with mock.patch("os.environ", new={}):
                test_name = "_" * 400
                test_output = runner._get_output_path(test_name)
                self.assertEqual(len(test_output), 260 - 100 + 1)

            with mock.patch("os.environ",
                            new={"VUNIT_TEST_OUTPUT_PATH_MARGIN": "-1000"}):
                output_path = "output_path"
                test_name = "_" * 400
                test_output = runner._get_output_path(test_name)
                self.assertEqual(
                    test_output,
                    str(
                        Path(output_path).resolve() /
                        (test_name + "_" + hash_string(test_name))),
                )

            with mock.patch("os.environ",
                            new={"VUNIT_SHORT_TEST_OUTPUT_PATHS": ""}):
                output_path = "output_path"
                test_name = "_" * 400
                test_output = runner._get_output_path(test_name)
                self.assertEqual(
                    test_output,
                    str(Path(output_path).resolve() / hash_string(test_name)),
                )
Esempio n. 2
0
    def test_create_output_path_on_windows(self):
        with mock.patch("sys.platform", new="win32"):
            with mock.patch("os.environ", new={}):
                output_path = "output_path"
                test_name = "_" * 400
                test_output = create_output_path(output_path, test_name)
                self.assertEqual(len(test_output), 260 - 100 + 1)

            with mock.patch("os.environ",
                            new={"VUNIT_TEST_OUTPUT_PATH_MARGIN": "-1000"}):
                output_path = "output_path"
                test_name = "_" * 400
                test_output = create_output_path(output_path, test_name)
                self.assertEqual(
                    test_output,
                    join(abspath(output_path),
                         test_name + "_" + hash_string(test_name)))

            with mock.patch("os.environ",
                            new={"VUNIT_SHORT_TEST_OUTPUT_PATHS": ""}):
                output_path = "output_path"
                test_name = "_" * 400
                test_output = create_output_path(output_path, test_name)
                self.assertEqual(
                    test_output,
                    join(abspath(output_path), hash_string(test_name)))
Esempio n. 3
0
def _file_content_hash(file_name, encoding, database=None, newline=None):
    """
    Returns the file content as well as the hash of the content

    Use the database to keep a persistent cache of the last content
    hash.  If the file modification date has not changed assume the
    hash is the same and do not re-open the file.
    """

    if database is None:
        content = read_file(file_name, encoding=encoding, newline=newline)
        return content, hash_string(content)

    key = ("cached._file_content_hash(%s, newline=%s)" % (file_name, newline)).encode()

    if key not in database:
        content = read_file(file_name, encoding=encoding, newline=newline)
        content_hash = hash_string(content)
        timestamp = os.path.getmtime(file_name)
        database[key] = timestamp, content_hash
        return content, content_hash

    timestamp = os.path.getmtime(file_name)
    last_timestamp, last_content_hash = database[key]
    if timestamp != last_timestamp:
        content = read_file(file_name, encoding=encoding, newline=newline)
        content_hash = hash_string(content)
        database[key] = timestamp, content_hash
        return content, content_hash

    return None, last_content_hash
Esempio n. 4
0
    def test_create_output_path_on_linux(self):
        with mock.patch("sys.platform", new="linux"):
            with mock.patch("os.environ", new={}):
                output_path = "output_path"
                test_name = "_" * 400
                test_output = create_output_path(output_path, test_name)
                self.assertEqual(
                    test_output,
                    join(abspath(output_path),
                         test_name + "_" + hash_string(test_name)))

                output_path = "output_path"
                test_name = "123._-+"
                test_output = create_output_path(output_path, test_name)
                self.assertEqual(
                    test_output,
                    join(abspath(output_path),
                         test_name + "_" + hash_string(test_name)))

                output_path = "output_path"
                test_name = "#<>:"
                safe_name = "____"
                test_output = create_output_path(output_path, test_name)
                self.assertEqual(
                    test_output,
                    join(abspath(output_path),
                         safe_name + "_" + hash_string(test_name)))
Esempio n. 5
0
    def test_get_output_path_on_linux(self):
        output_path = "output_path"
        report = TestReport()
        runner = TestRunner(report, output_path)

        with mock.patch("sys.platform", new="linux"):
            with mock.patch("os.environ", new={}):
                test_name = "_" * 400
                test_output = runner._get_output_path(test_name)
                self.assertEqual(
                    test_output,
                    str(Path(output_path).resolve() / (test_name + "_" + hash_string(test_name))),
                )

                output_path = "output_path"
                test_name = "123._-+"
                test_output = runner._get_output_path(test_name)
                self.assertEqual(
                    test_output,
                    str(Path(output_path).resolve() / (test_name + "_" + hash_string(test_name))),
                )

                output_path = "output_path"
                test_name = "#<>:"
                safe_name = "____"
                test_output = runner._get_output_path(test_name)
                self.assertEqual(
                    test_output,
                    str(Path(output_path).resolve() / (safe_name + "_" + hash_string(test_name))),
                )
Esempio n. 6
0
def _file_content_hash(file_name, encoding, database=None, newline=None):
    """
    Returns the file content as well as the hash of the content

    Use the database to keep a persistent cache of the last content
    hash.  If the file modification date has not changed assume the
    hash is the same and do not re-open the file.
    """

    if database is None:
        content = read_file(file_name, encoding=encoding, newline=newline)
        return content, hash_string(content)

    key = ("cached._file_content_hash(%s, newline=%s)" %
           (file_name, newline)).encode()

    if key not in database:
        content = read_file(file_name, encoding=encoding, newline=newline)
        content_hash = hash_string(content)
        timestamp = os.path.getmtime(file_name)
        database[key] = timestamp, content_hash
        return content, content_hash

    timestamp = os.path.getmtime(file_name)
    last_timestamp, last_content_hash = database[key]
    if timestamp != last_timestamp:
        content = read_file(file_name, encoding=encoding, newline=newline)
        content_hash = hash_string(content)
        database[key] = timestamp, content_hash
        return content, content_hash

    return None, last_content_hash
Esempio n. 7
0
 def content_hash(self):
     """
     Compute hash of contents and compile options
     """
     return hash_string(
         self._content_hash
         + self._compile_options_hash()
         + hash_string(str(self._vhdl_standard))
     )
Esempio n. 8
0
 def __init__(self, name, library, verilog_parser, include_dirs=None, defines=None):
     SourceFile.__init__(self, name, library, 'verilog')
     self.package_dependencies = []
     self.module_dependencies = []
     self.include_dirs = include_dirs if include_dirs is not None else []
     self.defines = defines.copy() if defines is not None else {}
     code = ostools.read_file(self.name, encoding=HDL_FILE_ENCODING)
     self._content_hash = hash_string(code)
     for key, value in self.defines.items():
         self._content_hash = hash_string(self._content_hash + hash_string(key))
         self._content_hash = hash_string(self._content_hash + hash_string(value))
     self.parse(code, verilog_parser, include_dirs)
Esempio n. 9
0
 def __init__(self, name, library, verilog_parser, include_dirs=None, defines=None):
     SourceFile.__init__(self, name, library, 'verilog')
     self.package_dependencies = []
     self.module_dependencies = []
     self.include_dirs = include_dirs if include_dirs is not None else []
     self.defines = defines.copy() if defines is not None else {}
     code = ostools.read_file(self.name)
     self._content_hash = hash_string(code)
     for key, value in self.defines.items():
         self._content_hash = hash_string(self._content_hash + hash_string(key))
         self._content_hash = hash_string(self._content_hash + hash_string(value))
     self.parse(code, verilog_parser, include_dirs)
Esempio n. 10
0
    def parse(self, code, parser, include_dirs):
        """
        Parse Verilog code and adding dependencies and design units
        """
        try:
            design_file = parser.parse(code, self.name, include_dirs, self.defines)
            for included_file_name in design_file.included_files:
                self._content_hash = hash_string(self._content_hash +
                                                 ostools.read_file(included_file_name, encoding=HDL_FILE_ENCODING))
            for module in design_file.modules:
                self.design_units.append(ModuleDesignUnit(module.name, self, module.parameters))

            for package in design_file.packages:
                self.design_units.append(VerilogDesignUnit(package.name, self, "package"))

            for package_name in design_file.imports:
                self.package_dependencies.append(package_name)

            for package_name in design_file.package_references:
                self.package_dependencies.append(package_name)

            for instance_name in design_file.instances:
                self.module_dependencies.append(instance_name)

        except KeyboardInterrupt:
            raise
        except:  # pylint: disable=bare-except
            traceback.print_exc()
            LOGGER.error("Failed to parse %s", self.name)
Esempio n. 11
0
 def _hash_file_name_of(self, source_file):
     """
     Returns the name of the hash file associated with the source_file
     """
     library = self.get_library(source_file.library.name)
     prefix = hash_string(str(Path(source_file.name).parent))
     return str(Path(library.directory) / prefix / Path(source_file.name).name / ".vunit_hash")
Esempio n. 12
0
    def _compile_options_hash(self):
        """
        Compute hash of compile options

        Needs to be updated if there are nested dictionaries
        """
        return hash_string(repr(sorted(self._compile_options.items())))
Esempio n. 13
0
    def _create_test_mapping_file(self, test_suites):
        """
        Create a file mapping test name to test output folder.
        This is to allow the user to find the test output folder when it is hashed
        """
        mapping_file_name = join(self._output_path, "test_name_to_path_mapping.txt")

        # Load old mapping to remember non-deleted test folders as well
        # even when re-running only a single test case
        if exists(mapping_file_name):
            with open(mapping_file_name, "r") as fptr:
                mapping = set(fptr.read().splitlines())
        else:
            mapping = set()

        for test_suite in test_suites:
            name_hash = hash_string(test_suite.name)
            HASH_TO_TEST_NAME[name_hash] = test_suite.name
            mapping.add("%s %s" % (name_hash, test_suite.name))

        # Sort by everything except hash
        mapping = sorted(mapping, key=lambda value: value[value.index(" "):])

        with open(mapping_file_name, "w") as fptr:
            for value in mapping:
                fptr.write(value + "\n")
Esempio n. 14
0
    def _compile_options_hash(self):
        """
        Compute hash of compile options

        Needs to be updated if there are nested dictionaries
        """
        return hash_string(repr(sorted(self._compile_options.items())))
Esempio n. 15
0
 def __init__(self, name, library, vhdl_parser):
     SourceFile.__init__(self, name, library, 'vhdl')
     self.dependencies = []
     self.depending_components = []
     code = ostools.read_file(self.name)
     self._content_hash = hash_string(code)
     self.parse(code, vhdl_parser)
Esempio n. 16
0
 def __init__(self, name, library, vhdl_parser):
     SourceFile.__init__(self, name, library, 'vhdl')
     self.dependencies = []
     self.depending_components = []
     code = ostools.read_file(self.name)
     self._content_hash = hash_string(code)
     self.parse(code, vhdl_parser)
Esempio n. 17
0
 def _hash_file_name_of(self, source_file):
     """
     Returns the name of the hash file associated with the source_file
     """
     library = self.get_library(source_file.library.name)
     prefix = hash_string(dirname(source_file.name))
     return join(library.directory, prefix, basename(source_file.name) + ".vunit_hash")
Esempio n. 18
0
def create_output_path(output_file, test_suite_name):
    """
    Create the full output path of a test case.
    Ensure no bad characters and no long path names.
    """
    hash_name = hash_string(test_suite_name)
    return join(output_file, hash_name)
Esempio n. 19
0
    def _create_test_mapping_file(self, test_suites):
        """
        Create a file mapping test name to test output folder.
        This is to allow the user to find the test output folder when it is hashed
        """
        mapping_file_name = join(self._output_path, "test_name_to_path_mapping.txt")

        # Load old mapping to remember non-deleted test folders as well
        # even when re-running only a single test case
        if exists(mapping_file_name):
            with open(mapping_file_name, "r") as fptr:
                mapping = set(fptr.read().splitlines())
        else:
            mapping = set()

        for test_suite in test_suites:
            name_hash = hash_string(test_suite.name)
            mapping.add("%s %s" % (name_hash, test_suite.name))

        # Sort by everything except hash
        mapping = sorted(mapping, key=lambda value: value[value.index(" "):])

        with open(mapping_file_name, "w") as fptr:
            for value in mapping:
                fptr.write(value + "\n")
Esempio n. 20
0
    def parse(self, code, parser, include_dirs):
        """
        Parse Verilog code and adding dependencies and design units
        """
        try:
            design_file = parser.parse(code, self.name, include_dirs,
                                       self.defines)
            for included_file_name in design_file.included_files:
                self._content_hash = hash_string(
                    self._content_hash + ostools.read_file(included_file_name))
            for module in design_file.modules:
                self.design_units.append(
                    ModuleDesignUnit(module.name, self, module.parameters))

            for package in design_file.packages:
                self.design_units.append(
                    VerilogDesignUnit(package.name, self, "package"))

            for package_name in design_file.imports:
                self.package_dependencies.append(package_name)

            for package_name in design_file.package_references:
                self.package_dependencies.append(package_name)

            for instance_name in design_file.instances:
                self.module_dependencies.append(instance_name)

        except KeyboardInterrupt:
            raise
        except:  # pylint: disable=bare-except
            traceback.print_exc()
            LOGGER.error("Failed to parse %s", self.name)
Esempio n. 21
0
 def _hash_file_name_of(self, source_file):
     """
     Returns the name of the hash file associated with the source_file
     """
     library = self.get_library(source_file.library.name)
     prefix = hash_string(dirname(source_file.name))
     return join(library.directory, prefix, basename(source_file.name) + ".vunit_hash")
Esempio n. 22
0
def create_output_path(output_file, test_suite_name):
    """
    Create the full output path of a test case.
    Ensure no bad characters and no long path names.
    """
    hash_name = hash_string(test_suite_name)
    return join(output_file, hash_name)
Esempio n. 23
0
 def __init__(self, name, library, verilog_parser, include_dirs):
     SourceFile.__init__(self, name, library, 'verilog')
     self.package_dependencies = []
     self.module_dependencies = []
     self.include_dirs = include_dirs if include_dirs is not None else []
     code = ostools.read_file(self.name)
     self._content_hash = hash_string(code)
     self.parse(code, verilog_parser, include_dirs)
Esempio n. 24
0
    def __init__(
            self,  # pylint: disable=too-many-arguments
            name,
            library,
            verilog_parser,
            include_dirs=None,
            defines=None,
            no_parse=False):
        SourceFile.__init__(self, name, library, 'verilog')
        self.package_dependencies = []
        self.module_dependencies = []
        self.include_dirs = include_dirs if include_dirs is not None else []
        self.defines = defines.copy() if defines is not None else {}
        code = ostools.read_file(self.name, encoding=HDL_FILE_ENCODING)
        self._content_hash = hash_string(code)

        for path in self.include_dirs:
            self._content_hash = hash_string(self._content_hash +
                                             hash_string(path))

        for key, value in self.defines.items():
            self._content_hash = hash_string(self._content_hash +
                                             hash_string(key))
            self._content_hash = hash_string(self._content_hash +
                                             hash_string(value))

        if not no_parse:
            self.parse(code, verilog_parser, include_dirs)
Esempio n. 25
0
 def _content_hash(self, file_name):
     """
     Hash the contents of the file
     """
     if file_name is None or not exists(file_name):
         return None
     if file_name not in self._content_cache:
         self._content_cache[file_name] = "sha1:" + hash_string(read_file(file_name))
     return self._content_cache[file_name]
Esempio n. 26
0
 def __init__(self, name, library, vhdl_parser, vhdl_standard):
     SourceFile.__init__(self, name, library, 'vhdl')
     self.dependencies = []
     self.depending_components = []
     self._vhdl_standard = vhdl_standard
     check_vhdl_standard(vhdl_standard)
     code = ostools.read_file(self.name, encoding=HDL_FILE_ENCODING)
     self._content_hash = hash_string(code)
     self.parse(code, vhdl_parser)
Esempio n. 27
0
 def __init__(self, name, library, vhdl_parser, vhdl_standard):
     SourceFile.__init__(self, name, library, 'vhdl')
     self.dependencies = []
     self.depending_components = []
     self._vhdl_standard = vhdl_standard
     check_vhdl_standard(vhdl_standard)
     code = ostools.read_file(self.name, encoding=HDL_FILE_ENCODING)
     self._content_hash = hash_string(code)
     self.parse(code, vhdl_parser)
Esempio n. 28
0
 def _content_hash(self, file_name):
     """
     Hash the contents of the file
     """
     if file_name is None or not exists(file_name):
         return None
     if file_name not in self._content_cache:
         self._content_cache[file_name] = "sha1:" + hash_string(read_file(file_name))
     return self._content_cache[file_name]
Esempio n. 29
0
    def __init__(  # pylint: disable=too-many-arguments
        self,
        file_type,
        name,
        library,
        verilog_parser,
        database,
        include_dirs=None,
        defines=None,
        no_parse=False,
    ):
        SourceFile.__init__(self, name, library, file_type)
        self.package_dependencies = []
        self.module_dependencies = []
        self.include_dirs = include_dirs if include_dirs is not None else []
        self.defines = defines.copy() if defines is not None else {}
        self._content_hash = file_content_hash(self.name,
                                               encoding=HDL_FILE_ENCODING,
                                               database=database)

        for path in self.include_dirs:
            self._content_hash = hash_string(self._content_hash +
                                             hash_string(path))

        for key, value in sorted(self.defines.items()):
            self._content_hash = hash_string(self._content_hash +
                                             hash_string(key))
            self._content_hash = hash_string(self._content_hash +
                                             hash_string(value))

        if not no_parse:
            self.parse(verilog_parser, database, include_dirs)
Esempio n. 30
0
    def test_create_output_path_on_windows(self):
        with mock.patch("sys.platform", new="win32"):
            with mock.patch("os.environ", new={}):
                output_path = "output_path"
                test_name = "_" * 400
                test_output = create_output_path(output_path, test_name)
                self.assertEqual(len(test_output), 260 - 100 + 1)

            with mock.patch("os.environ", new={"VUNIT_TEST_OUTPUT_PATH_MARGIN": "-1000"}):
                output_path = "output_path"
                test_name = "_" * 400
                test_output = create_output_path(output_path, test_name)
                self.assertEqual(test_output, join(abspath(output_path), test_name + "_" + hash_string(test_name)))

            with mock.patch("os.environ", new={"VUNIT_SHORT_TEST_OUTPUT_PATHS": ""}):
                output_path = "output_path"
                test_name = "_" * 400
                test_output = create_output_path(output_path, test_name)
                self.assertEqual(test_output, join(abspath(output_path), hash_string(test_name)))
Esempio n. 31
0
def create_output_path(output_path, test_suite_name):
    """
    Create the full output path of a test case.
    Ensure no bad characters and no long path names.
    """
    output_path = abspath(output_path)
    safe_name = "".join(char if _is_legal(char) else '_' for char in test_suite_name) + "_"
    hash_name = hash_string(test_suite_name)

    if "VUNIT_SHORT_TEST_OUTPUT_PATHS" in os.environ:
        full_name = hash_name
    elif sys.platform == "win32":
        max_path = 260
        margin = int(os.environ.get("VUNIT_TEST_OUTPUT_PATH_MARGIN", "100"))
        prefix_len = len(output_path)
        full_name = safe_name[:min(max_path - margin - prefix_len - len(hash_name), len(safe_name))] + hash_name
    else:
        full_name = safe_name + hash_name

    return join(output_path, full_name)
Esempio n. 32
0
def create_output_path(output_path, test_suite_name):
    """
    Create the full output path of a test case.
    Ensure no bad characters and no long path names.
    """
    output_path = abspath(output_path)
    safe_name = "".join(char if _is_legal(char) else '_' for char in test_suite_name) + "_"
    hash_name = hash_string(test_suite_name)

    if "VUNIT_SHORT_TEST_OUTPUT_PATHS" in os.environ:
        full_name = hash_name
    elif sys.platform == "win32":
        max_path = 260
        margin = int(os.environ.get("VUNIT_TEST_OUTPUT_PATH_MARGIN", "100"))
        prefix_len = len(output_path)
        full_name = safe_name[:min(max_path - margin - prefix_len - len(hash_name), len(safe_name))] + hash_name
    else:
        full_name = safe_name + hash_name

    return join(output_path, full_name)
Esempio n. 33
0
    def parse(self, code, file_name, content_hash=None):
        """
        Parse the VHDL code and return a VHDLDesignFile parse result
        parse result is re-used if content hash found in database
        """
        file_name = abspath(file_name)

        if content_hash is None:
            content_hash = "sha1:" + hash_string(code)
        key = ("CachedVHDLParser.parse(%s)" % file_name).encode()

        if key in self._database:
            design_file, old_content_hash = self._database[key]
            if content_hash == old_content_hash:
                LOGGER.debug("Re-using cached VHDL parse results for %s with content_hash=%s",
                             file_name, content_hash)
                return design_file

        design_file = VHDLDesignFile.parse(code)
        self._database[key] = design_file, content_hash
        return design_file
Esempio n. 34
0
    def parse(self, code, file_name, content_hash=None):
        """
        Parse the VHDL code and return a VHDLDesignFile parse result
        parse result is re-used if content hash found in database
        """
        file_name = abspath(file_name)

        if content_hash is None:
            content_hash = "sha1:" + hash_string(code)
        key = ("CachedVHDLParser.parse(%s)" % file_name).encode()

        if key in self._database:
            design_file, old_content_hash = self._database[key]
            if content_hash == old_content_hash:
                LOGGER.debug("Re-using cached VHDL parse results for %s with content_hash=%s",
                             file_name, content_hash)
                return design_file

        design_file = VHDLDesignFile.parse(code)
        self._database[key] = design_file, content_hash
        return design_file
Esempio n. 35
0
    def parse(self, parser, database, include_dirs):
        """
        Parse Verilog code and adding dependencies and design units
        """
        try:
            design_file = parser.parse(self.name, include_dirs, self.defines)
            for included_file_name in design_file.included_files:
                self._content_hash = hash_string(
                    self._content_hash + file_content_hash(
                        included_file_name,
                        encoding=HDL_FILE_ENCODING,
                        database=database,
                    ))

            for module in design_file.modules:
                self.design_units.append(
                    Module(module.name, self, module.parameters))

            for package in design_file.packages:
                self.design_units.append(
                    DesignUnit(package.name, self, "package"))

            for package_name in design_file.imports:
                self.package_dependencies.append(package_name)

            for package_name in design_file.package_references:
                self.package_dependencies.append(package_name)

            for instance_name in design_file.instances:
                self.module_dependencies.append(instance_name)

        except KeyboardInterrupt as exk:
            raise KeyboardInterrupt from exk
        except:  # pylint: disable=bare-except
            traceback.print_exc()
            LOGGER.error("Failed to parse %s", self.name)
Esempio n. 36
0
    def __init__(self,  # pylint: disable=too-many-arguments
                 file_type, name, library, verilog_parser, database, include_dirs=None, defines=None, no_parse=False):
        SourceFile.__init__(self, name, library, file_type)
        self.package_dependencies = []
        self.module_dependencies = []
        self.include_dirs = include_dirs if include_dirs is not None else []
        self.defines = defines.copy() if defines is not None else {}
        self._content_hash = file_content_hash(self.name, encoding=HDL_FILE_ENCODING,
                                               database=database)

        for path in self.include_dirs:
            self._content_hash = hash_string(self._content_hash + hash_string(path))

        for key, value in sorted(self.defines.items()):
            self._content_hash = hash_string(self._content_hash + hash_string(key))
            self._content_hash = hash_string(self._content_hash + hash_string(value))

        if not no_parse:
            self.parse(verilog_parser, database, include_dirs)
Esempio n. 37
0
 def content_hash(self):
     """
     Compute hash of contents and compile options
     """
     return hash_string(self._content_hash + self._compile_options_hash() + hash_string(self._vhdl_standard))
Esempio n. 38
0
    def test_create_output_path_on_linux(self):
        with mock.patch("sys.platform", new="linux"):
            with mock.patch("os.environ", new={}):
                output_path = "output_path"
                test_name = "_" * 400
                test_output = create_output_path(output_path, test_name)
                self.assertEqual(test_output, join(abspath(output_path), test_name + "_" + hash_string(test_name)))

                output_path = "output_path"
                test_name = "123._-+"
                test_output = create_output_path(output_path, test_name)
                self.assertEqual(test_output, join(abspath(output_path), test_name + "_" + hash_string(test_name)))

                output_path = "output_path"
                test_name = "#<>:"
                safe_name = "____"
                test_output = create_output_path(output_path, test_name)
                self.assertEqual(test_output, join(abspath(output_path), safe_name + "_" + hash_string(test_name)))