The-OpenROAD-Project_OpenROAD/docs/agents/testing-strategy.md

OpenROAD Testing Strategy

This document defines where new tests should live and how to handle the dependencies that make C++ unit testing of OpenROAD hard. It complements testing.md, which covers the mechanics of writing and registering a test.

Goal

Move the bulk of functional correctness coverage into minimally-scoped C++ unit tests, while keeping a thin layer of Tcl/Python tests that prove the bindings work and a small curated set of full-flow tests that prove the stages compose. Core logic should be tested with semantic assertions, not golden-file diffs.

Policy. The end state is to migrate off the bulk of the Tcl/Python golden tests, not keep them indefinitely. But that migration is a large, incremental effort delivered as a long series of small steps -- never a single big-bang rewrite. Two things happen in parallel:

1. New tests default to C++ unit tests now (this strategy's pyramid).
2. Existing golden tests are retired in batches as their coverage is re-expressed in C++ -- the C++ test and the removal of the Tcl/Python test it replaces land in the same change. Prioritized by pain (flaky/slow/ frequently-broken modules and code you are already touching), with each batch a reviewable change of its own.

A golden test is only deleted once equivalent or better coverage exists in C++; don't drop coverage to hit a ratio. Until then it stays.

Why move off golden-file tests

The repo today is ~1,674 Tcl + ~265 Python regression tests vs. ~55 C++ unit tests. Most functionality is verified by reading LEF/DEF, running a command, and diff-ing a golden .ok/.defok/.vok file. That model has structural weaknesses:

1. It tests serialization, not logic. A passing diff means bytes matched, not that the result is correct. When a buffer count changes you learn something differed, not whether the new number is right.
2. It couples to unrelated behavior. diff_file breaks on any upstream formatting/ordering change, and it only reports the first difference (so golden regen must be wholesale).
3. No fault isolation. A flow test exercises the readers + STA + the unit under test at once; a failure could be anywhere.
4. It's slow. Each test spawns a full openroad process and re-parses the Nangate45/Sky130 libraries.

C++ unit tests built on the existing fixtures fix all four: semantic assertions, no file coupling, single-unit scope, sub-millisecond setup.

The test pyramid

Aim every new test at the lowest tier that can express it.

Tier 1 -- C++ unit tests (default; target the majority of new tests)

One function/class, inputs built programmatically, assertions on observable state (EXPECT_EQ(net->getITermCount(), 3)), not on a serialized dump. This is where algorithmic correctness, edge cases, and regression-bug pins belong.

Tier 2 -- Binding smoke tests (thin: ~1 per public command)

Their only job is to prove the Tcl/Python binding marshals arguments and returns without crashing -- not to validate the algorithm. Call the command once on a trivial design and assert it ran. Prefer PASSFAIL_TESTS (exit-code only) over golden diffs so there is no .ok file to maintain. For commands whose execution is expensive (e.g. detailed_route), running them even once is the wrong cost trade-off -- see Binding tests for expensive commands for how to prove translation without executing the work.

Tier 3 -- Full-flow integration tests (keep deliberately few)

A curated handful per module that prove the stages compose end-to-end on a real design (e.g. gcd, aes). These are the "the flow still works" canaries. You want dozens across the project, not hundreds -- and this small curated set is the permanent home of golden-file testing. Most of today's golden tests are really unit-logic tests wearing a flow-test costume: those are the migration target (demote to Tier 1), not this canary layer. Resist adding new Tier-3 tests when a Tier-1 test would do.

The migration shape is therefore: a new feature lands as Tier-1 semantic tests plus one Tier-2 smoke test, instead of a new Tier-3 golden test.

Handling dependencies

This is the crux. Pick the lightest fixture that exposes the dependency the unit actually needs.

Dependency of the unit under test	Fixture / approach	Cost
None -- pure algorithm/geometry/graph kernel	No fixture; plain structs + odb geom primitives	trivial
An odb database (cells, nets, placement)	tst::Fixture / odb::SimpleDbFixture + makeInst/makeBTerm/makeNets	sub-ms
STA timing	tst::IntegratedFixture (kNangate45 / kSky130hd)	ms (libs loaded once)
Genuine cross-tool composition	Keep as a Tier-3 flow test	full process

The existing fixture stack already supports this:

• tst::Fixture (src/tst/include/tst/fixture.h) -- owns db_, sta_, logger_; provides loadTechLef/loadLibaryLef/readLiberty and the netlist builders makeInst, makeBTerm, makeNets. The header explicitly states these are meant to make C++ setup "competitive with writing a Verilog or DEF test case by hand."
• odb::SimpleDbFixture (src/odb/test/cpp/helper/helper.h) -- pre-builds a minimal tech/lib/chip/block and createMaster* helpers.
• tst::IntegratedFixture (src/tst/include/tst/IntegratedFixture.h) -- wires sta_, resizer_, dp_, grt_, ant_, stt_, ep_ against real libs and offers readVerilogAndSetup. This is how rsz and dbSta already test; use them as the reference pattern.

Principles

1. Depend on data/interfaces, not the whole pipeline. If a function needs a fully placed-and-routed DB just to test one calculation, that is a design smell. Refactor the kernel to take the data it needs (a struct, a span, an odb geometry) so it can be tested with no fixture. This refactor-for-testability is the single highest-leverage move -- it improves the code and makes the test trivial.
2. Builders over checked-in files. Every time a test needs "a block with a row of 3 placed cells," that should be a fixture method, not a new DEF. Growing per-module builder helpers (the SimpleDbFixture pattern, extended to dpl/grt/cts/...) is the shared library that makes Tier-1 cheap. Invest here.
3. Inject dependencies. Prefer constructor/parameter injection so a unit can be handed a minimal hand-built DB (or a narrow fake of an external tool's output) instead of discovering global state.
4. Do not mock odb. It is the lingua franca, it is cheap to instantiate, and faking it is more work than building a tiny real one. Fake/stub only expensive external tools, and only when the unit needs a narrow slice of their output.

Keeping binding tests minimal but honest

• One smoke test per public Tcl command and per Python command, on a trivial design, asserting invocation + basic return marshaling. Convert to PASSFAIL_TESTS where possible.
• Treat the C++ test as the source of truth for correctness; bindings prove plumbing only. Do not duplicate algorithm assertions across Tcl + Python.
• A future linter (not yet implemented) could enumerate public commands from the .tcl/.i files and flag any without a smoke test, guaranteeing binding coverage without hand-curation.

Binding tests for expensive commands

The Tier-2 recipe -- "call the command once on a trivial design" -- assumes the command is cheap to run. For commands that do heavy work (global_route, global_placement, clock_tree_synthesis, detailed_route, ...), executing the algorithm contributes nothing to the binding guarantee and costs seconds-to-minutes per test. The translation contract you actually want to pin is narrow: every flag/key reaches the right C++ parameter and defaults are applied. None of that requires the algorithm to run.

Preferred policy: validate arguments in C++, not in the binding. A value check written in a .tcl proc (sta::check_positive_integer, range/cardinality guards) only protects the Tcl entry point -- the Python binding and direct C++ callers bypass it, so the check has to be duplicated or is simply missing. Put the check behind the C++ entry point instead and one implementation covers all three usages. utl::Validator (src/utl/include/utl/validation.h) exists to make this easy: construct it with a Logger* and ToolId, then call check_positive / check_non_negative / check_range / check_percentage / check_non_null, each of which emits a tool-scoped logged error on violation. Use it in the engine's argument-ingestion path (e.g. where parameters are set) rather than re-deriving the same guard per language. This also keeps the .tcl/.py proc to near-pure marshaling, which shrinks what the binding test must cover -- and the validation itself becomes a cheap Tier-1 C++ test that exercises the error paths directly, with no process launch.

The key observation is that a command's .tcl proc or .py function does two separable things: it configures the engine from the parsed arguments, then calls a distinct execute entry point that does the expensive work. The execute step is almost always a single thin SWIG free function -- grt::global_route, cts::run_triton_cts, the gpl::replace_*_cmd calls. Because it is a plain proc in the tool's namespace, a binding test can rename it (in Tcl) or reassign/mock it (in Python) to a no-op spy, then invoke the real public command. All the argument handling runs; the engine does not, so the test is sub-millisecond.

Mind the proc's preconditions, though. Invoking the real command also runs any guards that sit before the execute call, and many commands require a loaded design: global_route errors GRT-0051/GRT-0052 on a missing tech/block (src/grt/src/GlobalRouter.tcl) and clock_tree_synthesis errors CTS-0103 on a missing block (src/cts/src/TritonCTS.tcl) before their execute calls are ever reached. So a no-design spy test for those fails on the guard, not on the spy. Give the test the minimal DB the proc's preconditions demand -- a tiny LEF/DEF or a SimpleDbFixture-style block is enough, since the expensive algorithm still never runs. (A command with no such precondition can be spied with no design loaded at all.) If you instead want to assert that a precondition guard itself fires, that is a separate, cheaper test: invoke the command with the precondition unmet and check the error code -- no spy needed, because the guard errors out before the execute call regardless.

What you assert depends on where the configure logic lives, which varies by command:

• Setters, then a separate execute (e.g. global_route, clock_tree_synthesis). The proc translates each flag/key into its own cheap set_* SWIG call (grt::set_infinite_cap, cts::set_insertion_delay, ...) before the execute call. Spy only the execute; let the setters run for real and assert the resulting configured state via getters (or spy the individual setters and check they were called with the right values). This is the most common shape.
• Arguments forwarded to C++ (e.g. global_placement). The proc passes the raw key/flag arrays to a C++ command function that parses them itself. This is the shape the validate-in-C++ policy points toward: parsing and utl::Validator checks live in one place that all bindings share, so a C++ unit test on that parsing/validation is the natural binding check; spying the execute still lets the proc reach it without running the placer.
• Configure and execute fused (e.g. detailed_route). A single detailed_route_cmd both marshals its arguments and calls main(). Spying it skips the run, so capture the arguments the spy received and assert them. Better, split the marshaling (setParams) from execution (main) so the cheap part is independently reachable -- this is the refactor that makes the command match the others, and lets a C++ test assert a getParams() round-trip directly.

In every case the heavy main()/run is off the translation path, so the test costs nothing at runtime. As with cheap commands, the C++ unit test remains the source of truth for algorithmic correctness -- do not assert behavior here.

The reusable design principle: validate arguments in C++, and keep the expensive execute step as its own thin free function distinct from argument handling. Validation in C++ covers Tcl, Python, and C++ callers from one place; a separate execute step keeps the heavy work off the translation path. Most commands already separate execute; a fused entry point like detailed_route_cmd is the outlier worth refactoring. Commands built this way are cheap to binding-test regardless of how expensive their execution is. (Free-function entry points also matter because a method on a SWIG object is much harder to intercept than a namespaced proc.)

Decision tree for a new test

Is it pure logic with no DB?            -> Tier 1, no fixture
Does it need an odb DB only?            -> Tier 1, tst::Fixture / SimpleDbFixture
Does it need STA/resizer/router state?  -> Tier 1, tst::IntegratedFixture
Is it only proving a binding marshals?  -> Tier 2, smoke test (PASSFAIL)
  ...and the command is expensive to run? -> Tier 2, intercept the C++ entry (no execution)
Does it genuinely span multiple tools?  -> Tier 3, flow test (golden, used sparingly)

Runbook: retiring a batch of golden tests

Rule: the C++ test and the removal of the Tcl/Python test(s) it replaces land in the same change. Once a behavior is covered by a C++ unit test, the golden test that previously pinned it is redundant and should be deleted in that same commit -- not left behind "for safety" and not deferred to a later cleanup. The one gate is coverage equivalence (step 5): you only delete what the C++ test now covers.

A "batch" is one such reviewable change: it adds C++ tests for a small, related group of behaviors and removes the golden tests they supersede. Keep batches small enough to review in one sitting -- a few related tests, not a whole module at once.

1. Pick a target. Prioritize by pain: flaky/slow/frequently-broken tests, tests for code you are already modifying, or a tightly-related cluster (e.g. all buffer_ports*). Avoid the curated Tier-3 flow canaries -- those stay.
2. Characterize what each golden test actually verifies. Read the .tcl/.py and its .ok/.defok/.vok. Write down the intent ("inserts a buffer on each output port", "rejects nets wider than the layer max"), not the byte diff. This intent is what the C++ test will assert.
3. Choose the fixture via the decision tree above -- the lightest one that exposes the dependency. If the unit needs the whole pipeline to test one calculation, refactor the kernel to take its data directly first (a separate, prior change), then test it with no/low fixture.
4. Write the C++ unit test(s) with semantic assertions on observable state. One behavior per TEST_F; build inputs with makeInst/makeBTerm/makeNets or createMaster* rather than checked-in DEFs. Add a builder helper if the same construction recurs. Register in BOTH build systems.
5. Confirm coverage is equal-or-better. The C++ tests must cover every behavior the golden test pinned (use the intent list from step 2 as a checklist). A C++ test that asserts more (e.g. an error/rejection path the golden never reached) is the goal. If some behavior genuinely cannot be re-expressed in C++, keep that one golden test and note why -- but still remove the rest of the batch.
6. Delete the superseded Tcl/Python test(s) and their artifacts, and de-register from BOTH build systems -- in this same change. Remove the .tcl/.py and its .ok/.defok/.vok; drop the name from src/<module>/test/CMakeLists.txt (or_integration_tests) and src/<module>/test/BUILD (regression_test). Remove checked-in DEF/LEF data only if nothing else references it (grep first -- fixtures like Nangate45 and shared data/ files are used by many tests).
7. Check residual binding coverage. Removing a golden test does not have to mean the command loses all Tcl/Python exercise: a command is often also touched by a broader binding test (e.g. odb's test_inst.py/test_inst.tcl). If the deleted test was the only thing invoking that command from a binding, add a thin Tier-2 smoke test (PASSFAIL, trivial design) so the entry point stays exercised. Note in the commit where binding coverage now lives.
8. Verify. Run the module's C++ tests and remaining regressions in both builds (ctest/make test and the Bazel target) to confirm the new tests pass and nothing references the removed names.

The discipline that keeps this safe: deletion is gated on coverage equivalence (step 5), and every add/remove touches CMake + Bazel together (a half-registered or half-deregistered test breaks Bazel CI while passing local make test).

Registration reminder

Every new test -- C++ or Tcl -- must be registered in both CMake and Bazel. Forgetting the Bazel BUILD entry passes local make test but breaks Bazel CI. See testing.md for the exact macros (or_integration_tests / regression_test / cc_test + gtest_discover_tests).