verilator-dspsim 5.30.0__tar.gz

verilator_dspsim-5.30.0/.github/workflows/build_wheels.yaml

@@ -0,0 +1,83 @@
+name: Build
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+      - releases/**
+
+jobs:
+  build_windows_wheels:
+    name: Python cibuildwheel windows
+    runs-on: ["self-hosted", "Windows", "x64"]
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.13'
+          cache: 'pip' # caching pip dependencies
+
+      - name: Build Windows wheels
+        run: pipx run cibuildwheel
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cibw-wheels-windows
+          path: ./wheelhouse/*
+
+  build_linux_wheels:
+    name: Python cibuildwheel linux
+    runs-on: ["self-hosted", "Linux", "x64"]
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.13'
+
+      - name: Build Linux wheels
+        run: pipx run cibuildwheel --platform linux
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cibw-wheels-linux
+          path: ./wheelhouse/*
+
+  build_sdist:
+    name: Build source distribution
+    runs-on: ["self-hosted", "Windows", "x64"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.13'
+          cache: 'pip' # caching pip dependencies
+
+      - name: Build sdist
+        run: pipx run build --sdist
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cibw-sdist
+          path: ./dist/*
+
+  # upload_pypi:
+  #   needs: [build_windows_wheels, build_linux_wheels, build_sdist]
+  #   runs-on: ubuntu-latest
+  #   environment: pypi
+  #   permissions:
+  #     id-token: write
+  #   if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
+  #   steps:
+  #     - uses: actions/download-artifact@v4
+  #       with:
+  #         # unpacks all CIBW artifacts into dist/
+  #         pattern: cibw-*
+  #         path: dist
+  #         merge-multiple: true
+
+  #     - uses: pypa/gh-action-pypi-publish@release/v1
+  #       with:
+  #         repository-url: https://test.pypi.org/legacy/

verilator_dspsim-5.30.0/.gitignore

@@ -0,0 +1,7 @@
+venv
+build
+dist
+__pycache__
+wheelhouse
+.env
+archive

verilator_dspsim-5.30.0/CMakeLists.txt

@@ -0,0 +1,21 @@
+cmake_minimum_required(VERSION 3.26)
+project(${SKBUILD_PROJECT_NAME} LANGUAGES CXX VERSION ${SKBUILD_PROJECT_VERSION})
+
+# Use fetch content to build verilator as a dependency.
+# scikit-build-core will install all CMake targets into the wheel.
+
+# Building Verilator on Windows requires using CMake, so this is the normal process
+# for building Verilator. Before installing, you must install any dependencies. 
+# Follow the Verilator user manual to see how to install.
+# TODO: Maybe I can install flex/bison here too?
+
+# Alegedly, building verilator with CMake on linux is still experimental.
+# I am using Ubuntu 22.04 on WSL, and it seems to work just fine.
+include(FetchContent)
+FetchContent_Declare(
+    verilator
+    GIT_REPOSITORY https://github.com/verilator/verilator.git
+    GIT_TAG v5.030)
+FetchContent_MakeAvailable(verilator)
+
+# No need to do anything else.

verilator_dspsim-5.30.0/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

verilator_dspsim-5.30.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.1
+Name: verilator-dspsim
+Version: 5.30.0
+Summary: A Python wrapper around an installation of Verilator.
+Author: Frank Sodari
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Project-URL: Homepage, https://github.com/fsodari/verilator-python
+Description-Content-Type: text/markdown
+
+# Verilator Python
+
+This python package contains a pre-built installation of verilator, and a python wrapper to run verilator. It should function exactly the same as if you installed verilator through normal means.
+
+Installing this python package will install "verilator.exe" into the python environments scripts/bin folder, so it can be ran and can easily be found by CMake.
+
+The main goal of this project is to simplify distributing verilator and using it within a python application.
+
+# Installation
+
+
+Verilator requires that the operating system used to build verilator is the same as the operating system used to run verilator, so wheels built on windows should work well.
+
+Otherwise, you can build from source. This requires having a compatible compiler installed, and any dependencies. Read the verilator user manual for more information.
+
+
+## Install Options
+
+pypi.org
+```
+pip install verilator-dspsim
+```
+
+from source
+```
+pip install .
+```
+
+cached build directory
+```
+pip install --no-build-isolation -Cbuild-dir=build -v .
+```
+
+editable install
+```
+pip install --no-build-isolation -Cbuild-dir=build --config-settings=editable.rebuild=true -v -e .
+```
+
+## Example Project
+
+The example project "example" in the root of this repository
+uses scikit-build-core, nanobind, and verilator to build a simple
+verilator simulation wrapped in a python package.
+
+You will need to have am appropriate compiler installed.
+Windows: MSVC, Linux: gcc, Mac: clang? (I don't have a Mac)
+
+- Install the verilator package from pypi.org, or from source.
+
+- Build and install the example python extension
+
+- Run the example
+
+```
+pip install verilator-dspsim
+pip install ./example
+python -c "import example;example.run_simulation()"
+```

verilator_dspsim-5.30.0/README.md

@@ -0,0 +1,58 @@
+# Verilator Python
+
+This python package contains a pre-built installation of verilator, and a python wrapper to run verilator. It should function exactly the same as if you installed verilator through normal means.
+
+Installing this python package will install "verilator.exe" into the python environments scripts/bin folder, so it can be ran and can easily be found by CMake.
+
+The main goal of this project is to simplify distributing verilator and using it within a python application.
+
+# Installation
+
+
+Verilator requires that the operating system used to build verilator is the same as the operating system used to run verilator, so wheels built on windows should work well.
+
+Otherwise, you can build from source. This requires having a compatible compiler installed, and any dependencies. Read the verilator user manual for more information.
+
+
+## Install Options
+
+pypi.org
+```
+pip install verilator-dspsim
+```
+
+from source
+```
+pip install .
+```
+
+cached build directory
+```
+pip install --no-build-isolation -Cbuild-dir=build -v .
+```
+
+editable install
+```
+pip install --no-build-isolation -Cbuild-dir=build --config-settings=editable.rebuild=true -v -e .
+```
+
+## Example Project
+
+The example project "example" in the root of this repository
+uses scikit-build-core, nanobind, and verilator to build a simple
+verilator simulation wrapped in a python package.
+
+You will need to have am appropriate compiler installed.
+Windows: MSVC, Linux: gcc, Mac: clang? (I don't have a Mac)
+
+- Install the verilator package from pypi.org, or from source.
+
+- Build and install the example python extension
+
+- Run the example
+
+```
+pip install verilator-dspsim
+pip install ./example
+python -c "import example;example.run_simulation()"
+```

verilator_dspsim-5.30.0/example/CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.26)
+project(${SKBUILD_PROJECT_NAME} LANGUAGES CXX VERSION ${SKBUILD_PROJECT_VERSION})
+
+find_package(Python COMPONENTS Interpreter Development.Module ${SKBUILD_SABI_MODULE} REQUIRED)
+find_package(verilator CONFIG REQUIRED)
+find_package(nanobind CONFIG REQUIRED)
+
+message("Found Python: ${Python_EXECUTABLE}")
+message("Found Verilator: ${verilator_DIR}")
+message("Found Nanobind: ${nanobind_DIR}")
+
+add_subdirectory(src)

verilator_dspsim-5.30.0/example/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["scikit-build-core>=0.10.6", "nanobind>=2.2.0"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "example"
+version = "0.0.1"
+
+[tool.scikit-build]
+cmake.build-type = "Release"
+
+# Install the package
+# pip install .
+
+# Run the example
+# python -c "import example;example.run_simulation()"

verilator_dspsim-5.30.0/example/src/CMakeLists.txt

@@ -0,0 +1,19 @@
+# Create nanobind module
+nanobind_add_module(_example _example.cpp)
+
+# Verilate the verilog module and link it to the nanobind module.
+verilate(_example SOURCES example.sv)
+
+# Generate nanobind type stubs.
+nanobind_add_stub(
+    _example_stub
+    INSTALL_TIME
+    MODULE _example
+    OUTPUT example/_example.pyi
+    PYTHON_PATH $<TARGET_FILE_DIR:_example>
+    DEPENDS _example
+    MARKER_FILE example/py.typed)
+
+# Install the nanobind wheel.
+install(TARGETS _example LIBRARY DESTINATION example)
+install(FILES _example.cpp DESTINATION ${SKBUILD_HEADERS_DIR}) 

verilator_dspsim-5.30.0/example/src/_example.cpp

@@ -0,0 +1,30 @@
+#include <nanobind/nanobind.h>
+
+// Verilated model.
+#include "Vexample.h"
+
+// MSVC requires this must be defined.
+double sc_time_stamp() { return 0; }
+
+// Instatiate the model, and run it through a simulation.
+void run_simulation()
+{
+    Vexample example;
+    example.eval();
+
+    for (int i = 0; i < 10; i++)
+    {
+        example.clk = 1;
+        example.eval();
+        example.clk = 0;
+        example.eval();
+    }
+}
+
+// Define the nanobind module.
+NB_MODULE(_example, m)
+{
+    m.doc() = "Python Verilator Example";
+
+    m.def("run_simulation", &run_simulation);
+}

verilator_dspsim-5.30.0/example/src/example/__init__.py

@@ -0,0 +1,12 @@
+"""
+Imports the contents of the nanobind module _example
+
+Test the example by running
+python -c "import example;example.run_simulation()"
+
+"""
+
+__version__ = "0.0.1"
+
+# Import contents from the nanobind module.
+from ._example import run_simulation

verilator_dspsim-5.30.0/example/src/example.sv

@@ -0,0 +1,14 @@
+module example #(
+    parameter DW = 32
+) (
+    input  logic clk,
+    input  logic rst
+);
+
+int foo_ctr = 0;
+always @(posedge clk) begin
+    foo_ctr <= foo_ctr + 1;
+    $display("Example: %d", foo_ctr);
+end
+
+endmodule

verilator_dspsim-5.30.0/pyproject.toml

@@ -0,0 +1,75 @@
+[build-system]
+requires = ["scikit-build-core>=0.10.6"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "verilator-dspsim"
+dynamic = ["version"]
+description = "A Python wrapper around an installation of Verilator."
+readme = "README.md"
+authors = [{ name = "Frank Sodari" }]
+classifiers = [
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)",
+    "Programming Language :: C++",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://github.com/fsodari/verilator-python"
+
+# Get the version. Make this automatically match verilator? How? Manually make an update every verilator release?
+[tool.scikit-build.metadata.version]
+provider = "scikit_build_core.metadata.regex"
+input = "src/verilator/__init__.py"
+
+[tool.scikit-build]
+cmake.version = ">=3.26.1"
+cmake.build-type = "Release"
+build.verbose = true
+
+# Supporting cp312 stable abi.
+wheel.py-api = "cp312"
+
+# The installed package.
+wheel.packages = ["src/verilator"]
+
+# This needs to be set so that verilator installs at site-packages/verilator
+wheel.install-dir = "verilator"
+
+[project.scripts]
+verilator = "verilator:_verilator_cli"
+
+[tool.cibuildwheel]
+# Run pytest to ensure that the package was correctly built
+test-command = "pytest {project}/tests"
+test-requires = "pytest"
+
+# 64 bit builds
+archs = ["auto64"]
+
+build = ["cp312-*", "cp313-*"]
+# Don't build arm. Use only > cp39, no PyPy. Not using musl anywhere so no musl (it works though)
+skip = ["*-win_arm64"]
+
+# manylinux builds
+[tool.cibuildwheel.linux]
+before-all = [
+    "yum install -y flex",
+    "yum install -y bison",
+    "yum install -y ccache",
+]
+
+# musllinux builds
+[[tool.cibuildwheel.overrides]]
+select = "*-musllinux*"
+before-all = [
+    "apk add flex",
+    "apk add flex-dev",
+    "apk add bison",
+    "apk add ccache",
+]

verilator_dspsim-5.30.0/scripts/einstall.ps1

@@ -0,0 +1 @@
+pip install --no-build-isolation -Cbuild-dir=build --config-settings=editable.rebuild=true -v -e .

verilator_dspsim-5.30.0/scripts/einstall.sh

@@ -0,0 +1 @@
+pip install --no-build-isolation -Cbuild-dir=build --config-settings=editable.rebuild=true -v -e .

verilator_dspsim-5.30.0/scripts/install.ps1

@@ -0,0 +1 @@
+pip install --no-build-isolation -Cbuild-dir=build -v .

verilator_dspsim-5.30.0/scripts/install.sh

@@ -0,0 +1 @@
+pip install --no-build-isolation -Cbuild-dir=build -v .

verilator_dspsim-5.30.0/src/verilator/__init__.py

@@ -0,0 +1,83 @@
+"""
+Verilator wrapper.
+
+Running verilator typically requires having VERILATOR_ROOT set in the environment.
+VERILATOR_ROOT is also used by find_package in CMake.
+
+When importing or running this package, this will automatically
+set VERILATOR_ROOT in the environment before running verilator.
+
+When using this with scikit-build-core, scikit-build core will add the
+site-packages directory to CMAKE_PREFIX_PATH, so find_package(verilator)
+should work without any extra hints.
+
+When using just CMake, you may need to set VERILATOR_ROOT env variable,
+manually or set CMAKE_PREFIX_PATH.
+
+run this python command to get verilator_root for convenience
+python -c "import verilator;print(verilator.verilator_root())"
+"""
+
+# Use same version number as the checked out verilator version.
+__version__ = "5.30.0"
+
+import sys
+from pathlib import Path
+import subprocess
+import os
+
+
+def verilator_root() -> Path:
+    """
+    Get the path to verilator_root.
+    This will typically be at site-packages/verilator
+    """
+    # Verilator is installed in the same directory as this package.
+    return Path(__file__).parent
+
+
+def verilator_bin() -> Path:
+    """
+    Get the path to verilator_bin
+    This will typically be at site-packages/verilator/bin
+    """
+    if sys.platform == "win32":
+        return verilator_root() / "bin/verilator_bin.exe"
+    else:
+        return verilator_root() / "bin/verilator"
+
+
+def verilator(args: list[str], capture_output: bool = False):
+    """
+    Run verilator with the given args.
+
+    Returns the return code of
+    """
+
+    # Set VERILATOR_ROOT in the environment. Verilator usually requires this.
+    os.environ["VERILATOR_ROOT"] = str(verilator_root())
+
+    # Prepend the verilator_exe path to the verilator args.
+    command_args = [verilator_bin()] + args
+
+    # Run using subprocess.
+    return subprocess.run(command_args, capture_output=capture_output, check=True)
+
+
+def _verilator_cli() -> int:
+    """
+    Run verilator using command line arguments.
+    Used by __main__
+
+    Otherwise it's probably best to use verilator(sys.argv[1:])
+    instead of calling this function.
+    """
+    result = verilator(sys.argv[1:])
+    exit(result.returncode)
+
+
+__all__ = [
+    "verilator",
+    "verilator_root",
+    "verilator_bin",
+]

verilator_dspsim-5.30.0/src/verilator/__main__.py

@@ -0,0 +1,17 @@
+"""
+Run the verilator_cli command when running this package as a module.
+
+python -m verilator
+
+Alternatively, this package will install scripts in the python environment under bin or Scripts
+This directory is on the path so you can just run "verilator" on the command line.
+
+I'm not sure what happens if verilator is already on the path elsewhere...
+
+Either option is available for use.
+"""
+
+from . import _verilator_cli
+
+if __name__ == "__main__":
+    exit(_verilator_cli())

verilator_dspsim-5.30.0/tests/test_verilator.py

@@ -0,0 +1,52 @@
+"""
+Test if the package works.
+"""
+
+import verilator
+import subprocess
+from packaging.version import Version
+import site
+from pathlib import Path
+
+
+def _parse_version_stdout(stdout: bytes):
+    """Parse the version from stdout. Used to test if verilator works."""
+    return Version(stdout.decode().strip().strip("rev "))
+
+
+def test_verilator():
+    """"""
+    # Print the version
+    result = verilator.verilator(["--version"], capture_output=True)
+
+    # Parse the result
+    v = _parse_version_stdout(result.stdout)
+
+    # Make sure the version run by verilator matches
+    assert v == Version(verilator.__version__)
+
+
+def test_verilator_cli():
+    """"""
+    # Run subprocess instead. Print the version.
+    result = subprocess.run(["verilator", "--version"], capture_output=True, check=True)
+
+    # Parse the result
+    v = _parse_version_stdout(result.stdout)
+
+    # Make sure the version run by verilator matches
+    assert v == Version(verilator.__version__)
+
+
+def test_verilator_root():
+    """"""
+    # Check the root.
+    verilator_root = verilator.verilator_root()
+
+    # We expect this package to be installed in site-packages.
+    assert verilator_root.parent in [Path(p) for p in site.getsitepackages()]
+
+    # Check for expected files.
+    assert verilator_root.exists()
+    assert verilator.verilator_bin().exists()
+    assert Path(verilator_root / "verilator-config.cmake").exists()