luke
/
OpenSTA
mirror of https://github.com/The-OpenROAD-Project/OpenSTA.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

test: add explicit assertions to all cpp test cases 

Signed-off-by: Jaehyun Kim <jhkim@precisioninno.com>
This commit is contained in:
Jaehyun Kim 2026-02-22 21:14:35 +09:00
parent 10104f85ea
commit a58d7e4cc6
9 changed files with 3188 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
dcalc/test/cpp/TestDcalc.cc
View File

@ -2478,9 +2478,12 @@ TEST_F(ArcDcalcResultTest, MultipleLoadSetGet) {
// NetCaps additional coverage - default constructor doesn't zero-init
TEST_F(StaDcalcTest, NetCapsDefaultConstructorExists) {
ASSERT_NO_THROW(( [&](){
NetCaps caps;
// Default constructor doesn't initialize members, just verify construction
SUCCEED();
}() ));
}
TEST_F(StaDcalcTest, NetCapsParameterizedConstructor) {
@ -2523,33 +2526,48 @@ TEST_F(StaDcalcTest, GraphDelayCalcConstruct) {
}
TEST_F(StaDcalcTest, GraphDelayCalcClear3) {
ASSERT_NO_THROW(( [&](){
GraphDelayCalc *gdc = sta_->graphDelayCalc();
gdc->clear();
SUCCEED();
}() ));
}
TEST_F(StaDcalcTest, GraphDelayCalcDelaysInvalid3) {
ASSERT_NO_THROW(( [&](){
GraphDelayCalc *gdc = sta_->graphDelayCalc();
gdc->delaysInvalid();
SUCCEED();
}() ));
}
TEST_F(StaDcalcTest, GraphDelayCalcSetObserver) {
ASSERT_NO_THROW(( [&](){
GraphDelayCalc *gdc = sta_->graphDelayCalc();
gdc->setObserver(nullptr);
SUCCEED();
}() ));
}
TEST_F(StaDcalcTest, GraphDelayCalcLevelsChanged) {
ASSERT_NO_THROW(( [&](){
GraphDelayCalc *gdc = sta_->graphDelayCalc();
gdc->levelsChangedBefore();
SUCCEED();
}() ));
}
TEST_F(StaDcalcTest, GraphDelayCalcCopyState3) {
ASSERT_NO_THROW(( [&](){
GraphDelayCalc *gdc = sta_->graphDelayCalc();
gdc->copyState(sta_);
SUCCEED();
}() ));
}
TEST_F(StaDcalcTest, GraphDelayCalcIncrTolerance) {

3
dcalc/test/cpp/TestFindRoot.cc
View File

@ -147,6 +147,7 @@ TEST_F(FindRootTest, ZeroTolerance) {
// Only 1 iteration allowed
TEST_F(FindRootTest, OneIteration) {
ASSERT_NO_THROW(( [&](){
FindRootFunc func = [](double x, double &y, double &dy) {
y = x * x - 4.0;
dy = 2.0 * x;
@ -156,6 +157,8 @@ TEST_F(FindRootTest, OneIteration) {
// With only 1 iteration, a quadratic likely won't converge to tight tol
// The algorithm may or may not fail depending on initial bisection step
(void)root; // just ensure no crash
}() ));
}
// Two iterations

3
graph/test/cpp/TestGraph.cc
View File

@ -405,10 +405,13 @@ TEST(EdgeStandaloneTest, ObjectIdx)
TEST(EdgeStandaloneTest, SetIsDisabledConstraint)
{
ASSERT_NO_THROW(( [&](){
Edge e;
e.setIsDisabledConstraint(true);
// Can only fully test when arc_set is set; test the setter at least
e.setIsDisabledConstraint(false);
}() ));
}
TEST(EdgeStandaloneTest, RemoveDelayAnnotated)

417
liberty/test/cpp/TestLiberty.cc
View File

File diff suppressed because it is too large Load Diff

39
network/test/cpp/TestNetwork.cc
View File

@ -1934,13 +1934,19 @@ TEST_F(ConcreteNetworkLinkedTest, AddConstantNet) {
// Network: readNetlistBefore, setLinkFunc
TEST(ConcreteNetworkExtraTest, ReadNetlistBefore) {
ASSERT_NO_THROW(( [&](){
ConcreteNetwork network;
network.readNetlistBefore();
}() ));
}
TEST(ConcreteNetworkExtraTest, SetLinkFunc) {
ASSERT_NO_THROW(( [&](){
ConcreteNetwork network;
network.setLinkFunc(nullptr);
}() ));
}
// Network: setCellNetworkView, cellNetworkView, deleteCellNetworkViews
@ -2374,38 +2380,53 @@ TEST_F(ConcreteNetworkLinkedTest, FindInstancesHierMatching) {
// Network Set/Map comparators constructors
TEST_F(ConcreteNetworkLinkedTest, PinIdLessConstructor) {
ASSERT_NO_THROW(( [&](){
PinIdLess less(&network_);
bool result = less(pin_u1_a_, pin_u2_a_);
(void)result;
}() ));
}
TEST_F(ConcreteNetworkLinkedTest, NetIdLessConstructor) {
ASSERT_NO_THROW(( [&](){
NetIdLess less(&network_);
bool result = less(net1_, net2_);
(void)result;
}() ));
}
TEST_F(ConcreteNetworkLinkedTest, InstanceIdLessConstructor) {
ASSERT_NO_THROW(( [&](){
InstanceIdLess less(&network_);
bool result = less(u1_, u2_);
(void)result;
}() ));
}
TEST_F(ConcreteNetworkLinkedTest, PortIdLessConstructor) {
ASSERT_NO_THROW(( [&](){
Cell *inv_cell = network_.findCell(lib_, "INV");
Port *port_a = network_.findPort(inv_cell, "A");
Port *port_y = network_.findPort(inv_cell, "Y");
PortIdLess less(&network_);
bool result = less(port_a, port_y);
(void)result;
}() ));
}
TEST_F(ConcreteNetworkLinkedTest, CellIdLessConstructor) {
ASSERT_NO_THROW(( [&](){
Cell *inv_cell = network_.findCell(lib_, "INV");
Cell *top_cell = network_.findCell(lib_, "TOP");
CellIdLess less(&network_);
bool result = less(inv_cell, top_cell);
(void)result;
}() ));
}
// PinSet: with network constructor and intersects
@ -2420,12 +2441,15 @@ TEST_F(ConcreteNetworkLinkedTest, PinSetWithNetwork) {
// PinSet: compare
TEST_F(ConcreteNetworkLinkedTest, PinSetCompare) {
ASSERT_NO_THROW(( [&](){
PinSet set1(&network_);
set1.insert(pin_u1_a_);
PinSet set2(&network_);
set2.insert(pin_u2_a_);
int cmp = PinSet::compare(&set1, &set2, &network_);
(void)cmp;
}() ));
}
// InstanceSet: with network and intersects
@ -2450,12 +2474,15 @@ TEST_F(ConcreteNetworkLinkedTest, NetSetWithNetwork) {
// NetSet: compare
TEST_F(ConcreteNetworkLinkedTest, NetSetCompare) {
ASSERT_NO_THROW(( [&](){
NetSet set1(&network_);
set1.insert(net1_);
NetSet set2(&network_);
set2.insert(net2_);
int cmp = NetSet::compare(&set1, &set2, &network_);
(void)cmp;
}() ));
}
// CellSet constructor
@ -2874,9 +2901,12 @@ TEST_F(NetworkAdapterTest, AdapterCellGetAttribute) {
// NetworkNameAdapter: attributeMap(Cell) forwarding
TEST_F(NetworkAdapterTest, AdapterCellAttributeMap) {
ASSERT_NO_THROW(( [&](){
const AttributeMap &map = sdc_net_->attributeMap(inv_cell_);
(void)map;
// Just verify it doesn't crash
}() ));
}
// NetworkNameAdapter: library(Cell) forwarding
@ -3028,8 +3058,11 @@ TEST_F(NetworkAdapterTest, AdapterInstanceGetAttribute) {
// NetworkNameAdapter: attributeMap(Instance) forwarding
TEST_F(NetworkAdapterTest, AdapterInstanceAttributeMap) {
ASSERT_NO_THROW(( [&](){
const AttributeMap &map = sdc_net_->attributeMap(u1_);
(void)map;
}() ));
}
// NetworkNameAdapter: parent(Instance) forwarding
@ -3132,8 +3165,11 @@ TEST_F(NetworkAdapterTest, AdapterPinDirection) {
// NetworkNameAdapter: vertexId(Pin) forwarding
TEST_F(NetworkAdapterTest, AdapterPinVertexId) {
ASSERT_NO_THROW(( [&](){
VertexId vid = sdc_net_->vertexId(pin_b1_a_);
(void)vid; // Just verify it doesn't crash
}() ));
}
// NetworkNameAdapter: setVertexId forwarding
@ -5680,9 +5716,12 @@ TEST_F(NetworkAdapterTest, AdapterPortName3) {
// R10_ NetworkAdapter: busName forwarding
// Covers: NetworkNameAdapter::busName(Port const*) const
TEST_F(NetworkAdapterTest, AdapterBusName) {
ASSERT_NO_THROW(( [&](){
const char *name = sdc_net_->busName(port_a_);
// Scalar port busName is nullptr
(void)name;
}() ));
}
// R10_ NetworkAdapter: makeNet forwarding

39
parasitics/test/cpp/TestParasitics.cc
View File

@ -653,9 +653,12 @@ TEST_F(ConcreteParasiticBaseVirtualTest, PoleResidueBasePiModel) {
// Test base class setPiModel is no-op
TEST_F(ConcreteParasiticBaseVirtualTest, PoleResidueBaseSetPiModel) {
ASSERT_NO_THROW(( [&](){
ConcretePoleResidue pr;
pr.setPiModel(1.0f, 2.0f, 3.0f);
// no crash
}() ));
}
// Test base class findElmore returns exists=false
@ -669,9 +672,12 @@ TEST_F(ConcreteParasiticBaseVirtualTest, PoleResidueBaseFindElmore) {
// Test base class setElmore is no-op
TEST_F(ConcreteParasiticBaseVirtualTest, PoleResidueBaseSetElmore) {
ASSERT_NO_THROW(( [&](){
ConcretePoleResidue pr;
pr.setElmore(nullptr, 5.0f);
// no crash
}() ));
}
// Test base class findPoleResidue returns nullptr
@ -682,6 +688,7 @@ TEST_F(ConcreteParasiticBaseVirtualTest, PoleResidueBaseFindPoleResidue) {
// Test base class setPoleResidue (3-arg from ConcreteParasitic) is no-op
TEST_F(ConcreteParasiticBaseVirtualTest, PoleResidueBaseSetPoleResidue3) {
ASSERT_NO_THROW(( [&](){
ConcretePoleResidue pr;
// The 3-arg setPoleResidue from ConcreteParasitic base
ComplexFloatSeq *poles = new ComplexFloatSeq;
@ -691,6 +698,8 @@ TEST_F(ConcreteParasiticBaseVirtualTest, PoleResidueBaseSetPoleResidue3) {
// base is no-op, so clean up
delete poles;
delete residues;
}() ));
}
// Test ConcretePoleResidue unannotatedLoads returns empty
@ -723,9 +732,12 @@ TEST_F(ConcreteParasiticBaseVirtualTest, PiPoleResidueFindElmore) {
// Test ConcretePiPoleResidue setElmore is base no-op
TEST_F(ConcreteParasiticBaseVirtualTest, PiPoleResidueSetElmore) {
ASSERT_NO_THROW(( [&](){
ConcretePiPoleResidue pipr(1e-12f, 100.0f, 2e-12f);
pipr.setElmore(nullptr, 5.0f);
// no crash, base no-op
}() ));
}
// Test ConcretePiElmore isPoleResidue returns false (base)
@ -1320,21 +1332,27 @@ TEST_F(StaParasiticsTest, ParasiticNodeResistorMap) {
// Test findNode (deprecated) - delegates to findParasiticNode
TEST_F(StaParasiticsTest, FindNodeDeprecated) {
ASSERT_NO_THROW(( [&](){
Parasitics *parasitics = sta_->parasitics();
ConcretePiElmore pe(1e-12f, 100.0f, 2e-12f);
// findNode on non-network parasitic should work but return nullptr
// since it's not a parasitic network
// Actually findNode calls findParasiticNode which casts to ConcreteParasiticNetwork
// This would be undefined behavior on non-network, so skip
}() ));
}
// Test unannotatedLoads through parasitics API with PiElmore
TEST_F(StaParasiticsTest, UnannotatedLoadsPiElmore) {
ASSERT_NO_THROW(( [&](){
Parasitics *parasitics = sta_->parasitics();
ConcretePiElmore pe(1e-12f, 100.0f, 2e-12f);
// With no network loads, should just return what parasitics->loads returns
// which needs a connected pin. With nullptr pin, this will likely crash
// or return empty. Let's just test the API exists and compiles.
}() ));
}
// Test ConcreteParasiticNode with pin-based construction
@ -1615,44 +1633,59 @@ TEST_F(StaParasiticsTest, PiPoleResidueIsPiModel) {
// Test Parasitics::report() on PiElmore
TEST_F(StaParasiticsTest, ReportPiElmore) {
ASSERT_NO_THROW(( [&](){
Parasitics *parasitics = sta_->parasitics();
ConcretePiElmore pe(1e-12f, 100.0f, 2e-12f);
// report() is a base class no-op, should not crash
parasitics->report(&pe);
}() ));
}
// Test ConcreteParasiticNetwork::disconnectPin
TEST_F(StaParasiticsTest, NetworkDisconnectPin) {
ASSERT_NO_THROW(( [&](){
const Network *network = sta_->network();
ConcreteParasiticNetwork pnet(nullptr, false, network);
// disconnectPin with nullptr should not crash
pnet.disconnectPin(nullptr, nullptr, network);
}() ));
}
// Test ConcreteParasitics deleteParasitics (Pin overload)
TEST_F(StaParasiticsTest, DeleteParasiticsPin) {
ASSERT_NO_THROW(( [&](){
Parasitics *parasitics = sta_->parasitics();
// Should not crash with nullptr
parasitics->deleteParasitics(static_cast<const Pin*>(nullptr),
static_cast<const ParasiticAnalysisPt*>(nullptr));
}() ));
}
// Test ConcreteParasitics deleteParasiticNetworks
TEST_F(StaParasiticsTest, DeleteParasiticNetworks) {
ASSERT_NO_THROW(( [&](){
Parasitics *parasitics = sta_->parasitics();
ConcreteParasitics *concrete = dynamic_cast<ConcreteParasitics*>(parasitics);
if (concrete) {
concrete->deleteParasiticNetworks(nullptr);
}
}() ));
}
// Test ConcreteParasitics deletePinBefore
TEST_F(StaParasiticsTest, DeletePinBefore) {
ASSERT_NO_THROW(( [&](){
Parasitics *parasitics = sta_->parasitics();
ConcreteParasitics *concrete = dynamic_cast<ConcreteParasitics*>(parasitics);
if (concrete) {
concrete->deletePinBefore(nullptr);
}
}() ));
}
// Test ConcreteParasiticNetwork capacitance with grounded caps and coupling caps
@ -1851,11 +1884,14 @@ TEST_F(ReduceParasiticsTest, ConcreteParasiticDeleteViaBasePtr) {
// Test parasiticAnalysisPtIndex is protected - test indirectly through
// the public API that uses it (e.g., deleteParasitics with Pin/apt)
TEST_F(ReduceParasiticsTest, ParasiticAnalysisPtViaDeleteParasiticsPin) {
ASSERT_NO_THROW(( [&](){
Parasitics *parasitics = sta_->parasitics();
ParasiticAnalysisPt apt("test", 0, 0);
// deleteParasitics(Pin*, apt*) internally calls parasiticAnalysisPtIndex
// With nullptr pin, it creates an entry in the map but finds no parasitics
parasitics->deleteParasitics(static_cast<const Pin*>(nullptr), &apt);
}() ));
}
// Test Parasitics::findNode(Parasitic, Pin) base class implementation
@ -1903,6 +1939,7 @@ TEST_F(ReduceParasiticsTest, RspfPiSingleValues) {
// Test deleteParasitics(Net, ParasiticAnalysisPt) - requires network with drivers
// This is a no-op when net is nullptr because drivers() returns empty
TEST_F(ReduceParasiticsTest, DeleteParasiticsNetApt) {
ASSERT_NO_THROW(( [&](){
Parasitics *parasitics = sta_->parasitics();
ConcreteParasitics *concrete = dynamic_cast<ConcreteParasitics*>(parasitics);
if (concrete) {
@ -1911,6 +1948,8 @@ TEST_F(ReduceParasiticsTest, DeleteParasiticsNetApt) {
// Note: deleteParasitics(Net*, apt*) calls network_->drivers(net)
// which may crash with nullptr net, so skip this test
}
}() ));
}
} // namespace sta

450
sdc/test/cpp/TestSdc.cc
View File

File diff suppressed because it is too large Load Diff

2258
search/test/cpp/TestSearch.cc
View File

File diff suppressed because it is too large Load Diff

27
util/test/cpp/TestUtil.cc
View File

@ -942,9 +942,12 @@ TEST(ReportTest, LogToFile)
TEST(ReportTest, LogEndWithoutLog)
{
ASSERT_NO_THROW(( [&](){
Report report;
// Should not crash when no log is active
report.logEnd();
}() ));
}
TEST(ReportTest, RedirectFileBegin)
@ -992,9 +995,12 @@ TEST(ReportTest, RedirectFileAppendBegin)
TEST(ReportTest, RedirectFileEndWithoutRedirect)
{
ASSERT_NO_THROW(( [&](){
Report report;
// Should not crash
report.redirectFileEnd();
}() ));
}
TEST(ReportTest, RedirectFileNotWritable)
@ -1969,10 +1975,13 @@ TEST(StringUtilCovTest, StringPrintArgs)
// stringDeleteCheck (only for non-tmp strings - should not crash)
TEST(StringUtilCovTest, StringDeleteCheckNonTmp)
{
ASSERT_NO_THROW(( [&](){
char *s = stringPrint("not tmp");
// This should not crash or exit; it's not a tmp string
stringDeleteCheck(s);
stringDelete(s);
}() ));
}
// Test that isTmpString returns false for heap-allocated strings
@ -2174,12 +2183,15 @@ TEST(ReportStdCovTest, ReportStdError)
TEST(ReportStdCovTest, PrintConsoleDirect)
{
ASSERT_NO_THROW(( [&](){
Report *report = makeReportStd();
// reportLine calls printConsole
report->reportLine("direct console print test");
// printError calls printErrorConsole - triggered by warn
report->warn(998, "stderr test");
delete report;
}() ));
}
////////////////////////////////////////////////////////////////
@ -2293,6 +2305,7 @@ TEST(MachineCovTest, SystemRunTime)
TEST(StatsCovTest, StatsConstructAndReport)
{
ASSERT_NO_THROW(( [&](){
Report report;
Debug debug(&report);
// With debug stats level 0, constructor/report are no-ops
@ -2303,6 +2316,8 @@ TEST(StatsCovTest, StatsConstructAndReport)
debug.setLevel("stats", 1);
Stats stats2(&debug, &report);
stats2.report("test step 2");
}() ));
}
////////////////////////////////////////////////////////////////
@ -2341,6 +2356,7 @@ TEST(GzstreamCovTest, WriteGzFile)
TEST(GzstreamCovTest, FlushExplicit)
{
ASSERT_NO_THROW(( [&](){
const char *tmpgz = "/tmp/test_gzstream_flush.gz";
{
gzstream::ogzstream gz(tmpgz);
@ -2348,6 +2364,8 @@ TEST(GzstreamCovTest, FlushExplicit)
gz.flush(); // This triggers sync() -> flush_buffer()
}
std::remove(tmpgz);
}() ));
}
////////////////////////////////////////////////////////////////
@ -2467,12 +2485,15 @@ TEST(ReportCovTest, RedirectStringPrintCoverage)
TEST(ReportStdCovTest, PrintErrorConsole)
{
ASSERT_NO_THROW(( [&](){
Report *report = makeReportStd();
// warn() outputs to stderr via printErrorConsole
report->warn(777, "testing stderr output");
// fileWarn also goes through printErrorConsole
report->fileWarn(778, "test.v", 1, "file warning test");
delete report;
}() ));
}
////////////////////////////////////////////////////////////////
@ -2491,10 +2512,13 @@ TEST(StringUtilCovTest, MakeTmpStringStdString)
// so we cannot test that path. Test only with non-tmp strings.
TEST(StringUtilCovTest, StringDeleteCheckRegular)
{
ASSERT_NO_THROW(( [&](){
char *s = stringCopy("regular");
// Should not crash - regular string can be deleted
stringDeleteCheck(s);
stringDelete(s);
}() ));
}
// Test Report redirectStringPrint with empty string
@ -2593,10 +2617,13 @@ TEST(ReportStdCovTest, ReportStdConstructor)
// Covers: ReportStd::printErrorConsole
TEST(ReportStdCovTest, PrintErrorConsoleViaWarn)
{
ASSERT_NO_THROW(( [&](){
Report *report = makeReportStd();
// warn uses printErrorConsole path
report->warn(9999, "test warning %d", 42);
delete report;
}() ));
}
// Test Report suppress/unsuppress messages