From b77779f7a60f3f540d92379da7dad92294a4f6db Mon Sep 17 00:00:00 2001 From: Jaehyun Kim Date: Fri, 13 Feb 2026 20:36:42 +0900 Subject: [PATCH] test: Refactoring. Standardize Google Test naming conventions by removing `R#_` prefixes, improve temporary file creation with `mkstemp`, etc Signed-off-by: Jaehyun Kim --- dcalc/test/cpp/TestDcalc.cc | 352 ++-- graph/test/cpp/TestGraph.cc | 62 +- liberty/test/cpp/TestLiberty.cc | 934 ++++----- network/test/cpp/TestNetwork.cc | 614 +++--- parasitics/test/cpp/TestParasitics.cc | 50 +- power/VcdParse.cc | 7 + power/test/cpp/TestPower.cc | 182 +- sdc/test/cpp/TestSdc.cc | 824 ++++---- sdf/test/cpp/TestSdf.cc | 154 +- search/test/cpp/TestSearch.cc | 2668 ++++++++++++------------- spice/test/cpp/TestSpice.cc | 137 +- spice/test/spice_write.tcl | 4 +- util/test/cpp/TestUtil.cc | 88 +- verilog/test/cpp/TestVerilog.cc | 436 ++-- 14 files changed, 3250 insertions(+), 3262 deletions(-) diff --git a/dcalc/test/cpp/TestDcalc.cc b/dcalc/test/cpp/TestDcalc.cc index 227159f6..005d5c9b 100644 --- a/dcalc/test/cpp/TestDcalc.cc +++ b/dcalc/test/cpp/TestDcalc.cc @@ -1446,7 +1446,7 @@ TEST_F(StaDcalcTest, NetCapsInitMultiple) { //////////////////////////////////////////////////////////////// // Test ArcDcalcResult copy -TEST_F(ArcDcalcResultTest, R5_CopyResult) { +TEST_F(ArcDcalcResultTest, CopyResult) { ArcDcalcResult result(2); result.setGateDelay(1e-10f); result.setDrvrSlew(2e-10f); @@ -1465,7 +1465,7 @@ TEST_F(ArcDcalcResultTest, R5_CopyResult) { } // Test ArcDcalcArg assignment -TEST_F(ArcDcalcArgTest, R5_Assignment) { +TEST_F(ArcDcalcArgTest, Assignment) { ArcDcalcArg arg; arg.setLoadCap(3.5e-12f); arg.setInputDelay(1.5e-9f); @@ -1479,7 +1479,7 @@ TEST_F(ArcDcalcArgTest, R5_Assignment) { } // Test ArcDcalcArg: set and get all fields -TEST_F(ArcDcalcArgTest, R5_AllSettersGetters) { +TEST_F(ArcDcalcArgTest, AllSettersGetters) { ArcDcalcArg arg; arg.setLoadCap(1e-12f); arg.setInputDelay(2e-9f); @@ -1494,7 +1494,7 @@ TEST_F(ArcDcalcArgTest, R5_AllSettersGetters) { } // Test FindRoot: with derivative zero (should still converge or fail gracefully) -TEST_F(FindRootAdditionalTest, R5_FlatDerivative) { +TEST_F(FindRootAdditionalTest, FlatDerivative) { // Function with zero derivative at some points FindRootFunc func = [](double x, double &y, double &dy) { y = (x - 2.0) * (x - 2.0) * (x - 2.0); @@ -1509,7 +1509,7 @@ TEST_F(FindRootAdditionalTest, R5_FlatDerivative) { } // Test FindRoot: linear function -TEST_F(FindRootAdditionalTest, R5_LinearFunction) { +TEST_F(FindRootAdditionalTest, LinearFunction) { FindRootFunc func = [](double x, double &y, double &dy) { y = 2.0 * x - 6.0; dy = 2.0; @@ -1521,7 +1521,7 @@ TEST_F(FindRootAdditionalTest, R5_LinearFunction) { } // Test FindRoot 4-arg: negative y1 and positive y2 -TEST_F(FindRootAdditionalTest, R5_FourArgNormalBracket) { +TEST_F(FindRootAdditionalTest, FourArgNormalBracket) { FindRootFunc func = [](double x, double &y, double &dy) { y = x * x - 4.0; dy = 2.0 * x; @@ -1534,14 +1534,14 @@ TEST_F(FindRootAdditionalTest, R5_FourArgNormalBracket) { } // Test ArcDcalcResult: default gate delay is zero -TEST_F(ArcDcalcResultTest, R5_DefaultValues) { +TEST_F(ArcDcalcResultTest, DefaultValues) { ArcDcalcResult result; EXPECT_FLOAT_EQ(delayAsFloat(result.gateDelay()), 0.0f); EXPECT_FLOAT_EQ(delayAsFloat(result.drvrSlew()), 0.0f); } // Test UnitDelayCalc copyState -TEST_F(StaDcalcTest, R5_UnitDelayCalcCopyState) { +TEST_F(StaDcalcTest, UnitDelayCalcCopyState) { ArcDelayCalc *calc = makeDelayCalc("unit", sta_); ASSERT_NE(calc, nullptr); calc->copyState(sta_); @@ -1549,7 +1549,7 @@ TEST_F(StaDcalcTest, R5_UnitDelayCalcCopyState) { } // Test LumpedCap copyState -TEST_F(StaDcalcTest, R5_LumpedCapCopyState) { +TEST_F(StaDcalcTest, LumpedCapCopyState) { ArcDelayCalc *calc = makeDelayCalc("lumped_cap", sta_); ASSERT_NE(calc, nullptr); calc->copyState(sta_); @@ -1557,7 +1557,7 @@ TEST_F(StaDcalcTest, R5_LumpedCapCopyState) { } // Test Arnoldi copyState -TEST_F(StaDcalcTest, R5_ArnoldiCopyState) { +TEST_F(StaDcalcTest, ArnoldiCopyState) { ArcDelayCalc *calc = makeDelayCalc("arnoldi", sta_); ASSERT_NE(calc, nullptr); calc->copyState(sta_); @@ -1565,7 +1565,7 @@ TEST_F(StaDcalcTest, R5_ArnoldiCopyState) { } // Test all calcs reduceSupported -TEST_F(StaDcalcTest, R5_AllCalcsReduceSupported) { +TEST_F(StaDcalcTest, AllCalcsReduceSupported) { StringSeq names = delayCalcNames(); for (const char *name : names) { ArcDelayCalc *calc = makeDelayCalc(name, sta_); @@ -1578,7 +1578,7 @@ TEST_F(StaDcalcTest, R5_AllCalcsReduceSupported) { } // Test NetCaps with large values -TEST_F(StaDcalcTest, R5_NetCapsLargeValues) { +TEST_F(StaDcalcTest, NetCapsLargeValues) { NetCaps caps(100e-12f, 200e-12f, 1000.0f, true); EXPECT_FLOAT_EQ(caps.pinCap(), 100e-12f); EXPECT_FLOAT_EQ(caps.wireCap(), 200e-12f); @@ -1587,7 +1587,7 @@ TEST_F(StaDcalcTest, R5_NetCapsLargeValues) { } // Test ArcDcalcResult with resize down -TEST_F(ArcDcalcResultTest, R5_ResizeDown) { +TEST_F(ArcDcalcResultTest, ResizeDown) { ArcDcalcResult result(5); for (size_t i = 0; i < 5; i++) { result.setWireDelay(i, static_cast(i) * 1e-12f); @@ -1599,20 +1599,20 @@ TEST_F(ArcDcalcResultTest, R5_ResizeDown) { } // Test MultiDrvrNet drvrs -TEST_F(StaDcalcTest, R5_MultiDrvrNetDrvrs) { +TEST_F(StaDcalcTest, MultiDrvrNetDrvrs) { MultiDrvrNet mdn; VertexSeq &drvrs = mdn.drvrs(); EXPECT_TRUE(drvrs.empty()); } // Test GraphDelayCalc delayCalc returns non-null after init -TEST_F(StaDcalcTest, R5_GraphDelayCalcExists) { +TEST_F(StaDcalcTest, GraphDelayCalcExists) { GraphDelayCalc *gdc = sta_->graphDelayCalc(); EXPECT_NE(gdc, nullptr); } // Test UnitDelayCalc reduceParasitic Net overload -TEST_F(StaDcalcTest, R5_UnitDelayCalcReduceParasiticNetOverload) { +TEST_F(StaDcalcTest, UnitDelayCalcReduceParasiticNetOverload) { ArcDelayCalc *calc = makeDelayCalc("unit", sta_); ASSERT_NE(calc, nullptr); calc->reduceParasitic(static_cast(nullptr), @@ -1908,7 +1908,7 @@ TEST_F(DesignDcalcTest, ArcDcalcArgAccessorsWithDesign) { //////////////////////////////////////////////////////////////// // NetCaps: init with different values -TEST_F(StaDcalcTest, R6_NetCapsInitVariants) { +TEST_F(StaDcalcTest, NetCapsInitVariants) { NetCaps caps; caps.init(0.0f, 0.0f, 0.0f, false); EXPECT_FLOAT_EQ(caps.pinCap(), 0.0f); @@ -1924,7 +1924,7 @@ TEST_F(StaDcalcTest, R6_NetCapsInitVariants) { } // NetCaps: parameterized constructor with zero values -TEST_F(StaDcalcTest, R6_NetCapsConstructorZero) { +TEST_F(StaDcalcTest, NetCapsConstructorZero) { NetCaps caps(0.0f, 0.0f, 0.0f, false); EXPECT_FLOAT_EQ(caps.pinCap(), 0.0f); EXPECT_FLOAT_EQ(caps.wireCap(), 0.0f); @@ -1933,7 +1933,7 @@ TEST_F(StaDcalcTest, R6_NetCapsConstructorZero) { } // NetCaps: parameterized constructor with large values -TEST_F(StaDcalcTest, R6_NetCapsConstructorLarge) { +TEST_F(StaDcalcTest, NetCapsConstructorLarge) { NetCaps caps(1e-6f, 5e-7f, 100.0f, true); EXPECT_FLOAT_EQ(caps.pinCap(), 1e-6f); EXPECT_FLOAT_EQ(caps.wireCap(), 5e-7f); @@ -1942,7 +1942,7 @@ TEST_F(StaDcalcTest, R6_NetCapsConstructorLarge) { } // ArcDcalcArg: drvrCell returns nullptr with null drvrPin -TEST_F(ArcDcalcArgTest, R6_DrvrCellNullPin) { +TEST_F(ArcDcalcArgTest, DrvrCellNullPin) { ArcDcalcArg arg; // With null drvrPin, drvrCell returns nullptr // Can't call drvrCell with null arc, it would dereference arc_. @@ -1951,7 +1951,7 @@ TEST_F(ArcDcalcArgTest, R6_DrvrCellNullPin) { } // ArcDcalcArg: assignment/move semantics via vector -TEST_F(ArcDcalcArgTest, R6_ArgInVector) { +TEST_F(ArcDcalcArgTest, ArgInVector) { ArcDcalcArgSeq args; ArcDcalcArg arg1; arg1.setLoadCap(1.0e-12f); @@ -1973,7 +1973,7 @@ TEST_F(ArcDcalcArgTest, R6_ArgInVector) { } // ArcDcalcResult: copy semantics -TEST_F(ArcDcalcResultTest, R6_ResultCopy) { +TEST_F(ArcDcalcResultTest, ResultCopy) { ArcDcalcResult result(3); result.setGateDelay(5e-10f); result.setDrvrSlew(2e-10f); @@ -1993,7 +1993,7 @@ TEST_F(ArcDcalcResultTest, R6_ResultCopy) { } // ArcDcalcResult: in vector (exercises copy/move) -TEST_F(ArcDcalcResultTest, R6_ResultInVector) { +TEST_F(ArcDcalcResultTest, ResultInVector) { ArcDcalcResultSeq results; for (int i = 0; i < 5; i++) { ArcDcalcResult r(2); @@ -2011,7 +2011,7 @@ TEST_F(ArcDcalcResultTest, R6_ResultInVector) { } // GraphDelayCalc: delaysInvalid -TEST_F(StaDcalcTest, R6_GraphDelayCalcDelaysInvalid) { +TEST_F(StaDcalcTest, GraphDelayCalcDelaysInvalid2) { GraphDelayCalc *gdc = sta_->graphDelayCalc(); ASSERT_NE(gdc, nullptr); // Should not crash @@ -2019,21 +2019,21 @@ TEST_F(StaDcalcTest, R6_GraphDelayCalcDelaysInvalid) { } // GraphDelayCalc: clear -TEST_F(StaDcalcTest, R6_GraphDelayCalcClear) { +TEST_F(StaDcalcTest, GraphDelayCalcClear2) { GraphDelayCalc *gdc = sta_->graphDelayCalc(); ASSERT_NE(gdc, nullptr); gdc->clear(); } // GraphDelayCalc: copyState -TEST_F(StaDcalcTest, R6_GraphDelayCalcCopyState) { +TEST_F(StaDcalcTest, GraphDelayCalcCopyState2) { GraphDelayCalc *gdc = sta_->graphDelayCalc(); ASSERT_NE(gdc, nullptr); gdc->copyState(sta_); } // Test all calcs: finishDrvrPin does not crash -TEST_F(StaDcalcTest, R6_AllCalcsFinishDrvrPin) { +TEST_F(StaDcalcTest, AllCalcsFinishDrvrPin) { StringSeq names = delayCalcNames(); for (const char *name : names) { ArcDelayCalc *calc = makeDelayCalc(name, sta_); @@ -2044,7 +2044,7 @@ TEST_F(StaDcalcTest, R6_AllCalcsFinishDrvrPin) { } // Test all calcs: setDcalcArgParasiticSlew (single) with empty arg -TEST_F(StaDcalcTest, R6_AllCalcsSetDcalcArgSingle) { +TEST_F(StaDcalcTest, AllCalcsSetDcalcArgSingle) { StringSeq names = delayCalcNames(); for (const char *name : names) { ArcDelayCalc *calc = makeDelayCalc(name, sta_); @@ -2056,7 +2056,7 @@ TEST_F(StaDcalcTest, R6_AllCalcsSetDcalcArgSingle) { } // Test all calcs: setDcalcArgParasiticSlew (seq) with empty seq -TEST_F(StaDcalcTest, R6_AllCalcsSetDcalcArgSeqEmpty) { +TEST_F(StaDcalcTest, AllCalcsSetDcalcArgSeqEmpty) { StringSeq names = delayCalcNames(); for (const char *name : names) { ArcDelayCalc *calc = makeDelayCalc(name, sta_); @@ -2068,7 +2068,7 @@ TEST_F(StaDcalcTest, R6_AllCalcsSetDcalcArgSeqEmpty) { } // Test all calcs: inputPortDelay with null args -TEST_F(StaDcalcTest, R6_AllCalcsInputPortDelayNull) { +TEST_F(StaDcalcTest, AllCalcsInputPortDelayNull) { StringSeq names = delayCalcNames(); for (const char *name : names) { ArcDelayCalc *calc = makeDelayCalc(name, sta_); @@ -2083,7 +2083,7 @@ TEST_F(StaDcalcTest, R6_AllCalcsInputPortDelayNull) { } // FindRoot: additional test for 4-arg overload with tight bounds -TEST_F(FindRootAdditionalTest, R6_TightBoundsLinear) { +TEST_F(FindRootAdditionalTest, TightBoundsLinear) { FindRootFunc func = [](double x, double &y, double &dy) { y = 2.0 * x - 6.0; dy = 2.0; @@ -2096,7 +2096,7 @@ TEST_F(FindRootAdditionalTest, R6_TightBoundsLinear) { } // FindRoot: test where Newton step goes out of bracket -TEST_F(FindRootAdditionalTest, R6_NewtonOutOfBracket) { +TEST_F(FindRootAdditionalTest, NewtonOutOfBracket) { // Using a function where Newton step may overshoot FindRootFunc func = [](double x, double &y, double &dy) { y = x * x * x - x - 2.0; @@ -2110,7 +2110,7 @@ TEST_F(FindRootAdditionalTest, R6_NewtonOutOfBracket) { } // FindRoot: sin function -TEST_F(FindRootAdditionalTest, R6_SinRoot) { +TEST_F(FindRootAdditionalTest, SinRoot) { FindRootFunc func = [](double x, double &y, double &dy) { y = sin(x); dy = cos(x); @@ -2123,7 +2123,7 @@ TEST_F(FindRootAdditionalTest, R6_SinRoot) { } // FindRoot: exponential function -TEST_F(FindRootAdditionalTest, R6_ExpMinusConst) { +TEST_F(FindRootAdditionalTest, ExpMinusConst) { FindRootFunc func = [](double x, double &y, double &dy) { y = exp(x) - 3.0; dy = exp(x); @@ -2135,21 +2135,21 @@ TEST_F(FindRootAdditionalTest, R6_ExpMinusConst) { } // GraphDelayCalc: levelsChangedBefore -TEST_F(StaDcalcTest, R6_GraphDelayCalcLevelsChangedBefore) { +TEST_F(StaDcalcTest, GraphDelayCalcLevelsChangedBefore) { GraphDelayCalc *gdc = sta_->graphDelayCalc(); ASSERT_NE(gdc, nullptr); gdc->levelsChangedBefore(); } // GraphDelayCalc: setObserver with nullptr -TEST_F(StaDcalcTest, R6_GraphDelayCalcSetObserverNull) { +TEST_F(StaDcalcTest, GraphDelayCalcSetObserverNull) { GraphDelayCalc *gdc = sta_->graphDelayCalc(); ASSERT_NE(gdc, nullptr); gdc->setObserver(nullptr); } // MultiDrvrNet: drvrs vector -TEST_F(StaDcalcTest, R6_MultiDrvrNetDrvrs) { +TEST_F(StaDcalcTest, MultiDrvrNetDrvrs2) { MultiDrvrNet mdn; EXPECT_TRUE(mdn.drvrs().empty()); // drvrs() returns a reference to internal vector @@ -2158,7 +2158,7 @@ TEST_F(StaDcalcTest, R6_MultiDrvrNetDrvrs) { } // ArcDcalcArg: multiple set/get cycles -TEST_F(ArcDcalcArgTest, R6_MultipleSetGetCycles) { +TEST_F(ArcDcalcArgTest, MultipleSetGetCycles) { ArcDcalcArg arg; for (int i = 0; i < 10; i++) { float cap = static_cast(i) * 1e-12f; @@ -2174,7 +2174,7 @@ TEST_F(ArcDcalcArgTest, R6_MultipleSetGetCycles) { } // ArcDcalcResult: zero gate delay and nonzero wire delays -TEST_F(ArcDcalcResultTest, R6_ZeroGateNonzeroWire) { +TEST_F(ArcDcalcResultTest, ZeroGateNonzeroWire) { ArcDcalcResult result(2); result.setGateDelay(0.0f); result.setDrvrSlew(0.0f); @@ -2192,7 +2192,7 @@ TEST_F(ArcDcalcResultTest, R6_ZeroGateNonzeroWire) { } // ArcDcalcResult: resize down then up -TEST_F(ArcDcalcResultTest, R6_ResizeDownThenUp) { +TEST_F(ArcDcalcResultTest, ResizeDownThenUp) { ArcDcalcResult result(5); for (size_t i = 0; i < 5; i++) { result.setWireDelay(i, static_cast(i) * 1e-12f); @@ -2209,7 +2209,7 @@ TEST_F(ArcDcalcResultTest, R6_ResizeDownThenUp) { } // DesignDcalc: timing with ccs_ceff calculator -TEST_F(DesignDcalcTest, R6_TimingCcsCeff) { +TEST_F(DesignDcalcTest, TimingCcsCeff2) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("ccs_ceff"); sta_->updateTiming(true); @@ -2217,7 +2217,7 @@ TEST_F(DesignDcalcTest, R6_TimingCcsCeff) { } // DesignDcalc: timing with prima calculator -TEST_F(DesignDcalcTest, R6_TimingPrima) { +TEST_F(DesignDcalcTest, TimingPrima2) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("prima"); sta_->updateTiming(true); @@ -2225,7 +2225,7 @@ TEST_F(DesignDcalcTest, R6_TimingPrima) { } // DesignDcalc: findDelays with lumped_cap -TEST_F(DesignDcalcTest, R6_FindDelaysLumpedCap) { +TEST_F(DesignDcalcTest, FindDelaysLumpedCap) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("lumped_cap"); sta_->findDelays(); @@ -2233,7 +2233,7 @@ TEST_F(DesignDcalcTest, R6_FindDelaysLumpedCap) { } // DesignDcalc: findDelays with unit -TEST_F(DesignDcalcTest, R6_FindDelaysUnit) { +TEST_F(DesignDcalcTest, FindDelaysUnit) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("unit"); sta_->findDelays(); @@ -2241,7 +2241,7 @@ TEST_F(DesignDcalcTest, R6_FindDelaysUnit) { } // DesignDcalc: findDelays with dmp_ceff_two_pole -TEST_F(DesignDcalcTest, R6_FindDelaysDmpTwoPole) { +TEST_F(DesignDcalcTest, FindDelaysDmpTwoPole) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_two_pole"); sta_->findDelays(); @@ -2249,7 +2249,7 @@ TEST_F(DesignDcalcTest, R6_FindDelaysDmpTwoPole) { } // DesignDcalc: findDelays with arnoldi -TEST_F(DesignDcalcTest, R6_FindDelaysArnoldi) { +TEST_F(DesignDcalcTest, FindDelaysArnoldi) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("arnoldi"); sta_->findDelays(); @@ -2257,7 +2257,7 @@ TEST_F(DesignDcalcTest, R6_FindDelaysArnoldi) { } // DesignDcalc: findDelays with ccs_ceff -TEST_F(DesignDcalcTest, R6_FindDelaysCcsCeff) { +TEST_F(DesignDcalcTest, FindDelaysCcsCeff) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("ccs_ceff"); sta_->findDelays(); @@ -2265,7 +2265,7 @@ TEST_F(DesignDcalcTest, R6_FindDelaysCcsCeff) { } // DesignDcalc: findDelays with prima -TEST_F(DesignDcalcTest, R6_FindDelaysPrima) { +TEST_F(DesignDcalcTest, FindDelaysPrima) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("prima"); sta_->findDelays(); @@ -2273,7 +2273,7 @@ TEST_F(DesignDcalcTest, R6_FindDelaysPrima) { } // ArcDcalcArg: copy constructor -TEST_F(ArcDcalcArgTest, R6_CopyConstructor) { +TEST_F(ArcDcalcArgTest, CopyConstructor) { ArcDcalcArg arg; arg.setLoadCap(5.0e-12f); arg.setInSlew(100e-12f); @@ -2291,7 +2291,7 @@ TEST_F(ArcDcalcArgTest, R6_CopyConstructor) { } // ArcDcalcArg: default constructed values -TEST_F(ArcDcalcArgTest, R6_DefaultValues) { +TEST_F(ArcDcalcArgTest, DefaultValues) { ArcDcalcArg arg; EXPECT_EQ(arg.inPin(), nullptr); EXPECT_EQ(arg.drvrPin(), nullptr); @@ -2303,7 +2303,7 @@ TEST_F(ArcDcalcArgTest, R6_DefaultValues) { } // ArcDcalcArg: setParasitic round-trip -TEST_F(ArcDcalcArgTest, R6_SetParasitic) { +TEST_F(ArcDcalcArgTest, SetParasitic2) { ArcDcalcArg arg; EXPECT_EQ(arg.parasitic(), nullptr); // Set to a non-null sentinel (won't be dereferenced) @@ -2315,7 +2315,7 @@ TEST_F(ArcDcalcArgTest, R6_SetParasitic) { } // ArcDcalcResult: zero loads -TEST_F(ArcDcalcResultTest, R6_ZeroLoads) { +TEST_F(ArcDcalcResultTest, ZeroLoads) { ArcDcalcResult result; result.setGateDelay(1e-10f); result.setDrvrSlew(5e-11f); @@ -2324,7 +2324,7 @@ TEST_F(ArcDcalcResultTest, R6_ZeroLoads) { } // ArcDcalcResult: single load -TEST_F(ArcDcalcResultTest, R6_SingleLoad) { +TEST_F(ArcDcalcResultTest, SingleLoad2) { ArcDcalcResult result(1); result.setGateDelay(2e-10f); result.setDrvrSlew(1e-10f); @@ -2335,7 +2335,7 @@ TEST_F(ArcDcalcResultTest, R6_SingleLoad) { } // ArcDcalcResult: setLoadCount from zero -TEST_F(ArcDcalcResultTest, R6_SetLoadCountFromZero) { +TEST_F(ArcDcalcResultTest, SetLoadCountFromZero) { ArcDcalcResult result; result.setLoadCount(3); result.setWireDelay(0, 1e-12f); @@ -2345,7 +2345,7 @@ TEST_F(ArcDcalcResultTest, R6_SetLoadCountFromZero) { } // Test all calcs: name() returns non-empty string -TEST_F(StaDcalcTest, R6_AllCalcsName) { +TEST_F(StaDcalcTest, AllCalcsName) { StringSeq names = delayCalcNames(); for (const char *name : names) { ArcDelayCalc *calc = makeDelayCalc(name, sta_); @@ -2357,7 +2357,7 @@ TEST_F(StaDcalcTest, R6_AllCalcsName) { } // Test all calcs: reduceSupported returns a bool -TEST_F(StaDcalcTest, R6_AllCalcsReduceSupported) { +TEST_F(StaDcalcTest, AllCalcsReduceSupported2) { StringSeq names = delayCalcNames(); for (const char *name : names) { ArcDelayCalc *calc = makeDelayCalc(name, sta_); @@ -2370,7 +2370,7 @@ TEST_F(StaDcalcTest, R6_AllCalcsReduceSupported) { } // Test all calcs: copy() produces a valid calc -TEST_F(StaDcalcTest, R6_AllCalcsCopy) { +TEST_F(StaDcalcTest, AllCalcsCopy) { StringSeq names = delayCalcNames(); for (const char *name : names) { ArcDelayCalc *calc = makeDelayCalc(name, sta_); @@ -2384,7 +2384,7 @@ TEST_F(StaDcalcTest, R6_AllCalcsCopy) { } // FindRoot: quadratic function with exact root -TEST_F(FindRootAdditionalTest, R6_QuadraticExact) { +TEST_F(FindRootAdditionalTest, QuadraticExact) { FindRootFunc func = [](double x, double &y, double &dy) { y = x * x - 4.0; dy = 2.0 * x; @@ -2396,7 +2396,7 @@ TEST_F(FindRootAdditionalTest, R6_QuadraticExact) { } // FindRoot: 4-arg overload with quadratic -TEST_F(FindRootAdditionalTest, R6_QuadraticFourArg) { +TEST_F(FindRootAdditionalTest, QuadraticFourArg) { FindRootFunc func = [](double x, double &y, double &dy) { y = x * x - 9.0; dy = 2.0 * x; @@ -2417,50 +2417,50 @@ TEST_F(FindRootAdditionalTest, R6_QuadraticFourArg) { // R8_DrvrNetNull removed (segfault - dereferences null pin) // ArcDcalcArg: multiple set/get with edge cases -TEST_F(ArcDcalcArgTest, R8_ZeroLoadCap) { +TEST_F(ArcDcalcArgTest, ZeroLoadCap) { ArcDcalcArg arg; arg.setLoadCap(0.0f); EXPECT_FLOAT_EQ(arg.loadCap(), 0.0f); } -TEST_F(ArcDcalcArgTest, R8_NegativeInputDelay) { +TEST_F(ArcDcalcArgTest, NegativeInputDelay) { ArcDcalcArg arg; arg.setInputDelay(-1.0e-9f); EXPECT_FLOAT_EQ(arg.inputDelay(), -1.0e-9f); } -TEST_F(ArcDcalcArgTest, R8_VeryLargeLoadCap) { +TEST_F(ArcDcalcArgTest, VeryLargeLoadCap) { ArcDcalcArg arg; arg.setLoadCap(1.0e-3f); EXPECT_FLOAT_EQ(arg.loadCap(), 1.0e-3f); } -TEST_F(ArcDcalcArgTest, R8_VerySmallSlew) { +TEST_F(ArcDcalcArgTest, VerySmallSlew) { ArcDcalcArg arg; arg.setInSlew(1.0e-15f); EXPECT_FLOAT_EQ(arg.inSlewFlt(), 1.0e-15f); } // ArcDcalcResult: edge cases -TEST_F(ArcDcalcResultTest, R8_NegativeGateDelay) { +TEST_F(ArcDcalcResultTest, NegativeGateDelay) { ArcDcalcResult result; result.setGateDelay(-1.0e-10f); EXPECT_FLOAT_EQ(delayAsFloat(result.gateDelay()), -1.0e-10f); } -TEST_F(ArcDcalcResultTest, R8_VeryLargeWireDelay) { +TEST_F(ArcDcalcResultTest, VeryLargeWireDelay) { ArcDcalcResult result(1); result.setWireDelay(0, 1.0e-3f); EXPECT_FLOAT_EQ(delayAsFloat(result.wireDelay(0)), 1.0e-3f); } -TEST_F(ArcDcalcResultTest, R8_ZeroDrvrSlew) { +TEST_F(ArcDcalcResultTest, ZeroDrvrSlew) { ArcDcalcResult result; result.setDrvrSlew(0.0f); EXPECT_FLOAT_EQ(delayAsFloat(result.drvrSlew()), 0.0f); } -TEST_F(ArcDcalcResultTest, R8_MultipleLoadSetGet) { +TEST_F(ArcDcalcResultTest, MultipleLoadSetGet) { ArcDcalcResult result(5); for (size_t i = 0; i < 5; i++) { float delay = static_cast(i + 1) * 1e-12f; @@ -2477,13 +2477,13 @@ TEST_F(ArcDcalcResultTest, R8_MultipleLoadSetGet) { } // NetCaps additional coverage - default constructor doesn't zero-init -TEST_F(StaDcalcTest, R8_NetCapsDefaultConstructorExists) { +TEST_F(StaDcalcTest, NetCapsDefaultConstructorExists) { NetCaps caps; // Default constructor doesn't initialize members, just verify construction SUCCEED(); } -TEST_F(StaDcalcTest, R8_NetCapsParameterizedConstructor) { +TEST_F(StaDcalcTest, NetCapsParameterizedConstructor) { NetCaps caps(1.0e-12f, 2.0e-12f, 3.0f, true); EXPECT_FLOAT_EQ(caps.pinCap(), 1.0e-12f); EXPECT_FLOAT_EQ(caps.wireCap(), 2.0e-12f); @@ -2491,7 +2491,7 @@ TEST_F(StaDcalcTest, R8_NetCapsParameterizedConstructor) { EXPECT_TRUE(caps.hasNetLoad()); } -TEST_F(StaDcalcTest, R8_NetCapsInit) { +TEST_F(StaDcalcTest, NetCapsInit) { NetCaps caps; caps.init(5.0e-12f, 10.0e-12f, 2.0f, true); EXPECT_FLOAT_EQ(caps.pinCap(), 5.0e-12f); @@ -2500,7 +2500,7 @@ TEST_F(StaDcalcTest, R8_NetCapsInit) { EXPECT_TRUE(caps.hasNetLoad()); } -TEST_F(StaDcalcTest, R8_NetCapsInitZero) { +TEST_F(StaDcalcTest, NetCapsInitZero) { NetCaps caps(1.0f, 2.0f, 3.0f, true); caps.init(0.0f, 0.0f, 0.0f, false); EXPECT_FLOAT_EQ(caps.pinCap(), 0.0f); @@ -2509,7 +2509,7 @@ TEST_F(StaDcalcTest, R8_NetCapsInitZero) { EXPECT_FALSE(caps.hasNetLoad()); } -TEST_F(StaDcalcTest, R8_NetCapsLargeValues) { +TEST_F(StaDcalcTest, NetCapsLargeValues2) { NetCaps caps(100.0e-12f, 200.0e-12f, 50.0f, true); EXPECT_FLOAT_EQ(caps.pinCap(), 100.0e-12f); EXPECT_FLOAT_EQ(caps.wireCap(), 200.0e-12f); @@ -2517,42 +2517,42 @@ TEST_F(StaDcalcTest, R8_NetCapsLargeValues) { } // GraphDelayCalc additional coverage -TEST_F(StaDcalcTest, R8_GraphDelayCalcConstruct) { +TEST_F(StaDcalcTest, GraphDelayCalcConstruct) { GraphDelayCalc *gdc = sta_->graphDelayCalc(); EXPECT_NE(gdc, nullptr); } -TEST_F(StaDcalcTest, R8_GraphDelayCalcClear) { +TEST_F(StaDcalcTest, GraphDelayCalcClear3) { GraphDelayCalc *gdc = sta_->graphDelayCalc(); gdc->clear(); SUCCEED(); } -TEST_F(StaDcalcTest, R8_GraphDelayCalcDelaysInvalid) { +TEST_F(StaDcalcTest, GraphDelayCalcDelaysInvalid3) { GraphDelayCalc *gdc = sta_->graphDelayCalc(); gdc->delaysInvalid(); SUCCEED(); } -TEST_F(StaDcalcTest, R8_GraphDelayCalcSetObserver) { +TEST_F(StaDcalcTest, GraphDelayCalcSetObserver) { GraphDelayCalc *gdc = sta_->graphDelayCalc(); gdc->setObserver(nullptr); SUCCEED(); } -TEST_F(StaDcalcTest, R8_GraphDelayCalcLevelsChanged) { +TEST_F(StaDcalcTest, GraphDelayCalcLevelsChanged) { GraphDelayCalc *gdc = sta_->graphDelayCalc(); gdc->levelsChangedBefore(); SUCCEED(); } -TEST_F(StaDcalcTest, R8_GraphDelayCalcCopyState) { +TEST_F(StaDcalcTest, GraphDelayCalcCopyState3) { GraphDelayCalc *gdc = sta_->graphDelayCalc(); gdc->copyState(sta_); SUCCEED(); } -TEST_F(StaDcalcTest, R8_GraphDelayCalcIncrTolerance) { +TEST_F(StaDcalcTest, GraphDelayCalcIncrTolerance) { GraphDelayCalc *gdc = sta_->graphDelayCalc(); float tol = gdc->incrementalDelayTolerance(); EXPECT_GE(tol, 0.0f); @@ -2569,7 +2569,7 @@ TEST_F(StaDcalcTest, R8_GraphDelayCalcIncrTolerance) { // R8_AllCalcsReportCheckDelay removed (segfault) // FindRoot: additional edge cases -TEST_F(FindRootAdditionalTest, R8_LinearFunction) { +TEST_F(FindRootAdditionalTest, LinearFunction2) { FindRootFunc func = [](double x, double &y, double &dy) { y = 2.0 * x - 10.0; dy = 2.0; @@ -2580,7 +2580,7 @@ TEST_F(FindRootAdditionalTest, R8_LinearFunction) { EXPECT_NEAR(root, 5.0, 1e-8); } -TEST_F(FindRootAdditionalTest, R8_FourArgLinear) { +TEST_F(FindRootAdditionalTest, FourArgLinear) { FindRootFunc func = [](double x, double &y, double &dy) { y = 3.0 * x - 6.0; dy = 3.0; @@ -2592,7 +2592,7 @@ TEST_F(FindRootAdditionalTest, R8_FourArgLinear) { EXPECT_NEAR(root, 2.0, 1e-8); } -TEST_F(FindRootAdditionalTest, R8_HighOrderPoly) { +TEST_F(FindRootAdditionalTest, HighOrderPoly) { FindRootFunc func = [](double x, double &y, double &dy) { y = x * x * x * x - 16.0; dy = 4.0 * x * x * x; @@ -2603,7 +2603,7 @@ TEST_F(FindRootAdditionalTest, R8_HighOrderPoly) { EXPECT_NEAR(root, 2.0, 1e-6); } -TEST_F(FindRootAdditionalTest, R8_NegativeRoot) { +TEST_F(FindRootAdditionalTest, NegativeRoot) { FindRootFunc func = [](double x, double &y, double &dy) { y = x + 3.0; dy = 1.0; @@ -2614,7 +2614,7 @@ TEST_F(FindRootAdditionalTest, R8_NegativeRoot) { EXPECT_NEAR(root, -3.0, 1e-8); } -TEST_F(FindRootAdditionalTest, R8_TrigFunction) { +TEST_F(FindRootAdditionalTest, TrigFunction) { FindRootFunc func = [](double x, double &y, double &dy) { y = std::cos(x); dy = -std::sin(x); @@ -2626,7 +2626,7 @@ TEST_F(FindRootAdditionalTest, R8_TrigFunction) { EXPECT_NEAR(root, M_PI / 2.0, 1e-8); } -TEST_F(FindRootAdditionalTest, R8_VeryTightBounds) { +TEST_F(FindRootAdditionalTest, VeryTightBounds) { FindRootFunc func = [](double x, double &y, double &dy) { y = x - 5.0; dy = 1.0; @@ -2637,7 +2637,7 @@ TEST_F(FindRootAdditionalTest, R8_VeryTightBounds) { EXPECT_NEAR(root, 5.0, 1e-8); } -TEST_F(FindRootAdditionalTest, R8_ExpFunction) { +TEST_F(FindRootAdditionalTest, ExpFunction) { FindRootFunc func = [](double x, double &y, double &dy) { y = std::exp(x) - 10.0; dy = std::exp(x); @@ -2648,7 +2648,7 @@ TEST_F(FindRootAdditionalTest, R8_ExpFunction) { EXPECT_NEAR(root, std::log(10.0), 1e-8); } -TEST_F(FindRootAdditionalTest, R8_FourArgSwap) { +TEST_F(FindRootAdditionalTest, FourArgSwap) { FindRootFunc func = [](double x, double &y, double &dy) { y = x - 7.0; dy = 1.0; @@ -2661,28 +2661,28 @@ TEST_F(FindRootAdditionalTest, R8_FourArgSwap) { } // DesignDcalcTest: additional delay calculator exercises on real design -TEST_F(DesignDcalcTest, R8_TimingLumpedCap) { +TEST_F(DesignDcalcTest, TimingLumpedCap2) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("lumped_cap"); sta_->updateTiming(true); SUCCEED(); } -TEST_F(DesignDcalcTest, R8_TimingUnit) { +TEST_F(DesignDcalcTest, TimingUnit2) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("unit"); sta_->updateTiming(true); SUCCEED(); } -TEST_F(DesignDcalcTest, R8_TimingArnoldi) { +TEST_F(DesignDcalcTest, TimingArnoldi2) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("arnoldi"); sta_->updateTiming(true); SUCCEED(); } -TEST_F(DesignDcalcTest, R8_FindDelaysDmpElmore) { +TEST_F(DesignDcalcTest, FindDelaysDmpElmore) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); @@ -2692,21 +2692,21 @@ TEST_F(DesignDcalcTest, R8_FindDelaysDmpElmore) { SUCCEED(); } -TEST_F(DesignDcalcTest, R8_FindDelaysDmpTwoPole) { +TEST_F(DesignDcalcTest, FindDelaysDmpTwoPole2) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_two_pole"); sta_->updateTiming(true); SUCCEED(); } -TEST_F(DesignDcalcTest, R8_FindDelaysCcsCeff) { +TEST_F(DesignDcalcTest, FindDelaysCcsCeff2) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("ccs_ceff"); sta_->updateTiming(true); SUCCEED(); } -TEST_F(DesignDcalcTest, R8_FindDelaysPrima) { +TEST_F(DesignDcalcTest, FindDelaysPrima2) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("prima"); sta_->updateTiming(true); @@ -2720,14 +2720,14 @@ TEST_F(DesignDcalcTest, R8_FindDelaysPrima) { // R8_LumpedCapReportGateDelay removed (segfault) // LumpedCap: safe exercises that don't need real timing arcs -TEST_F(StaDcalcTest, R8_LumpedCapFinishDrvrPin) { +TEST_F(StaDcalcTest, LumpedCapFinishDrvrPin2) { ArcDelayCalc *calc = makeDelayCalc("lumped_cap", sta_); ASSERT_NE(calc, nullptr); calc->finishDrvrPin(); delete calc; } -TEST_F(StaDcalcTest, R8_LumpedCapCopyState) { +TEST_F(StaDcalcTest, LumpedCapCopyState2) { ArcDelayCalc *calc = makeDelayCalc("lumped_cap", sta_); ASSERT_NE(calc, nullptr); calc->copyState(sta_); @@ -2738,14 +2738,14 @@ TEST_F(StaDcalcTest, R8_LumpedCapCopyState) { // R8_DmpCeffElmoreFindParasitic removed (segfault) // R8_DmpCeffElmoreInputPortDelay removed (segfault) -TEST_F(StaDcalcTest, R8_DmpCeffElmoreFinishDrvrPin) { +TEST_F(StaDcalcTest, DmpCeffElmoreFinishDrvrPin2) { ArcDelayCalc *calc = makeDelayCalc("dmp_ceff_elmore", sta_); ASSERT_NE(calc, nullptr); calc->finishDrvrPin(); delete calc; } -TEST_F(StaDcalcTest, R8_DmpCeffElmoreCopyState) { +TEST_F(StaDcalcTest, DmpCeffElmoreCopyState) { ArcDelayCalc *calc = makeDelayCalc("dmp_ceff_elmore", sta_); ASSERT_NE(calc, nullptr); calc->copyState(sta_); @@ -2756,14 +2756,14 @@ TEST_F(StaDcalcTest, R8_DmpCeffElmoreCopyState) { // R8_DmpCeffTwoPoleFindParasitic removed (segfault) // R8_DmpCeffTwoPoleInputPortDelay removed (segfault) -TEST_F(StaDcalcTest, R8_DmpCeffTwoPoleFinishDrvrPin) { +TEST_F(StaDcalcTest, DmpCeffTwoPoleFinishDrvrPin2) { ArcDelayCalc *calc = makeDelayCalc("dmp_ceff_two_pole", sta_); ASSERT_NE(calc, nullptr); calc->finishDrvrPin(); delete calc; } -TEST_F(StaDcalcTest, R8_DmpCeffTwoPoleCopyState) { +TEST_F(StaDcalcTest, DmpCeffTwoPoleCopyState) { ArcDelayCalc *calc = makeDelayCalc("dmp_ceff_two_pole", sta_); ASSERT_NE(calc, nullptr); calc->copyState(sta_); @@ -2774,14 +2774,14 @@ TEST_F(StaDcalcTest, R8_DmpCeffTwoPoleCopyState) { // R8_CcsCeffFindParasitic removed (segfault) // R8_CcsCeffInputPortDelay removed (segfault) -TEST_F(StaDcalcTest, R8_CcsCeffFinishDrvrPin) { +TEST_F(StaDcalcTest, CcsCeffFinishDrvrPin2) { ArcDelayCalc *calc = makeDelayCalc("ccs_ceff", sta_); ASSERT_NE(calc, nullptr); calc->finishDrvrPin(); delete calc; } -TEST_F(StaDcalcTest, R8_CcsCeffCopyState) { +TEST_F(StaDcalcTest, CcsCeffCopyState2) { ArcDelayCalc *calc = makeDelayCalc("ccs_ceff", sta_); ASSERT_NE(calc, nullptr); calc->copyState(sta_); @@ -2792,7 +2792,7 @@ TEST_F(StaDcalcTest, R8_CcsCeffCopyState) { // R8_PrimaFindParasitic removed (segfault) // R8_PrimaInputPortDelay removed (segfault) -TEST_F(StaDcalcTest, R8_PrimaCopyState) { +TEST_F(StaDcalcTest, PrimaCopyState2) { ArcDelayCalc *calc = makeDelayCalc("prima", sta_); ASSERT_NE(calc, nullptr); calc->copyState(sta_); @@ -2801,19 +2801,19 @@ TEST_F(StaDcalcTest, R8_PrimaCopyState) { } // ArcDcalcArg: FullConstructor variants -TEST_F(ArcDcalcArgTest, R8_FullConstructorAllZeros) { +TEST_F(ArcDcalcArgTest, FullConstructorAllZeros) { ArcDcalcArg arg(nullptr, nullptr, nullptr, nullptr, 0.0f, 0.0f, nullptr); EXPECT_FLOAT_EQ(arg.inSlewFlt(), 0.0f); EXPECT_FLOAT_EQ(arg.loadCap(), 0.0f); EXPECT_FLOAT_EQ(arg.inputDelay(), 0.0f); } -TEST_F(ArcDcalcArgTest, R8_InputDelayConstructorZero) { +TEST_F(ArcDcalcArgTest, InputDelayConstructorZero) { ArcDcalcArg arg(nullptr, nullptr, nullptr, nullptr, 0.0f); EXPECT_FLOAT_EQ(arg.inputDelay(), 0.0f); } -TEST_F(ArcDcalcArgTest, R8_CopyAssignment) { +TEST_F(ArcDcalcArgTest, CopyAssignment) { ArcDcalcArg arg; arg.setLoadCap(3.0e-12f); arg.setInputDelay(2.0e-9f); @@ -2827,7 +2827,7 @@ TEST_F(ArcDcalcArgTest, R8_CopyAssignment) { } // ArcDcalcResult: copy construction -TEST_F(ArcDcalcResultTest, R8_CopyConstruction) { +TEST_F(ArcDcalcResultTest, CopyConstruction) { ArcDcalcResult result(3); result.setGateDelay(1e-10f); result.setDrvrSlew(2e-10f); @@ -2847,7 +2847,7 @@ TEST_F(ArcDcalcResultTest, R8_CopyConstruction) { } // ArcDcalcArgSeq operations -TEST_F(ArcDcalcArgTest, R8_ArgSeqOperations) { +TEST_F(ArcDcalcArgTest, ArgSeqOperations) { ArcDcalcArgSeq args; for (int i = 0; i < 5; i++) { ArcDcalcArg arg; @@ -2864,7 +2864,7 @@ TEST_F(ArcDcalcArgTest, R8_ArgSeqOperations) { // R8_AllCalcsReduceParasiticNet removed (segfault) // All delay calcs: setDcalcArgParasiticSlew (single and seq) -TEST_F(StaDcalcTest, R8_AllCalcsSetDcalcArgParasitic) { +TEST_F(StaDcalcTest, AllCalcsSetDcalcArgParasitic) { StringSeq names = delayCalcNames(); for (const char *name : names) { ArcDelayCalc *calc = makeDelayCalc(name, sta_); @@ -2883,7 +2883,7 @@ TEST_F(StaDcalcTest, R8_AllCalcsSetDcalcArgParasitic) { //////////////////////////////////////////////////////////////// // R9_ Test reportDelayCalc with dmp_ceff_elmore (exercises gateDelaySlew) -TEST_F(DesignDcalcTest, R9_ReportDelayCalcDmpElmore) { +TEST_F(DesignDcalcTest, ReportDelayCalcDmpElmore) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); @@ -2912,7 +2912,7 @@ TEST_F(DesignDcalcTest, R9_ReportDelayCalcDmpElmore) { } // R9_ Test reportDelayCalc with dmp_ceff_two_pole -TEST_F(DesignDcalcTest, R9_ReportDelayCalcDmpTwoPole) { +TEST_F(DesignDcalcTest, ReportDelayCalcDmpTwoPole) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_two_pole"); sta_->updateTiming(true); @@ -2941,7 +2941,7 @@ TEST_F(DesignDcalcTest, R9_ReportDelayCalcDmpTwoPole) { } // R9_ Test reportDelayCalc with ccs_ceff -TEST_F(DesignDcalcTest, R9_ReportDelayCalcCcsCeff) { +TEST_F(DesignDcalcTest, ReportDelayCalcCcsCeff) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("ccs_ceff"); sta_->updateTiming(true); @@ -2970,7 +2970,7 @@ TEST_F(DesignDcalcTest, R9_ReportDelayCalcCcsCeff) { } // R9_ Test reportDelayCalc with lumped_cap -TEST_F(DesignDcalcTest, R9_ReportDelayCalcLumpedCap) { +TEST_F(DesignDcalcTest, ReportDelayCalcLumpedCap) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("lumped_cap"); sta_->updateTiming(true); @@ -2999,7 +2999,7 @@ TEST_F(DesignDcalcTest, R9_ReportDelayCalcLumpedCap) { } // R9_ Test reportDelayCalc with arnoldi -TEST_F(DesignDcalcTest, R9_ReportDelayCalcArnoldi) { +TEST_F(DesignDcalcTest, ReportDelayCalcArnoldi) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("arnoldi"); sta_->updateTiming(true); @@ -3028,7 +3028,7 @@ TEST_F(DesignDcalcTest, R9_ReportDelayCalcArnoldi) { } // R9_ Test reportDelayCalc with prima -TEST_F(DesignDcalcTest, R9_ReportDelayCalcPrima) { +TEST_F(DesignDcalcTest, ReportDelayCalcPrima) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("prima"); Corner *corner = sta_->cmdCorner(); @@ -3060,7 +3060,7 @@ TEST_F(DesignDcalcTest, R9_ReportDelayCalcPrima) { } // R9_ Test incremental timing with different calculators -TEST_F(DesignDcalcTest, R9_IncrementalDmpTwoPole) { +TEST_F(DesignDcalcTest, IncrementalDmpTwoPole) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_two_pole"); sta_->updateTiming(true); @@ -3068,7 +3068,7 @@ TEST_F(DesignDcalcTest, R9_IncrementalDmpTwoPole) { SUCCEED(); } -TEST_F(DesignDcalcTest, R9_IncrementalCcsCeff) { +TEST_F(DesignDcalcTest, IncrementalCcsCeff) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("ccs_ceff"); sta_->updateTiming(true); @@ -3076,7 +3076,7 @@ TEST_F(DesignDcalcTest, R9_IncrementalCcsCeff) { SUCCEED(); } -TEST_F(DesignDcalcTest, R9_IncrementalLumpedCap) { +TEST_F(DesignDcalcTest, IncrementalLumpedCap) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("lumped_cap"); sta_->updateTiming(true); @@ -3084,7 +3084,7 @@ TEST_F(DesignDcalcTest, R9_IncrementalLumpedCap) { SUCCEED(); } -TEST_F(DesignDcalcTest, R9_IncrementalArnoldi) { +TEST_F(DesignDcalcTest, IncrementalArnoldi) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("arnoldi"); sta_->updateTiming(true); @@ -3092,7 +3092,7 @@ TEST_F(DesignDcalcTest, R9_IncrementalArnoldi) { SUCCEED(); } -TEST_F(DesignDcalcTest, R9_IncrementalPrima) { +TEST_F(DesignDcalcTest, IncrementalPrima) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("prima"); sta_->updateTiming(true); @@ -3101,7 +3101,7 @@ TEST_F(DesignDcalcTest, R9_IncrementalPrima) { } // R9_ Cycle through all calculators -TEST_F(DesignDcalcTest, R9_CycleAllCalcs) { +TEST_F(DesignDcalcTest, CycleAllCalcs) { ASSERT_TRUE(design_loaded_); const char *calcs[] = {"unit", "lumped_cap", "dmp_ceff_elmore", "dmp_ceff_two_pole", "arnoldi", "ccs_ceff", "prima"}; @@ -3115,7 +3115,7 @@ TEST_F(DesignDcalcTest, R9_CycleAllCalcs) { // R9_ReportMultipleEdges removed (segfault) // R9_ Test findDelays then verify graph vertices have edge delays -TEST_F(DesignDcalcTest, R9_VerifyEdgeDelays) { +TEST_F(DesignDcalcTest, VerifyEdgeDelays) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); @@ -3137,7 +3137,7 @@ TEST_F(DesignDcalcTest, R9_VerifyEdgeDelays) { } // R9_ Test min analysis report -TEST_F(DesignDcalcTest, R9_MinAnalysisReport) { +TEST_F(DesignDcalcTest, MinAnalysisReport) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); @@ -3165,7 +3165,7 @@ TEST_F(DesignDcalcTest, R9_MinAnalysisReport) { } // R9_ Test arnoldi reduce on design -TEST_F(DesignDcalcTest, R9_ArnoldiReduceDesign) { +TEST_F(DesignDcalcTest, ArnoldiReduceDesign) { ASSERT_TRUE(design_loaded_); Corner *corner = sta_->cmdCorner(); Instance *top = sta_->network()->topInstance(); @@ -3207,7 +3207,7 @@ TEST_F(DesignDcalcTest, R9_ArnoldiReduceDesign) { } // R9_ CcsCeff watchPin with design pin -TEST_F(DesignDcalcTest, R9_CcsCeffWatchPinDesign) { +TEST_F(DesignDcalcTest, CcsCeffWatchPinDesign) { ASSERT_TRUE(design_loaded_); ArcDelayCalc *calc = makeDelayCalc("ccs_ceff", sta_); CcsCeffDelayCalc *ccs = dynamic_cast(calc); @@ -3225,7 +3225,7 @@ TEST_F(DesignDcalcTest, R9_CcsCeffWatchPinDesign) { } // R9_ PrimaDelayCalc watchPin with design pin -TEST_F(DesignDcalcTest, R9_PrimaWatchPinDesign) { +TEST_F(DesignDcalcTest, PrimaWatchPinDesign) { ASSERT_TRUE(design_loaded_); ArcDelayCalc *calc = makeDelayCalc("prima", sta_); PrimaDelayCalc *prima = dynamic_cast(calc); @@ -3243,7 +3243,7 @@ TEST_F(DesignDcalcTest, R9_PrimaWatchPinDesign) { } // R9_ Test setIncrementalDelayTolerance + retiming -TEST_F(DesignDcalcTest, R9_IncrTolRetiming) { +TEST_F(DesignDcalcTest, IncrTolRetiming) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->setIncrementalDelayTolerance(0.01f); @@ -3254,7 +3254,7 @@ TEST_F(DesignDcalcTest, R9_IncrTolRetiming) { } // R9_ Test findDelays with graph verification -TEST_F(DesignDcalcTest, R9_FindDelaysVerifyGraph) { +TEST_F(DesignDcalcTest, FindDelaysVerifyGraph) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->findDelays(); @@ -3264,7 +3264,7 @@ TEST_F(DesignDcalcTest, R9_FindDelaysVerifyGraph) { } // R9_ NetCaps very small values -TEST_F(StaDcalcTest, R9_NetCapsVerySmall) { +TEST_F(StaDcalcTest, NetCapsVerySmall) { NetCaps caps; caps.init(1e-18f, 2e-18f, 0.001f, true); EXPECT_FLOAT_EQ(caps.pinCap(), 1e-18f); @@ -3273,7 +3273,7 @@ TEST_F(StaDcalcTest, R9_NetCapsVerySmall) { } // R9_ NetCaps negative values -TEST_F(StaDcalcTest, R9_NetCapsNegative) { +TEST_F(StaDcalcTest, NetCapsNegative) { NetCaps caps; caps.init(-1e-12f, -2e-12f, -1.0f, false); EXPECT_FLOAT_EQ(caps.pinCap(), -1e-12f); @@ -3281,7 +3281,7 @@ TEST_F(StaDcalcTest, R9_NetCapsNegative) { } // R9_ ArcDcalcArg full constructor with all non-null -TEST_F(ArcDcalcArgTest, R9_FullConstructorNonNull) { +TEST_F(ArcDcalcArgTest, FullConstructorNonNull) { int d1=1,d2=2,d3=3,d4=4,d5=5; ArcDcalcArg arg(reinterpret_cast(&d1), reinterpret_cast(&d2), @@ -3303,7 +3303,7 @@ TEST_F(ArcDcalcArgTest, R9_FullConstructorNonNull) { } // R9_ ArcDcalcResult large load count ops -TEST_F(ArcDcalcResultTest, R9_LargeLoadCountOps) { +TEST_F(ArcDcalcResultTest, LargeLoadCountOps) { ArcDcalcResult result(50); result.setGateDelay(1e-9f); result.setDrvrSlew(5e-10f); @@ -3316,7 +3316,7 @@ TEST_F(ArcDcalcResultTest, R9_LargeLoadCountOps) { } // R9_ ArcDcalcResult: resize multiple times -TEST_F(ArcDcalcResultTest, R9_ResizeMultiple) { +TEST_F(ArcDcalcResultTest, ResizeMultiple) { ArcDcalcResult result; for (int s = 1; s <= 10; s++) { result.setLoadCount(s); @@ -3327,7 +3327,7 @@ TEST_F(ArcDcalcResultTest, R9_ResizeMultiple) { } // R9_ ArcDcalcResultSeq operations -TEST_F(ArcDcalcResultTest, R9_ResultSeqOps) { +TEST_F(ArcDcalcResultTest, ResultSeqOps) { ArcDcalcResultSeq results; for (int i = 0; i < 10; i++) { ArcDcalcResult r(3); @@ -3339,7 +3339,7 @@ TEST_F(ArcDcalcResultTest, R9_ResultSeqOps) { } // R9_ FindRoot: steep derivative -TEST_F(FindRootAdditionalTest, R9_SteepDerivative) { +TEST_F(FindRootAdditionalTest, SteepDerivative) { FindRootFunc func = [](double x, double &y, double &dy) { y = 1000.0 * x - 500.0; dy = 1000.0; @@ -3351,7 +3351,7 @@ TEST_F(FindRootAdditionalTest, R9_SteepDerivative) { } // R9_ FindRoot: quartic function -TEST_F(FindRootAdditionalTest, R9_QuarticRoot) { +TEST_F(FindRootAdditionalTest, QuarticRoot) { FindRootFunc func = [](double x, double &y, double &dy) { y = x*x*x*x - 81.0; dy = 4.0*x*x*x; @@ -3363,7 +3363,7 @@ TEST_F(FindRootAdditionalTest, R9_QuarticRoot) { } // R9_ FindRoot: 4-arg negative bracket -TEST_F(FindRootAdditionalTest, R9_FourArgNegBracket) { +TEST_F(FindRootAdditionalTest, FourArgNegBracket) { FindRootFunc func = [](double x, double &y, double &dy) { y = x + 5.0; dy = 1.0; @@ -3375,7 +3375,7 @@ TEST_F(FindRootAdditionalTest, R9_FourArgNegBracket) { } // R9_ MultiDrvrNet set and reset -TEST_F(StaDcalcTest, R9_MultiDrvrNetSetReset) { +TEST_F(StaDcalcTest, MultiDrvrNetSetReset) { MultiDrvrNet mdn; int d1=1,d2=2; mdn.setDcalcDrvr(reinterpret_cast(&d1)); @@ -3387,7 +3387,7 @@ TEST_F(StaDcalcTest, R9_MultiDrvrNetSetReset) { } // R9_ All calcs copyState twice -TEST_F(StaDcalcTest, R9_AllCalcsCopyStateTwice) { +TEST_F(StaDcalcTest, AllCalcsCopyStateTwice) { StringSeq names = delayCalcNames(); for (const char *name : names) { ArcDelayCalc *calc = makeDelayCalc(name, sta_); @@ -3399,7 +3399,7 @@ TEST_F(StaDcalcTest, R9_AllCalcsCopyStateTwice) { } // R9_ GraphDelayCalc levels then clear -TEST_F(StaDcalcTest, R9_GraphDelayCalcLevelsClear) { +TEST_F(StaDcalcTest, GraphDelayCalcLevelsClear) { GraphDelayCalc *gdc = sta_->graphDelayCalc(); ASSERT_NE(gdc, nullptr); gdc->levelsChangedBefore(); @@ -3408,7 +3408,7 @@ TEST_F(StaDcalcTest, R9_GraphDelayCalcLevelsClear) { } // R9_ All calcs inputPortDelay with non-zero slew -TEST_F(StaDcalcTest, R9_AllCalcsInputPortDelaySlew) { +TEST_F(StaDcalcTest, AllCalcsInputPortDelaySlew) { StringSeq names = delayCalcNames(); for (const char *name : names) { ArcDelayCalc *calc = makeDelayCalc(name, sta_); @@ -3428,7 +3428,7 @@ TEST_F(StaDcalcTest, R9_AllCalcsInputPortDelaySlew) { // R10_ DmpCeffElmore: explicit make/delete exercises constructor/destructor // Covers: DmpCeffElmoreDelayCalc::DmpCeffElmoreDelayCalc, DmpCeffDelayCalc::~DmpCeffDelayCalc -TEST_F(StaDcalcTest, R10_DmpCeffElmoreMakeDelete) { +TEST_F(StaDcalcTest, DmpCeffElmoreMakeDelete) { ArcDelayCalc *calc = makeDmpCeffElmoreDelayCalc(sta_); ASSERT_NE(calc, nullptr); EXPECT_STREQ(calc->name(), "dmp_ceff_elmore"); @@ -3438,7 +3438,7 @@ TEST_F(StaDcalcTest, R10_DmpCeffElmoreMakeDelete) { // R10_ DmpCeffTwoPole: explicit make/delete exercises constructor/destructor // Covers: DmpCeffTwoPoleDelayCalc::DmpCeffTwoPoleDelayCalc, DmpCeffDelayCalc::~DmpCeffDelayCalc -TEST_F(StaDcalcTest, R10_DmpCeffTwoPoleMakeDelete) { +TEST_F(StaDcalcTest, DmpCeffTwoPoleMakeDelete) { ArcDelayCalc *calc = makeDmpCeffTwoPoleDelayCalc(sta_); ASSERT_NE(calc, nullptr); EXPECT_STREQ(calc->name(), "dmp_ceff_two_pole"); @@ -3448,7 +3448,7 @@ TEST_F(StaDcalcTest, R10_DmpCeffTwoPoleMakeDelete) { // R10_ DmpCeffElmore: copy exercises copy constructor chain // Covers: DmpCeffElmoreDelayCalc::copy -> DmpCeffElmoreDelayCalc(StaState*) -TEST_F(StaDcalcTest, R10_DmpCeffElmoreCopy) { +TEST_F(StaDcalcTest, DmpCeffElmoreCopy2) { ArcDelayCalc *calc = makeDmpCeffElmoreDelayCalc(sta_); ASSERT_NE(calc, nullptr); ArcDelayCalc *copy = calc->copy(); @@ -3460,7 +3460,7 @@ TEST_F(StaDcalcTest, R10_DmpCeffElmoreCopy) { // R10_ DmpCeffTwoPole: copy exercises copy constructor chain // Covers: DmpCeffTwoPoleDelayCalc::copy -TEST_F(StaDcalcTest, R10_DmpCeffTwoPoleCopy) { +TEST_F(StaDcalcTest, DmpCeffTwoPoleCopy2) { ArcDelayCalc *calc = makeDmpCeffTwoPoleDelayCalc(sta_); ASSERT_NE(calc, nullptr); ArcDelayCalc *copy = calc->copy(); @@ -3471,7 +3471,7 @@ TEST_F(StaDcalcTest, R10_DmpCeffTwoPoleCopy) { } // R10_ DmpCeffElmore: copyState exercises DmpCeffDelayCalc::copyState -TEST_F(StaDcalcTest, R10_DmpCeffElmoreCopyState) { +TEST_F(StaDcalcTest, DmpCeffElmoreCopyState2) { ArcDelayCalc *calc = makeDmpCeffElmoreDelayCalc(sta_); ASSERT_NE(calc, nullptr); calc->copyState(sta_); @@ -3480,7 +3480,7 @@ TEST_F(StaDcalcTest, R10_DmpCeffElmoreCopyState) { } // R10_ DmpCeffTwoPole: copyState exercises DmpCeffDelayCalc::copyState -TEST_F(StaDcalcTest, R10_DmpCeffTwoPoleCopyState) { +TEST_F(StaDcalcTest, DmpCeffTwoPoleCopyState2) { ArcDelayCalc *calc = makeDmpCeffTwoPoleDelayCalc(sta_); ASSERT_NE(calc, nullptr); calc->copyState(sta_); @@ -3490,7 +3490,7 @@ TEST_F(StaDcalcTest, R10_DmpCeffTwoPoleCopyState) { // R10_ DmpCeffElmore inputPortDelay with null args // Covers: DmpCeffElmoreDelayCalc::inputPortDelay -TEST_F(StaDcalcTest, R10_DmpCeffElmoreInputPortDelay) { +TEST_F(StaDcalcTest, DmpCeffElmoreInputPortDelay2) { ArcDelayCalc *calc = makeDmpCeffElmoreDelayCalc(sta_); ASSERT_NE(calc, nullptr); LoadPinIndexMap load_pin_index_map(sta_->network()); @@ -3503,7 +3503,7 @@ TEST_F(StaDcalcTest, R10_DmpCeffElmoreInputPortDelay) { // R10_ DmpCeffTwoPole inputPortDelay with null args // Covers: DmpCeffTwoPoleDelayCalc::inputPortDelay -TEST_F(StaDcalcTest, R10_DmpCeffTwoPoleInputPortDelay) { +TEST_F(StaDcalcTest, DmpCeffTwoPoleInputPortDelay2) { ArcDelayCalc *calc = makeDmpCeffTwoPoleDelayCalc(sta_); ASSERT_NE(calc, nullptr); LoadPinIndexMap load_pin_index_map(sta_->network()); @@ -3515,7 +3515,7 @@ TEST_F(StaDcalcTest, R10_DmpCeffTwoPoleInputPortDelay) { } // R10_ DmpCeffElmore: setDcalcArgParasiticSlew with empty args -TEST_F(StaDcalcTest, R10_DmpCeffElmoreSetDcalcArgEmpty) { +TEST_F(StaDcalcTest, DmpCeffElmoreSetDcalcArgEmpty) { ArcDelayCalc *calc = makeDmpCeffElmoreDelayCalc(sta_); ASSERT_NE(calc, nullptr); ArcDcalcArgSeq args; @@ -3524,7 +3524,7 @@ TEST_F(StaDcalcTest, R10_DmpCeffElmoreSetDcalcArgEmpty) { } // R10_ DmpCeffTwoPole: setDcalcArgParasiticSlew with empty args -TEST_F(StaDcalcTest, R10_DmpCeffTwoPoleSetDcalcArgEmpty) { +TEST_F(StaDcalcTest, DmpCeffTwoPoleSetDcalcArgEmpty) { ArcDelayCalc *calc = makeDmpCeffTwoPoleDelayCalc(sta_); ASSERT_NE(calc, nullptr); ArcDcalcArgSeq args; @@ -3533,7 +3533,7 @@ TEST_F(StaDcalcTest, R10_DmpCeffTwoPoleSetDcalcArgEmpty) { } // R10_ DmpCeffElmore: finishDrvrPin doesn't crash -TEST_F(StaDcalcTest, R10_DmpCeffElmoreFinishDrvrPin) { +TEST_F(StaDcalcTest, DmpCeffElmoreFinishDrvrPin3) { ArcDelayCalc *calc = makeDmpCeffElmoreDelayCalc(sta_); ASSERT_NE(calc, nullptr); calc->finishDrvrPin(); @@ -3541,7 +3541,7 @@ TEST_F(StaDcalcTest, R10_DmpCeffElmoreFinishDrvrPin) { } // R10_ DmpCeffTwoPole: finishDrvrPin doesn't crash -TEST_F(StaDcalcTest, R10_DmpCeffTwoPoleFinishDrvrPin) { +TEST_F(StaDcalcTest, DmpCeffTwoPoleFinishDrvrPin3) { ArcDelayCalc *calc = makeDmpCeffTwoPoleDelayCalc(sta_); ASSERT_NE(calc, nullptr); calc->finishDrvrPin(); @@ -3552,7 +3552,7 @@ TEST_F(StaDcalcTest, R10_DmpCeffTwoPoleFinishDrvrPin) { // Covers: GraphDelayCalc::findDelays(Vertex*), initRootSlews, findDriverArcDelays, // zeroSlewAndWireDelays, FindVertexDelays ctor/dtor/copy, // DmpCeffDelayCalc::gateDelaySlew, DmpAlg internal methods -TEST_F(DesignDcalcTest, R10_DmpCeffElmoreVertexDelays) { +TEST_F(DesignDcalcTest, DmpCeffElmoreVertexDelays) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); @@ -3580,7 +3580,7 @@ TEST_F(DesignDcalcTest, R10_DmpCeffElmoreVertexDelays) { // R10_ DesignDcalcTest: Full timing with dmp_ceff_two_pole with detailed parasitics // Covers: DmpCeffTwoPoleDelayCalc::loadDelay, gateDelay -TEST_F(DesignDcalcTest, R10_DmpCeffTwoPoleWithParasitics) { +TEST_F(DesignDcalcTest, DmpCeffTwoPoleWithParasitics) { ASSERT_TRUE(design_loaded_); Corner *corner = sta_->cmdCorner(); Instance *top = sta_->network()->topInstance(); @@ -3596,7 +3596,7 @@ TEST_F(DesignDcalcTest, R10_DmpCeffTwoPoleWithParasitics) { // R10_ DesignDcalcTest: reportDelayCalc exercises report path // Covers: GraphDelayCalc::reportDelayCalc -TEST_F(DesignDcalcTest, R10_ReportDelayCalcDmpElmore) { +TEST_F(DesignDcalcTest, ReportDelayCalcDmpElmore2) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); @@ -3634,7 +3634,7 @@ TEST_F(DesignDcalcTest, R10_ReportDelayCalcDmpElmore) { // R10_ DesignDcalcTest: loadCap query after timing // Covers: GraphDelayCalc::loadCap variants -TEST_F(DesignDcalcTest, R10_LoadCapQuery) { +TEST_F(DesignDcalcTest, LoadCapQuery) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); @@ -3665,7 +3665,7 @@ TEST_F(DesignDcalcTest, R10_LoadCapQuery) { // R10_ DesignDcalcTest: netCaps query after timing // Covers: GraphDelayCalc::netCaps -TEST_F(DesignDcalcTest, R10_NetCapsQuery) { +TEST_F(DesignDcalcTest, NetCapsQuery) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); @@ -3693,7 +3693,7 @@ TEST_F(DesignDcalcTest, R10_NetCapsQuery) { // R10_ DesignDcalcTest: makeLoadPinIndexMap exercises vertex pin mapping // Covers: GraphDelayCalc::makeLoadPinIndexMap -TEST_F(DesignDcalcTest, R10_MakeLoadPinIndexMap) { +TEST_F(DesignDcalcTest, MakeLoadPinIndexMap) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); @@ -3718,7 +3718,7 @@ TEST_F(DesignDcalcTest, R10_MakeLoadPinIndexMap) { // R10_ DesignDcalcTest: findDriverArcDelays exercises the public 5-arg overload // Covers: GraphDelayCalc::findDriverArcDelays -TEST_F(DesignDcalcTest, R10_FindDriverArcDelays) { +TEST_F(DesignDcalcTest, FindDriverArcDelays) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); @@ -3756,7 +3756,7 @@ TEST_F(DesignDcalcTest, R10_FindDriverArcDelays) { // R10_ DesignDcalcTest: edgeFromSlew exercises slew lookup (TimingRole overload) // Covers: GraphDelayCalc::edgeFromSlew -TEST_F(DesignDcalcTest, R10_EdgeFromSlew) { +TEST_F(DesignDcalcTest, EdgeFromSlew) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); @@ -3785,7 +3785,7 @@ TEST_F(DesignDcalcTest, R10_EdgeFromSlew) { // R10_ DesignDcalcTest: incremental delay tolerance exercises incremental code path // Covers: GraphDelayCalc::incrementalDelayTolerance -TEST_F(DesignDcalcTest, R10_IncrementalDelayToleranceQuery) { +TEST_F(DesignDcalcTest, IncrementalDelayToleranceQuery) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); GraphDelayCalc *gdc = sta_->graphDelayCalc(); @@ -3803,7 +3803,7 @@ TEST_F(DesignDcalcTest, R10_IncrementalDelayToleranceQuery) { // R10_ DesignDcalcTest: delayInvalid(Vertex*) and delayInvalid(Pin*) // Covers: GraphDelayCalc::delayInvalid variants -TEST_F(DesignDcalcTest, R10_DelayInvalidVariants) { +TEST_F(DesignDcalcTest, DelayInvalidVariants) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); @@ -3828,7 +3828,7 @@ TEST_F(DesignDcalcTest, R10_DelayInvalidVariants) { // R10_ DesignDcalcTest: CCS ceff with actual parasitics // Covers: CcsCeffDelayCalc paths -TEST_F(DesignDcalcTest, R10_CcsCeffWithParasitics) { +TEST_F(DesignDcalcTest, CcsCeffWithParasitics) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("ccs_ceff"); sta_->updateTiming(true); @@ -3839,7 +3839,7 @@ TEST_F(DesignDcalcTest, R10_CcsCeffWithParasitics) { } // R10_ DesignDcalcTest: CCS ceff with unreduced parasitics -TEST_F(DesignDcalcTest, R10_CcsCeffUnreducedParasitics) { +TEST_F(DesignDcalcTest, CcsCeffUnreducedParasitics) { ASSERT_TRUE(design_loaded_); Corner *corner = sta_->cmdCorner(); Instance *top = sta_->network()->topInstance(); @@ -3855,7 +3855,7 @@ TEST_F(DesignDcalcTest, R10_CcsCeffUnreducedParasitics) { // R10_ DesignDcalcTest: prima with timing and reporting // Covers: PrimaDelayCalc internal methods -TEST_F(DesignDcalcTest, R10_PrimaTimingWithReport) { +TEST_F(DesignDcalcTest, PrimaTimingWithReport) { ASSERT_TRUE(design_loaded_); Corner *corner = sta_->cmdCorner(); Instance *top = sta_->network()->topInstance(); @@ -3895,7 +3895,7 @@ TEST_F(DesignDcalcTest, R10_PrimaTimingWithReport) { // R10_ DesignDcalcTest: bidirectDrvrSlewFromLoad // Covers: GraphDelayCalc::bidirectDrvrSlewFromLoad -TEST_F(DesignDcalcTest, R10_BidirectDrvrSlewFromLoad) { +TEST_F(DesignDcalcTest, BidirectDrvrSlewFromLoad) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); @@ -3916,7 +3916,7 @@ TEST_F(DesignDcalcTest, R10_BidirectDrvrSlewFromLoad) { // R10_ DesignDcalcTest: minPeriod query // Covers: GraphDelayCalc::minPeriod -TEST_F(DesignDcalcTest, R10_MinPeriodQuery) { +TEST_F(DesignDcalcTest, MinPeriodQuery) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); @@ -3938,7 +3938,7 @@ TEST_F(DesignDcalcTest, R10_MinPeriodQuery) { // R10_ DesignDcalcTest: Arnoldi with loadCap and netCaps query // Covers: ArnoldiDelayCalc paths, delay_work_alloc, rcmodel -TEST_F(DesignDcalcTest, R10_ArnoldiLoadCapAndNetCaps) { +TEST_F(DesignDcalcTest, ArnoldiLoadCapAndNetCaps) { ASSERT_TRUE(design_loaded_); Corner *corner = sta_->cmdCorner(); Instance *top = sta_->network()->topInstance(); @@ -3968,7 +3968,7 @@ TEST_F(DesignDcalcTest, R10_ArnoldiLoadCapAndNetCaps) { } // R10_ ArcDcalcArg: edge() accessor returns nullptr for default-constructed arg -TEST_F(ArcDcalcArgTest, R10_DefaultEdgeIsNull) { +TEST_F(ArcDcalcArgTest, DefaultEdgeIsNull) { ArcDcalcArg arg; EXPECT_EQ(arg.edge(), nullptr); EXPECT_EQ(arg.arc(), nullptr); @@ -3979,7 +3979,7 @@ TEST_F(ArcDcalcArgTest, R10_DefaultEdgeIsNull) { // R10_ DesignDcalcTest: exercise findDelays(Level) triggering FindVertexDelays BFS // Covers: FindVertexDelays::FindVertexDelays, ~FindVertexDelays, copy -TEST_F(DesignDcalcTest, R10_FindDelaysLevel) { +TEST_F(DesignDcalcTest, FindDelaysLevel) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->ensureGraph(); @@ -3989,7 +3989,7 @@ TEST_F(DesignDcalcTest, R10_FindDelaysLevel) { // R10_ DesignDcalcTest: ArcDcalcArg with actual design edge // Covers: ArcDcalcArg::inEdge, drvrVertex, drvrNet with real data -TEST_F(DesignDcalcTest, R10_ArcDcalcArgWithRealEdge) { +TEST_F(DesignDcalcTest, ArcDcalcArgWithRealEdge) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); @@ -4033,7 +4033,7 @@ TEST_F(DesignDcalcTest, R10_ArcDcalcArgWithRealEdge) { // R10_ DesignDcalcTest: makeArcDcalcArg with instance names // Covers: makeArcDcalcArg -TEST_F(DesignDcalcTest, R10_MakeArcDcalcArgByName) { +TEST_F(DesignDcalcTest, MakeArcDcalcArgByName) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); @@ -4046,7 +4046,7 @@ TEST_F(DesignDcalcTest, R10_MakeArcDcalcArgByName) { // R10_ DesignDcalcTest: DmpCeff with incremental invalidation and recompute // Covers: GraphDelayCalc incremental paths -TEST_F(DesignDcalcTest, R10_DmpCeffElmoreLevelBasedIncremental) { +TEST_F(DesignDcalcTest, DmpCeffElmoreLevelBasedIncremental) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->setIncrementalDelayTolerance(0.005f); @@ -4072,7 +4072,7 @@ TEST_F(DesignDcalcTest, R10_DmpCeffElmoreLevelBasedIncremental) { // R10_ DesignDcalcTest: Arnoldi reduce all driver nets // Covers: ArnoldiDelayCalc::reduce paths, delay_work_alloc -TEST_F(DesignDcalcTest, R10_ArnoldiReduceAllNets) { +TEST_F(DesignDcalcTest, ArnoldiReduceAllNets) { ASSERT_TRUE(design_loaded_); Corner *corner = sta_->cmdCorner(); Instance *top = sta_->network()->topInstance(); @@ -4116,7 +4116,7 @@ TEST_F(DesignDcalcTest, R10_ArnoldiReduceAllNets) { // R10_ DesignDcalcTest: levelChangedBefore exercises vertex level change // Covers: GraphDelayCalc::levelChangedBefore -TEST_F(DesignDcalcTest, R10_LevelChangedBefore) { +TEST_F(DesignDcalcTest, LevelChangedBefore) { ASSERT_TRUE(design_loaded_); sta_->setArcDelayCalc("dmp_ceff_elmore"); sta_->updateTiming(true); diff --git a/graph/test/cpp/TestGraph.cc b/graph/test/cpp/TestGraph.cc index 3e565594..e2755ce2 100644 --- a/graph/test/cpp/TestGraph.cc +++ b/graph/test/cpp/TestGraph.cc @@ -480,7 +480,7 @@ TEST(VertexStandaloneTest, SlewsDefault) // Test Edge::arcDelayAnnotateBit - static method // Covers: Edge::arcDelayAnnotateBit -TEST(EdgeStandaloneTest, R5_ArcDelayAnnotateBit) +TEST(EdgeStandaloneTest, ArcDelayAnnotateBit) { // arcDelayAnnotateBit returns a bitmask for a given index // The function is static and protected, but accessible indirectly @@ -494,7 +494,7 @@ TEST(EdgeStandaloneTest, R5_ArcDelayAnnotateBit) // Test Edge init (protected but covered via Graph::makeEdge) // Covers: Edge::init -TEST(EdgeStandaloneTest, R5_EdgeInitViaTimingArcSet) +TEST(EdgeStandaloneTest, EdgeInitViaTimingArcSet) { Edge e; // setTimingArcSet exercises part of what init does @@ -504,7 +504,7 @@ TEST(EdgeStandaloneTest, R5_EdgeInitViaTimingArcSet) // Test Vertex setSlews // Covers: Vertex::setSlews -TEST(VertexStandaloneTest, R5_SetSlews) +TEST(VertexStandaloneTest, SetSlews) { Vertex v; EXPECT_EQ(v.slews(), nullptr); @@ -522,7 +522,7 @@ TEST(VertexStandaloneTest, R5_SetSlews) // Test Vertex setPaths // Covers: Vertex::setPaths (public method on Vertex) -TEST(VertexStandaloneTest, R5_SetPaths) +TEST(VertexStandaloneTest, SetPaths) { Vertex v; EXPECT_EQ(v.paths(), nullptr); @@ -532,7 +532,7 @@ TEST(VertexStandaloneTest, R5_SetPaths) } // Test Edge timing sense combinations -TEST(EdgeStandaloneTest, R5_SimTimingSenseCombinations) +TEST(EdgeStandaloneTest, SimTimingSenseCombinations) { Edge e; e.setSimTimingSense(TimingSense::positive_unate); @@ -546,7 +546,7 @@ TEST(EdgeStandaloneTest, R5_SimTimingSenseCombinations) } // Test multiple BFS queue indices -TEST(VertexStandaloneTest, R5_BfsMultipleQueues) +TEST(VertexStandaloneTest, BfsMultipleQueues) { Vertex v; // Test multiple BFS queue indices @@ -563,7 +563,7 @@ TEST(VertexStandaloneTest, R5_BfsMultipleQueues) } // Test Edge from/to vertex IDs -TEST(EdgeStandaloneTest, R5_FromToIds) +TEST(EdgeStandaloneTest, FromToIds) { Edge e; // Default-constructed edge has from/to of 0 @@ -574,7 +574,7 @@ TEST(EdgeStandaloneTest, R5_FromToIds) } // Test Vertex level setting with various values -TEST(VertexStandaloneTest, R5_LevelBoundaryValues) +TEST(VertexStandaloneTest, LevelBoundaryValues) { Vertex v; v.setLevel(0); @@ -598,7 +598,7 @@ TEST(VertexStandaloneTest, R5_LevelBoundaryValues) // Test Edge arcDelayAnnotateBit via removeDelayAnnotated path // Covers: Edge::arcDelayAnnotateBit -TEST(EdgeStandaloneTest, R6_ArcDelayAnnotateBitPath) +TEST(EdgeStandaloneTest, ArcDelayAnnotateBitPath) { Edge e; // Set some delay annotations then remove them @@ -610,7 +610,7 @@ TEST(EdgeStandaloneTest, R6_ArcDelayAnnotateBitPath) // Test Edge setTimingArcSet with nullptr // Covers: Edge::init (partial) via setTimingArcSet -TEST(EdgeStandaloneTest, R6_SetTimingArcSetNull) +TEST(EdgeStandaloneTest, SetTimingArcSetNull) { Edge e; e.setTimingArcSet(nullptr); @@ -619,7 +619,7 @@ TEST(EdgeStandaloneTest, R6_SetTimingArcSetNull) // Test Vertex setSlews indirectly - slews_ is protected // Covers: Vertex::setSlews path -TEST(VertexStandaloneTest, R6_VertexSlewsProtected) +TEST(VertexStandaloneTest, VertexSlewsProtected) { Vertex v; // Initially slews_ is nullptr @@ -631,7 +631,7 @@ TEST(VertexStandaloneTest, R6_VertexSlewsProtected) // Test Edge from/to IDs are zero for default-constructed edge // Covers: Edge::from, Edge::to -TEST(EdgeStandaloneTest, R6_DefaultFromToZero) +TEST(EdgeStandaloneTest, DefaultFromToZero) { Edge e; EXPECT_EQ(e.from(), static_cast(0)); @@ -640,7 +640,7 @@ TEST(EdgeStandaloneTest, R6_DefaultFromToZero) // Test Vertex isRoot and level interaction // Covers: Vertex::isRoot, Vertex::level, Vertex::setLevel -TEST(VertexStandaloneTest, R6_IsRootLevelInteraction) +TEST(VertexStandaloneTest, IsRootLevelInteraction) { Vertex v; // Level 0 = root @@ -656,7 +656,7 @@ TEST(VertexStandaloneTest, R6_IsRootLevelInteraction) // Test Vertex all BFS indices // Covers: Vertex::bfsInQueue, Vertex::setBfsInQueue -TEST(VertexStandaloneTest, R6_BfsAllIndices) +TEST(VertexStandaloneTest, BfsAllIndices) { Vertex v; // Set all BFS indices to true @@ -682,7 +682,7 @@ TEST(VertexStandaloneTest, R6_BfsAllIndices) // Test Vertex SimValue with all LogicValues // Covers: Vertex::setSimValue, Vertex::simValue, Vertex::isConstant -TEST(VertexStandaloneTest, R6_SimValueAllStates) +TEST(VertexStandaloneTest, SimValueAllStates) { Vertex v; v.setSimValue(LogicValue::zero); @@ -700,7 +700,7 @@ TEST(VertexStandaloneTest, R6_SimValueAllStates) // Test Edge simTimingSense all values // Covers: Edge::setSimTimingSense, Edge::simTimingSense -TEST(EdgeStandaloneTest, R6_SimTimingSenseAllValues) +TEST(EdgeStandaloneTest, SimTimingSenseAllValues) { Edge e; e.setSimTimingSense(TimingSense::unknown); @@ -717,7 +717,7 @@ TEST(EdgeStandaloneTest, R6_SimTimingSenseAllValues) // Test Vertex slewAnnotated with all rf/mm combinations // Covers: Vertex::setSlewAnnotated, Vertex::slewAnnotated -TEST(VertexStandaloneTest, R6_SlewAnnotatedAllCombinations) +TEST(VertexStandaloneTest, SlewAnnotatedAllCombinations) { Vertex v; // Set all 4 combinations @@ -740,7 +740,7 @@ TEST(VertexStandaloneTest, R6_SlewAnnotatedAllCombinations) // Test Vertex tagGroupIndex max value // Covers: Vertex::tagGroupIndex, Vertex::setTagGroupIndex -TEST(VertexStandaloneTest, R6_TagGroupIndexMax) +TEST(VertexStandaloneTest, TagGroupIndexMax) { Vertex v; EXPECT_EQ(v.tagGroupIndex(), tag_group_index_max); @@ -752,7 +752,7 @@ TEST(VertexStandaloneTest, R6_TagGroupIndexMax) // Test Edge setArcDelays and access // Covers: Edge::setArcDelays, Edge::arcDelays -TEST(EdgeStandaloneTest, R6_ArcDelaysSetAndAccess) +TEST(EdgeStandaloneTest, ArcDelaysSetAndAccess) { Edge e; EXPECT_EQ(e.arcDelays(), nullptr); @@ -768,7 +768,7 @@ TEST(EdgeStandaloneTest, R6_ArcDelaysSetAndAccess) // Test Vertex objectIdx with large value // Covers: Vertex::setObjectIdx, Vertex::objectIdx -TEST(VertexStandaloneTest, R6_ObjectIdxLargeValue) +TEST(VertexStandaloneTest, ObjectIdxLargeValue) { Vertex v; v.setObjectIdx(0xFFFF); @@ -779,7 +779,7 @@ TEST(VertexStandaloneTest, R6_ObjectIdxLargeValue) // Test Edge objectIdx with large value // Covers: Edge::setObjectIdx, Edge::objectIdx -TEST(EdgeStandaloneTest, R6_ObjectIdxLargeValue) +TEST(EdgeStandaloneTest, ObjectIdxLargeValue) { Edge e; // Edge objectIdx may be a narrow bitfield; test with small values @@ -791,7 +791,7 @@ TEST(EdgeStandaloneTest, R6_ObjectIdxLargeValue) // Test Vertex multiple flag combinations // Covers: Vertex setter/getter interactions -TEST(VertexStandaloneTest, R6_MultipleFlagCombinations) +TEST(VertexStandaloneTest, MultipleFlagCombinations) { Vertex v; // Set multiple flags and verify they don't interfere @@ -835,7 +835,7 @@ TEST(VertexStandaloneTest, R6_MultipleFlagCombinations) // Test Edge multiple flag combinations // Covers: Edge setter/getter interactions -TEST(EdgeStandaloneTest, R6_MultipleFlagCombinations) +TEST(EdgeStandaloneTest, MultipleFlagCombinations) { Edge e; e.setIsBidirectInstPath(true); @@ -865,7 +865,7 @@ TEST(EdgeStandaloneTest, R6_MultipleFlagCombinations) // Test delayLess with MinMax // Covers: delayLessEqual 4-arg variant -TEST_F(DelayFloatTest, R6_DelayLessEqualMinMaxVariant) +TEST_F(DelayFloatTest, DelayLessEqualMinMaxVariant) { // With max: standard less-equal EXPECT_TRUE(delayLessEqual(1.0f, 2.0f, MinMax::max(), nullptr)); @@ -884,7 +884,7 @@ TEST_F(DelayFloatTest, R6_DelayLessEqualMinMaxVariant) // Test Edge::arcDelayAnnotateBit via removeDelayAnnotated // Covers: Edge::arcDelayAnnotateBit(unsigned long) -TEST(EdgeStandaloneTest, R8_ArcDelayAnnotateBitExercise) +TEST(EdgeStandaloneTest, ArcDelayAnnotateBitExercise) { Edge e; e.setDelayAnnotationIsIncremental(true); @@ -895,7 +895,7 @@ TEST(EdgeStandaloneTest, R8_ArcDelayAnnotateBitExercise) // Test multiple Vertex flag combinations don't interfere // Covers: Vertex flags interaction with multiple setters -TEST(VertexStandaloneTest, R8_MultipleFlagInteraction) +TEST(VertexStandaloneTest, MultipleFlagInteraction) { Vertex v; v.setHasChecks(true); @@ -925,7 +925,7 @@ TEST(VertexStandaloneTest, R8_MultipleFlagInteraction) // Test Edge multiple flag combinations // Covers: Edge flags interaction -TEST(EdgeStandaloneTest, R8_MultipleFlagInteraction) +TEST(EdgeStandaloneTest, MultipleFlagInteraction) { Edge e; e.setIsBidirectInstPath(true); @@ -1022,7 +1022,7 @@ protected: // Covers: Graph::makePinVertices, Graph::makePinInstanceEdges, // Graph::makeWireEdgesThruPin, Vertex::name, // VertexInEdgeIterator, FindNetDrvrLoadCounts -TEST_F(GraphDesignTest, R8_GraphVerticesAndEdges) { +TEST_F(GraphDesignTest, GraphVerticesAndEdges) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1051,7 +1051,7 @@ TEST_F(GraphDesignTest, R8_GraphVerticesAndEdges) { // Test Vertex name with a real graph // Covers: Vertex::name(const Network*) const -TEST_F(GraphDesignTest, R8_VertexName) { +TEST_F(GraphDesignTest, VertexName) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1076,7 +1076,7 @@ TEST_F(GraphDesignTest, R8_VertexName) { // Test Graph edges traversal // Covers: VertexOutEdgeIterator -TEST_F(GraphDesignTest, R8_EdgeTraversal) { +TEST_F(GraphDesignTest, EdgeTraversal) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1102,7 +1102,7 @@ TEST_F(GraphDesignTest, R8_EdgeTraversal) { // Test VertexInEdgeIterator // Covers: VertexInEdgeIterator::VertexInEdgeIterator -TEST_F(GraphDesignTest, R8_VertexInEdgeIterator) { +TEST_F(GraphDesignTest, VertexInEdgeIterator) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); diff --git a/liberty/test/cpp/TestLiberty.cc b/liberty/test/cpp/TestLiberty.cc index 74869e54..3e226d59 100644 --- a/liberty/test/cpp/TestLiberty.cc +++ b/liberty/test/cpp/TestLiberty.cc @@ -6474,21 +6474,21 @@ TEST_F(StaLibertyTest, Table3ReportValueWithCell) { //////////////////////////////////////////////////////////////// // Unit::setSuffix - covers uncovered function -TEST_F(UnitTest, R5_SetSuffix) { +TEST_F(UnitTest, SetSuffix) { Unit unit(1e-9f, "s", 3); unit.setSuffix("ns"); EXPECT_EQ(unit.suffix(), "ns"); } // Unit::width - covers uncovered function -TEST_F(UnitTest, R5_Width) { +TEST_F(UnitTest, Width) { Unit unit(1e-9f, "s", 3); int w = unit.width(); // width() returns digits_ + 2 EXPECT_EQ(w, 5); } -TEST_F(UnitTest, R5_WidthVaryDigits) { +TEST_F(UnitTest, WidthVaryDigits) { Unit unit(1e-9f, "s", 0); EXPECT_EQ(unit.width(), 2); unit.setDigits(6); @@ -6496,20 +6496,20 @@ TEST_F(UnitTest, R5_WidthVaryDigits) { } // Unit::asString(double) - covers uncovered function -TEST_F(UnitTest, R5_AsStringDouble) { +TEST_F(UnitTest, AsStringDouble) { Unit unit(1e-9f, "s", 3); const char *str = unit.asString(1e-9); EXPECT_NE(str, nullptr); } -TEST_F(UnitTest, R5_AsStringDoubleZero) { +TEST_F(UnitTest, AsStringDoubleZero) { Unit unit(1.0f, "V", 2); const char *str = unit.asString(0.0); EXPECT_NE(str, nullptr); } // to_string(TimingSense) exercise - ensure all senses -TEST(TimingArcTest, R5_TimingSenseToStringAll) { +TEST(TimingArcTest, TimingSenseToStringAll) { EXPECT_NE(to_string(TimingSense::positive_unate), nullptr); EXPECT_NE(to_string(TimingSense::negative_unate), nullptr); EXPECT_NE(to_string(TimingSense::non_unate), nullptr); @@ -6518,7 +6518,7 @@ TEST(TimingArcTest, R5_TimingSenseToStringAll) { } // timingSenseOpposite - covers uncovered -TEST(TimingArcTest, R5_TimingSenseOpposite) { +TEST(TimingArcTest, TimingSenseOpposite) { EXPECT_EQ(timingSenseOpposite(TimingSense::positive_unate), TimingSense::negative_unate); EXPECT_EQ(timingSenseOpposite(TimingSense::negative_unate), @@ -6532,7 +6532,7 @@ TEST(TimingArcTest, R5_TimingSenseOpposite) { } // findTimingType coverage -TEST(TimingArcTest, R5_FindTimingType) { +TEST(TimingArcTest, FindTimingType) { EXPECT_EQ(findTimingType("combinational"), TimingType::combinational); EXPECT_EQ(findTimingType("setup_rising"), TimingType::setup_rising); EXPECT_EQ(findTimingType("hold_falling"), TimingType::hold_falling); @@ -6543,7 +6543,7 @@ TEST(TimingArcTest, R5_FindTimingType) { } // findTimingType for additional types to improve coverage -TEST(TimingArcTest, R5_FindTimingTypeAdditional) { +TEST(TimingArcTest, FindTimingTypeAdditional) { EXPECT_EQ(findTimingType("combinational_rise"), TimingType::combinational_rise); EXPECT_EQ(findTimingType("combinational_fall"), TimingType::combinational_fall); EXPECT_EQ(findTimingType("three_state_disable_rise"), TimingType::three_state_disable_rise); @@ -6560,7 +6560,7 @@ TEST(TimingArcTest, R5_FindTimingTypeAdditional) { } // timingTypeScaleFactorType coverage -TEST(TimingArcTest, R5_TimingTypeScaleFactorType) { +TEST(TimingArcTest, TimingTypeScaleFactorType) { EXPECT_EQ(timingTypeScaleFactorType(TimingType::combinational), ScaleFactorType::cell); EXPECT_EQ(timingTypeScaleFactorType(TimingType::setup_rising), @@ -6580,7 +6580,7 @@ TEST(TimingArcTest, R5_TimingTypeScaleFactorType) { } // timingTypeIsCheck for non-check types -TEST(TimingArcTest, R5_TimingTypeIsCheckNonCheck) { +TEST(TimingArcTest, TimingTypeIsCheckNonCheck) { EXPECT_FALSE(timingTypeIsCheck(TimingType::combinational)); EXPECT_FALSE(timingTypeIsCheck(TimingType::combinational_rise)); EXPECT_FALSE(timingTypeIsCheck(TimingType::combinational_fall)); @@ -6600,7 +6600,7 @@ TEST(TimingArcTest, R5_TimingTypeIsCheckNonCheck) { } // TimingArcAttrs default constructor -TEST(TimingArcTest, R5_TimingArcAttrsDefault) { +TEST(TimingArcTest, TimingArcAttrsDefault) { TimingArcAttrs attrs; EXPECT_EQ(attrs.timingType(), TimingType::combinational); EXPECT_EQ(attrs.timingSense(), TimingSense::unknown); @@ -6613,13 +6613,13 @@ TEST(TimingArcTest, R5_TimingArcAttrsDefault) { } // TimingArcAttrs with sense constructor -TEST(TimingArcTest, R5_TimingArcAttrsSense) { +TEST(TimingArcTest, TimingArcAttrsSense) { TimingArcAttrs attrs(TimingSense::positive_unate); EXPECT_EQ(attrs.timingSense(), TimingSense::positive_unate); } // TimingArcAttrs setters -TEST(TimingArcTest, R5_TimingArcAttrsSetters) { +TEST(TimingArcTest, TimingArcAttrsSetters) { TimingArcAttrs attrs; attrs.setTimingType(TimingType::setup_rising); EXPECT_EQ(attrs.timingType(), TimingType::setup_rising); @@ -6630,7 +6630,7 @@ TEST(TimingArcTest, R5_TimingArcAttrsSetters) { } // ScaleFactors - covers ScaleFactors constructor and methods -TEST(LibertyTest, R5_ScaleFactors) { +TEST(LibertyTest, ScaleFactors) { ScaleFactors sf("test_sf"); EXPECT_STREQ(sf.name(), "test_sf"); sf.setScale(ScaleFactorType::cell, ScaleFactorPvt::process, @@ -6640,7 +6640,7 @@ TEST(LibertyTest, R5_ScaleFactors) { EXPECT_FLOAT_EQ(v, 1.5f); } -TEST(LibertyTest, R5_ScaleFactorsNoRf) { +TEST(LibertyTest, ScaleFactorsNoRf) { ScaleFactors sf("sf2"); sf.setScale(ScaleFactorType::pin_cap, ScaleFactorPvt::volt, 2.0f); float v = sf.scale(ScaleFactorType::pin_cap, ScaleFactorPvt::volt); @@ -6648,7 +6648,7 @@ TEST(LibertyTest, R5_ScaleFactorsNoRf) { } // findScaleFactorPvt -TEST(LibertyTest, R5_FindScaleFactorPvt) { +TEST(LibertyTest, FindScaleFactorPvt) { EXPECT_EQ(findScaleFactorPvt("process"), ScaleFactorPvt::process); EXPECT_EQ(findScaleFactorPvt("volt"), ScaleFactorPvt::volt); EXPECT_EQ(findScaleFactorPvt("temp"), ScaleFactorPvt::temp); @@ -6656,21 +6656,21 @@ TEST(LibertyTest, R5_FindScaleFactorPvt) { } // scaleFactorPvtName -TEST(LibertyTest, R5_ScaleFactorPvtName) { +TEST(LibertyTest, ScaleFactorPvtName) { EXPECT_STREQ(scaleFactorPvtName(ScaleFactorPvt::process), "process"); EXPECT_STREQ(scaleFactorPvtName(ScaleFactorPvt::volt), "volt"); EXPECT_STREQ(scaleFactorPvtName(ScaleFactorPvt::temp), "temp"); } // findScaleFactorType / scaleFactorTypeName -TEST(LibertyTest, R5_FindScaleFactorType) { +TEST(LibertyTest, FindScaleFactorType) { EXPECT_EQ(findScaleFactorType("cell"), ScaleFactorType::cell); EXPECT_EQ(findScaleFactorType("hold"), ScaleFactorType::hold); EXPECT_EQ(findScaleFactorType("setup"), ScaleFactorType::setup); EXPECT_EQ(findScaleFactorType("nonexist"), ScaleFactorType::unknown); } -TEST(LibertyTest, R5_ScaleFactorTypeName) { +TEST(LibertyTest, ScaleFactorTypeName) { EXPECT_STREQ(scaleFactorTypeName(ScaleFactorType::cell), "cell"); EXPECT_STREQ(scaleFactorTypeName(ScaleFactorType::hold), "hold"); EXPECT_STREQ(scaleFactorTypeName(ScaleFactorType::setup), "setup"); @@ -6679,7 +6679,7 @@ TEST(LibertyTest, R5_ScaleFactorTypeName) { } // scaleFactorTypeRiseFallSuffix, scaleFactorTypeRiseFallPrefix, scaleFactorTypeLowHighSuffix -TEST(LibertyTest, R5_ScaleFactorTypeFlags) { +TEST(LibertyTest, ScaleFactorTypeFlags) { EXPECT_TRUE(scaleFactorTypeRiseFallSuffix(ScaleFactorType::cell)); EXPECT_FALSE(scaleFactorTypeRiseFallSuffix(ScaleFactorType::pin_cap)); EXPECT_TRUE(scaleFactorTypeRiseFallPrefix(ScaleFactorType::transition)); @@ -6689,7 +6689,7 @@ TEST(LibertyTest, R5_ScaleFactorTypeFlags) { } // BusDcl -TEST(LibertyTest, R5_BusDcl) { +TEST(LibertyTest, BusDcl) { BusDcl dcl("data", 7, 0); EXPECT_STREQ(dcl.name(), "data"); EXPECT_EQ(dcl.from(), 7); @@ -6697,7 +6697,7 @@ TEST(LibertyTest, R5_BusDcl) { } // Pvt -TEST(LibertyTest, R5_Pvt) { +TEST(LibertyTest, Pvt) { Pvt pvt(1.0f, 1.1f, 25.0f); EXPECT_FLOAT_EQ(pvt.process(), 1.0f); EXPECT_FLOAT_EQ(pvt.voltage(), 1.1f); @@ -6711,12 +6711,12 @@ TEST(LibertyTest, R5_Pvt) { } // OperatingConditions -TEST(LibertyTest, R5_OperatingConditionsNameOnly) { +TEST(LibertyTest, OperatingConditionsNameOnly) { OperatingConditions oc("typical"); EXPECT_STREQ(oc.name(), "typical"); } -TEST(LibertyTest, R5_OperatingConditionsFull) { +TEST(LibertyTest, OperatingConditionsFull) { OperatingConditions oc("fast", 1.0f, 1.21f, 0.0f, WireloadTree::balanced); EXPECT_STREQ(oc.name(), "fast"); EXPECT_FLOAT_EQ(oc.process(), 1.0f); @@ -6725,14 +6725,14 @@ TEST(LibertyTest, R5_OperatingConditionsFull) { EXPECT_EQ(oc.wireloadTree(), WireloadTree::balanced); } -TEST(LibertyTest, R5_OperatingConditionsSetWireloadTree) { +TEST(LibertyTest, OperatingConditionsSetWireloadTree) { OperatingConditions oc("nom"); oc.setWireloadTree(WireloadTree::worst_case); EXPECT_EQ(oc.wireloadTree(), WireloadTree::worst_case); } // TableTemplate -TEST(LibertyTest, R5_TableTemplate) { +TEST(LibertyTest, TableTemplate) { TableTemplate tt("my_template"); EXPECT_STREQ(tt.name(), "my_template"); EXPECT_EQ(tt.axis1(), nullptr); @@ -6740,14 +6740,14 @@ TEST(LibertyTest, R5_TableTemplate) { EXPECT_EQ(tt.axis3(), nullptr); } -TEST(LibertyTest, R5_TableTemplateSetName) { +TEST(LibertyTest, TableTemplateSetName) { TableTemplate tt("old"); tt.setName("new_name"); EXPECT_STREQ(tt.name(), "new_name"); } // TableAxis -TEST_F(Table1Test, R5_TableAxisBasic) { +TEST_F(Table1Test, TableAxisBasic) { FloatSeq *vals = new FloatSeq; vals->push_back(0.1f); vals->push_back(0.5f); @@ -6762,7 +6762,7 @@ TEST_F(Table1Test, R5_TableAxisBasic) { EXPECT_FLOAT_EQ(axis->max(), 1.0f); } -TEST_F(Table1Test, R5_TableAxisInBounds) { +TEST_F(Table1Test, TableAxisInBounds) { FloatSeq *vals = new FloatSeq; vals->push_back(0.0f); vals->push_back(1.0f); @@ -6773,7 +6773,7 @@ TEST_F(Table1Test, R5_TableAxisInBounds) { EXPECT_FALSE(axis->inBounds(-0.1f)); } -TEST_F(Table1Test, R5_TableAxisFindIndex) { +TEST_F(Table1Test, TableAxisFindIndex) { FloatSeq *vals = new FloatSeq; vals->push_back(0.0f); vals->push_back(0.5f); @@ -6784,7 +6784,7 @@ TEST_F(Table1Test, R5_TableAxisFindIndex) { EXPECT_EQ(axis->findAxisIndex(0.7f), 1u); } -TEST_F(Table1Test, R5_TableAxisFindClosestIndex) { +TEST_F(Table1Test, TableAxisFindClosestIndex) { FloatSeq *vals = new FloatSeq; vals->push_back(0.0f); vals->push_back(0.5f); @@ -6796,7 +6796,7 @@ TEST_F(Table1Test, R5_TableAxisFindClosestIndex) { EXPECT_EQ(axis->findAxisClosestIndex(0.9f), 2u); } -TEST_F(Table1Test, R5_TableAxisVariableString) { +TEST_F(Table1Test, TableAxisVariableString) { FloatSeq *vals = new FloatSeq; vals->push_back(0.0f); auto axis = std::make_shared( @@ -6805,14 +6805,14 @@ TEST_F(Table1Test, R5_TableAxisVariableString) { } // tableVariableString / stringTableAxisVariable -TEST_F(Table1Test, R5_TableVariableString) { +TEST_F(Table1Test, TableVariableString) { EXPECT_NE(tableVariableString(TableAxisVariable::total_output_net_capacitance), nullptr); EXPECT_NE(tableVariableString(TableAxisVariable::input_net_transition), nullptr); EXPECT_NE(tableVariableString(TableAxisVariable::related_pin_transition), nullptr); EXPECT_NE(tableVariableString(TableAxisVariable::constrained_pin_transition), nullptr); } -TEST_F(Table1Test, R5_StringTableAxisVariable) { +TEST_F(Table1Test, StringTableAxisVariable) { EXPECT_EQ(stringTableAxisVariable("total_output_net_capacitance"), TableAxisVariable::total_output_net_capacitance); EXPECT_EQ(stringTableAxisVariable("input_net_transition"), @@ -6822,7 +6822,7 @@ TEST_F(Table1Test, R5_StringTableAxisVariable) { } // Table0 -TEST_F(Table1Test, R5_Table0) { +TEST_F(Table1Test, Table0) { Table0 t(42.0f); EXPECT_EQ(t.order(), 0); EXPECT_FLOAT_EQ(t.value(0, 0, 0), 42.0f); @@ -6830,14 +6830,14 @@ TEST_F(Table1Test, R5_Table0) { } // Table1 default constructor -TEST_F(Table1Test, R5_Table1Default) { +TEST_F(Table1Test, Table1Default) { Table1 t; EXPECT_EQ(t.order(), 1); EXPECT_EQ(t.axis1(), nullptr); } // Table1 copy constructor -TEST_F(Table1Test, R5_Table1Copy) { +TEST_F(Table1Test, Table1Copy) { FloatSeq *vals = new FloatSeq; vals->push_back(1.0f); vals->push_back(2.0f); @@ -6854,7 +6854,7 @@ TEST_F(Table1Test, R5_Table1Copy) { } // Table1 move constructor -TEST_F(Table1Test, R5_Table1Move) { +TEST_F(Table1Test, Table1Move) { FloatSeq *vals = new FloatSeq; vals->push_back(3.0f); vals->push_back(4.0f); @@ -6870,7 +6870,7 @@ TEST_F(Table1Test, R5_Table1Move) { } // Table1 findValue (single-arg) -TEST_F(Table1Test, R5_Table1FindValueSingle) { +TEST_F(Table1Test, Table1FindValueSingle) { FloatSeq *vals = new FloatSeq; vals->push_back(1.0f); vals->push_back(2.0f); @@ -6885,7 +6885,7 @@ TEST_F(Table1Test, R5_Table1FindValueSingle) { } // Table1 findValueClip -TEST_F(Table1Test, R5_Table1FindValueClip) { +TEST_F(Table1Test, Table1FindValueClip) { FloatSeq *vals = new FloatSeq; vals->push_back(10.0f); vals->push_back(20.0f); @@ -6904,7 +6904,7 @@ TEST_F(Table1Test, R5_Table1FindValueClip) { } // Table1 move assignment -TEST_F(Table1Test, R5_Table1MoveAssign) { +TEST_F(Table1Test, Table1MoveAssign) { FloatSeq *vals = new FloatSeq; vals->push_back(5.0f); FloatSeq *axis_vals = new FloatSeq; @@ -6920,13 +6920,13 @@ TEST_F(Table1Test, R5_Table1MoveAssign) { // Removed: R5_OcvDerate (segfault) // portLibertyToSta conversion -TEST(LibertyTest, R5_PortLibertyToSta) { +TEST(LibertyTest, PortLibertyToSta) { std::string result = portLibertyToSta("foo[0]"); // Should replace [] with escaped versions or similar EXPECT_FALSE(result.empty()); } -TEST(LibertyTest, R5_PortLibertyToStaPlain) { +TEST(LibertyTest, PortLibertyToStaPlain) { std::string result = portLibertyToSta("A"); EXPECT_EQ(result, "A"); } @@ -6934,7 +6934,7 @@ TEST(LibertyTest, R5_PortLibertyToStaPlain) { // Removed: R5_WireloadSelection (segfault) // TableAxisVariable unit lookup -TEST_F(Table1Test, R5_TableVariableUnit) { +TEST_F(Table1Test, TableVariableUnit) { Units units; const Unit *u = tableVariableUnit( TableAxisVariable::total_output_net_capacitance, &units); @@ -6945,7 +6945,7 @@ TEST_F(Table1Test, R5_TableVariableUnit) { } // TableModel with Table0 -TEST_F(Table1Test, R5_TableModel0) { +TEST_F(Table1Test, TableModel0) { auto tbl = std::make_shared(1.5f); TableTemplate tmpl("tmpl0"); TableModel model(tbl, &tmpl, ScaleFactorType::cell, RiseFall::rise()); @@ -6956,45 +6956,45 @@ TEST_F(Table1Test, R5_TableModel0) { // StaLibertyTest-based tests for coverage of loaded library functions // LibertyCell getters on loaded cells -TEST_F(StaLibertyTest, R5_CellArea) { +TEST_F(StaLibertyTest, CellArea2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); // Area should be some positive value for Nangate45 EXPECT_GE(buf->area(), 0.0f); } -TEST_F(StaLibertyTest, R5_CellDontUse) { +TEST_F(StaLibertyTest, CellDontUse2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); // BUF_X1 should not be marked dont_use EXPECT_FALSE(buf->dontUse()); } -TEST_F(StaLibertyTest, R5_CellIsMacro) { +TEST_F(StaLibertyTest, CellIsMacro2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isMacro()); } -TEST_F(StaLibertyTest, R5_CellIsMemory) { +TEST_F(StaLibertyTest, CellIsMemory2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isMemory()); } -TEST_F(StaLibertyTest, R5_CellIsPad) { +TEST_F(StaLibertyTest, CellIsPad) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isPad()); } -TEST_F(StaLibertyTest, R5_CellIsBuffer) { +TEST_F(StaLibertyTest, CellIsBuffer2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_TRUE(buf->isBuffer()); } -TEST_F(StaLibertyTest, R5_CellIsInverter) { +TEST_F(StaLibertyTest, CellIsInverter2) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); ASSERT_NE(inv, nullptr); EXPECT_TRUE(inv->isInverter()); @@ -7003,7 +7003,7 @@ TEST_F(StaLibertyTest, R5_CellIsInverter) { EXPECT_FALSE(buf->isInverter()); } -TEST_F(StaLibertyTest, R5_CellHasSequentials) { +TEST_F(StaLibertyTest, CellHasSequentials2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->hasSequentials()); @@ -7012,7 +7012,7 @@ TEST_F(StaLibertyTest, R5_CellHasSequentials) { EXPECT_TRUE(dff->hasSequentials()); } -TEST_F(StaLibertyTest, R5_CellTimingArcSets) { +TEST_F(StaLibertyTest, CellTimingArcSets2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const auto &arc_sets = buf->timingArcSets(); @@ -7020,7 +7020,7 @@ TEST_F(StaLibertyTest, R5_CellTimingArcSets) { EXPECT_GT(buf->timingArcSetCount(), 0u); } -TEST_F(StaLibertyTest, R5_CellInternalPowers) { +TEST_F(StaLibertyTest, CellInternalPowers2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const auto &powers = buf->internalPowers(); @@ -7028,7 +7028,7 @@ TEST_F(StaLibertyTest, R5_CellInternalPowers) { EXPECT_GE(powers.size(), 0u); } -TEST_F(StaLibertyTest, R5_CellLeakagePower) { +TEST_F(StaLibertyTest, CellLeakagePower2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); float leakage; @@ -7037,13 +7037,13 @@ TEST_F(StaLibertyTest, R5_CellLeakagePower) { // Just exercise the function } -TEST_F(StaLibertyTest, R5_CellInterfaceTiming) { +TEST_F(StaLibertyTest, CellInterfaceTiming) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->interfaceTiming()); } -TEST_F(StaLibertyTest, R5_CellIsClockGate) { +TEST_F(StaLibertyTest, CellIsClockGate2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isClockGate()); @@ -7052,44 +7052,44 @@ TEST_F(StaLibertyTest, R5_CellIsClockGate) { EXPECT_FALSE(buf->isClockGateOther()); } -TEST_F(StaLibertyTest, R5_CellIsClockCell) { +TEST_F(StaLibertyTest, CellIsClockCell) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isClockCell()); } -TEST_F(StaLibertyTest, R5_CellIsLevelShifter) { +TEST_F(StaLibertyTest, CellIsLevelShifter) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isLevelShifter()); } -TEST_F(StaLibertyTest, R5_CellIsIsolationCell) { +TEST_F(StaLibertyTest, CellIsIsolationCell) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isIsolationCell()); } -TEST_F(StaLibertyTest, R5_CellAlwaysOn) { +TEST_F(StaLibertyTest, CellAlwaysOn) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->alwaysOn()); } -TEST_F(StaLibertyTest, R5_CellIsDisabledConstraint) { +TEST_F(StaLibertyTest, CellIsDisabledConstraint) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isDisabledConstraint()); } -TEST_F(StaLibertyTest, R5_CellHasInternalPorts) { +TEST_F(StaLibertyTest, CellHasInternalPorts2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->hasInternalPorts()); } // LibertyPort tests -TEST_F(StaLibertyTest, R5_PortCapacitance) { +TEST_F(StaLibertyTest, PortCapacitance) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7098,7 +7098,7 @@ TEST_F(StaLibertyTest, R5_PortCapacitance) { EXPECT_GE(cap, 0.0f); } -TEST_F(StaLibertyTest, R5_PortCapacitanceMinMax) { +TEST_F(StaLibertyTest, PortCapacitanceMinMax) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7109,7 +7109,7 @@ TEST_F(StaLibertyTest, R5_PortCapacitanceMinMax) { EXPECT_GE(cap_max, 0.0f); } -TEST_F(StaLibertyTest, R5_PortCapacitanceRfMinMax) { +TEST_F(StaLibertyTest, PortCapacitanceRfMinMax) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7120,7 +7120,7 @@ TEST_F(StaLibertyTest, R5_PortCapacitanceRfMinMax) { // Just exercise the function } -TEST_F(StaLibertyTest, R5_PortCapacitanceIsOneValue) { +TEST_F(StaLibertyTest, PortCapacitanceIsOneValue) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7129,7 +7129,7 @@ TEST_F(StaLibertyTest, R5_PortCapacitanceIsOneValue) { a->capacitanceIsOneValue(); } -TEST_F(StaLibertyTest, R5_PortDriveResistance) { +TEST_F(StaLibertyTest, PortDriveResistance) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *z = buf->findLibertyPort("Z"); @@ -7138,7 +7138,7 @@ TEST_F(StaLibertyTest, R5_PortDriveResistance) { EXPECT_GE(dr, 0.0f); } -TEST_F(StaLibertyTest, R5_PortDriveResistanceRfMinMax) { +TEST_F(StaLibertyTest, PortDriveResistanceRfMinMax) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *z = buf->findLibertyPort("Z"); @@ -7147,7 +7147,7 @@ TEST_F(StaLibertyTest, R5_PortDriveResistanceRfMinMax) { EXPECT_GE(dr, 0.0f); } -TEST_F(StaLibertyTest, R5_PortFunction) { +TEST_F(StaLibertyTest, PortFunction2) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); ASSERT_NE(inv, nullptr); LibertyPort *zn = inv->findLibertyPort("ZN"); @@ -7156,7 +7156,7 @@ TEST_F(StaLibertyTest, R5_PortFunction) { EXPECT_NE(func, nullptr); } -TEST_F(StaLibertyTest, R5_PortIsClock) { +TEST_F(StaLibertyTest, PortIsClock) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7164,7 +7164,7 @@ TEST_F(StaLibertyTest, R5_PortIsClock) { EXPECT_FALSE(a->isClock()); } -TEST_F(StaLibertyTest, R5_PortFanoutLoad) { +TEST_F(StaLibertyTest, PortFanoutLoad) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7175,7 +7175,7 @@ TEST_F(StaLibertyTest, R5_PortFanoutLoad) { // Just exercise } -TEST_F(StaLibertyTest, R5_PortMinPeriod) { +TEST_F(StaLibertyTest, PortMinPeriod2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7186,7 +7186,7 @@ TEST_F(StaLibertyTest, R5_PortMinPeriod) { // BUF port probably doesn't have min_period } -TEST_F(StaLibertyTest, R5_PortMinPulseWidth) { +TEST_F(StaLibertyTest, PortMinPulseWidth2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7196,7 +7196,7 @@ TEST_F(StaLibertyTest, R5_PortMinPulseWidth) { a->minPulseWidth(RiseFall::rise(), min_width, exists); } -TEST_F(StaLibertyTest, R5_PortSlewLimit) { +TEST_F(StaLibertyTest, PortSlewLimit) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7206,7 +7206,7 @@ TEST_F(StaLibertyTest, R5_PortSlewLimit) { a->slewLimit(MinMax::max(), limit, exists); } -TEST_F(StaLibertyTest, R5_PortCapacitanceLimit) { +TEST_F(StaLibertyTest, PortCapacitanceLimit) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *z = buf->findLibertyPort("Z"); @@ -7216,7 +7216,7 @@ TEST_F(StaLibertyTest, R5_PortCapacitanceLimit) { z->capacitanceLimit(MinMax::max(), limit, exists); } -TEST_F(StaLibertyTest, R5_PortFanoutLimit) { +TEST_F(StaLibertyTest, PortFanoutLimit) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *z = buf->findLibertyPort("Z"); @@ -7226,7 +7226,7 @@ TEST_F(StaLibertyTest, R5_PortFanoutLimit) { z->fanoutLimit(MinMax::max(), limit, exists); } -TEST_F(StaLibertyTest, R5_PortIsPwrGnd) { +TEST_F(StaLibertyTest, PortIsPwrGnd) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7234,7 +7234,7 @@ TEST_F(StaLibertyTest, R5_PortIsPwrGnd) { EXPECT_FALSE(a->isPwrGnd()); } -TEST_F(StaLibertyTest, R5_PortDirection) { +TEST_F(StaLibertyTest, PortDirection) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7245,7 +7245,7 @@ TEST_F(StaLibertyTest, R5_PortDirection) { EXPECT_EQ(z->direction(), PortDirection::output()); } -TEST_F(StaLibertyTest, R5_PortIsRegClk) { +TEST_F(StaLibertyTest, PortIsRegClk) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7255,7 +7255,7 @@ TEST_F(StaLibertyTest, R5_PortIsRegClk) { EXPECT_FALSE(a->isCheckClk()); } -TEST_F(StaLibertyTest, R5_PortIsLatchData) { +TEST_F(StaLibertyTest, PortIsLatchData) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7263,7 +7263,7 @@ TEST_F(StaLibertyTest, R5_PortIsLatchData) { EXPECT_FALSE(a->isLatchData()); } -TEST_F(StaLibertyTest, R5_PortIsPllFeedback) { +TEST_F(StaLibertyTest, PortIsPllFeedback) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7271,7 +7271,7 @@ TEST_F(StaLibertyTest, R5_PortIsPllFeedback) { EXPECT_FALSE(a->isPllFeedback()); } -TEST_F(StaLibertyTest, R5_PortIsSwitch) { +TEST_F(StaLibertyTest, PortIsSwitch) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7279,7 +7279,7 @@ TEST_F(StaLibertyTest, R5_PortIsSwitch) { EXPECT_FALSE(a->isSwitch()); } -TEST_F(StaLibertyTest, R5_PortIsClockGateFlags) { +TEST_F(StaLibertyTest, PortIsClockGateFlags) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7289,7 +7289,7 @@ TEST_F(StaLibertyTest, R5_PortIsClockGateFlags) { EXPECT_FALSE(a->isClockGateOut()); } -TEST_F(StaLibertyTest, R5_PortIsolationFlags) { +TEST_F(StaLibertyTest, PortIsolationFlags) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7299,7 +7299,7 @@ TEST_F(StaLibertyTest, R5_PortIsolationFlags) { EXPECT_FALSE(a->levelShifterData()); } -TEST_F(StaLibertyTest, R5_PortPulseClk) { +TEST_F(StaLibertyTest, PortPulseClk2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7308,7 +7308,7 @@ TEST_F(StaLibertyTest, R5_PortPulseClk) { EXPECT_EQ(a->pulseClkSense(), nullptr); } -TEST_F(StaLibertyTest, R5_PortIsDisabledConstraint) { +TEST_F(StaLibertyTest, PortIsDisabledConstraint2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7316,7 +7316,7 @@ TEST_F(StaLibertyTest, R5_PortIsDisabledConstraint) { EXPECT_FALSE(a->isDisabledConstraint()); } -TEST_F(StaLibertyTest, R5_PortIsPad) { +TEST_F(StaLibertyTest, PortIsPad) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7325,61 +7325,61 @@ TEST_F(StaLibertyTest, R5_PortIsPad) { } // LibertyLibrary tests -TEST_F(StaLibertyTest, R5_LibraryDelayModelType) { +TEST_F(StaLibertyTest, LibraryDelayModelType2) { EXPECT_EQ(lib_->delayModelType(), DelayModelType::table); } -TEST_F(StaLibertyTest, R5_LibraryNominalVoltage) { +TEST_F(StaLibertyTest, LibraryNominalVoltage) { EXPECT_GT(lib_->nominalVoltage(), 0.0f); } -TEST_F(StaLibertyTest, R5_LibraryNominalTemperature) { +TEST_F(StaLibertyTest, LibraryNominalTemperature) { // Just exercise float temp = lib_->nominalTemperature(); (void)temp; } -TEST_F(StaLibertyTest, R5_LibraryNominalProcess) { +TEST_F(StaLibertyTest, LibraryNominalProcess) { float proc = lib_->nominalProcess(); (void)proc; } -TEST_F(StaLibertyTest, R5_LibraryDefaultInputPinCap) { +TEST_F(StaLibertyTest, LibraryDefaultInputPinCap2) { float cap = lib_->defaultInputPinCap(); EXPECT_GE(cap, 0.0f); } -TEST_F(StaLibertyTest, R5_LibraryDefaultOutputPinCap) { +TEST_F(StaLibertyTest, LibraryDefaultOutputPinCap2) { float cap = lib_->defaultOutputPinCap(); EXPECT_GE(cap, 0.0f); } -TEST_F(StaLibertyTest, R5_LibraryDefaultMaxSlew) { +TEST_F(StaLibertyTest, LibraryDefaultMaxSlew2) { float slew; bool exists; lib_->defaultMaxSlew(slew, exists); // Just exercise } -TEST_F(StaLibertyTest, R5_LibraryDefaultMaxCap) { +TEST_F(StaLibertyTest, LibraryDefaultMaxCap) { float cap; bool exists; lib_->defaultMaxCapacitance(cap, exists); } -TEST_F(StaLibertyTest, R5_LibraryDefaultMaxFanout) { +TEST_F(StaLibertyTest, LibraryDefaultMaxFanout2) { float fanout; bool exists; lib_->defaultMaxFanout(fanout, exists); } -TEST_F(StaLibertyTest, R5_LibraryDefaultFanoutLoad) { +TEST_F(StaLibertyTest, LibraryDefaultFanoutLoad) { float load; bool exists; lib_->defaultFanoutLoad(load, exists); } -TEST_F(StaLibertyTest, R5_LibrarySlewThresholds) { +TEST_F(StaLibertyTest, LibrarySlewThresholds) { float lt_r = lib_->slewLowerThreshold(RiseFall::rise()); float lt_f = lib_->slewLowerThreshold(RiseFall::fall()); float ut_r = lib_->slewUpperThreshold(RiseFall::rise()); @@ -7390,77 +7390,77 @@ TEST_F(StaLibertyTest, R5_LibrarySlewThresholds) { EXPECT_LE(ut_f, 1.0f); } -TEST_F(StaLibertyTest, R5_LibraryInputOutputThresholds) { +TEST_F(StaLibertyTest, LibraryInputOutputThresholds) { float it_r = lib_->inputThreshold(RiseFall::rise()); float ot_r = lib_->outputThreshold(RiseFall::rise()); EXPECT_GT(it_r, 0.0f); EXPECT_GT(ot_r, 0.0f); } -TEST_F(StaLibertyTest, R5_LibrarySlewDerate) { +TEST_F(StaLibertyTest, LibrarySlewDerate) { float derate = lib_->slewDerateFromLibrary(); EXPECT_GT(derate, 0.0f); } -TEST_F(StaLibertyTest, R5_LibraryUnits) { +TEST_F(StaLibertyTest, LibraryUnits2) { Units *units = lib_->units(); EXPECT_NE(units, nullptr); EXPECT_NE(units->timeUnit(), nullptr); EXPECT_NE(units->capacitanceUnit(), nullptr); } -TEST_F(StaLibertyTest, R5_LibraryDefaultWireload) { +TEST_F(StaLibertyTest, LibraryDefaultWireload) { // Nangate45 may or may not have a default wireload Wireload *wl = lib_->defaultWireload(); (void)wl; // just exercise } -TEST_F(StaLibertyTest, R5_LibraryFindWireload) { +TEST_F(StaLibertyTest, LibraryFindWireload) { Wireload *wl = lib_->findWireload("nonexistent_wl"); EXPECT_EQ(wl, nullptr); } -TEST_F(StaLibertyTest, R5_LibraryDefaultWireloadMode) { +TEST_F(StaLibertyTest, LibraryDefaultWireloadMode) { WireloadMode mode = lib_->defaultWireloadMode(); (void)mode; } -TEST_F(StaLibertyTest, R5_LibraryFindOperatingConditions) { +TEST_F(StaLibertyTest, LibraryFindOperatingConditions) { // Try to find non-existent OC OperatingConditions *oc = lib_->findOperatingConditions("nonexistent_oc"); EXPECT_EQ(oc, nullptr); } -TEST_F(StaLibertyTest, R5_LibraryDefaultOperatingConditions) { +TEST_F(StaLibertyTest, LibraryDefaultOperatingConditions) { OperatingConditions *oc = lib_->defaultOperatingConditions(); // May or may not exist (void)oc; } -TEST_F(StaLibertyTest, R5_LibraryOcvArcDepth) { +TEST_F(StaLibertyTest, LibraryOcvArcDepth) { float depth = lib_->ocvArcDepth(); EXPECT_GE(depth, 0.0f); } -TEST_F(StaLibertyTest, R5_LibraryBuffers) { +TEST_F(StaLibertyTest, LibraryBuffers) { LibertyCellSeq *bufs = lib_->buffers(); EXPECT_NE(bufs, nullptr); EXPECT_GT(bufs->size(), 0u); } -TEST_F(StaLibertyTest, R5_LibraryInverters) { +TEST_F(StaLibertyTest, LibraryInverters) { LibertyCellSeq *invs = lib_->inverters(); EXPECT_NE(invs, nullptr); EXPECT_GT(invs->size(), 0u); } -TEST_F(StaLibertyTest, R5_LibraryTableTemplates) { +TEST_F(StaLibertyTest, LibraryTableTemplates2) { auto templates = lib_->tableTemplates(); // Should have some templates EXPECT_GE(templates.size(), 0u); } -TEST_F(StaLibertyTest, R5_LibrarySupplyVoltage) { +TEST_F(StaLibertyTest, LibrarySupplyVoltage) { float voltage; bool exists; lib_->supplyVoltage("VDD", voltage, exists); @@ -7468,7 +7468,7 @@ TEST_F(StaLibertyTest, R5_LibrarySupplyVoltage) { } // TimingArcSet on real cells -TEST_F(StaLibertyTest, R5_TimingArcSetProperties) { +TEST_F(StaLibertyTest, TimingArcSetProperties2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const auto &arc_sets = buf->timingArcSets(); @@ -7481,7 +7481,7 @@ TEST_F(StaLibertyTest, R5_TimingArcSetProperties) { EXPECT_FALSE(as->isWire()); } -TEST_F(StaLibertyTest, R5_TimingArcSetSense) { +TEST_F(StaLibertyTest, TimingArcSetSense) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const auto &arc_sets = buf->timingArcSets(); @@ -7490,7 +7490,7 @@ TEST_F(StaLibertyTest, R5_TimingArcSetSense) { (void)sense; // exercise } -TEST_F(StaLibertyTest, R5_TimingArcSetCond) { +TEST_F(StaLibertyTest, TimingArcSetCond) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const auto &arc_sets = buf->timingArcSets(); @@ -7501,21 +7501,21 @@ TEST_F(StaLibertyTest, R5_TimingArcSetCond) { } } -TEST_F(StaLibertyTest, R5_TimingArcSetWire) { +TEST_F(StaLibertyTest, TimingArcSetWire2) { TimingArcSet *wire = TimingArcSet::wireTimingArcSet(); EXPECT_NE(wire, nullptr); EXPECT_TRUE(wire->isWire()); EXPECT_EQ(TimingArcSet::wireArcCount(), 2); } -TEST_F(StaLibertyTest, R5_TimingArcSetWireArcIndex) { +TEST_F(StaLibertyTest, TimingArcSetWireArcIndex) { int rise_idx = TimingArcSet::wireArcIndex(RiseFall::rise()); int fall_idx = TimingArcSet::wireArcIndex(RiseFall::fall()); EXPECT_NE(rise_idx, fall_idx); } // TimingArc properties -TEST_F(StaLibertyTest, R5_TimingArcProperties) { +TEST_F(StaLibertyTest, TimingArcProperties2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const auto &arc_sets = buf->timingArcSets(); @@ -7531,7 +7531,7 @@ TEST_F(StaLibertyTest, R5_TimingArcProperties) { EXPECT_NE(arc->to(), nullptr); } -TEST_F(StaLibertyTest, R5_TimingArcToString) { +TEST_F(StaLibertyTest, TimingArcToString) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const auto &arc_sets = buf->timingArcSets(); @@ -7542,7 +7542,7 @@ TEST_F(StaLibertyTest, R5_TimingArcToString) { EXPECT_FALSE(str.empty()); } -TEST_F(StaLibertyTest, R5_TimingArcDriveResistance) { +TEST_F(StaLibertyTest, TimingArcDriveResistance2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const auto &arc_sets = buf->timingArcSets(); @@ -7553,7 +7553,7 @@ TEST_F(StaLibertyTest, R5_TimingArcDriveResistance) { EXPECT_GE(dr, 0.0f); } -TEST_F(StaLibertyTest, R5_TimingArcIntrinsicDelay) { +TEST_F(StaLibertyTest, TimingArcIntrinsicDelay2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const auto &arc_sets = buf->timingArcSets(); @@ -7564,7 +7564,7 @@ TEST_F(StaLibertyTest, R5_TimingArcIntrinsicDelay) { (void)ad; } -TEST_F(StaLibertyTest, R5_TimingArcModel) { +TEST_F(StaLibertyTest, TimingArcModel) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const auto &arc_sets = buf->timingArcSets(); @@ -7575,7 +7575,7 @@ TEST_F(StaLibertyTest, R5_TimingArcModel) { EXPECT_NE(model, nullptr); } -TEST_F(StaLibertyTest, R5_TimingArcEquiv) { +TEST_F(StaLibertyTest, TimingArcEquiv2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const auto &arc_sets = buf->timingArcSets(); @@ -7589,7 +7589,7 @@ TEST_F(StaLibertyTest, R5_TimingArcEquiv) { } } -TEST_F(StaLibertyTest, R5_TimingArcSetEquiv) { +TEST_F(StaLibertyTest, TimingArcSetEquiv) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const auto &arc_sets = buf->timingArcSets(); @@ -7597,7 +7597,7 @@ TEST_F(StaLibertyTest, R5_TimingArcSetEquiv) { EXPECT_TRUE(TimingArcSet::equiv(arc_sets[0], arc_sets[0])); } -TEST_F(StaLibertyTest, R5_TimingArcSetLess) { +TEST_F(StaLibertyTest, TimingArcSetLess) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const auto &arc_sets = buf->timingArcSets(); @@ -7609,7 +7609,7 @@ TEST_F(StaLibertyTest, R5_TimingArcSetLess) { } // LibertyPort equiv and less -TEST_F(StaLibertyTest, R5_LibertyPortEquiv) { +TEST_F(StaLibertyTest, LibertyPortEquiv) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7620,7 +7620,7 @@ TEST_F(StaLibertyTest, R5_LibertyPortEquiv) { EXPECT_FALSE(LibertyPort::equiv(a, z)); } -TEST_F(StaLibertyTest, R5_LibertyPortLess) { +TEST_F(StaLibertyTest, LibertyPortLess) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7634,7 +7634,7 @@ TEST_F(StaLibertyTest, R5_LibertyPortLess) { } // LibertyPortNameLess comparator -TEST_F(StaLibertyTest, R5_LibertyPortNameLess) { +TEST_F(StaLibertyTest, LibertyPortNameLess) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7648,7 +7648,7 @@ TEST_F(StaLibertyTest, R5_LibertyPortNameLess) { } // LibertyCell bufferPorts -TEST_F(StaLibertyTest, R5_BufferPorts) { +TEST_F(StaLibertyTest, BufferPorts) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); ASSERT_TRUE(buf->isBuffer()); @@ -7660,7 +7660,7 @@ TEST_F(StaLibertyTest, R5_BufferPorts) { } // Cell port iterators -TEST_F(StaLibertyTest, R5_CellPortIterator) { +TEST_F(StaLibertyTest, CellPortIterator) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyCellPortIterator iter(buf); @@ -7673,7 +7673,7 @@ TEST_F(StaLibertyTest, R5_CellPortIterator) { EXPECT_GT(count, 0); } -TEST_F(StaLibertyTest, R5_CellPortBitIterator) { +TEST_F(StaLibertyTest, CellPortBitIterator) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyCellPortBitIterator iter(buf); @@ -7687,28 +7687,28 @@ TEST_F(StaLibertyTest, R5_CellPortBitIterator) { } // Library default pin resistances -TEST_F(StaLibertyTest, R5_LibraryDefaultIntrinsic) { +TEST_F(StaLibertyTest, LibraryDefaultIntrinsic) { float intrinsic; bool exists; lib_->defaultIntrinsic(RiseFall::rise(), intrinsic, exists); lib_->defaultIntrinsic(RiseFall::fall(), intrinsic, exists); } -TEST_F(StaLibertyTest, R5_LibraryDefaultOutputPinRes) { +TEST_F(StaLibertyTest, LibraryDefaultOutputPinRes) { float res; bool exists; lib_->defaultOutputPinRes(RiseFall::rise(), res, exists); lib_->defaultOutputPinRes(RiseFall::fall(), res, exists); } -TEST_F(StaLibertyTest, R5_LibraryDefaultBidirectPinRes) { +TEST_F(StaLibertyTest, LibraryDefaultBidirectPinRes) { float res; bool exists; lib_->defaultBidirectPinRes(RiseFall::rise(), res, exists); lib_->defaultBidirectPinRes(RiseFall::fall(), res, exists); } -TEST_F(StaLibertyTest, R5_LibraryDefaultPinResistance) { +TEST_F(StaLibertyTest, LibraryDefaultPinResistance) { float res; bool exists; lib_->defaultPinResistance(RiseFall::rise(), PortDirection::output(), @@ -7718,7 +7718,7 @@ TEST_F(StaLibertyTest, R5_LibraryDefaultPinResistance) { } // Test modeDef on cell -TEST_F(StaLibertyTest, R5_CellModeDef) { +TEST_F(StaLibertyTest, CellModeDef) { LibertyCell *dff = lib_->findLibertyCell("DFF_X1"); if (dff) { // Try to find a nonexistent mode def @@ -7727,7 +7727,7 @@ TEST_F(StaLibertyTest, R5_CellModeDef) { } // LibertyCell findTimingArcSet by index -TEST_F(StaLibertyTest, R5_CellFindTimingArcSetByIndex) { +TEST_F(StaLibertyTest, CellFindTimingArcSetByIndex2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const auto &arc_sets = buf->timingArcSets(); @@ -7738,7 +7738,7 @@ TEST_F(StaLibertyTest, R5_CellFindTimingArcSetByIndex) { } // LibertyCell hasTimingArcs -TEST_F(StaLibertyTest, R5_CellHasTimingArcs) { +TEST_F(StaLibertyTest, CellHasTimingArcs2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7747,25 +7747,25 @@ TEST_F(StaLibertyTest, R5_CellHasTimingArcs) { } // Library supply -TEST_F(StaLibertyTest, R5_LibrarySupplyExists) { +TEST_F(StaLibertyTest, LibrarySupplyExists) { // Try non-existent supply EXPECT_FALSE(lib_->supplyExists("NONEXISTENT_VDD")); } // Library findWireloadSelection -TEST_F(StaLibertyTest, R5_LibraryFindWireloadSelection) { +TEST_F(StaLibertyTest, LibraryFindWireloadSelection) { WireloadSelection *ws = lib_->findWireloadSelection("nonexistent_sel"); EXPECT_EQ(ws, nullptr); } // Library defaultWireloadSelection -TEST_F(StaLibertyTest, R5_LibraryDefaultWireloadSelection) { +TEST_F(StaLibertyTest, LibraryDefaultWireloadSelection) { WireloadSelection *ws = lib_->defaultWireloadSelection(); (void)ws; } // LibertyPort member iterator -TEST_F(StaLibertyTest, R5_PortMemberIterator) { +TEST_F(StaLibertyTest, PortMemberIterator) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7782,7 +7782,7 @@ TEST_F(StaLibertyTest, R5_PortMemberIterator) { } // LibertyPort relatedGroundPin / relatedPowerPin -TEST_F(StaLibertyTest, R5_PortRelatedPins) { +TEST_F(StaLibertyTest, PortRelatedPins2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *z = buf->findLibertyPort("Z"); @@ -7793,7 +7793,7 @@ TEST_F(StaLibertyTest, R5_PortRelatedPins) { } // LibertyPort receiverModel -TEST_F(StaLibertyTest, R5_PortReceiverModel) { +TEST_F(StaLibertyTest, PortReceiverModel2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -7804,7 +7804,7 @@ TEST_F(StaLibertyTest, R5_PortReceiverModel) { } // LibertyCell footprint -TEST_F(StaLibertyTest, R5_CellFootprint) { +TEST_F(StaLibertyTest, CellFootprint2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const char *fp = buf->footprint(); @@ -7812,21 +7812,21 @@ TEST_F(StaLibertyTest, R5_CellFootprint) { } // LibertyCell ocv methods -TEST_F(StaLibertyTest, R5_CellOcvArcDepth) { +TEST_F(StaLibertyTest, CellOcvArcDepth2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); float depth = buf->ocvArcDepth(); EXPECT_GE(depth, 0.0f); } -TEST_F(StaLibertyTest, R5_CellOcvDerate) { +TEST_F(StaLibertyTest, CellOcvDerate2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); OcvDerate *derate = buf->ocvDerate(); (void)derate; } -TEST_F(StaLibertyTest, R5_CellFindOcvDerate) { +TEST_F(StaLibertyTest, CellFindOcvDerate) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); OcvDerate *derate = buf->findOcvDerate("nonexistent"); @@ -7834,7 +7834,7 @@ TEST_F(StaLibertyTest, R5_CellFindOcvDerate) { } // LibertyCell scaleFactors -TEST_F(StaLibertyTest, R5_CellScaleFactors) { +TEST_F(StaLibertyTest, CellScaleFactors2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); ScaleFactors *sf = buf->scaleFactors(); @@ -7842,14 +7842,14 @@ TEST_F(StaLibertyTest, R5_CellScaleFactors) { } // LibertyCell testCell -TEST_F(StaLibertyTest, R5_CellTestCell) { +TEST_F(StaLibertyTest, CellTestCell) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_EQ(buf->testCell(), nullptr); } // LibertyCell sequentials -TEST_F(StaLibertyTest, R5_CellSequentials) { +TEST_F(StaLibertyTest, CellSequentials) { LibertyCell *dff = lib_->findLibertyCell("DFF_X1"); if (dff) { const auto &seqs = dff->sequentials(); @@ -7858,7 +7858,7 @@ TEST_F(StaLibertyTest, R5_CellSequentials) { } // LibertyCell leakagePowers -TEST_F(StaLibertyTest, R5_CellLeakagePowers) { +TEST_F(StaLibertyTest, CellLeakagePowers) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LeakagePowerSeq *lps = buf->leakagePowers(); @@ -7866,27 +7866,27 @@ TEST_F(StaLibertyTest, R5_CellLeakagePowers) { } // LibertyCell statetable -TEST_F(StaLibertyTest, R5_CellStatetable) { +TEST_F(StaLibertyTest, CellStatetable) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_EQ(buf->statetable(), nullptr); } // LibertyCell findBusDcl -TEST_F(StaLibertyTest, R5_CellFindBusDcl) { +TEST_F(StaLibertyTest, CellFindBusDcl) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_EQ(buf->findBusDcl("nonexistent"), nullptr); } // LibertyLibrary scaleFactor -TEST_F(StaLibertyTest, R5_LibraryScaleFactor) { +TEST_F(StaLibertyTest, LibraryScaleFactor) { float sf = lib_->scaleFactor(ScaleFactorType::cell, nullptr); EXPECT_FLOAT_EQ(sf, 1.0f); } // LibertyLibrary addSupplyVoltage / supplyVoltage -TEST_F(StaLibertyTest, R5_LibraryAddSupplyVoltage) { +TEST_F(StaLibertyTest, LibraryAddSupplyVoltage) { lib_->addSupplyVoltage("test_supply", 1.1f); float voltage; bool exists; @@ -7897,51 +7897,51 @@ TEST_F(StaLibertyTest, R5_LibraryAddSupplyVoltage) { } // LibertyLibrary BusDcl operations -TEST_F(StaLibertyTest, R5_LibraryBusDcls) { +TEST_F(StaLibertyTest, LibraryBusDcls2) { auto dcls = lib_->busDcls(); // Just exercise the function (void)dcls; } // LibertyLibrary findScaleFactors -TEST_F(StaLibertyTest, R5_LibraryFindScaleFactors) { +TEST_F(StaLibertyTest, LibraryFindScaleFactors) { ScaleFactors *sf = lib_->findScaleFactors("nonexistent"); EXPECT_EQ(sf, nullptr); } // LibertyLibrary scaleFactors -TEST_F(StaLibertyTest, R5_LibraryScaleFactors) { +TEST_F(StaLibertyTest, LibraryScaleFactors2) { ScaleFactors *sf = lib_->scaleFactors(); (void)sf; } // LibertyLibrary findTableTemplate -TEST_F(StaLibertyTest, R5_LibraryFindTableTemplate) { +TEST_F(StaLibertyTest, LibraryFindTableTemplate) { TableTemplate *tt = lib_->findTableTemplate("nonexistent", TableTemplateType::delay); EXPECT_EQ(tt, nullptr); } // LibertyLibrary defaultOcvDerate -TEST_F(StaLibertyTest, R5_LibraryDefaultOcvDerate) { +TEST_F(StaLibertyTest, LibraryDefaultOcvDerate) { OcvDerate *derate = lib_->defaultOcvDerate(); (void)derate; } // LibertyLibrary findOcvDerate -TEST_F(StaLibertyTest, R5_LibraryFindOcvDerate) { +TEST_F(StaLibertyTest, LibraryFindOcvDerate) { OcvDerate *derate = lib_->findOcvDerate("nonexistent"); EXPECT_EQ(derate, nullptr); } // LibertyLibrary findDriverWaveform -TEST_F(StaLibertyTest, R5_LibraryFindDriverWaveform) { +TEST_F(StaLibertyTest, LibraryFindDriverWaveform) { DriverWaveform *dw = lib_->findDriverWaveform("nonexistent"); EXPECT_EQ(dw, nullptr); } // LibertyLibrary driverWaveformDefault -TEST_F(StaLibertyTest, R5_LibraryDriverWaveformDefault) { +TEST_F(StaLibertyTest, LibraryDriverWaveformDefault) { DriverWaveform *dw = lib_->driverWaveformDefault(); (void)dw; } @@ -8131,13 +8131,13 @@ TEST(R6_WireloadSelectionTest, MultipleEntries) { // R6 tests: GateLinearModel / CheckLinearModel more coverage //////////////////////////////////////////////////////////////// -TEST_F(LinearModelTest, R6_GateLinearModelDriveResistance) { +TEST_F(LinearModelTest, GateLinearModelDriveResistance) { GateLinearModel model(cell_, 1.0f, 0.5f); float res = model.driveResistance(nullptr); EXPECT_FLOAT_EQ(res, 0.5f); } -TEST_F(LinearModelTest, R6_CheckLinearModelCheckDelay) { +TEST_F(LinearModelTest, CheckLinearModelCheckDelay2) { CheckLinearModel model(cell_, 2.0f); ArcDelay delay = model.checkDelay(nullptr, 0.0f, 0.0f, 0.0f, false); EXPECT_FLOAT_EQ(delayAsFloat(delay), 2.0f); @@ -8591,15 +8591,15 @@ TEST(R6_TestCellTest, CellIsInverter) { // R6 tests: StaLibertyTest - functions on real parsed library //////////////////////////////////////////////////////////////// -TEST_F(StaLibertyTest, R6_LibraryNominalValues) { +TEST_F(StaLibertyTest, LibraryNominalValues2) { EXPECT_GT(lib_->nominalVoltage(), 0.0f); } -TEST_F(StaLibertyTest, R6_LibraryDelayModel) { +TEST_F(StaLibertyTest, LibraryDelayModel) { EXPECT_EQ(lib_->delayModelType(), DelayModelType::table); } -TEST_F(StaLibertyTest, R6_FindCell) { +TEST_F(StaLibertyTest, FindCell) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); EXPECT_NE(inv, nullptr); if (inv) { @@ -8608,7 +8608,7 @@ TEST_F(StaLibertyTest, R6_FindCell) { } } -TEST_F(StaLibertyTest, R6_CellTimingArcSets) { +TEST_F(StaLibertyTest, CellTimingArcSets3) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); EXPECT_NE(inv, nullptr); if (inv) { @@ -8616,25 +8616,25 @@ TEST_F(StaLibertyTest, R6_CellTimingArcSets) { } } -TEST_F(StaLibertyTest, R6_LibrarySlewDerate) { +TEST_F(StaLibertyTest, LibrarySlewDerate2) { float derate = lib_->slewDerateFromLibrary(); EXPECT_GT(derate, 0.0f); } -TEST_F(StaLibertyTest, R6_LibraryInputThresholds) { +TEST_F(StaLibertyTest, LibraryInputThresholds) { float rise_thresh = lib_->inputThreshold(RiseFall::rise()); float fall_thresh = lib_->inputThreshold(RiseFall::fall()); EXPECT_GT(rise_thresh, 0.0f); EXPECT_GT(fall_thresh, 0.0f); } -TEST_F(StaLibertyTest, R6_LibrarySlewThresholds) { +TEST_F(StaLibertyTest, LibrarySlewThresholds2) { float lower_rise = lib_->slewLowerThreshold(RiseFall::rise()); float upper_rise = lib_->slewUpperThreshold(RiseFall::rise()); EXPECT_LT(lower_rise, upper_rise); } -TEST_F(StaLibertyTest, R6_CellPortIteration) { +TEST_F(StaLibertyTest, CellPortIteration) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); EXPECT_NE(inv, nullptr); if (inv) { @@ -8650,7 +8650,7 @@ TEST_F(StaLibertyTest, R6_CellPortIteration) { } } -TEST_F(StaLibertyTest, R6_PortCapacitance) { +TEST_F(StaLibertyTest, PortCapacitance2) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); EXPECT_NE(inv, nullptr); if (inv) { @@ -8663,7 +8663,7 @@ TEST_F(StaLibertyTest, R6_PortCapacitance) { } } -TEST_F(StaLibertyTest, R6_CellLeakagePower) { +TEST_F(StaLibertyTest, CellLeakagePower3) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); EXPECT_NE(inv, nullptr); if (inv) { @@ -8675,17 +8675,17 @@ TEST_F(StaLibertyTest, R6_CellLeakagePower) { } } -TEST_F(StaLibertyTest, R6_PatternMatchCells) { +TEST_F(StaLibertyTest, PatternMatchCells) { PatternMatch pattern("INV_*"); LibertyCellSeq matches = lib_->findLibertyCellsMatching(&pattern); EXPECT_GT(matches.size(), 0u); } -TEST_F(StaLibertyTest, R6_LibraryName) { +TEST_F(StaLibertyTest, LibraryName) { EXPECT_NE(lib_->name(), nullptr); } -TEST_F(StaLibertyTest, R6_LibraryFilename) { +TEST_F(StaLibertyTest, LibraryFilename) { EXPECT_NE(lib_->filename(), nullptr); } @@ -8695,7 +8695,7 @@ TEST_F(StaLibertyTest, R6_LibraryFilename) { // Covers LibertyStmt::LibertyStmt(int), LibertyStmt::isVariable(), // LibertyGroup::isGroup(), LibertyGroup::findAttr() -TEST(LibertyParserTest, R7_LibertyGroupConstruction) { +TEST(LibertyParserTest, LibertyGroupConstruction) { LibertyAttrValueSeq *params = new LibertyAttrValueSeq; LibertyStringAttrValue *val = new LibertyStringAttrValue("test_lib"); params->push_back(val); @@ -8712,7 +8712,7 @@ TEST(LibertyParserTest, R7_LibertyGroupConstruction) { // R7_LibertySimpleAttr removed (segfault) // Covers LibertyComplexAttr::isSimple() -TEST(LibertyParserTest, R7_LibertyComplexAttr) { +TEST(LibertyParserTest, LibertyComplexAttr) { LibertyAttrValueSeq *vals = new LibertyAttrValueSeq; vals->push_back(new LibertyFloatAttrValue(1.0f)); vals->push_back(new LibertyFloatAttrValue(2.0f)); @@ -8730,7 +8730,7 @@ TEST(LibertyParserTest, R7_LibertyComplexAttr) { // R7_LibertyFloatAttrValueStringValue removed (segfault) // Covers LibertyDefine::isDefine() -TEST(LibertyParserTest, R7_LibertyDefine) { +TEST(LibertyParserTest, LibertyDefine) { LibertyDefine def("my_define", LibertyGroupType::cell, LibertyAttrType::attr_string, 20); EXPECT_TRUE(def.isDefine()); @@ -8743,7 +8743,7 @@ TEST(LibertyParserTest, R7_LibertyDefine) { } // Covers LibertyVariable::isVariable() -TEST(LibertyParserTest, R7_LibertyVariable) { +TEST(LibertyParserTest, LibertyVariable) { LibertyVariable var("input_threshold_pct_rise", 50.0f, 15); EXPECT_TRUE(var.isVariable()); EXPECT_FALSE(var.isGroup()); @@ -8763,7 +8763,7 @@ TEST(LibertyParserTest, R7_LibertyVariable) { //////////////////////////////////////////////////////////////// // Covers LibertyBuilder::~LibertyBuilder() -TEST(LibertyBuilderTest, R7_LibertyBuilderDestructor) { +TEST(LibertyBuilderTest, LibertyBuilderDestructor) { LibertyBuilder *builder = new LibertyBuilder(); EXPECT_NE(builder, nullptr); delete builder; @@ -8776,7 +8776,7 @@ TEST(LibertyBuilderTest, R7_LibertyBuilderDestructor) { //////////////////////////////////////////////////////////////// // Covers WireloadForArea::WireloadForArea(float, float, const Wireload*) -TEST_F(StaLibertyTest, R7_WireloadSelectionFindWireload) { +TEST_F(StaLibertyTest, WireloadSelectionFindWireload) { // Create a WireloadSelection and add entries which // internally creates WireloadForArea objects WireloadSelection sel("test_sel"); @@ -8802,7 +8802,7 @@ TEST_F(StaLibertyTest, R7_WireloadSelectionFindWireload) { //////////////////////////////////////////////////////////////// // Covers LibertyPort::findLibertyMember(int) const -TEST_F(StaLibertyTest, R7_FindLibertyMember) { +TEST_F(StaLibertyTest, FindLibertyMember) { // Search for a bus port in the library LibertyCell *cell = nullptr; LibertyCellIterator cell_iter(lib_); @@ -8835,7 +8835,7 @@ TEST_F(StaLibertyTest, R7_FindLibertyMember) { // Covers LibertyCell::inferLatchRoles through readLiberty // (the library load already calls inferLatchRoles internally) -TEST_F(StaLibertyTest, R7_InferLatchRolesAlreadyCalled) { +TEST_F(StaLibertyTest, InferLatchRolesAlreadyCalled) { // Find a latch cell LibertyCell *cell = lib_->findLibertyCell("DFFR_X1"); if (cell) { @@ -8850,7 +8850,7 @@ TEST_F(StaLibertyTest, R7_InferLatchRolesAlreadyCalled) { // Covers TimingArc::setIndex, TimingArcSet::deleteTimingArc // Through iteration over arcs from library -TEST_F(StaLibertyTest, R7_TimingArcIteration) { +TEST_F(StaLibertyTest, TimingArcIteration) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); EXPECT_NE(inv, nullptr); if (inv) { @@ -8869,7 +8869,7 @@ TEST_F(StaLibertyTest, R7_TimingArcIteration) { // Covers LibertyPort::cornerPort (the DcalcAnalysisPt variant) // by accessing corner info -TEST_F(StaLibertyTest, R7_PortCornerPort) { +TEST_F(StaLibertyTest, PortCornerPort2) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); EXPECT_NE(inv, nullptr); if (inv) { @@ -8888,7 +8888,7 @@ TEST_F(StaLibertyTest, R7_PortCornerPort) { //////////////////////////////////////////////////////////////// // LibertyCell::dontUse -TEST_F(StaLibertyTest, R8_CellDontUse) { +TEST_F(StaLibertyTest, CellDontUse3) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); // Default dontUse should be false @@ -8896,7 +8896,7 @@ TEST_F(StaLibertyTest, R8_CellDontUse) { } // LibertyCell::setDontUse -TEST_F(StaLibertyTest, R8_CellSetDontUse) { +TEST_F(StaLibertyTest, CellSetDontUse2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); buf->setDontUse(true); @@ -8906,21 +8906,21 @@ TEST_F(StaLibertyTest, R8_CellSetDontUse) { } // LibertyCell::isBuffer for non-buffer cell -TEST_F(StaLibertyTest, R8_CellIsBufferNonBuffer) { +TEST_F(StaLibertyTest, CellIsBufferNonBuffer) { LibertyCell *and2 = lib_->findLibertyCell("AND2_X1"); ASSERT_NE(and2, nullptr); EXPECT_FALSE(and2->isBuffer()); } // LibertyCell::isInverter for non-inverter cell -TEST_F(StaLibertyTest, R8_CellIsInverterNonInverter) { +TEST_F(StaLibertyTest, CellIsInverterNonInverter) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isInverter()); } // LibertyCell::hasInternalPorts -TEST_F(StaLibertyTest, R8_CellHasInternalPorts) { +TEST_F(StaLibertyTest, CellHasInternalPorts3) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); // Simple buffer has no internal ports @@ -8928,14 +8928,14 @@ TEST_F(StaLibertyTest, R8_CellHasInternalPorts) { } // LibertyCell::isMacro -TEST_F(StaLibertyTest, R8_CellIsMacro) { +TEST_F(StaLibertyTest, CellIsMacro3) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isMacro()); } // LibertyCell::setIsMacro -TEST_F(StaLibertyTest, R8_CellSetIsMacro) { +TEST_F(StaLibertyTest, CellSetIsMacro2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); buf->setIsMacro(true); @@ -8945,14 +8945,14 @@ TEST_F(StaLibertyTest, R8_CellSetIsMacro) { } // LibertyCell::isMemory -TEST_F(StaLibertyTest, R8_CellIsMemory) { +TEST_F(StaLibertyTest, CellIsMemory3) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isMemory()); } // LibertyCell::setIsMemory -TEST_F(StaLibertyTest, R8_CellSetIsMemory) { +TEST_F(StaLibertyTest, CellSetIsMemory) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); buf->setIsMemory(true); @@ -8961,14 +8961,14 @@ TEST_F(StaLibertyTest, R8_CellSetIsMemory) { } // LibertyCell::isPad -TEST_F(StaLibertyTest, R8_CellIsPad) { +TEST_F(StaLibertyTest, CellIsPad2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isPad()); } // LibertyCell::setIsPad -TEST_F(StaLibertyTest, R8_CellSetIsPad) { +TEST_F(StaLibertyTest, CellSetIsPad) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); buf->setIsPad(true); @@ -8977,14 +8977,14 @@ TEST_F(StaLibertyTest, R8_CellSetIsPad) { } // LibertyCell::isClockCell -TEST_F(StaLibertyTest, R8_CellIsClockCell) { +TEST_F(StaLibertyTest, CellIsClockCell2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isClockCell()); } // LibertyCell::setIsClockCell -TEST_F(StaLibertyTest, R8_CellSetIsClockCell) { +TEST_F(StaLibertyTest, CellSetIsClockCell) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); buf->setIsClockCell(true); @@ -8993,14 +8993,14 @@ TEST_F(StaLibertyTest, R8_CellSetIsClockCell) { } // LibertyCell::isLevelShifter -TEST_F(StaLibertyTest, R8_CellIsLevelShifter) { +TEST_F(StaLibertyTest, CellIsLevelShifter2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isLevelShifter()); } // LibertyCell::setIsLevelShifter -TEST_F(StaLibertyTest, R8_CellSetIsLevelShifter) { +TEST_F(StaLibertyTest, CellSetIsLevelShifter) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); buf->setIsLevelShifter(true); @@ -9009,14 +9009,14 @@ TEST_F(StaLibertyTest, R8_CellSetIsLevelShifter) { } // LibertyCell::isIsolationCell -TEST_F(StaLibertyTest, R8_CellIsIsolationCell) { +TEST_F(StaLibertyTest, CellIsIsolationCell2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isIsolationCell()); } // LibertyCell::setIsIsolationCell -TEST_F(StaLibertyTest, R8_CellSetIsIsolationCell) { +TEST_F(StaLibertyTest, CellSetIsIsolationCell) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); buf->setIsIsolationCell(true); @@ -9025,14 +9025,14 @@ TEST_F(StaLibertyTest, R8_CellSetIsIsolationCell) { } // LibertyCell::alwaysOn -TEST_F(StaLibertyTest, R8_CellAlwaysOn) { +TEST_F(StaLibertyTest, CellAlwaysOn2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->alwaysOn()); } // LibertyCell::setAlwaysOn -TEST_F(StaLibertyTest, R8_CellSetAlwaysOn) { +TEST_F(StaLibertyTest, CellSetAlwaysOn) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); buf->setAlwaysOn(true); @@ -9041,14 +9041,14 @@ TEST_F(StaLibertyTest, R8_CellSetAlwaysOn) { } // LibertyCell::interfaceTiming -TEST_F(StaLibertyTest, R8_CellInterfaceTiming) { +TEST_F(StaLibertyTest, CellInterfaceTiming2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->interfaceTiming()); } // LibertyCell::setInterfaceTiming -TEST_F(StaLibertyTest, R8_CellSetInterfaceTiming) { +TEST_F(StaLibertyTest, CellSetInterfaceTiming) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); buf->setInterfaceTiming(true); @@ -9057,7 +9057,7 @@ TEST_F(StaLibertyTest, R8_CellSetInterfaceTiming) { } // LibertyCell::isClockGate and related -TEST_F(StaLibertyTest, R8_CellIsClockGate) { +TEST_F(StaLibertyTest, CellIsClockGate3) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isClockGate()); @@ -9067,7 +9067,7 @@ TEST_F(StaLibertyTest, R8_CellIsClockGate) { } // LibertyCell::setClockGateType -TEST_F(StaLibertyTest, R8_CellSetClockGateType) { +TEST_F(StaLibertyTest, CellSetClockGateType) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); buf->setClockGateType(ClockGateType::latch_posedge); @@ -9082,7 +9082,7 @@ TEST_F(StaLibertyTest, R8_CellSetClockGateType) { } // LibertyCell::isDisabledConstraint -TEST_F(StaLibertyTest, R8_CellIsDisabledConstraint) { +TEST_F(StaLibertyTest, CellIsDisabledConstraint2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->isDisabledConstraint()); @@ -9092,21 +9092,21 @@ TEST_F(StaLibertyTest, R8_CellIsDisabledConstraint) { } // LibertyCell::hasSequentials -TEST_F(StaLibertyTest, R8_CellHasSequentialsBuf) { +TEST_F(StaLibertyTest, CellHasSequentialsBuf) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_FALSE(buf->hasSequentials()); } // LibertyCell::hasSequentials on DFF -TEST_F(StaLibertyTest, R8_CellHasSequentialsDFF) { +TEST_F(StaLibertyTest, CellHasSequentialsDFF) { LibertyCell *dff = lib_->findLibertyCell("DFF_X1"); ASSERT_NE(dff, nullptr); EXPECT_TRUE(dff->hasSequentials()); } // LibertyCell::sequentials -TEST_F(StaLibertyTest, R8_CellSequentialsDFF) { +TEST_F(StaLibertyTest, CellSequentialsDFF) { LibertyCell *dff = lib_->findLibertyCell("DFF_X1"); ASSERT_NE(dff, nullptr); auto &seqs = dff->sequentials(); @@ -9114,7 +9114,7 @@ TEST_F(StaLibertyTest, R8_CellSequentialsDFF) { } // LibertyCell::leakagePower -TEST_F(StaLibertyTest, R8_CellLeakagePower) { +TEST_F(StaLibertyTest, CellLeakagePower4) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); float leakage; @@ -9126,7 +9126,7 @@ TEST_F(StaLibertyTest, R8_CellLeakagePower) { } // LibertyCell::leakagePowers -TEST_F(StaLibertyTest, R8_CellLeakagePowers) { +TEST_F(StaLibertyTest, CellLeakagePowers2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LeakagePowerSeq *leaks = buf->leakagePowers(); @@ -9134,7 +9134,7 @@ TEST_F(StaLibertyTest, R8_CellLeakagePowers) { } // LibertyCell::internalPowers -TEST_F(StaLibertyTest, R8_CellInternalPowers) { +TEST_F(StaLibertyTest, CellInternalPowers3) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); auto &powers = buf->internalPowers(); @@ -9143,7 +9143,7 @@ TEST_F(StaLibertyTest, R8_CellInternalPowers) { } // LibertyCell::ocvArcDepth (from cell, not library) -TEST_F(StaLibertyTest, R8_CellOcvArcDepth) { +TEST_F(StaLibertyTest, CellOcvArcDepth3) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); float depth = buf->ocvArcDepth(); @@ -9152,7 +9152,7 @@ TEST_F(StaLibertyTest, R8_CellOcvArcDepth) { } // LibertyCell::setOcvArcDepth -TEST_F(StaLibertyTest, R8_CellSetOcvArcDepth) { +TEST_F(StaLibertyTest, CellSetOcvArcDepth2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); buf->setOcvArcDepth(3.0f); @@ -9160,7 +9160,7 @@ TEST_F(StaLibertyTest, R8_CellSetOcvArcDepth) { } // LibertyCell::ocvDerate -TEST_F(StaLibertyTest, R8_CellOcvDerate) { +TEST_F(StaLibertyTest, CellOcvDerate3) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); OcvDerate *derate = buf->ocvDerate(); @@ -9169,7 +9169,7 @@ TEST_F(StaLibertyTest, R8_CellOcvDerate) { } // LibertyCell::footprint -TEST_F(StaLibertyTest, R8_CellFootprint) { +TEST_F(StaLibertyTest, CellFootprint3) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const char *fp = buf->footprint(); @@ -9178,7 +9178,7 @@ TEST_F(StaLibertyTest, R8_CellFootprint) { } // LibertyCell::setFootprint -TEST_F(StaLibertyTest, R8_CellSetFootprint) { +TEST_F(StaLibertyTest, CellSetFootprint) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); buf->setFootprint("test_footprint"); @@ -9186,7 +9186,7 @@ TEST_F(StaLibertyTest, R8_CellSetFootprint) { } // LibertyCell::userFunctionClass -TEST_F(StaLibertyTest, R8_CellUserFunctionClass) { +TEST_F(StaLibertyTest, CellUserFunctionClass2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const char *ufc = buf->userFunctionClass(); @@ -9194,7 +9194,7 @@ TEST_F(StaLibertyTest, R8_CellUserFunctionClass) { } // LibertyCell::setUserFunctionClass -TEST_F(StaLibertyTest, R8_CellSetUserFunctionClass) { +TEST_F(StaLibertyTest, CellSetUserFunctionClass) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); buf->setUserFunctionClass("my_class"); @@ -9202,7 +9202,7 @@ TEST_F(StaLibertyTest, R8_CellSetUserFunctionClass) { } // LibertyCell::setSwitchCellType -TEST_F(StaLibertyTest, R8_CellSwitchCellType) { +TEST_F(StaLibertyTest, CellSwitchCellType) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); buf->setSwitchCellType(SwitchCellType::coarse_grain); @@ -9212,7 +9212,7 @@ TEST_F(StaLibertyTest, R8_CellSwitchCellType) { } // LibertyCell::setLevelShifterType -TEST_F(StaLibertyTest, R8_CellLevelShifterType) { +TEST_F(StaLibertyTest, CellLevelShifterType) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); buf->setLevelShifterType(LevelShifterType::HL); @@ -9224,7 +9224,7 @@ TEST_F(StaLibertyTest, R8_CellLevelShifterType) { } // LibertyCell::cornerCell -TEST_F(StaLibertyTest, R8_CellCornerCell) { +TEST_F(StaLibertyTest, CellCornerCell2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyCell *corner = buf->cornerCell(0); @@ -9233,7 +9233,7 @@ TEST_F(StaLibertyTest, R8_CellCornerCell) { } // LibertyCell::scaleFactors -TEST_F(StaLibertyTest, R8_CellScaleFactors) { +TEST_F(StaLibertyTest, CellScaleFactors3) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); ScaleFactors *sf = buf->scaleFactors(); @@ -9242,7 +9242,7 @@ TEST_F(StaLibertyTest, R8_CellScaleFactors) { } // LibertyLibrary::delayModelType -TEST_F(StaLibertyTest, R8_LibDelayModelType) { +TEST_F(StaLibertyTest, LibDelayModelType) { ASSERT_NE(lib_, nullptr); DelayModelType dmt = lib_->delayModelType(); // table is the most common @@ -9250,7 +9250,7 @@ TEST_F(StaLibertyTest, R8_LibDelayModelType) { } // LibertyLibrary::nominalProcess, nominalVoltage, nominalTemperature -TEST_F(StaLibertyTest, R8_LibNominalPVT) { +TEST_F(StaLibertyTest, LibNominalPVT) { ASSERT_NE(lib_, nullptr); float proc = lib_->nominalProcess(); float volt = lib_->nominalVoltage(); @@ -9262,7 +9262,7 @@ TEST_F(StaLibertyTest, R8_LibNominalPVT) { } // LibertyLibrary::setNominalProcess/Voltage/Temperature -TEST_F(StaLibertyTest, R8_LibSetNominalPVT) { +TEST_F(StaLibertyTest, LibSetNominalPVT) { ASSERT_NE(lib_, nullptr); lib_->setNominalProcess(1.5f); EXPECT_FLOAT_EQ(lib_->nominalProcess(), 1.5f); @@ -9273,7 +9273,7 @@ TEST_F(StaLibertyTest, R8_LibSetNominalPVT) { } // LibertyLibrary::defaultInputPinCap and setDefaultInputPinCap -TEST_F(StaLibertyTest, R8_LibDefaultInputPinCap) { +TEST_F(StaLibertyTest, LibDefaultInputPinCap) { ASSERT_NE(lib_, nullptr); float orig_cap = lib_->defaultInputPinCap(); lib_->setDefaultInputPinCap(0.5f); @@ -9282,7 +9282,7 @@ TEST_F(StaLibertyTest, R8_LibDefaultInputPinCap) { } // LibertyLibrary::defaultOutputPinCap and setDefaultOutputPinCap -TEST_F(StaLibertyTest, R8_LibDefaultOutputPinCap) { +TEST_F(StaLibertyTest, LibDefaultOutputPinCap) { ASSERT_NE(lib_, nullptr); float orig_cap = lib_->defaultOutputPinCap(); lib_->setDefaultOutputPinCap(0.3f); @@ -9291,14 +9291,14 @@ TEST_F(StaLibertyTest, R8_LibDefaultOutputPinCap) { } // LibertyLibrary::defaultBidirectPinCap -TEST_F(StaLibertyTest, R8_LibDefaultBidirectPinCap) { +TEST_F(StaLibertyTest, LibDefaultBidirectPinCap) { ASSERT_NE(lib_, nullptr); lib_->setDefaultBidirectPinCap(0.2f); EXPECT_FLOAT_EQ(lib_->defaultBidirectPinCap(), 0.2f); } // LibertyLibrary::defaultIntrinsic -TEST_F(StaLibertyTest, R8_LibDefaultIntrinsic) { +TEST_F(StaLibertyTest, LibDefaultIntrinsic) { ASSERT_NE(lib_, nullptr); lib_->setDefaultIntrinsic(RiseFall::rise(), 0.1f); float val; @@ -9309,7 +9309,7 @@ TEST_F(StaLibertyTest, R8_LibDefaultIntrinsic) { } // LibertyLibrary::defaultOutputPinRes -TEST_F(StaLibertyTest, R8_LibDefaultOutputPinRes) { +TEST_F(StaLibertyTest, LibDefaultOutputPinRes) { ASSERT_NE(lib_, nullptr); lib_->setDefaultOutputPinRes(RiseFall::rise(), 10.0f); float res; @@ -9320,7 +9320,7 @@ TEST_F(StaLibertyTest, R8_LibDefaultOutputPinRes) { } // LibertyLibrary::defaultBidirectPinRes -TEST_F(StaLibertyTest, R8_LibDefaultBidirectPinRes) { +TEST_F(StaLibertyTest, LibDefaultBidirectPinRes) { ASSERT_NE(lib_, nullptr); lib_->setDefaultBidirectPinRes(RiseFall::fall(), 5.0f); float res; @@ -9331,7 +9331,7 @@ TEST_F(StaLibertyTest, R8_LibDefaultBidirectPinRes) { } // LibertyLibrary::defaultPinResistance -TEST_F(StaLibertyTest, R8_LibDefaultPinResistance) { +TEST_F(StaLibertyTest, LibDefaultPinResistance) { ASSERT_NE(lib_, nullptr); lib_->setDefaultOutputPinRes(RiseFall::rise(), 12.0f); float res; @@ -9342,7 +9342,7 @@ TEST_F(StaLibertyTest, R8_LibDefaultPinResistance) { } // LibertyLibrary::defaultMaxSlew -TEST_F(StaLibertyTest, R8_LibDefaultMaxSlew) { +TEST_F(StaLibertyTest, LibDefaultMaxSlew) { ASSERT_NE(lib_, nullptr); lib_->setDefaultMaxSlew(1.0f); float slew; @@ -9353,7 +9353,7 @@ TEST_F(StaLibertyTest, R8_LibDefaultMaxSlew) { } // LibertyLibrary::defaultMaxCapacitance -TEST_F(StaLibertyTest, R8_LibDefaultMaxCapacitance) { +TEST_F(StaLibertyTest, LibDefaultMaxCapacitance) { ASSERT_NE(lib_, nullptr); lib_->setDefaultMaxCapacitance(2.0f); float cap; @@ -9364,7 +9364,7 @@ TEST_F(StaLibertyTest, R8_LibDefaultMaxCapacitance) { } // LibertyLibrary::defaultMaxFanout -TEST_F(StaLibertyTest, R8_LibDefaultMaxFanout) { +TEST_F(StaLibertyTest, LibDefaultMaxFanout) { ASSERT_NE(lib_, nullptr); lib_->setDefaultMaxFanout(8.0f); float fanout; @@ -9375,7 +9375,7 @@ TEST_F(StaLibertyTest, R8_LibDefaultMaxFanout) { } // LibertyLibrary::defaultFanoutLoad -TEST_F(StaLibertyTest, R8_LibDefaultFanoutLoad) { +TEST_F(StaLibertyTest, LibDefaultFanoutLoad) { ASSERT_NE(lib_, nullptr); lib_->setDefaultFanoutLoad(1.5f); float load; @@ -9386,7 +9386,7 @@ TEST_F(StaLibertyTest, R8_LibDefaultFanoutLoad) { } // LibertyLibrary thresholds -TEST_F(StaLibertyTest, R8_LibThresholds) { +TEST_F(StaLibertyTest, LibThresholds) { ASSERT_NE(lib_, nullptr); lib_->setInputThreshold(RiseFall::rise(), 0.6f); EXPECT_FLOAT_EQ(lib_->inputThreshold(RiseFall::rise()), 0.6f); @@ -9402,7 +9402,7 @@ TEST_F(StaLibertyTest, R8_LibThresholds) { } // LibertyLibrary::slewDerateFromLibrary -TEST_F(StaLibertyTest, R8_LibSlewDerate) { +TEST_F(StaLibertyTest, LibSlewDerate) { ASSERT_NE(lib_, nullptr); float orig = lib_->slewDerateFromLibrary(); lib_->setSlewDerateFromLibrary(0.5f); @@ -9411,7 +9411,7 @@ TEST_F(StaLibertyTest, R8_LibSlewDerate) { } // LibertyLibrary::defaultWireloadMode -TEST_F(StaLibertyTest, R8_LibDefaultWireloadMode) { +TEST_F(StaLibertyTest, LibDefaultWireloadMode) { ASSERT_NE(lib_, nullptr); lib_->setDefaultWireloadMode(WireloadMode::enclosed); EXPECT_EQ(lib_->defaultWireloadMode(), WireloadMode::enclosed); @@ -9420,21 +9420,21 @@ TEST_F(StaLibertyTest, R8_LibDefaultWireloadMode) { } // LibertyLibrary::ocvArcDepth -TEST_F(StaLibertyTest, R8_LibOcvArcDepth) { +TEST_F(StaLibertyTest, LibOcvArcDepth) { ASSERT_NE(lib_, nullptr); lib_->setOcvArcDepth(2.0f); EXPECT_FLOAT_EQ(lib_->ocvArcDepth(), 2.0f); } // LibertyLibrary::defaultOcvDerate -TEST_F(StaLibertyTest, R8_LibDefaultOcvDerate) { +TEST_F(StaLibertyTest, LibDefaultOcvDerate) { ASSERT_NE(lib_, nullptr); OcvDerate *orig = lib_->defaultOcvDerate(); (void)orig; } // LibertyLibrary::supplyVoltage -TEST_F(StaLibertyTest, R8_LibSupplyVoltage) { +TEST_F(StaLibertyTest, LibSupplyVoltage) { ASSERT_NE(lib_, nullptr); lib_->addSupplyVoltage("VDD", 1.1f); EXPECT_TRUE(lib_->supplyExists("VDD")); @@ -9447,7 +9447,7 @@ TEST_F(StaLibertyTest, R8_LibSupplyVoltage) { } // LibertyLibrary::buffers and inverters lists -TEST_F(StaLibertyTest, R8_LibBuffersInverters) { +TEST_F(StaLibertyTest, LibBuffersInverters) { ASSERT_NE(lib_, nullptr); LibertyCellSeq *bufs = lib_->buffers(); EXPECT_NE(bufs, nullptr); @@ -9458,20 +9458,20 @@ TEST_F(StaLibertyTest, R8_LibBuffersInverters) { } // LibertyLibrary::findOcvDerate (non-existent) -TEST_F(StaLibertyTest, R8_LibFindOcvDerateNonExistent) { +TEST_F(StaLibertyTest, LibFindOcvDerateNonExistent) { ASSERT_NE(lib_, nullptr); EXPECT_EQ(lib_->findOcvDerate("nonexistent_derate"), nullptr); } // LibertyCell::findOcvDerate (non-existent) -TEST_F(StaLibertyTest, R8_CellFindOcvDerateNonExistent) { +TEST_F(StaLibertyTest, CellFindOcvDerateNonExistent) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); EXPECT_EQ(buf->findOcvDerate("nonexistent"), nullptr); } // LibertyCell::setOcvDerate -TEST_F(StaLibertyTest, R8_CellSetOcvDerateNull) { +TEST_F(StaLibertyTest, CellSetOcvDerateNull) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); buf->setOcvDerate(nullptr); @@ -9479,7 +9479,7 @@ TEST_F(StaLibertyTest, R8_CellSetOcvDerateNull) { } // OperatingConditions construction -TEST_F(StaLibertyTest, R8_OperatingConditionsConstruct) { +TEST_F(StaLibertyTest, OperatingConditionsConstruct) { OperatingConditions oc("typical", 1.0f, 1.1f, 25.0f, WireloadTree::balanced); EXPECT_STREQ(oc.name(), "typical"); EXPECT_FLOAT_EQ(oc.process(), 1.0f); @@ -9489,7 +9489,7 @@ TEST_F(StaLibertyTest, R8_OperatingConditionsConstruct) { } // OperatingConditions::setWireloadTree -TEST_F(StaLibertyTest, R8_OperatingConditionsSetWireloadTree) { +TEST_F(StaLibertyTest, OperatingConditionsSetWireloadTree) { OperatingConditions oc("test"); oc.setWireloadTree(WireloadTree::worst_case); EXPECT_EQ(oc.wireloadTree(), WireloadTree::worst_case); @@ -9498,7 +9498,7 @@ TEST_F(StaLibertyTest, R8_OperatingConditionsSetWireloadTree) { } // Pvt class -TEST_F(StaLibertyTest, R8_PvtConstruct) { +TEST_F(StaLibertyTest, PvtConstruct) { Pvt pvt(1.0f, 1.1f, 25.0f); EXPECT_FLOAT_EQ(pvt.process(), 1.0f); EXPECT_FLOAT_EQ(pvt.voltage(), 1.1f); @@ -9506,7 +9506,7 @@ TEST_F(StaLibertyTest, R8_PvtConstruct) { } // Pvt setters -TEST_F(StaLibertyTest, R8_PvtSetters) { +TEST_F(StaLibertyTest, PvtSetters) { Pvt pvt(1.0f, 1.1f, 25.0f); pvt.setProcess(2.0f); EXPECT_FLOAT_EQ(pvt.process(), 2.0f); @@ -9517,13 +9517,13 @@ TEST_F(StaLibertyTest, R8_PvtSetters) { } // ScaleFactors -TEST_F(StaLibertyTest, R8_ScaleFactorsConstruct) { +TEST_F(StaLibertyTest, ScaleFactorsConstruct) { ScaleFactors sf("test_sf"); EXPECT_STREQ(sf.name(), "test_sf"); } // ScaleFactors::setScale and scale -TEST_F(StaLibertyTest, R8_ScaleFactorsSetGet) { +TEST_F(StaLibertyTest, ScaleFactorsSetGet) { ScaleFactors sf("test_sf"); sf.setScale(ScaleFactorType::cell, ScaleFactorPvt::process, RiseFall::rise(), 1.5f); @@ -9533,7 +9533,7 @@ TEST_F(StaLibertyTest, R8_ScaleFactorsSetGet) { } // ScaleFactors::setScale without rf and scale without rf -TEST_F(StaLibertyTest, R8_ScaleFactorsSetGetNoRF) { +TEST_F(StaLibertyTest, ScaleFactorsSetGetNoRF) { ScaleFactors sf("test_sf2"); sf.setScale(ScaleFactorType::cell, ScaleFactorPvt::volt, 2.0f); float val = sf.scale(ScaleFactorType::cell, ScaleFactorPvt::volt); @@ -9541,7 +9541,7 @@ TEST_F(StaLibertyTest, R8_ScaleFactorsSetGetNoRF) { } // LibertyLibrary::addScaleFactors and findScaleFactors -TEST_F(StaLibertyTest, R8_LibAddFindScaleFactors) { +TEST_F(StaLibertyTest, LibAddFindScaleFactors) { ASSERT_NE(lib_, nullptr); ScaleFactors *sf = new ScaleFactors("custom_sf"); sf->setScale(ScaleFactorType::cell, ScaleFactorPvt::process, @@ -9552,7 +9552,7 @@ TEST_F(StaLibertyTest, R8_LibAddFindScaleFactors) { } // LibertyLibrary::findOperatingConditions -TEST_F(StaLibertyTest, R8_LibFindOperatingConditions) { +TEST_F(StaLibertyTest, LibFindOperatingConditions) { ASSERT_NE(lib_, nullptr); OperatingConditions *oc = new OperatingConditions("fast", 0.5f, 1.32f, -40.0f, WireloadTree::best_case); lib_->addOperatingConditions(oc); @@ -9562,7 +9562,7 @@ TEST_F(StaLibertyTest, R8_LibFindOperatingConditions) { } // LibertyLibrary::setDefaultOperatingConditions -TEST_F(StaLibertyTest, R8_LibSetDefaultOperatingConditions) { +TEST_F(StaLibertyTest, LibSetDefaultOperatingConditions) { ASSERT_NE(lib_, nullptr); OperatingConditions *oc = new OperatingConditions("default_oc"); lib_->addOperatingConditions(oc); @@ -9571,7 +9571,7 @@ TEST_F(StaLibertyTest, R8_LibSetDefaultOperatingConditions) { } // FuncExpr make/access -TEST_F(StaLibertyTest, R8_FuncExprMakePort) { +TEST_F(StaLibertyTest, FuncExprMakePort) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); ASSERT_NE(inv, nullptr); LibertyPort *a = inv->findLibertyPort("A"); @@ -9586,7 +9586,7 @@ TEST_F(StaLibertyTest, R8_FuncExprMakePort) { } // FuncExpr::makeNot -TEST_F(StaLibertyTest, R8_FuncExprMakeNot) { +TEST_F(StaLibertyTest, FuncExprMakeNot) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); ASSERT_NE(inv, nullptr); LibertyPort *a = inv->findLibertyPort("A"); @@ -9602,7 +9602,7 @@ TEST_F(StaLibertyTest, R8_FuncExprMakeNot) { } // FuncExpr::makeAnd -TEST_F(StaLibertyTest, R8_FuncExprMakeAnd) { +TEST_F(StaLibertyTest, FuncExprMakeAnd) { LibertyCell *and2 = lib_->findLibertyCell("AND2_X1"); ASSERT_NE(and2, nullptr); LibertyPort *a1 = and2->findLibertyPort("A1"); @@ -9619,7 +9619,7 @@ TEST_F(StaLibertyTest, R8_FuncExprMakeAnd) { } // FuncExpr::makeOr -TEST_F(StaLibertyTest, R8_FuncExprMakeOr) { +TEST_F(StaLibertyTest, FuncExprMakeOr) { LibertyCell *or2 = lib_->findLibertyCell("OR2_X1"); ASSERT_NE(or2, nullptr); LibertyPort *a1 = or2->findLibertyPort("A1"); @@ -9634,7 +9634,7 @@ TEST_F(StaLibertyTest, R8_FuncExprMakeOr) { } // FuncExpr::makeXor -TEST_F(StaLibertyTest, R8_FuncExprMakeXor) { +TEST_F(StaLibertyTest, FuncExprMakeXor) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); ASSERT_NE(inv, nullptr); LibertyPort *a = inv->findLibertyPort("A"); @@ -9647,7 +9647,7 @@ TEST_F(StaLibertyTest, R8_FuncExprMakeXor) { } // FuncExpr::makeZero and makeOne -TEST_F(StaLibertyTest, R8_FuncExprMakeZeroOne) { +TEST_F(StaLibertyTest, FuncExprMakeZeroOne) { FuncExpr *zero = FuncExpr::makeZero(); EXPECT_NE(zero, nullptr); EXPECT_EQ(zero->op(), FuncExpr::op_zero); @@ -9660,7 +9660,7 @@ TEST_F(StaLibertyTest, R8_FuncExprMakeZeroOne) { } // FuncExpr::equiv -TEST_F(StaLibertyTest, R8_FuncExprEquiv) { +TEST_F(StaLibertyTest, FuncExprEquiv) { FuncExpr *zero1 = FuncExpr::makeZero(); FuncExpr *zero2 = FuncExpr::makeZero(); EXPECT_TRUE(FuncExpr::equiv(zero1, zero2)); @@ -9672,7 +9672,7 @@ TEST_F(StaLibertyTest, R8_FuncExprEquiv) { } // FuncExpr::hasPort -TEST_F(StaLibertyTest, R8_FuncExprHasPort) { +TEST_F(StaLibertyTest, FuncExprHasPort) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); ASSERT_NE(inv, nullptr); LibertyPort *a = inv->findLibertyPort("A"); @@ -9686,7 +9686,7 @@ TEST_F(StaLibertyTest, R8_FuncExprHasPort) { } // FuncExpr::portTimingSense -TEST_F(StaLibertyTest, R8_FuncExprPortTimingSense) { +TEST_F(StaLibertyTest, FuncExprPortTimingSense) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); ASSERT_NE(inv, nullptr); LibertyPort *a = inv->findLibertyPort("A"); @@ -9698,7 +9698,7 @@ TEST_F(StaLibertyTest, R8_FuncExprPortTimingSense) { } // FuncExpr::copy -TEST_F(StaLibertyTest, R8_FuncExprCopy) { +TEST_F(StaLibertyTest, FuncExprCopy) { FuncExpr *one = FuncExpr::makeOne(); FuncExpr *copy = one->copy(); EXPECT_NE(copy, nullptr); @@ -9708,7 +9708,7 @@ TEST_F(StaLibertyTest, R8_FuncExprCopy) { } // LibertyPort properties -TEST_F(StaLibertyTest, R8_PortProperties) { +TEST_F(StaLibertyTest, PortProperties) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); ASSERT_NE(inv, nullptr); LibertyPort *a = inv->findLibertyPort("A"); @@ -9721,7 +9721,7 @@ TEST_F(StaLibertyTest, R8_PortProperties) { } // LibertyPort::function -TEST_F(StaLibertyTest, R8_PortFunction) { +TEST_F(StaLibertyTest, PortFunction3) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); ASSERT_NE(inv, nullptr); LibertyPort *zn = inv->findLibertyPort("ZN"); @@ -9731,7 +9731,7 @@ TEST_F(StaLibertyTest, R8_PortFunction) { } // LibertyPort::driveResistance -TEST_F(StaLibertyTest, R8_PortDriveResistance) { +TEST_F(StaLibertyTest, PortDriveResistance2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *z = buf->findLibertyPort("Z"); @@ -9741,7 +9741,7 @@ TEST_F(StaLibertyTest, R8_PortDriveResistance) { } // LibertyPort::capacitance with min/max -TEST_F(StaLibertyTest, R8_PortCapacitanceMinMax) { +TEST_F(StaLibertyTest, PortCapacitanceMinMax2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -9753,7 +9753,7 @@ TEST_F(StaLibertyTest, R8_PortCapacitanceMinMax) { } // LibertyPort::capacitance with rf and min/max -TEST_F(StaLibertyTest, R8_PortCapacitanceRfMinMax) { +TEST_F(StaLibertyTest, PortCapacitanceRfMinMax2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -9763,7 +9763,7 @@ TEST_F(StaLibertyTest, R8_PortCapacitanceRfMinMax) { } // LibertyPort::slewLimit -TEST_F(StaLibertyTest, R8_PortSlewLimit) { +TEST_F(StaLibertyTest, PortSlewLimit2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *z = buf->findLibertyPort("Z"); @@ -9777,7 +9777,7 @@ TEST_F(StaLibertyTest, R8_PortSlewLimit) { } // LibertyPort::capacitanceLimit -TEST_F(StaLibertyTest, R8_PortCapacitanceLimit) { +TEST_F(StaLibertyTest, PortCapacitanceLimit2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *z = buf->findLibertyPort("Z"); @@ -9790,7 +9790,7 @@ TEST_F(StaLibertyTest, R8_PortCapacitanceLimit) { } // LibertyPort::fanoutLoad -TEST_F(StaLibertyTest, R8_PortFanoutLoad) { +TEST_F(StaLibertyTest, PortFanoutLoad2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -9803,7 +9803,7 @@ TEST_F(StaLibertyTest, R8_PortFanoutLoad) { } // LibertyPort::isClock -TEST_F(StaLibertyTest, R8_PortIsClock) { +TEST_F(StaLibertyTest, PortIsClock2) { LibertyCell *dff = lib_->findLibertyCell("DFF_X1"); ASSERT_NE(dff, nullptr); LibertyPort *ck = dff->findLibertyPort("CK"); @@ -9815,7 +9815,7 @@ TEST_F(StaLibertyTest, R8_PortIsClock) { } // LibertyPort::setIsClock -TEST_F(StaLibertyTest, R8_PortSetIsClock) { +TEST_F(StaLibertyTest, PortSetIsClock) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -9826,7 +9826,7 @@ TEST_F(StaLibertyTest, R8_PortSetIsClock) { } // LibertyPort::isRegClk -TEST_F(StaLibertyTest, R8_PortIsRegClk) { +TEST_F(StaLibertyTest, PortIsRegClk2) { LibertyCell *dff = lib_->findLibertyCell("DFF_X1"); ASSERT_NE(dff, nullptr); LibertyPort *ck = dff->findLibertyPort("CK"); @@ -9835,7 +9835,7 @@ TEST_F(StaLibertyTest, R8_PortIsRegClk) { } // LibertyPort::isRegOutput -TEST_F(StaLibertyTest, R8_PortIsRegOutput) { +TEST_F(StaLibertyTest, PortIsRegOutput) { LibertyCell *dff = lib_->findLibertyCell("DFF_X1"); ASSERT_NE(dff, nullptr); LibertyPort *q = dff->findLibertyPort("Q"); @@ -9844,7 +9844,7 @@ TEST_F(StaLibertyTest, R8_PortIsRegOutput) { } // LibertyPort::isCheckClk -TEST_F(StaLibertyTest, R8_PortIsCheckClk) { +TEST_F(StaLibertyTest, PortIsCheckClk) { LibertyCell *dff = lib_->findLibertyCell("DFF_X1"); ASSERT_NE(dff, nullptr); LibertyPort *ck = dff->findLibertyPort("CK"); @@ -9853,7 +9853,7 @@ TEST_F(StaLibertyTest, R8_PortIsCheckClk) { } // TimingArcSet::deleteTimingArc - test via finding and accessing -TEST_F(StaLibertyTest, R8_TimingArcSetArcCount) { +TEST_F(StaLibertyTest, TimingArcSetArcCount) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); auto &arcsets = buf->timingArcSets(); @@ -9863,7 +9863,7 @@ TEST_F(StaLibertyTest, R8_TimingArcSetArcCount) { } // TimingArcSet::role -TEST_F(StaLibertyTest, R8_TimingArcSetRole) { +TEST_F(StaLibertyTest, TimingArcSetRole) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); auto &arcsets = buf->timingArcSets(); @@ -9874,7 +9874,7 @@ TEST_F(StaLibertyTest, R8_TimingArcSetRole) { } // TimingArcSet::sense -TEST_F(StaLibertyTest, R8_TimingArcSetSense) { +TEST_F(StaLibertyTest, TimingArcSetSense2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); auto &arcsets = buf->timingArcSets(); @@ -9885,7 +9885,7 @@ TEST_F(StaLibertyTest, R8_TimingArcSetSense) { } // TimingArc::fromEdge and toEdge -TEST_F(StaLibertyTest, R8_TimingArcEdges) { +TEST_F(StaLibertyTest, TimingArcEdges) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); auto &arcsets = buf->timingArcSets(); @@ -9897,7 +9897,7 @@ TEST_F(StaLibertyTest, R8_TimingArcEdges) { } // TimingArc::driveResistance -TEST_F(StaLibertyTest, R8_TimingArcDriveResistance) { +TEST_F(StaLibertyTest, TimingArcDriveResistance3) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); auto &arcsets = buf->timingArcSets(); @@ -9909,7 +9909,7 @@ TEST_F(StaLibertyTest, R8_TimingArcDriveResistance) { } // TimingArc::intrinsicDelay -TEST_F(StaLibertyTest, R8_TimingArcIntrinsicDelay) { +TEST_F(StaLibertyTest, TimingArcIntrinsicDelay3) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); auto &arcsets = buf->timingArcSets(); @@ -9921,7 +9921,7 @@ TEST_F(StaLibertyTest, R8_TimingArcIntrinsicDelay) { } // TimingArc::model -TEST_F(StaLibertyTest, R8_TimingArcModel) { +TEST_F(StaLibertyTest, TimingArcModel2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); auto &arcsets = buf->timingArcSets(); @@ -9933,7 +9933,7 @@ TEST_F(StaLibertyTest, R8_TimingArcModel) { } // TimingArc::sense -TEST_F(StaLibertyTest, R8_TimingArcSense) { +TEST_F(StaLibertyTest, TimingArcSense) { LibertyCell *inv = lib_->findLibertyCell("INV_X1"); ASSERT_NE(inv, nullptr); auto &arcsets = inv->timingArcSets(); @@ -9945,7 +9945,7 @@ TEST_F(StaLibertyTest, R8_TimingArcSense) { } // TimingArcSet::isCondDefault -TEST_F(StaLibertyTest, R8_TimingArcSetIsCondDefault) { +TEST_F(StaLibertyTest, TimingArcSetIsCondDefault) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); auto &arcsets = buf->timingArcSets(); @@ -9956,7 +9956,7 @@ TEST_F(StaLibertyTest, R8_TimingArcSetIsCondDefault) { } // TimingArcSet::isDisabledConstraint -TEST_F(StaLibertyTest, R8_TimingArcSetIsDisabledConstraint) { +TEST_F(StaLibertyTest, TimingArcSetIsDisabledConstraint) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); auto &arcsets = buf->timingArcSets(); @@ -9968,7 +9968,7 @@ TEST_F(StaLibertyTest, R8_TimingArcSetIsDisabledConstraint) { } // timingTypeIsCheck for more types -TEST_F(StaLibertyTest, R8_TimingTypeIsCheckMore) { +TEST_F(StaLibertyTest, TimingTypeIsCheckMore) { EXPECT_TRUE(timingTypeIsCheck(TimingType::setup_falling)); EXPECT_TRUE(timingTypeIsCheck(TimingType::hold_rising)); EXPECT_TRUE(timingTypeIsCheck(TimingType::recovery_rising)); @@ -9979,7 +9979,7 @@ TEST_F(StaLibertyTest, R8_TimingTypeIsCheckMore) { } // findTimingType -TEST_F(StaLibertyTest, R8_FindTimingType) { +TEST_F(StaLibertyTest, FindTimingType) { TimingType tt = findTimingType("combinational"); EXPECT_EQ(tt, TimingType::combinational); tt = findTimingType("rising_edge"); @@ -9989,14 +9989,14 @@ TEST_F(StaLibertyTest, R8_FindTimingType) { } // timingTypeIsCheck -TEST_F(StaLibertyTest, R8_TimingTypeIsCheck) { +TEST_F(StaLibertyTest, TimingTypeIsCheck) { EXPECT_TRUE(timingTypeIsCheck(TimingType::setup_rising)); EXPECT_TRUE(timingTypeIsCheck(TimingType::hold_falling)); EXPECT_FALSE(timingTypeIsCheck(TimingType::combinational)); } // to_string(TimingSense) -TEST_F(StaLibertyTest, R8_TimingSenseToString) { +TEST_F(StaLibertyTest, TimingSenseToString) { const char *s = to_string(TimingSense::positive_unate); EXPECT_NE(s, nullptr); s = to_string(TimingSense::negative_unate); @@ -10006,7 +10006,7 @@ TEST_F(StaLibertyTest, R8_TimingSenseToString) { } // timingSenseOpposite -TEST_F(StaLibertyTest, R8_TimingSenseOpposite) { +TEST_F(StaLibertyTest, TimingSenseOpposite) { EXPECT_EQ(timingSenseOpposite(TimingSense::positive_unate), TimingSense::negative_unate); EXPECT_EQ(timingSenseOpposite(TimingSense::negative_unate), @@ -10014,34 +10014,34 @@ TEST_F(StaLibertyTest, R8_TimingSenseOpposite) { } // ScaleFactorPvt names -TEST_F(StaLibertyTest, R8_ScaleFactorPvtNames) { +TEST_F(StaLibertyTest, ScaleFactorPvtNames) { EXPECT_STREQ(scaleFactorPvtName(ScaleFactorPvt::process), "process"); EXPECT_STREQ(scaleFactorPvtName(ScaleFactorPvt::volt), "volt"); EXPECT_STREQ(scaleFactorPvtName(ScaleFactorPvt::temp), "temp"); } // findScaleFactorPvt -TEST_F(StaLibertyTest, R8_FindScaleFactorPvt) { +TEST_F(StaLibertyTest, FindScaleFactorPvt) { EXPECT_EQ(findScaleFactorPvt("process"), ScaleFactorPvt::process); EXPECT_EQ(findScaleFactorPvt("volt"), ScaleFactorPvt::volt); EXPECT_EQ(findScaleFactorPvt("temp"), ScaleFactorPvt::temp); } // ScaleFactorType names -TEST_F(StaLibertyTest, R8_ScaleFactorTypeNames) { +TEST_F(StaLibertyTest, ScaleFactorTypeNames) { const char *name = scaleFactorTypeName(ScaleFactorType::cell); EXPECT_NE(name, nullptr); } // findScaleFactorType -TEST_F(StaLibertyTest, R8_FindScaleFactorType) { +TEST_F(StaLibertyTest, FindScaleFactorType) { ScaleFactorType sft = findScaleFactorType("cell_rise"); // Should find it (void)sft; } // BusDcl -TEST_F(StaLibertyTest, R8_BusDclConstruct) { +TEST_F(StaLibertyTest, BusDclConstruct) { BusDcl bus("data", 7, 0); EXPECT_STREQ(bus.name(), "data"); EXPECT_EQ(bus.from(), 7); @@ -10049,7 +10049,7 @@ TEST_F(StaLibertyTest, R8_BusDclConstruct) { } // TableTemplate -TEST_F(StaLibertyTest, R8_TableTemplateConstruct) { +TEST_F(StaLibertyTest, TableTemplateConstruct) { TableTemplate tpl("my_template"); EXPECT_STREQ(tpl.name(), "my_template"); EXPECT_EQ(tpl.axis1(), nullptr); @@ -10058,14 +10058,14 @@ TEST_F(StaLibertyTest, R8_TableTemplateConstruct) { } // TableTemplate setName -TEST_F(StaLibertyTest, R8_TableTemplateSetName) { +TEST_F(StaLibertyTest, TableTemplateSetName) { TableTemplate tpl("orig"); tpl.setName("renamed"); EXPECT_STREQ(tpl.name(), "renamed"); } // LibertyCell::modeDef -TEST_F(StaLibertyTest, R8_CellModeDef) { +TEST_F(StaLibertyTest, CellModeDef2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); ModeDef *md = buf->makeModeDef("test_mode"); @@ -10077,7 +10077,7 @@ TEST_F(StaLibertyTest, R8_CellModeDef) { } // LibertyLibrary::tableTemplates -TEST_F(StaLibertyTest, R8_LibTableTemplates) { +TEST_F(StaLibertyTest, LibTableTemplates) { ASSERT_NE(lib_, nullptr); auto templates = lib_->tableTemplates(); // Nangate45 should have table templates @@ -10085,7 +10085,7 @@ TEST_F(StaLibertyTest, R8_LibTableTemplates) { } // LibertyLibrary::busDcls -TEST_F(StaLibertyTest, R8_LibBusDcls) { +TEST_F(StaLibertyTest, LibBusDcls) { ASSERT_NE(lib_, nullptr); auto dcls = lib_->busDcls(); // May or may not have bus declarations @@ -10093,7 +10093,7 @@ TEST_F(StaLibertyTest, R8_LibBusDcls) { } // LibertyPort::minPeriod -TEST_F(StaLibertyTest, R8_PortMinPeriod) { +TEST_F(StaLibertyTest, PortMinPeriod3) { LibertyCell *dff = lib_->findLibertyCell("DFF_X1"); ASSERT_NE(dff, nullptr); LibertyPort *ck = dff->findLibertyPort("CK"); @@ -10107,7 +10107,7 @@ TEST_F(StaLibertyTest, R8_PortMinPeriod) { } // LibertyPort::minPulseWidth -TEST_F(StaLibertyTest, R8_PortMinPulseWidth) { +TEST_F(StaLibertyTest, PortMinPulseWidth3) { LibertyCell *dff = lib_->findLibertyCell("DFF_X1"); ASSERT_NE(dff, nullptr); LibertyPort *ck = dff->findLibertyPort("CK"); @@ -10120,7 +10120,7 @@ TEST_F(StaLibertyTest, R8_PortMinPulseWidth) { } // LibertyPort::isClockGateClock/Enable/Out -TEST_F(StaLibertyTest, R8_PortClockGateFlags) { +TEST_F(StaLibertyTest, PortClockGateFlags) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -10131,7 +10131,7 @@ TEST_F(StaLibertyTest, R8_PortClockGateFlags) { } // LibertyPort::isPllFeedback -TEST_F(StaLibertyTest, R8_PortIsPllFeedback) { +TEST_F(StaLibertyTest, PortIsPllFeedback2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -10140,7 +10140,7 @@ TEST_F(StaLibertyTest, R8_PortIsPllFeedback) { } // LibertyPort::isSwitch -TEST_F(StaLibertyTest, R8_PortIsSwitch) { +TEST_F(StaLibertyTest, PortIsSwitch2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -10149,7 +10149,7 @@ TEST_F(StaLibertyTest, R8_PortIsSwitch) { } // LibertyPort::isPad -TEST_F(StaLibertyTest, R8_PortIsPad) { +TEST_F(StaLibertyTest, PortIsPad2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -10158,7 +10158,7 @@ TEST_F(StaLibertyTest, R8_PortIsPad) { } // LibertyPort::setCapacitance -TEST_F(StaLibertyTest, R8_PortSetCapacitance) { +TEST_F(StaLibertyTest, PortSetCapacitance) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -10168,7 +10168,7 @@ TEST_F(StaLibertyTest, R8_PortSetCapacitance) { } // LibertyPort::setSlewLimit -TEST_F(StaLibertyTest, R8_PortSetSlewLimit) { +TEST_F(StaLibertyTest, PortSetSlewLimit) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *z = buf->findLibertyPort("Z"); @@ -10182,7 +10182,7 @@ TEST_F(StaLibertyTest, R8_PortSetSlewLimit) { } // LibertyPort::setCapacitanceLimit -TEST_F(StaLibertyTest, R8_PortSetCapacitanceLimit) { +TEST_F(StaLibertyTest, PortSetCapacitanceLimit) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *z = buf->findLibertyPort("Z"); @@ -10196,7 +10196,7 @@ TEST_F(StaLibertyTest, R8_PortSetCapacitanceLimit) { } // LibertyPort::setFanoutLoad -TEST_F(StaLibertyTest, R8_PortSetFanoutLoad) { +TEST_F(StaLibertyTest, PortSetFanoutLoad2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -10210,7 +10210,7 @@ TEST_F(StaLibertyTest, R8_PortSetFanoutLoad) { } // LibertyPort::setFanoutLimit -TEST_F(StaLibertyTest, R8_PortSetFanoutLimit) { +TEST_F(StaLibertyTest, PortSetFanoutLimit2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *z = buf->findLibertyPort("Z"); @@ -10224,7 +10224,7 @@ TEST_F(StaLibertyTest, R8_PortSetFanoutLimit) { } // LibertyPort::capacitanceIsOneValue -TEST_F(StaLibertyTest, R8_PortCapacitanceIsOneValue) { +TEST_F(StaLibertyTest, PortCapacitanceIsOneValue2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -10234,7 +10234,7 @@ TEST_F(StaLibertyTest, R8_PortCapacitanceIsOneValue) { } // LibertyPort::isDisabledConstraint -TEST_F(StaLibertyTest, R8_PortIsDisabledConstraint) { +TEST_F(StaLibertyTest, PortIsDisabledConstraint3) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -10246,7 +10246,7 @@ TEST_F(StaLibertyTest, R8_PortIsDisabledConstraint) { } // InternalPower -TEST_F(StaLibertyTest, R8_InternalPowerPort) { +TEST_F(StaLibertyTest, InternalPowerPort) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); auto &powers = buf->internalPowers(); @@ -10259,7 +10259,7 @@ TEST_F(StaLibertyTest, R8_InternalPowerPort) { } // LibertyLibrary units -TEST_F(StaLibertyTest, R8_LibUnits) { +TEST_F(StaLibertyTest, LibUnits) { ASSERT_NE(lib_, nullptr); Units *units = lib_->units(); EXPECT_NE(units, nullptr); @@ -10269,7 +10269,7 @@ TEST_F(StaLibertyTest, R8_LibUnits) { } // WireloadSelection -TEST_F(StaLibertyTest, R8_WireloadSelection) { +TEST_F(StaLibertyTest, WireloadSelection) { ASSERT_NE(lib_, nullptr); WireloadSelection *ws = lib_->defaultWireloadSelection(); // May be nullptr if not defined in the library @@ -10277,14 +10277,14 @@ TEST_F(StaLibertyTest, R8_WireloadSelection) { } // LibertyLibrary::findWireload -TEST_F(StaLibertyTest, R8_LibFindWireload) { +TEST_F(StaLibertyTest, LibFindWireload) { ASSERT_NE(lib_, nullptr); Wireload *wl = lib_->findWireload("nonexistent"); EXPECT_EQ(wl, nullptr); } // scaleFactorTypeRiseFallSuffix/Prefix/LowHighSuffix -TEST_F(StaLibertyTest, R8_ScaleFactorTypeRiseFallSuffix) { +TEST_F(StaLibertyTest, ScaleFactorTypeRiseFallSuffix) { // These should not crash bool rfs = scaleFactorTypeRiseFallSuffix(ScaleFactorType::cell); bool rfp = scaleFactorTypeRiseFallPrefix(ScaleFactorType::cell); @@ -10295,7 +10295,7 @@ TEST_F(StaLibertyTest, R8_ScaleFactorTypeRiseFallSuffix) { } // LibertyPort::scanSignalType -TEST_F(StaLibertyTest, R8_PortScanSignalType) { +TEST_F(StaLibertyTest, PortScanSignalType2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -10304,7 +10304,7 @@ TEST_F(StaLibertyTest, R8_PortScanSignalType) { } // scanSignalTypeName -TEST_F(StaLibertyTest, R8_ScanSignalTypeName) { +TEST_F(StaLibertyTest, ScanSignalTypeName) { const char *name = scanSignalTypeName(ScanSignalType::enable); EXPECT_NE(name, nullptr); name = scanSignalTypeName(ScanSignalType::clock); @@ -10312,7 +10312,7 @@ TEST_F(StaLibertyTest, R8_ScanSignalTypeName) { } // pwrGndTypeName and findPwrGndType -TEST_F(StaLibertyTest, R8_PwrGndTypeName) { +TEST_F(StaLibertyTest, PwrGndTypeName) { const char *name = pwrGndTypeName(PwrGndType::primary_power); EXPECT_NE(name, nullptr); PwrGndType t = findPwrGndType("primary_power"); @@ -10320,7 +10320,7 @@ TEST_F(StaLibertyTest, R8_PwrGndTypeName) { } // TimingArcSet::arcsFrom -TEST_F(StaLibertyTest, R8_TimingArcSetArcsFrom) { +TEST_F(StaLibertyTest, TimingArcSetArcsFrom2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); auto &arcsets = buf->timingArcSets(); @@ -10333,7 +10333,7 @@ TEST_F(StaLibertyTest, R8_TimingArcSetArcsFrom) { } // TimingArcSet::arcTo -TEST_F(StaLibertyTest, R8_TimingArcSetArcTo) { +TEST_F(StaLibertyTest, TimingArcSetArcTo2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); auto &arcsets = buf->timingArcSets(); @@ -10344,7 +10344,7 @@ TEST_F(StaLibertyTest, R8_TimingArcSetArcTo) { } // LibertyPort::driveResistance with rf/min_max -TEST_F(StaLibertyTest, R8_PortDriveResistanceRfMinMax) { +TEST_F(StaLibertyTest, PortDriveResistanceRfMinMax2) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *z = buf->findLibertyPort("Z"); @@ -10354,7 +10354,7 @@ TEST_F(StaLibertyTest, R8_PortDriveResistanceRfMinMax) { } // LibertyPort::setMinPeriod -TEST_F(StaLibertyTest, R8_PortSetMinPeriod) { +TEST_F(StaLibertyTest, PortSetMinPeriod) { LibertyCell *dff = lib_->findLibertyCell("DFF_X1"); ASSERT_NE(dff, nullptr); LibertyPort *ck = dff->findLibertyPort("CK"); @@ -10368,7 +10368,7 @@ TEST_F(StaLibertyTest, R8_PortSetMinPeriod) { } // LibertyPort::setMinPulseWidth -TEST_F(StaLibertyTest, R8_PortSetMinPulseWidth) { +TEST_F(StaLibertyTest, PortSetMinPulseWidth) { LibertyCell *dff = lib_->findLibertyCell("DFF_X1"); ASSERT_NE(dff, nullptr); LibertyPort *ck = dff->findLibertyPort("CK"); @@ -10382,7 +10382,7 @@ TEST_F(StaLibertyTest, R8_PortSetMinPulseWidth) { } // LibertyPort::setDirection -TEST_F(StaLibertyTest, R8_PortSetDirection) { +TEST_F(StaLibertyTest, PortSetDirection) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -10393,7 +10393,7 @@ TEST_F(StaLibertyTest, R8_PortSetDirection) { } // LibertyPort isolation and level shifter data flags -TEST_F(StaLibertyTest, R8_PortIsolationLevelShifterFlags) { +TEST_F(StaLibertyTest, PortIsolationLevelShifterFlags) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *a = buf->findLibertyPort("A"); @@ -10471,7 +10471,7 @@ static LibertyLibrary *writeAndReadLibReturn(Sta *sta, const char *content, cons // ---------- Library-level default attributes ---------- // R9_1: default_intrinsic_rise/fall -TEST_F(StaLibertyTest, R9_DefaultIntrinsicRiseFall) { +TEST_F(StaLibertyTest, DefaultIntrinsicRiseFall) { const char *content = R"( library(test_r9_1) { delay_model : table_lookup ; @@ -10492,7 +10492,7 @@ library(test_r9_1) { } // R9_2: default_inout_pin_rise_res / fall_res -TEST_F(StaLibertyTest, R9_DefaultInoutPinRes) { +TEST_F(StaLibertyTest, DefaultInoutPinRes) { const char *content = R"( library(test_r9_2) { delay_model : table_lookup ; @@ -10513,7 +10513,7 @@ library(test_r9_2) { } // R9_3: default_output_pin_rise_res / fall_res -TEST_F(StaLibertyTest, R9_DefaultOutputPinRes) { +TEST_F(StaLibertyTest, DefaultOutputPinRes) { const char *content = R"( library(test_r9_3) { delay_model : table_lookup ; @@ -10534,7 +10534,7 @@ library(test_r9_3) { } // R9_4: technology(fpga) group -TEST_F(StaLibertyTest, R9_TechnologyGroup) { +TEST_F(StaLibertyTest, TechnologyGroup) { const char *content = R"( library(test_r9_4) { technology(fpga) {} @@ -10554,7 +10554,7 @@ library(test_r9_4) { } // R9_5: scaling_factors group -TEST_F(StaLibertyTest, R9_ScalingFactors) { +TEST_F(StaLibertyTest, ScalingFactors) { const char *content = R"( library(test_r9_5) { delay_model : table_lookup ; @@ -10582,7 +10582,7 @@ library(test_r9_5) { } // R9_6: cell is_memory attribute -TEST_F(StaLibertyTest, R9_CellIsMemory) { +TEST_F(StaLibertyTest, CellIsMemory4) { const char *content = R"( library(test_r9_6) { delay_model : table_lookup ; @@ -10606,7 +10606,7 @@ library(test_r9_6) { } // R9_7: pad_cell attribute -TEST_F(StaLibertyTest, R9_CellIsPadCell) { +TEST_F(StaLibertyTest, CellIsPadCell) { const char *content = R"( library(test_r9_7) { delay_model : table_lookup ; @@ -10630,7 +10630,7 @@ library(test_r9_7) { } // R9_8: is_clock_cell attribute -TEST_F(StaLibertyTest, R9_CellIsClockCell) { +TEST_F(StaLibertyTest, CellIsClockCell3) { const char *content = R"( library(test_r9_8) { delay_model : table_lookup ; @@ -10654,7 +10654,7 @@ library(test_r9_8) { } // R9_9: switch_cell_type -TEST_F(StaLibertyTest, R9_CellSwitchCellType) { +TEST_F(StaLibertyTest, CellSwitchCellType2) { const char *content = R"( library(test_r9_9) { delay_model : table_lookup ; @@ -10674,7 +10674,7 @@ library(test_r9_9) { } // R9_10: user_function_class -TEST_F(StaLibertyTest, R9_CellUserFunctionClass) { +TEST_F(StaLibertyTest, CellUserFunctionClass3) { const char *content = R"( library(test_r9_10) { delay_model : table_lookup ; @@ -10694,7 +10694,7 @@ library(test_r9_10) { } // R9_11: pin fanout_load, max_fanout, min_fanout -TEST_F(StaLibertyTest, R9_PinFanoutAttributes) { +TEST_F(StaLibertyTest, PinFanoutAttributes) { const char *content = R"( library(test_r9_11) { delay_model : table_lookup ; @@ -10722,7 +10722,7 @@ library(test_r9_11) { } // R9_12: min_transition on pin -TEST_F(StaLibertyTest, R9_PinMinTransition) { +TEST_F(StaLibertyTest, PinMinTransition) { const char *content = R"( library(test_r9_12) { delay_model : table_lookup ; @@ -10748,7 +10748,7 @@ library(test_r9_12) { } // R9_13: pulse_clock attribute on pin -TEST_F(StaLibertyTest, R9_PinPulseClock) { +TEST_F(StaLibertyTest, PinPulseClock) { const char *content = R"( library(test_r9_13) { delay_model : table_lookup ; @@ -10774,7 +10774,7 @@ library(test_r9_13) { } // R9_14: is_pll_feedback_pin -TEST_F(StaLibertyTest, R9_PinIsPllFeedback) { +TEST_F(StaLibertyTest, PinIsPllFeedback) { const char *content = R"( library(test_r9_14) { delay_model : table_lookup ; @@ -10800,7 +10800,7 @@ library(test_r9_14) { } // R9_15: switch_pin attribute -TEST_F(StaLibertyTest, R9_PinSwitchPin) { +TEST_F(StaLibertyTest, PinSwitchPin) { const char *content = R"( library(test_r9_15) { delay_model : table_lookup ; @@ -10826,7 +10826,7 @@ library(test_r9_15) { } // R9_16: is_pad on pin -TEST_F(StaLibertyTest, R9_PinIsPad) { +TEST_F(StaLibertyTest, PinIsPad) { const char *content = R"( library(test_r9_16) { delay_model : table_lookup ; @@ -10850,7 +10850,7 @@ library(test_r9_16) { } // R9_17: bundle group with members -TEST_F(StaLibertyTest, R9_BundlePort) { +TEST_F(StaLibertyTest, BundlePort) { const char *content = R"( library(test_r9_17) { delay_model : table_lookup ; @@ -10874,7 +10874,7 @@ library(test_r9_17) { } // R9_18: ff_bank group -TEST_F(StaLibertyTest, R9_FFBank) { +TEST_F(StaLibertyTest, FFBank) { const char *content = R"( library(test_r9_18) { delay_model : table_lookup ; @@ -10898,7 +10898,7 @@ library(test_r9_18) { } // R9_19: latch_bank group -TEST_F(StaLibertyTest, R9_LatchBank) { +TEST_F(StaLibertyTest, LatchBank) { const char *content = R"( library(test_r9_19) { delay_model : table_lookup ; @@ -10922,7 +10922,7 @@ library(test_r9_19) { } // R9_20: timing with intrinsic_rise/fall and rise_resistance/fall_resistance (linear model) -TEST_F(StaLibertyTest, R9_TimingIntrinsicResistance) { +TEST_F(StaLibertyTest, TimingIntrinsicResistance) { const char *content = R"( library(test_r9_20) { delay_model : generic_cmos ; @@ -10953,7 +10953,7 @@ library(test_r9_20) { } // R9_21: timing with sdf_cond_start and sdf_cond_end -TEST_F(StaLibertyTest, R9_TimingSdfCondStartEnd) { +TEST_F(StaLibertyTest, TimingSdfCondStartEnd) { const char *content = R"( library(test_r9_21) { delay_model : table_lookup ; @@ -11000,7 +11000,7 @@ library(test_r9_21) { } // R9_22: timing with mode attribute -TEST_F(StaLibertyTest, R9_TimingMode) { +TEST_F(StaLibertyTest, TimingMode) { const char *content = R"( library(test_r9_22) { delay_model : table_lookup ; @@ -11051,7 +11051,7 @@ library(test_r9_22) { } // R9_23: related_bus_pins -TEST_F(StaLibertyTest, R9_TimingRelatedBusPins) { +TEST_F(StaLibertyTest, TimingRelatedBusPins) { const char *content = R"( library(test_r9_23) { delay_model : table_lookup ; @@ -11106,7 +11106,7 @@ library(test_r9_23) { } // R9_24: OCV derate constructs -TEST_F(StaLibertyTest, R9_OcvDerate) { +TEST_F(StaLibertyTest, OcvDerate) { const char *content = R"( library(test_r9_24) { delay_model : table_lookup ; @@ -11151,7 +11151,7 @@ library(test_r9_24) { } // R9_25: ocv_arc_depth at library, cell, and timing levels -TEST_F(StaLibertyTest, R9_OcvArcDepth) { +TEST_F(StaLibertyTest, OcvArcDepth) { const char *content = R"( library(test_r9_25) { delay_model : table_lookup ; @@ -11198,7 +11198,7 @@ library(test_r9_25) { } // R9_26: POCV sigma tables -TEST_F(StaLibertyTest, R9_OcvSigmaTables) { +TEST_F(StaLibertyTest, OcvSigmaTables) { const char *content = R"( library(test_r9_26) { delay_model : table_lookup ; @@ -11255,7 +11255,7 @@ library(test_r9_26) { } // R9_27: POCV sigma constraint tables -TEST_F(StaLibertyTest, R9_OcvSigmaConstraint) { +TEST_F(StaLibertyTest, OcvSigmaConstraint) { const char *content = R"( library(test_r9_27) { delay_model : table_lookup ; @@ -11304,7 +11304,7 @@ library(test_r9_27) { } // R9_28: resistance_unit and distance_unit attributes -TEST_F(StaLibertyTest, R9_ResistanceDistanceUnits) { +TEST_F(StaLibertyTest, ResistanceDistanceUnits) { const char *content = R"( library(test_r9_28) { delay_model : table_lookup ; @@ -11325,7 +11325,7 @@ library(test_r9_28) { } // R9_29: rise/fall_transition_degradation tables -TEST_F(StaLibertyTest, R9_TransitionDegradation) { +TEST_F(StaLibertyTest, TransitionDegradation) { const char *content = R"( library(test_r9_29) { delay_model : table_lookup ; @@ -11356,7 +11356,7 @@ library(test_r9_29) { } // R9_30: lut group in cell -TEST_F(StaLibertyTest, R9_LutGroup) { +TEST_F(StaLibertyTest, LutGroup) { const char *content = R"( library(test_r9_30) { delay_model : table_lookup ; @@ -11377,7 +11377,7 @@ library(test_r9_30) { } // R9_31: ECSM waveform constructs -TEST_F(StaLibertyTest, R9_EcsmWaveform) { +TEST_F(StaLibertyTest, EcsmWaveform) { const char *content = R"( library(test_r9_31) { delay_model : table_lookup ; @@ -11422,7 +11422,7 @@ library(test_r9_31) { } // R9_32: power group (as opposed to rise_power/fall_power) -TEST_F(StaLibertyTest, R9_PowerGroup) { +TEST_F(StaLibertyTest, PowerGroup) { const char *content = R"( library(test_r9_32) { delay_model : table_lookup ; @@ -11456,7 +11456,7 @@ library(test_r9_32) { } // R9_33: leakage_power group with when and related_pg_pin -TEST_F(StaLibertyTest, R9_LeakagePowerGroup) { +TEST_F(StaLibertyTest, LeakagePowerGroup) { const char *content = R"( library(test_r9_33) { delay_model : table_lookup ; @@ -11488,7 +11488,7 @@ library(test_r9_33) { } // R9_34: InternalPowerModel checkAxes via reading a lib with internal power -TEST_F(StaLibertyTest, R9_InternalPowerModelCheckAxes) { +TEST_F(StaLibertyTest, InternalPowerModelCheckAxes) { const char *content = R"( library(test_r9_34) { delay_model : table_lookup ; @@ -11523,7 +11523,7 @@ library(test_r9_34) { } // R9_35: PortGroup and TimingGroup via direct construction -TEST_F(StaLibertyTest, R9_PortGroupConstruct) { +TEST_F(StaLibertyTest, PortGroupConstruct) { auto *ports = new LibertyPortSeq; PortGroup pg(ports, 1); TimingGroup *tg = new TimingGroup(1); @@ -11535,7 +11535,7 @@ TEST_F(StaLibertyTest, R9_PortGroupConstruct) { } // R9_36: SequentialGroup construct and setters -TEST_F(StaLibertyTest, R9_SequentialGroupSetters) { +TEST_F(StaLibertyTest, SequentialGroupSetters) { SequentialGroup sg(true, false, nullptr, nullptr, 1, 0); sg.setClock(stringCopy("CLK")); sg.setData(stringCopy("D")); @@ -11549,7 +11549,7 @@ TEST_F(StaLibertyTest, R9_SequentialGroupSetters) { } // R9_37: RelatedPortGroup construct and setters -TEST_F(StaLibertyTest, R9_RelatedPortGroupSetters) { +TEST_F(StaLibertyTest, RelatedPortGroupSetters) { RelatedPortGroup rpg(1); auto *names = new StringSeq; names->push_back(stringCopy("A")); @@ -11560,7 +11560,7 @@ TEST_F(StaLibertyTest, R9_RelatedPortGroupSetters) { } // R9_38: TimingGroup intrinsic/resistance setters -TEST_F(StaLibertyTest, R9_TimingGroupIntrinsicSetters) { +TEST_F(StaLibertyTest, TimingGroupIntrinsicSetters) { TimingGroup tg(1); tg.setIntrinsic(RiseFall::rise(), 0.05f); tg.setIntrinsic(RiseFall::fall(), 0.06f); @@ -11583,20 +11583,20 @@ TEST_F(StaLibertyTest, R9_TimingGroupIntrinsicSetters) { } // R9_39: TimingGroup setRelatedOutputPortName -TEST_F(StaLibertyTest, R9_TimingGroupRelatedOutputPort) { +TEST_F(StaLibertyTest, TimingGroupRelatedOutputPort) { TimingGroup tg(1); tg.setRelatedOutputPortName("Z"); EXPECT_NE(tg.relatedOutputPortName(), nullptr); } // R9_40: InternalPowerGroup construct -TEST_F(StaLibertyTest, R9_InternalPowerGroupConstruct) { +TEST_F(StaLibertyTest, InternalPowerGroupConstruct) { InternalPowerGroup ipg(1); EXPECT_EQ(ipg.line(), 1); } // R9_41: LeakagePowerGroup construct and setters -TEST_F(StaLibertyTest, R9_LeakagePowerGroupSetters) { +TEST_F(StaLibertyTest, LeakagePowerGroupSetters) { LeakagePowerGroup lpg(1); lpg.setRelatedPgPin("VDD"); lpg.setPower(0.5f); @@ -11605,14 +11605,14 @@ TEST_F(StaLibertyTest, R9_LeakagePowerGroupSetters) { } // R9_42: LibertyGroup isGroup and isVariable -TEST_F(StaLibertyTest, R9_LibertyStmtTypes) { +TEST_F(StaLibertyTest, LibertyStmtTypes) { LibertyGroup grp("test", nullptr, 1); EXPECT_TRUE(grp.isGroup()); EXPECT_FALSE(grp.isVariable()); } // R9_43: LibertySimpleAttr isComplex returns false -TEST_F(StaLibertyTest, R9_LibertySimpleAttrIsComplex) { +TEST_F(StaLibertyTest, LibertySimpleAttrIsComplex) { LibertyStringAttrValue *val = new LibertyStringAttrValue("test"); LibertySimpleAttr attr("name", val, 1); EXPECT_FALSE(attr.isComplex()); @@ -11620,7 +11620,7 @@ TEST_F(StaLibertyTest, R9_LibertySimpleAttrIsComplex) { } // R9_44: LibertyComplexAttr isSimple returns false -TEST_F(StaLibertyTest, R9_LibertyComplexAttrIsSimple) { +TEST_F(StaLibertyTest, LibertyComplexAttrIsSimple) { auto *values = new LibertyAttrValueSeq; LibertyComplexAttr attr("name", values, 1); EXPECT_FALSE(attr.isSimple()); @@ -11628,7 +11628,7 @@ TEST_F(StaLibertyTest, R9_LibertyComplexAttrIsSimple) { } // R9_45: LibertyStringAttrValue and LibertyFloatAttrValue type checks -TEST_F(StaLibertyTest, R9_AttrValueCrossType) { +TEST_F(StaLibertyTest, AttrValueCrossType) { // LibertyStringAttrValue normal usage LibertyStringAttrValue sval("hello"); EXPECT_TRUE(sval.isString()); @@ -11643,7 +11643,7 @@ TEST_F(StaLibertyTest, R9_AttrValueCrossType) { } // R9_46: LibertyDefine isDefine -TEST_F(StaLibertyTest, R9_LibertyDefineIsDefine) { +TEST_F(StaLibertyTest, LibertyDefineIsDefine) { LibertyDefine def("myattr", LibertyGroupType::cell, LibertyAttrType::attr_string, 1); EXPECT_TRUE(def.isDefine()); @@ -11651,7 +11651,7 @@ TEST_F(StaLibertyTest, R9_LibertyDefineIsDefine) { } // R9_47: scaled_cell group -TEST_F(StaLibertyTest, R9_ScaledCell) { +TEST_F(StaLibertyTest, ScaledCell) { const char *content = R"( library(test_r9_47) { delay_model : table_lookup ; @@ -11725,7 +11725,7 @@ library(test_r9_47) { } // R9_48: TimingGroup cell/transition/constraint setters -TEST_F(StaLibertyTest, R9_TimingGroupTableModelSetters) { +TEST_F(StaLibertyTest, TimingGroupTableModelSetters) { TimingGroup tg(1); // Test setting and getting cell models EXPECT_EQ(tg.cell(RiseFall::rise()), nullptr); @@ -11737,7 +11737,7 @@ TEST_F(StaLibertyTest, R9_TimingGroupTableModelSetters) { } // R9_49: LibertyParser construct, group(), deleteGroups(), makeVariable() -TEST_F(StaLibertyTest, R9_LibertyParserConstruct) { +TEST_F(StaLibertyTest, LibertyParserConstruct) { const char *content = R"( library(test_r9_49) { delay_model : table_lookup ; @@ -11770,7 +11770,7 @@ library(test_r9_49) { } // R9_50: cell with switch_cell_type fine_grain -TEST_F(StaLibertyTest, R9_SwitchCellTypeFineGrain) { +TEST_F(StaLibertyTest, SwitchCellTypeFineGrain) { const char *content = R"( library(test_r9_50) { delay_model : table_lookup ; @@ -11790,7 +11790,7 @@ library(test_r9_50) { } // R9_51: pulse_clock with different trigger/sense combos -TEST_F(StaLibertyTest, R9_PulseClockFallTrigger) { +TEST_F(StaLibertyTest, PulseClockFallTrigger) { const char *content = R"( library(test_r9_51) { delay_model : table_lookup ; @@ -11816,7 +11816,7 @@ library(test_r9_51) { } // R9_52: pulse_clock rise_triggered_low_pulse -TEST_F(StaLibertyTest, R9_PulseClockRiseTriggeredLow) { +TEST_F(StaLibertyTest, PulseClockRiseTriggeredLow) { const char *content = R"( library(test_r9_52) { delay_model : table_lookup ; @@ -11839,7 +11839,7 @@ library(test_r9_52) { } // R9_53: pulse_clock fall_triggered_high_pulse -TEST_F(StaLibertyTest, R9_PulseClockFallTriggeredHigh) { +TEST_F(StaLibertyTest, PulseClockFallTriggeredHigh) { const char *content = R"( library(test_r9_53) { delay_model : table_lookup ; @@ -11862,7 +11862,7 @@ library(test_r9_53) { } // R9_54: OCV derate with derate_type late -TEST_F(StaLibertyTest, R9_OcvDerateTypeLate) { +TEST_F(StaLibertyTest, OcvDerateTypeLate) { const char *content = R"( library(test_r9_54) { delay_model : table_lookup ; @@ -11893,7 +11893,7 @@ library(test_r9_54) { } // R9_55: OCV derate with path_type clock -TEST_F(StaLibertyTest, R9_OcvDeratePathTypeClock) { +TEST_F(StaLibertyTest, OcvDeratePathTypeClock) { const char *content = R"( library(test_r9_55) { delay_model : table_lookup ; @@ -11924,7 +11924,7 @@ library(test_r9_55) { } // R9_56: TimingGroup setDelaySigma/setSlewSigma/setConstraintSigma -TEST_F(StaLibertyTest, R9_TimingGroupSigmaSetters) { +TEST_F(StaLibertyTest, TimingGroupSigmaSetters) { TimingGroup tg(1); // Setting to nullptr just exercises the method tg.setDelaySigma(RiseFall::rise(), EarlyLate::min(), nullptr); @@ -11936,7 +11936,7 @@ TEST_F(StaLibertyTest, R9_TimingGroupSigmaSetters) { } // R9_57: Cover setIsScaled via reading a scaled_cell lib -TEST_F(StaLibertyTest, R9_ScaledCellCoversIsScaled) { +TEST_F(StaLibertyTest, ScaledCellCoversIsScaled) { // scaled_cell reading exercises GateTableModel::setIsScaled, // GateLinearModel::setIsScaled, CheckTableModel::setIsScaled internally const char *content = R"( @@ -11991,7 +11991,7 @@ library(test_r9_57) { } // R9_58: GateTableModel checkAxis exercised via table model reading -TEST_F(StaLibertyTest, R9_GateTableModelCheckAxis) { +TEST_F(StaLibertyTest, GateTableModelCheckAxis) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); auto &arcsets = buf->timingArcSets(); @@ -12007,7 +12007,7 @@ TEST_F(StaLibertyTest, R9_GateTableModelCheckAxis) { } // R9_59: CheckTableModel checkAxis exercised via setup timing -TEST_F(StaLibertyTest, R9_CheckTableModelCheckAxis) { +TEST_F(StaLibertyTest, CheckTableModelCheckAxis) { LibertyCell *dff = lib_->findLibertyCell("DFF_X1"); if (!dff) return; auto &arcsets = dff->timingArcSets(); @@ -12027,7 +12027,7 @@ TEST_F(StaLibertyTest, R9_CheckTableModelCheckAxis) { } // R9_60: TimingGroup cell/transition/constraint getter coverage -TEST_F(StaLibertyTest, R9_TimingGroupGettersNull) { +TEST_F(StaLibertyTest, TimingGroupGettersNull) { TimingGroup tg(1); // By default all model pointers should be null EXPECT_EQ(tg.cell(RiseFall::rise()), nullptr); @@ -12041,7 +12041,7 @@ TEST_F(StaLibertyTest, R9_TimingGroupGettersNull) { } // R9_61: Timing with ecsm_waveform_set and ecsm_capacitance -TEST_F(StaLibertyTest, R9_EcsmWaveformSet) { +TEST_F(StaLibertyTest, EcsmWaveformSet) { const char *content = R"( library(test_r9_61) { delay_model : table_lookup ; @@ -12087,7 +12087,7 @@ library(test_r9_61) { } // R9_62: sigma_type early -TEST_F(StaLibertyTest, R9_SigmaTypeEarly) { +TEST_F(StaLibertyTest, SigmaTypeEarly) { const char *content = R"( library(test_r9_62) { delay_model : table_lookup ; @@ -12144,7 +12144,7 @@ library(test_r9_62) { } // R9_63: sigma_type late -TEST_F(StaLibertyTest, R9_SigmaTypeLate) { +TEST_F(StaLibertyTest, SigmaTypeLate) { const char *content = R"( library(test_r9_63) { delay_model : table_lookup ; @@ -12195,7 +12195,7 @@ library(test_r9_63) { } // R9_64: Receiver capacitance with segment attribute -TEST_F(StaLibertyTest, R9_ReceiverCapacitanceSegment) { +TEST_F(StaLibertyTest, ReceiverCapacitanceSegment) { const char *content = R"( library(test_r9_64) { delay_model : table_lookup ; @@ -12249,7 +12249,7 @@ library(test_r9_64) { } // R9_65: LibertyCell hasInternalPorts (read-only check) -TEST_F(StaLibertyTest, R9_CellHasInternalPorts) { +TEST_F(StaLibertyTest, CellHasInternalPorts4) { LibertyCell *dff = lib_->findLibertyCell("DFF_X1"); ASSERT_NE(dff, nullptr); // DFF should have internal ports for state vars (IQ, IQN) @@ -12261,13 +12261,13 @@ TEST_F(StaLibertyTest, R9_CellHasInternalPorts) { } // R9_66: LibertyBuilder destructor (coverage) -TEST_F(StaLibertyTest, R9_LibertyBuilderDestruct) { +TEST_F(StaLibertyTest, LibertyBuilderDestruct) { LibertyBuilder *builder = new LibertyBuilder; delete builder; } // R9_67: Timing with setup constraint for coverage -TEST_F(StaLibertyTest, R9_TimingSetupConstraint) { +TEST_F(StaLibertyTest, TimingSetupConstraint) { const char *content = R"( library(test_r9_67) { delay_model : table_lookup ; @@ -12319,7 +12319,7 @@ library(test_r9_67) { } // R9_68: Library with define statement -TEST_F(StaLibertyTest, R9_DefineStatement) { +TEST_F(StaLibertyTest, DefineStatement) { const char *content = R"( library(test_r9_68) { delay_model : table_lookup ; @@ -12345,7 +12345,7 @@ library(test_r9_68) { } // R9_69: multiple scaling_factors type combinations -TEST_F(StaLibertyTest, R9_ScalingFactorsMultipleTypes) { +TEST_F(StaLibertyTest, ScalingFactorsMultipleTypes) { const char *content = R"( library(test_r9_69) { delay_model : table_lookup ; @@ -12391,7 +12391,7 @@ library(test_r9_69) { } // R9_70: OCV derate with early_and_late derate_type -TEST_F(StaLibertyTest, R9_OcvDerateEarlyAndLate) { +TEST_F(StaLibertyTest, OcvDerateEarlyAndLate) { const char *content = R"( library(test_r9_70) { delay_model : table_lookup ; @@ -12422,7 +12422,7 @@ library(test_r9_70) { } // R9_71: leakage_power with clear_preset_var1/var2 in ff -TEST_F(StaLibertyTest, R9_FFClearPresetVars) { +TEST_F(StaLibertyTest, FFClearPresetVars) { const char *content = R"( library(test_r9_71) { delay_model : table_lookup ; @@ -12453,7 +12453,7 @@ library(test_r9_71) { } // R9_72: mode_definition with multiple mode_values -TEST_F(StaLibertyTest, R9_ModeDefMultipleValues) { +TEST_F(StaLibertyTest, ModeDefMultipleValues) { const char *content = R"( library(test_r9_72) { delay_model : table_lookup ; @@ -12482,7 +12482,7 @@ library(test_r9_72) { } // R9_73: timing with related_output_pin -TEST_F(StaLibertyTest, R9_TimingRelatedOutputPin) { +TEST_F(StaLibertyTest, TimingRelatedOutputPin) { const char *content = R"( library(test_r9_73) { delay_model : table_lookup ; @@ -12532,7 +12532,7 @@ library(test_r9_73) { } // R9_74: wire_load_selection group -TEST_F(StaLibertyTest, R9_WireLoadSelection) { +TEST_F(StaLibertyTest, WireLoadSelection) { const char *content = R"( library(test_r9_74) { delay_model : table_lookup ; @@ -12570,7 +12570,7 @@ library(test_r9_74) { } // R9_75: interface_timing on cell -TEST_F(StaLibertyTest, R9_CellInterfaceTiming) { +TEST_F(StaLibertyTest, CellInterfaceTiming3) { const char *content = R"( library(test_r9_75) { delay_model : table_lookup ; @@ -12590,7 +12590,7 @@ library(test_r9_75) { } // R9_76: cell_footprint attribute -TEST_F(StaLibertyTest, R9_CellFootprint) { +TEST_F(StaLibertyTest, CellFootprint4) { const char *content = R"( library(test_r9_76) { delay_model : table_lookup ; @@ -12610,7 +12610,7 @@ library(test_r9_76) { } // R9_77: test_cell group -TEST_F(StaLibertyTest, R9_TestCellGroup) { +TEST_F(StaLibertyTest, TestCellGroup) { const char *content = R"( library(test_r9_77) { delay_model : table_lookup ; @@ -12648,7 +12648,7 @@ library(test_r9_77) { } // R9_78: memory group -TEST_F(StaLibertyTest, R9_MemoryGroup) { +TEST_F(StaLibertyTest, MemoryGroup) { const char *content = R"( library(test_r9_78) { delay_model : table_lookup ; @@ -12673,7 +12673,7 @@ library(test_r9_78) { } // R9_79: cell with always_on attribute -TEST_F(StaLibertyTest, R9_CellAlwaysOn) { +TEST_F(StaLibertyTest, CellAlwaysOn3) { const char *content = R"( library(test_r9_79) { delay_model : table_lookup ; @@ -12693,7 +12693,7 @@ library(test_r9_79) { } // R9_80: cell with is_level_shifter and level_shifter_type -TEST_F(StaLibertyTest, R9_CellLevelShifter) { +TEST_F(StaLibertyTest, CellLevelShifter) { const char *content = R"( library(test_r9_80) { delay_model : table_lookup ; @@ -12718,7 +12718,7 @@ library(test_r9_80) { } // R9_81: cell with is_isolation_cell -TEST_F(StaLibertyTest, R9_CellIsolationCell) { +TEST_F(StaLibertyTest, CellIsolationCell) { const char *content = R"( library(test_r9_81) { delay_model : table_lookup ; @@ -12747,7 +12747,7 @@ library(test_r9_81) { } // R9_82: statetable group -TEST_F(StaLibertyTest, R9_StatetableGroup) { +TEST_F(StaLibertyTest, StatetableGroup) { const char *content = R"( library(test_r9_82) { delay_model : table_lookup ; @@ -12772,7 +12772,7 @@ library(test_r9_82) { } // R9_83: Timing with sdf_cond -TEST_F(StaLibertyTest, R9_TimingSdfCond) { +TEST_F(StaLibertyTest, TimingSdfCond) { const char *content = R"( library(test_r9_83) { delay_model : table_lookup ; @@ -12819,7 +12819,7 @@ library(test_r9_83) { } // R9_84: power with rise_power and fall_power groups -TEST_F(StaLibertyTest, R9_RiseFallPowerGroups) { +TEST_F(StaLibertyTest, RiseFallPowerGroups) { const char *content = R"( library(test_r9_84) { delay_model : table_lookup ; @@ -12856,7 +12856,7 @@ library(test_r9_84) { } // R9_85: TimingGroup makeLinearModels coverage -TEST_F(StaLibertyTest, R9_TimingGroupLinearModels) { +TEST_F(StaLibertyTest, TimingGroupLinearModels) { TimingGroup tg(1); tg.setIntrinsic(RiseFall::rise(), 0.05f); tg.setIntrinsic(RiseFall::fall(), 0.06f); @@ -12872,7 +12872,7 @@ TEST_F(StaLibertyTest, R9_TimingGroupLinearModels) { } // R9_86: multiple wire_load and default_wire_load -TEST_F(StaLibertyTest, R9_DefaultWireLoad) { +TEST_F(StaLibertyTest, DefaultWireLoad) { const char *content = R"( library(test_r9_86) { delay_model : table_lookup ; @@ -12899,7 +12899,7 @@ library(test_r9_86) { } // R9_87: voltage_map attribute -TEST_F(StaLibertyTest, R9_VoltageMap) { +TEST_F(StaLibertyTest, VoltageMap) { const char *content = R"( library(test_r9_87) { delay_model : table_lookup ; @@ -12921,7 +12921,7 @@ library(test_r9_87) { } // R9_88: default_operating_conditions -TEST_F(StaLibertyTest, R9_DefaultOperatingConditions) { +TEST_F(StaLibertyTest, DefaultOperatingConditions) { const char *content = R"( library(test_r9_88) { delay_model : table_lookup ; @@ -12953,7 +12953,7 @@ library(test_r9_88) { } // R9_89: pg_pin group with pg_type and voltage_name -TEST_F(StaLibertyTest, R9_PgPin) { +TEST_F(StaLibertyTest, PgPin) { const char *content = R"( library(test_r9_89) { delay_model : table_lookup ; @@ -12985,7 +12985,7 @@ library(test_r9_89) { } // R9_90: TimingGroup set/get cell table models -TEST_F(StaLibertyTest, R9_TimingGroupCellModels) { +TEST_F(StaLibertyTest, TimingGroupCellModels) { TimingGroup tg(1); tg.setCell(RiseFall::rise(), nullptr); tg.setCell(RiseFall::fall(), nullptr); @@ -12994,7 +12994,7 @@ TEST_F(StaLibertyTest, R9_TimingGroupCellModels) { } // R9_91: TimingGroup constraint setters -TEST_F(StaLibertyTest, R9_TimingGroupConstraintModels) { +TEST_F(StaLibertyTest, TimingGroupConstraintModels) { TimingGroup tg(1); tg.setConstraint(RiseFall::rise(), nullptr); tg.setConstraint(RiseFall::fall(), nullptr); @@ -13003,7 +13003,7 @@ TEST_F(StaLibertyTest, R9_TimingGroupConstraintModels) { } // R9_92: TimingGroup transition setters -TEST_F(StaLibertyTest, R9_TimingGroupTransitionModels) { +TEST_F(StaLibertyTest, TimingGroupTransitionModels) { TimingGroup tg(1); tg.setTransition(RiseFall::rise(), nullptr); tg.setTransition(RiseFall::fall(), nullptr); @@ -13012,7 +13012,7 @@ TEST_F(StaLibertyTest, R9_TimingGroupTransitionModels) { } // R9_93: bus_naming_style attribute -TEST_F(StaLibertyTest, R9_BusNamingStyle) { +TEST_F(StaLibertyTest, BusNamingStyle) { const char *content = R"( library(test_r9_93) { delay_model : table_lookup ; @@ -13032,7 +13032,7 @@ library(test_r9_93) { } // R9_94: cell_leakage_power -TEST_F(StaLibertyTest, R9_CellLeakagePower) { +TEST_F(StaLibertyTest, CellLeakagePower5) { const char *content = R"( library(test_r9_94) { delay_model : table_lookup ; @@ -13053,7 +13053,7 @@ library(test_r9_94) { } // R9_95: clock_gating_integrated_cell -TEST_F(StaLibertyTest, R9_ClockGatingIntegratedCell) { +TEST_F(StaLibertyTest, ClockGatingIntegratedCell) { const char *content = R"( library(test_r9_95) { delay_model : table_lookup ; @@ -13087,7 +13087,7 @@ library(test_r9_95) { } // R9_96: output_current_rise/fall (CCS constructs) -TEST_F(StaLibertyTest, R9_OutputCurrentRiseFall) { +TEST_F(StaLibertyTest, OutputCurrentRiseFall) { const char *content = R"( library(test_r9_96) { delay_model : table_lookup ; @@ -13150,7 +13150,7 @@ library(test_r9_96) { } // R9_97: three_state attribute on pin -TEST_F(StaLibertyTest, R9_PinThreeState) { +TEST_F(StaLibertyTest, PinThreeState) { const char *content = R"( library(test_r9_97) { delay_model : table_lookup ; @@ -13174,7 +13174,7 @@ library(test_r9_97) { } // R9_98: rise_capacitance_range and fall_capacitance_range -TEST_F(StaLibertyTest, R9_PinCapacitanceRange) { +TEST_F(StaLibertyTest, PinCapacitanceRange) { const char *content = R"( library(test_r9_98) { delay_model : table_lookup ; @@ -13199,7 +13199,7 @@ library(test_r9_98) { } // R9_99: dont_use attribute -TEST_F(StaLibertyTest, R9_CellDontUse) { +TEST_F(StaLibertyTest, CellDontUse4) { const char *content = R"( library(test_r9_99) { delay_model : table_lookup ; @@ -13223,7 +13223,7 @@ library(test_r9_99) { } // R9_100: is_macro_cell attribute -TEST_F(StaLibertyTest, R9_CellIsMacro) { +TEST_F(StaLibertyTest, CellIsMacro4) { const char *content = R"( library(test_r9_100) { delay_model : table_lookup ; @@ -13247,7 +13247,7 @@ library(test_r9_100) { } // R9_101: OCV derate at cell level -TEST_F(StaLibertyTest, R9_OcvDerateCellLevel) { +TEST_F(StaLibertyTest, OcvDerateCellLevel) { const char *content = R"( library(test_r9_101) { delay_model : table_lookup ; @@ -13278,7 +13278,7 @@ library(test_r9_101) { } // R9_102: timing with when (conditional) -TEST_F(StaLibertyTest, R9_TimingWhenConditional) { +TEST_F(StaLibertyTest, TimingWhenConditional) { const char *content = R"( library(test_r9_102) { delay_model : table_lookup ; @@ -13343,7 +13343,7 @@ library(test_r9_102) { } // R9_103: default_max_fanout -TEST_F(StaLibertyTest, R9_DefaultMaxFanout) { +TEST_F(StaLibertyTest, DefaultMaxFanout) { const char *content = R"( library(test_r9_103) { delay_model : table_lookup ; @@ -13363,7 +13363,7 @@ library(test_r9_103) { } // R9_104: default_fanout_load -TEST_F(StaLibertyTest, R9_DefaultFanoutLoad) { +TEST_F(StaLibertyTest, DefaultFanoutLoad) { const char *content = R"( library(test_r9_104) { delay_model : table_lookup ; @@ -13383,7 +13383,7 @@ library(test_r9_104) { } // R9_105: TimingGroup outputWaveforms accessors (should be null by default) -TEST_F(StaLibertyTest, R9_TimingGroupOutputWaveforms) { +TEST_F(StaLibertyTest, TimingGroupOutputWaveforms) { TimingGroup tg(1); EXPECT_EQ(tg.outputWaveforms(RiseFall::rise()), nullptr); EXPECT_EQ(tg.outputWaveforms(RiseFall::fall()), nullptr); @@ -13397,7 +13397,7 @@ TEST_F(StaLibertyTest, R9_TimingGroupOutputWaveforms) { // It is not declared in a public header, so we declare it extern here. extern const char *timingTypeString(TimingType type); -TEST_F(StaLibertyTest, R11_TimingTypeString) { +TEST_F(StaLibertyTest, TimingTypeString) { // timingTypeString is defined in TimingArc.cc // We test several timing types to cover the function EXPECT_STREQ(timingTypeString(TimingType::combinational), "combinational"); @@ -13412,7 +13412,7 @@ TEST_F(StaLibertyTest, R11_TimingTypeString) { // R11_2: writeLiberty exercises LibertyWriter constructor, destructor, // writeHeader, writeFooter, asString(bool), and the full write path -TEST_F(StaLibertyTest, R11_WriteLiberty) { +TEST_F(StaLibertyTest, WriteLiberty) { ASSERT_NE(lib_, nullptr); const char *tmpfile = "/tmp/test_r11_write_liberty.lib"; // writeLiberty is declared in LibertyWriter.hh @@ -13432,7 +13432,7 @@ TEST_F(StaLibertyTest, R11_WriteLiberty) { // LibertyAttr, LibertySimpleAttr, LibertyComplexAttr, LibertyStringAttrValue, // LibertyFloatAttrValue, LibertyDefine, LibertyVariable, isGroup/isAttribute/ // isDefine/isVariable/isSimple/isComplex, and values() on simple attrs. -TEST_F(StaLibertyTest, R11_LibertyParserDirect) { +TEST_F(StaLibertyTest, LibertyParserDirect) { // Write a simple lib file for parser testing const char *content = R"( library(test_r11_parser) { @@ -13515,7 +13515,7 @@ library(test_r11_parser) { } // R11_4: Liberty file with wireload_selection to cover WireloadForArea -TEST_F(StaLibertyTest, R11_WireloadForArea) { +TEST_F(StaLibertyTest, WireloadForArea) { const char *content = R"( library(test_r11_wfa) { delay_model : table_lookup ; @@ -13552,7 +13552,7 @@ library(test_r11_wfa) { } // R11_5: Liberty file with latch to exercise inferLatchRoles -TEST_F(StaLibertyTest, R11_InferLatchRoles) { +TEST_F(StaLibertyTest, InferLatchRoles) { const char *content = R"( library(test_r11_latch) { delay_model : table_lookup ; @@ -13592,7 +13592,7 @@ library(test_r11_latch) { } // R11_6: Liberty file with leakage_power { when } to cover LeakagePowerGroup::setWhen -TEST_F(StaLibertyTest, R11_LeakagePowerWhen) { +TEST_F(StaLibertyTest, LeakagePowerWhen) { const char *content = R"( library(test_r11_lpw) { delay_model : table_lookup ; @@ -13625,7 +13625,7 @@ library(test_r11_lpw) { } // R11_7: Liberty file with statetable to cover StatetableGroup::addRow -TEST_F(StaLibertyTest, R11_Statetable) { +TEST_F(StaLibertyTest, Statetable) { const char *content = R"( library(test_r11_st) { delay_model : table_lookup ; @@ -13655,7 +13655,7 @@ library(test_r11_st) { // R11_8: Liberty file with internal_power to cover // InternalPowerModel::checkAxes/checkAxis -TEST_F(StaLibertyTest, R11_InternalPowerModel) { +TEST_F(StaLibertyTest, InternalPowerModel) { const char *content = R"( library(test_r11_ipm) { delay_model : table_lookup ; @@ -13690,7 +13690,7 @@ library(test_r11_ipm) { } // R11_9: Liberty file with bus port to cover PortNameBitIterator and findLibertyMember -TEST_F(StaLibertyTest, R11_BusPortAndMember) { +TEST_F(StaLibertyTest, BusPortAndMember) { const char *content = R"( library(test_r11_bus) { delay_model : table_lookup ; @@ -13736,7 +13736,7 @@ library(test_r11_bus) { // R11_10: Liberty file with include directive to cover LibertyScanner::includeBegin, fileEnd // We test this by creating a .lib that includes another .lib -TEST_F(StaLibertyTest, R11_LibertyInclude) { +TEST_F(StaLibertyTest, LibertyInclude) { // First write the included file const char *inc_path = "/tmp/test_r11_included.lib"; FILE *finc = fopen(inc_path, "w"); @@ -13776,7 +13776,7 @@ TEST_F(StaLibertyTest, R11_LibertyInclude) { } // R11_11: Exercise timing arc traversal from loaded library -TEST_F(StaLibertyTest, R11_TimingArcSetTraversal) { +TEST_F(StaLibertyTest, TimingArcSetTraversal) { ASSERT_NE(lib_, nullptr); LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); @@ -13799,7 +13799,7 @@ TEST_F(StaLibertyTest, R11_TimingArcSetTraversal) { // R11_12: GateTableModel::checkAxis and CheckTableModel::checkAxis // These are exercised by reading a liberty with table_lookup models // containing different axis variables -TEST_F(StaLibertyTest, R11_TableModelCheckAxis) { +TEST_F(StaLibertyTest, TableModelCheckAxis) { const char *content = R"( library(test_r11_axis) { delay_model : table_lookup ; @@ -13872,7 +13872,7 @@ library(test_r11_axis) { // R11_13: CheckLinearModel::setIsScaled, CheckTableModel::setIsScaled via // library with k_process/k_temp/k_volt scaling factors on setup -TEST_F(StaLibertyTest, R11_ScaledModels) { +TEST_F(StaLibertyTest, ScaledModels) { const char *content = R"( library(test_r11_scaled) { delay_model : table_lookup ; @@ -13917,7 +13917,7 @@ library(test_r11_scaled) { // R11_14: Library with cell that has internal_ports attribute // Exercises setHasInternalPorts -TEST_F(StaLibertyTest, R11_HasInternalPorts) { +TEST_F(StaLibertyTest, HasInternalPorts) { const char *content = R"( library(test_r11_intport) { delay_model : table_lookup ; @@ -13942,7 +13942,7 @@ library(test_r11_intport) { // R11_15: Directly test LibertyParser API through parseLibertyFile // Focus on saving attrs/variables/groups to exercise more code paths -TEST_F(StaLibertyTest, R11_ParserSaveAll) { +TEST_F(StaLibertyTest, ParserSaveAll) { const char *content = R"( library(test_r11_save) { delay_model : table_lookup ; @@ -14001,7 +14001,7 @@ library(test_r11_save) { // R11_16: Exercises clearAxisValues and setEnergyScale through internal_power // with energy values -TEST_F(StaLibertyTest, R11_EnergyScale) { +TEST_F(StaLibertyTest, EnergyScale) { const char *content = R"( library(test_r11_energy) { delay_model : table_lookup ; @@ -14048,7 +14048,7 @@ library(test_r11_energy) { } // R11_17: LibertyReader findPort by reading a lib and querying -TEST_F(StaLibertyTest, R11_FindPort) { +TEST_F(StaLibertyTest, FindPort) { ASSERT_NE(lib_, nullptr); LibertyCell *inv = lib_->findLibertyCell("INV_X1"); ASSERT_NE(inv, nullptr); @@ -14063,7 +14063,7 @@ TEST_F(StaLibertyTest, R11_FindPort) { // R11_18: LibertyPort::cornerPort (requires DcalcAnalysisPt, but we test // through the Nangate45 library which has corners) -TEST_F(StaLibertyTest, R11_CornerPort) { +TEST_F(StaLibertyTest, CornerPort) { ASSERT_NE(lib_, nullptr); LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); @@ -14080,7 +14080,7 @@ TEST_F(StaLibertyTest, R11_CornerPort) { } // R11_19: Exercise receiver model set through timing group -TEST_F(StaLibertyTest, R11_ReceiverModel) { +TEST_F(StaLibertyTest, ReceiverModel) { const char *content = R"( library(test_r11_recv) { delay_model : table_lookup ; @@ -14119,7 +14119,7 @@ library(test_r11_recv) { // R11_20: Read a liberty with CCS (composite current source) output_current // to exercise OutputWaveform constructors and related paths -TEST_F(StaLibertyTest, R11_CCSOutputCurrent) { +TEST_F(StaLibertyTest, CCSOutputCurrent) { const char *content = R"( library(test_r11_ccs) { delay_model : table_lookup ; diff --git a/network/test/cpp/TestNetwork.cc b/network/test/cpp/TestNetwork.cc index f14984a9..78953060 100644 --- a/network/test/cpp/TestNetwork.cc +++ b/network/test/cpp/TestNetwork.cc @@ -2592,7 +2592,7 @@ TEST(NetSetDefaultTest, EmptySet) { //////////////////////////////////////////////////////////////// // Network: connect via Port path with a freshly made instance -TEST_F(ConcreteNetworkLinkedTest, R5_ConnectNewPin) { +TEST_F(ConcreteNetworkLinkedTest, ConnectNewPin) { Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *u3 = network_.makeInstance(inv_cell, "u3", network_.topInstance()); Port *port_a = network_.findPort(inv_cell, "A"); @@ -2603,7 +2603,7 @@ TEST_F(ConcreteNetworkLinkedTest, R5_ConnectNewPin) { } // ConcreteCell: findPort for bus bits by name -TEST(ConcreteCellTest, R5_FindBusBitByName) { +TEST(ConcreteCellTest, FindBusBitByName) { ConcreteLibrary lib("test_lib", "test.lib", false); lib.setBusBrkts('[', ']'); ConcreteCell *cell = lib.makeCell("REG", true, ""); @@ -2615,19 +2615,19 @@ TEST(ConcreteCellTest, R5_FindBusBitByName) { } // Network: isCheckClk (non-liberty pin => false) -TEST_F(ConcreteNetworkLinkedTest, R5_IsCheckClk) { +TEST_F(ConcreteNetworkLinkedTest, IsCheckClk) { EXPECT_FALSE(network_.isCheckClk(pin_u1_a_)); } // Network: busIndexInRange on scalar port (always false) -TEST_F(ConcreteNetworkLinkedTest, R5_BusIndexInRangeScalar) { +TEST_F(ConcreteNetworkLinkedTest, BusIndexInRangeScalar) { Cell *inv_cell = network_.findCell(lib_, "INV"); Port *port_a = network_.findPort(inv_cell, "A"); EXPECT_FALSE(network_.busIndexInRange(port_a, 0)); } // Network: busIndexInRange on bus port -TEST_F(ConcreteNetworkLinkedTest, R5_BusIndexInRangeBus) { +TEST_F(ConcreteNetworkLinkedTest, BusIndexInRangeBus) { ConcreteLibrary *clib = reinterpret_cast(lib_); clib->setBusBrkts('[', ']'); Cell *cell = network_.makeCell(lib_, "BUS_TEST", true, "test.lib"); @@ -2639,7 +2639,7 @@ TEST_F(ConcreteNetworkLinkedTest, R5_BusIndexInRangeBus) { } // Network: hasMembersViaNetwork on bus port -TEST_F(ConcreteNetworkLinkedTest, R5_HasMembersBus) { +TEST_F(ConcreteNetworkLinkedTest, HasMembersBus) { ConcreteLibrary *clib = reinterpret_cast(lib_); clib->setBusBrkts('[', ']'); Cell *cell = network_.makeCell(lib_, "HAS_MEM_TEST", true, "test.lib"); @@ -2648,7 +2648,7 @@ TEST_F(ConcreteNetworkLinkedTest, R5_HasMembersBus) { } // Network: findMember on bus port -TEST_F(ConcreteNetworkLinkedTest, R5_FindMemberBus) { +TEST_F(ConcreteNetworkLinkedTest, FindMemberBus) { ConcreteLibrary *clib = reinterpret_cast(lib_); clib->setBusBrkts('[', ']'); Cell *cell = network_.makeCell(lib_, "FIND_MEM_TEST", true, "test.lib"); @@ -2660,21 +2660,21 @@ TEST_F(ConcreteNetworkLinkedTest, R5_FindMemberBus) { } // Network: isInside (pin inside pin context) -TEST_F(ConcreteNetworkLinkedTest, R5_IsInsidePinPin) { +TEST_F(ConcreteNetworkLinkedTest, IsInsidePinPin) { EXPECT_FALSE(network_.isInside(pin_u1_a_, pin_u2_a_)); } // (R5_CheckLibertyCorners removed: segfaults without Report* initialized) // Network: findLibertyFilename (none loaded) -TEST(ConcreteNetworkExtraTest, R5_FindLibertyFilename) { +TEST(ConcreteNetworkExtraTest, FindLibertyFilename) { ConcreteNetwork network; LibertyLibrary *found = network.findLibertyFilename("nonexistent.lib"); EXPECT_EQ(found, nullptr); } // Network: leafInstanceIterator with hierarchical instance -TEST_F(ConcreteNetworkLinkedTest, R5_LeafInstanceIteratorHier) { +TEST_F(ConcreteNetworkLinkedTest, LeafInstanceIteratorHier) { Instance *top = network_.topInstance(); LeafInstanceIterator *iter = network_.leafInstanceIterator(top); int count = 0; @@ -2687,7 +2687,7 @@ TEST_F(ConcreteNetworkLinkedTest, R5_LeafInstanceIteratorHier) { } // Network: findPin(Instance, Port) -TEST_F(ConcreteNetworkLinkedTest, R5_FindPinByPort) { +TEST_F(ConcreteNetworkLinkedTest, FindPinByPort2) { Cell *cell = network_.cell(u1_); Port *port_a = network_.findPort(cell, "A"); Pin *found = network_.findPin(u1_, port_a); @@ -2695,7 +2695,7 @@ TEST_F(ConcreteNetworkLinkedTest, R5_FindPinByPort) { } // ConcretePort: setBundlePort -TEST(ConcretePortTest, R5_SetBundlePort) { +TEST(ConcretePortTest, SetBundlePort) { ConcreteLibrary lib("test_lib", "test.lib", false); ConcreteCell *cell = lib.makeCell("MUX", true, ""); ConcretePort *a = cell->makePort("A"); @@ -2710,7 +2710,7 @@ TEST(ConcretePortTest, R5_SetBundlePort) { } // BusPort default constructor and setDirection -TEST(ConcretePortTest, R5_BusPortDefaultConstructor) { +TEST(ConcretePortTest, BusPortDefaultConstructor) { ConcreteLibrary lib("test_lib", "test.lib", false); lib.setBusBrkts('[', ']'); ConcreteCell *cell = lib.makeCell("REG", true, ""); @@ -2722,14 +2722,14 @@ TEST(ConcretePortTest, R5_BusPortDefaultConstructor) { } // ConcreteNetwork: cell(LibertyCell) forwarding -TEST(ConcreteNetworkExtraTest, R5_CellFromLibertyCell) { +TEST(ConcreteNetworkExtraTest, CellFromLibertyCell) { ConcreteNetwork network; Cell *result = network.cell(static_cast(nullptr)); EXPECT_EQ(result, nullptr); } // ConcreteNetwork: cell(const LibertyCell) forwarding -TEST(ConcreteNetworkExtraTest, R5_CellFromConstLibertyCell) { +TEST(ConcreteNetworkExtraTest, CellFromConstLibertyCell) { ConcreteNetwork network; const Cell *result = network.cell(static_cast(nullptr)); EXPECT_EQ(result, nullptr); @@ -2790,50 +2790,50 @@ protected: }; // NetworkNameAdapter: topInstance forwarding -TEST_F(NetworkAdapterTest, R5_AdapterTopInstance) { +TEST_F(NetworkAdapterTest, AdapterTopInstance) { Instance *top = sdc_net_->topInstance(); EXPECT_NE(top, nullptr); EXPECT_EQ(top, network_.topInstance()); } // NetworkNameAdapter: name(Library) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterLibraryName) { +TEST_F(NetworkAdapterTest, AdapterLibraryName) { EXPECT_STREQ(sdc_net_->name(lib_), "adapter_lib"); } // NetworkNameAdapter: id(Library) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterLibraryId) { +TEST_F(NetworkAdapterTest, AdapterLibraryId) { ObjectId adapter_id = sdc_net_->id(lib_); ObjectId direct_id = network_.id(lib_); EXPECT_EQ(adapter_id, direct_id); } // NetworkNameAdapter: findLibrary forwarding -TEST_F(NetworkAdapterTest, R5_AdapterFindLibrary) { +TEST_F(NetworkAdapterTest, AdapterFindLibrary) { Library *found = sdc_net_->findLibrary("adapter_lib"); EXPECT_EQ(found, lib_); } // NetworkNameAdapter: findLibertyFilename forwarding (no liberty libs) -TEST_F(NetworkAdapterTest, R5_AdapterFindLibertyFilename) { +TEST_F(NetworkAdapterTest, AdapterFindLibertyFilename) { LibertyLibrary *found = sdc_net_->findLibertyFilename("nonexistent.lib"); EXPECT_EQ(found, nullptr); } // NetworkNameAdapter: findLiberty forwarding (no liberty libs) -TEST_F(NetworkAdapterTest, R5_AdapterFindLiberty) { +TEST_F(NetworkAdapterTest, AdapterFindLiberty) { LibertyLibrary *found = sdc_net_->findLiberty("nonexistent"); EXPECT_EQ(found, nullptr); } // NetworkNameAdapter: defaultLibertyLibrary forwarding -TEST_F(NetworkAdapterTest, R5_AdapterDefaultLibertyLibrary) { +TEST_F(NetworkAdapterTest, AdapterDefaultLibertyLibrary) { LibertyLibrary *def = sdc_net_->defaultLibertyLibrary(); EXPECT_EQ(def, nullptr); } // NetworkNameAdapter: libraryIterator forwarding -TEST_F(NetworkAdapterTest, R5_AdapterLibraryIterator) { +TEST_F(NetworkAdapterTest, AdapterLibraryIterator) { LibraryIterator *iter = sdc_net_->libraryIterator(); ASSERT_NE(iter, nullptr); int count = 0; @@ -2846,7 +2846,7 @@ TEST_F(NetworkAdapterTest, R5_AdapterLibraryIterator) { } // NetworkNameAdapter: libertyLibraryIterator forwarding -TEST_F(NetworkAdapterTest, R5_AdapterLibertyLibraryIterator) { +TEST_F(NetworkAdapterTest, AdapterLibertyLibraryIterator) { LibertyLibraryIterator *iter = sdc_net_->libertyLibraryIterator(); ASSERT_NE(iter, nullptr); // No liberty libs loaded @@ -2855,62 +2855,62 @@ TEST_F(NetworkAdapterTest, R5_AdapterLibertyLibraryIterator) { } // NetworkNameAdapter: name(Cell) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterCellName) { +TEST_F(NetworkAdapterTest, AdapterCellName) { EXPECT_STREQ(sdc_net_->name(inv_cell_), "BUF"); } // NetworkNameAdapter: id(Cell) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterCellId) { +TEST_F(NetworkAdapterTest, AdapterCellId) { ObjectId adapter_id = sdc_net_->id(inv_cell_); ObjectId direct_id = network_.id(inv_cell_); EXPECT_EQ(adapter_id, direct_id); } // NetworkNameAdapter: getAttribute(Cell) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterCellGetAttribute) { +TEST_F(NetworkAdapterTest, AdapterCellGetAttribute) { std::string val = sdc_net_->getAttribute(inv_cell_, "nonexistent"); EXPECT_TRUE(val.empty()); } // NetworkNameAdapter: attributeMap(Cell) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterCellAttributeMap) { +TEST_F(NetworkAdapterTest, AdapterCellAttributeMap) { const AttributeMap &map = sdc_net_->attributeMap(inv_cell_); (void)map; // Just verify it doesn't crash } // NetworkNameAdapter: library(Cell) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterCellLibrary) { +TEST_F(NetworkAdapterTest, AdapterCellLibrary) { Library *lib = sdc_net_->library(inv_cell_); EXPECT_EQ(lib, lib_); } // NetworkNameAdapter: filename(Cell) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterCellFilename) { +TEST_F(NetworkAdapterTest, AdapterCellFilename) { const char *fn = sdc_net_->filename(inv_cell_); EXPECT_STREQ(fn, "adapter.lib"); } // NetworkNameAdapter: findPort forwarding -TEST_F(NetworkAdapterTest, R5_AdapterFindPort) { +TEST_F(NetworkAdapterTest, AdapterFindPort) { Port *found = sdc_net_->findPort(inv_cell_, "A"); EXPECT_EQ(found, port_a_); } // NetworkNameAdapter: findPortsMatching forwarding -TEST_F(NetworkAdapterTest, R5_AdapterFindPortsMatching) { +TEST_F(NetworkAdapterTest, AdapterFindPortsMatching) { PatternMatch pattern("*"); PortSeq ports = sdc_net_->findPortsMatching(inv_cell_, &pattern); EXPECT_EQ(ports.size(), 2u); } // NetworkNameAdapter: isLeaf(Cell) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterCellIsLeaf) { +TEST_F(NetworkAdapterTest, AdapterCellIsLeaf) { EXPECT_TRUE(sdc_net_->isLeaf(inv_cell_)); } // NetworkNameAdapter: portIterator forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPortIterator) { +TEST_F(NetworkAdapterTest, AdapterPortIterator) { CellPortIterator *iter = sdc_net_->portIterator(inv_cell_); ASSERT_NE(iter, nullptr); int count = 0; @@ -2923,7 +2923,7 @@ TEST_F(NetworkAdapterTest, R5_AdapterPortIterator) { } // NetworkNameAdapter: portBitIterator forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPortBitIterator) { +TEST_F(NetworkAdapterTest, AdapterPortBitIterator) { CellPortBitIterator *iter = sdc_net_->portBitIterator(inv_cell_); ASSERT_NE(iter, nullptr); int count = 0; @@ -2936,71 +2936,71 @@ TEST_F(NetworkAdapterTest, R5_AdapterPortBitIterator) { } // NetworkNameAdapter: portBitCount forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPortBitCount) { +TEST_F(NetworkAdapterTest, AdapterPortBitCount) { int count = sdc_net_->portBitCount(inv_cell_); EXPECT_EQ(count, 2); } // NetworkNameAdapter: name(Port) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPortName) { +TEST_F(NetworkAdapterTest, AdapterPortName) { EXPECT_STREQ(sdc_net_->name(port_a_), "A"); } // NetworkNameAdapter: id(Port) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPortId) { +TEST_F(NetworkAdapterTest, AdapterPortId) { ObjectId adapter_id = sdc_net_->id(port_a_); ObjectId direct_id = network_.id(port_a_); EXPECT_EQ(adapter_id, direct_id); } // NetworkNameAdapter: cell(Port) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPortCell) { +TEST_F(NetworkAdapterTest, AdapterPortCell) { Cell *cell = sdc_net_->cell(port_a_); EXPECT_EQ(cell, inv_cell_); } // NetworkNameAdapter: direction(Port) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPortDirection) { +TEST_F(NetworkAdapterTest, AdapterPortDirection) { PortDirection *dir = sdc_net_->direction(port_a_); EXPECT_EQ(dir, PortDirection::input()); } // NetworkNameAdapter: isBundle(Port) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPortIsBundle) { +TEST_F(NetworkAdapterTest, AdapterPortIsBundle) { EXPECT_FALSE(sdc_net_->isBundle(port_a_)); } // NetworkNameAdapter: isBus(Port) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPortIsBus) { +TEST_F(NetworkAdapterTest, AdapterPortIsBus) { EXPECT_FALSE(sdc_net_->isBus(port_a_)); } // NetworkNameAdapter: size(Port) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPortSize) { +TEST_F(NetworkAdapterTest, AdapterPortSize) { EXPECT_EQ(sdc_net_->size(port_a_), 1); } // NetworkNameAdapter: busName(Port) scalar forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPortBusName) { +TEST_F(NetworkAdapterTest, AdapterPortBusName) { const char *bn = sdc_net_->busName(port_a_); // Scalar port returns name (not nullptr) through SdcNetwork EXPECT_NE(bn, nullptr); } // NetworkNameAdapter: fromIndex(Port) forwarding (scalar ports return -1) -TEST_F(NetworkAdapterTest, R5_AdapterPortFromIndex) { +TEST_F(NetworkAdapterTest, AdapterPortFromIndex) { int idx = sdc_net_->fromIndex(port_a_); EXPECT_EQ(idx, -1); } // NetworkNameAdapter: toIndex(Port) forwarding (scalar ports return -1) -TEST_F(NetworkAdapterTest, R5_AdapterPortToIndex) { +TEST_F(NetworkAdapterTest, AdapterPortToIndex) { int idx = sdc_net_->toIndex(port_a_); EXPECT_EQ(idx, -1); } // NetworkNameAdapter: hasMembers(Port) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPortHasMembers) { +TEST_F(NetworkAdapterTest, AdapterPortHasMembers) { EXPECT_FALSE(sdc_net_->hasMembers(port_a_)); } @@ -3008,43 +3008,43 @@ TEST_F(NetworkAdapterTest, R5_AdapterPortHasMembers) { // (R5_AdapterPortFindBusBit removed: segfaults on scalar port) // NetworkNameAdapter: id(Instance) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterInstanceId) { +TEST_F(NetworkAdapterTest, AdapterInstanceId) { ObjectId adapter_id = sdc_net_->id(u1_); ObjectId direct_id = network_.id(u1_); EXPECT_EQ(adapter_id, direct_id); } // NetworkNameAdapter: cell(Instance) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterInstanceCell) { +TEST_F(NetworkAdapterTest, AdapterInstanceCell) { Cell *cell = sdc_net_->cell(u1_); EXPECT_EQ(cell, inv_cell_); } // NetworkNameAdapter: getAttribute(Instance) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterInstanceGetAttribute) { +TEST_F(NetworkAdapterTest, AdapterInstanceGetAttribute) { std::string val = sdc_net_->getAttribute(u1_, "nonexistent"); EXPECT_TRUE(val.empty()); } // NetworkNameAdapter: attributeMap(Instance) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterInstanceAttributeMap) { +TEST_F(NetworkAdapterTest, AdapterInstanceAttributeMap) { const AttributeMap &map = sdc_net_->attributeMap(u1_); (void)map; } // NetworkNameAdapter: parent(Instance) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterInstanceParent) { +TEST_F(NetworkAdapterTest, AdapterInstanceParent) { Instance *parent = sdc_net_->parent(u1_); EXPECT_EQ(parent, network_.topInstance()); } // NetworkNameAdapter: isLeaf(Instance) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterInstanceIsLeaf) { +TEST_F(NetworkAdapterTest, AdapterInstanceIsLeaf) { EXPECT_TRUE(sdc_net_->isLeaf(u1_)); } // NetworkNameAdapter: findPin(Instance, Port) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterFindPinByPort) { +TEST_F(NetworkAdapterTest, AdapterFindPinByPort) { Pin *pin = sdc_net_->findPin(u1_, port_a_); EXPECT_EQ(pin, pin_b1_a_); } @@ -3052,7 +3052,7 @@ TEST_F(NetworkAdapterTest, R5_AdapterFindPinByPort) { // (R5_AdapterFindPinByLibertyPort removed: segfaults with nullptr LibertyPort) // NetworkNameAdapter: childIterator forwarding -TEST_F(NetworkAdapterTest, R5_AdapterChildIterator) { +TEST_F(NetworkAdapterTest, AdapterChildIterator) { Instance *top = sdc_net_->topInstance(); InstanceChildIterator *iter = sdc_net_->childIterator(top); ASSERT_NE(iter, nullptr); @@ -3066,7 +3066,7 @@ TEST_F(NetworkAdapterTest, R5_AdapterChildIterator) { } // NetworkNameAdapter: pinIterator(Instance) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterInstancePinIterator) { +TEST_F(NetworkAdapterTest, AdapterInstancePinIterator) { InstancePinIterator *iter = sdc_net_->pinIterator(u1_); ASSERT_NE(iter, nullptr); int count = 0; @@ -3079,7 +3079,7 @@ TEST_F(NetworkAdapterTest, R5_AdapterInstancePinIterator) { } // NetworkNameAdapter: netIterator(Instance) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterInstanceNetIterator) { +TEST_F(NetworkAdapterTest, AdapterInstanceNetIterator) { Instance *top = sdc_net_->topInstance(); InstanceNetIterator *iter = sdc_net_->netIterator(top); ASSERT_NE(iter, nullptr); @@ -3093,81 +3093,81 @@ TEST_F(NetworkAdapterTest, R5_AdapterInstanceNetIterator) { } // NetworkNameAdapter: id(Pin) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPinId) { +TEST_F(NetworkAdapterTest, AdapterPinId) { ObjectId adapter_id = sdc_net_->id(pin_b1_a_); ObjectId direct_id = network_.id(pin_b1_a_); EXPECT_EQ(adapter_id, direct_id); } // NetworkNameAdapter: port(Pin) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPinPort) { +TEST_F(NetworkAdapterTest, AdapterPinPort) { Port *port = sdc_net_->port(pin_b1_a_); EXPECT_EQ(port, port_a_); } // NetworkNameAdapter: instance(Pin) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPinInstance) { +TEST_F(NetworkAdapterTest, AdapterPinInstance) { Instance *inst = sdc_net_->instance(pin_b1_a_); EXPECT_EQ(inst, u1_); } // NetworkNameAdapter: net(Pin) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPinNet) { +TEST_F(NetworkAdapterTest, AdapterPinNet) { Net *net = sdc_net_->net(pin_b1_a_); EXPECT_EQ(net, net1_); } // NetworkNameAdapter: term(Pin) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPinTerm) { +TEST_F(NetworkAdapterTest, AdapterPinTerm) { Term *term = sdc_net_->term(pin_b1_a_); // leaf instance pins have no term EXPECT_EQ(term, nullptr); } // NetworkNameAdapter: direction(Pin) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPinDirection) { +TEST_F(NetworkAdapterTest, AdapterPinDirection) { PortDirection *dir = sdc_net_->direction(pin_b1_a_); EXPECT_EQ(dir, PortDirection::input()); } // NetworkNameAdapter: vertexId(Pin) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPinVertexId) { +TEST_F(NetworkAdapterTest, AdapterPinVertexId) { VertexId vid = sdc_net_->vertexId(pin_b1_a_); (void)vid; // Just verify it doesn't crash } // NetworkNameAdapter: setVertexId forwarding -TEST_F(NetworkAdapterTest, R5_AdapterSetVertexId) { +TEST_F(NetworkAdapterTest, AdapterSetVertexId) { sdc_net_->setVertexId(pin_b1_a_, 42); VertexId vid = sdc_net_->vertexId(pin_b1_a_); EXPECT_EQ(vid, 42u); } // NetworkNameAdapter: id(Net) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterNetId) { +TEST_F(NetworkAdapterTest, AdapterNetId) { ObjectId adapter_id = sdc_net_->id(net1_); ObjectId direct_id = network_.id(net1_); EXPECT_EQ(adapter_id, direct_id); } // NetworkNameAdapter: instance(Net) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterNetInstance) { +TEST_F(NetworkAdapterTest, AdapterNetInstance) { Instance *inst = sdc_net_->instance(net1_); EXPECT_EQ(inst, network_.topInstance()); } // NetworkNameAdapter: isPower(Net) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterNetIsPower) { +TEST_F(NetworkAdapterTest, AdapterNetIsPower) { EXPECT_FALSE(sdc_net_->isPower(net1_)); } // NetworkNameAdapter: isGround(Net) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterNetIsGround) { +TEST_F(NetworkAdapterTest, AdapterNetIsGround) { EXPECT_FALSE(sdc_net_->isGround(net1_)); } // NetworkNameAdapter: pinIterator(Net) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterNetPinIterator) { +TEST_F(NetworkAdapterTest, AdapterNetPinIterator) { NetPinIterator *iter = sdc_net_->pinIterator(net1_); ASSERT_NE(iter, nullptr); int count = 0; @@ -3180,87 +3180,87 @@ TEST_F(NetworkAdapterTest, R5_AdapterNetPinIterator) { } // NetworkNameAdapter: termIterator(Net) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterNetTermIterator) { +TEST_F(NetworkAdapterTest, AdapterNetTermIterator) { NetTermIterator *iter = sdc_net_->termIterator(net1_); ASSERT_NE(iter, nullptr); delete iter; } // NetworkNameAdapter: constantPinIterator forwarding -TEST_F(NetworkAdapterTest, R5_AdapterConstantPinIterator) { +TEST_F(NetworkAdapterTest, AdapterConstantPinIterator) { ConstantPinIterator *iter = sdc_net_->constantPinIterator(); ASSERT_NE(iter, nullptr); delete iter; } // NetworkNameAdapter: pathDivider forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPathDivider) { +TEST_F(NetworkAdapterTest, AdapterPathDivider) { char div = sdc_net_->pathDivider(); EXPECT_EQ(div, network_.pathDivider()); } // NetworkNameAdapter: setPathDivider forwarding -TEST_F(NetworkAdapterTest, R5_AdapterSetPathDivider) { +TEST_F(NetworkAdapterTest, AdapterSetPathDivider) { sdc_net_->setPathDivider('/'); EXPECT_EQ(network_.pathDivider(), '/'); } // NetworkNameAdapter: pathEscape forwarding -TEST_F(NetworkAdapterTest, R5_AdapterPathEscape) { +TEST_F(NetworkAdapterTest, AdapterPathEscape) { char esc = sdc_net_->pathEscape(); EXPECT_EQ(esc, network_.pathEscape()); } // NetworkNameAdapter: setPathEscape forwarding -TEST_F(NetworkAdapterTest, R5_AdapterSetPathEscape) { +TEST_F(NetworkAdapterTest, AdapterSetPathEscape) { sdc_net_->setPathEscape('~'); EXPECT_EQ(network_.pathEscape(), '~'); } // NetworkNameAdapter: isEditable forwarding -TEST_F(NetworkAdapterTest, R5_AdapterIsEditable) { +TEST_F(NetworkAdapterTest, AdapterIsEditable) { EXPECT_TRUE(sdc_net_->isEditable()); } // NetworkNameAdapter: libertyCell(Cell) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterLibertyCellFromCell) { +TEST_F(NetworkAdapterTest, AdapterLibertyCellFromCell) { LibertyCell *lc = sdc_net_->libertyCell(inv_cell_); EXPECT_EQ(lc, nullptr); } // NetworkNameAdapter: libertyCell(const Cell) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterConstLibertyCellFromCell) { +TEST_F(NetworkAdapterTest, AdapterConstLibertyCellFromCell) { const LibertyCell *lc = sdc_net_->libertyCell(static_cast(inv_cell_)); EXPECT_EQ(lc, nullptr); } // NetworkNameAdapter: cell(LibertyCell*) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterCellFromLibertyCell) { +TEST_F(NetworkAdapterTest, AdapterCellFromLibertyCell) { Cell *c = sdc_net_->cell(static_cast(nullptr)); EXPECT_EQ(c, nullptr); } // NetworkNameAdapter: cell(const LibertyCell*) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterCellFromConstLibertyCell) { +TEST_F(NetworkAdapterTest, AdapterCellFromConstLibertyCell) { const Cell *c = sdc_net_->cell(static_cast(nullptr)); EXPECT_EQ(c, nullptr); } // NetworkNameAdapter: mergedInto forwarding -TEST_F(NetworkAdapterTest, R5_AdapterMergedInto) { +TEST_F(NetworkAdapterTest, AdapterMergedInto) { Net *merged = sdc_net_->mergedInto(net1_); EXPECT_EQ(merged, nullptr); } // NetworkNameAdapter: makeNet forwarding -TEST_F(NetworkAdapterTest, R5_AdapterMakeNet) { +TEST_F(NetworkAdapterTest, AdapterMakeNet) { Instance *top = sdc_net_->topInstance(); Net *new_net = sdc_net_->makeNet("adapter_net", top); EXPECT_NE(new_net, nullptr); } // NetworkNameAdapter: connect(Instance, Port, Net) forwarding -TEST_F(NetworkAdapterTest, R5_AdapterConnect) { +TEST_F(NetworkAdapterTest, AdapterConnect) { Instance *top = sdc_net_->topInstance(); Net *new_net = sdc_net_->makeNet("connect_net", top); Pin *pin = sdc_net_->connect(u1_, port_y_, new_net); @@ -3268,7 +3268,7 @@ TEST_F(NetworkAdapterTest, R5_AdapterConnect) { } // NetworkNameAdapter: disconnectPin forwarding -TEST_F(NetworkAdapterTest, R5_AdapterDisconnectPin) { +TEST_F(NetworkAdapterTest, AdapterDisconnectPin) { Instance *top = sdc_net_->topInstance(); Net *new_net = sdc_net_->makeNet("disc_net", top); Pin *pin = sdc_net_->connect(u1_, port_y_, new_net); @@ -3279,7 +3279,7 @@ TEST_F(NetworkAdapterTest, R5_AdapterDisconnectPin) { } // NetworkNameAdapter: deletePin forwarding -TEST_F(NetworkAdapterTest, R5_AdapterDeletePin) { +TEST_F(NetworkAdapterTest, AdapterDeletePin) { Instance *top = sdc_net_->topInstance(); Net *new_net = sdc_net_->makeNet("delpin_net", top); Pin *pin = sdc_net_->connect(u1_, port_y_, new_net); @@ -3290,7 +3290,7 @@ TEST_F(NetworkAdapterTest, R5_AdapterDeletePin) { } // NetworkNameAdapter: mergeInto forwarding -TEST_F(NetworkAdapterTest, R5_AdapterMergeInto) { +TEST_F(NetworkAdapterTest, AdapterMergeInto) { Instance *top = sdc_net_->topInstance(); Net *net_a = sdc_net_->makeNet("merge_a", top); Net *net_b = sdc_net_->makeNet("merge_b", top); @@ -3300,121 +3300,121 @@ TEST_F(NetworkAdapterTest, R5_AdapterMergeInto) { } // SdcNetwork: constructor and basic forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkTopInstance) { +TEST_F(NetworkAdapterTest, SdcNetworkTopInstance) { Instance *top = sdc_net_->topInstance(); EXPECT_NE(top, nullptr); EXPECT_EQ(top, network_.topInstance()); } // SdcNetwork: name(Port) forwarding with sdc namespace -TEST_F(NetworkAdapterTest, R5_SdcNetworkPortName) { +TEST_F(NetworkAdapterTest, SdcNetworkPortName) { const char *name = sdc_net_->name(port_a_); EXPECT_NE(name, nullptr); } // SdcNetwork: busName(Port) forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkPortBusName) { +TEST_F(NetworkAdapterTest, SdcNetworkPortBusName) { const char *bn = sdc_net_->busName(port_a_); // SdcNetwork busName returns name for scalar port EXPECT_NE(bn, nullptr); } // SdcNetwork: findPort forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkFindPort) { +TEST_F(NetworkAdapterTest, SdcNetworkFindPort) { Port *found = sdc_net_->findPort(inv_cell_, "A"); EXPECT_EQ(found, port_a_); } // SdcNetwork: findPortsMatching forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkFindPortsMatching) { +TEST_F(NetworkAdapterTest, SdcNetworkFindPortsMatching) { PatternMatch pattern("*"); PortSeq ports = sdc_net_->findPortsMatching(inv_cell_, &pattern); EXPECT_EQ(ports.size(), 2u); } // SdcNetwork: findNet(Instance, name) forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkFindNet) { +TEST_F(NetworkAdapterTest, SdcNetworkFindNet) { Instance *top = sdc_net_->topInstance(); Net *found = sdc_net_->findNet(top, "w1"); EXPECT_EQ(found, net1_); } // SdcNetwork: name(Instance) forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkInstanceName) { +TEST_F(NetworkAdapterTest, SdcNetworkInstanceName) { const char *name = sdc_net_->name(u1_); EXPECT_NE(name, nullptr); } // SdcNetwork: pathName(Instance) forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkInstancePathName) { +TEST_F(NetworkAdapterTest, SdcNetworkInstancePathName) { const char *path = sdc_net_->pathName(u1_); EXPECT_NE(path, nullptr); } // SdcNetwork: pathName(Pin) forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkPinPathName) { +TEST_F(NetworkAdapterTest, SdcNetworkPinPathName) { const char *path = sdc_net_->pathName(pin_b1_a_); EXPECT_NE(path, nullptr); } // SdcNetwork: portName(Pin) forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkPinPortName) { +TEST_F(NetworkAdapterTest, SdcNetworkPinPortName) { const char *port_name = sdc_net_->portName(pin_b1_a_); EXPECT_NE(port_name, nullptr); } // SdcNetwork: name(Net) forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkNetName) { +TEST_F(NetworkAdapterTest, SdcNetworkNetName) { const char *name = sdc_net_->name(net1_); EXPECT_NE(name, nullptr); } // SdcNetwork: pathName(Net) forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkNetPathName) { +TEST_F(NetworkAdapterTest, SdcNetworkNetPathName) { const char *path = sdc_net_->pathName(net1_); EXPECT_NE(path, nullptr); } // SdcNetwork: findChild forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkFindChild) { +TEST_F(NetworkAdapterTest, SdcNetworkFindChild) { Instance *top = sdc_net_->topInstance(); Instance *child = sdc_net_->findChild(top, "b1"); EXPECT_EQ(child, u1_); } // SdcNetwork: findInstance by path name -TEST_F(NetworkAdapterTest, R5_SdcNetworkFindInstance) { +TEST_F(NetworkAdapterTest, SdcNetworkFindInstance) { Instance *found = sdc_net_->findInstance("b1"); EXPECT_EQ(found, u1_); } // SdcNetwork: findPin(path) forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkFindPinPath) { +TEST_F(NetworkAdapterTest, SdcNetworkFindPinPath) { Pin *found = sdc_net_->findPin("b1/A"); EXPECT_EQ(found, pin_b1_a_); } // SdcNetwork: findPin(Instance, port_name) forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkFindPinInstancePort) { +TEST_F(NetworkAdapterTest, SdcNetworkFindPinInstancePort) { Pin *found = sdc_net_->findPin(u1_, "A"); EXPECT_EQ(found, pin_b1_a_); } // SdcNetwork: findNet(path) forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkFindNetPath) { +TEST_F(NetworkAdapterTest, SdcNetworkFindNetPath) { Net *found = sdc_net_->findNet("w1"); EXPECT_EQ(found, net1_); } // SdcNetwork: findNetRelative forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkFindNetRelative) { +TEST_F(NetworkAdapterTest, SdcNetworkFindNetRelative) { Instance *top = sdc_net_->topInstance(); Net *found = sdc_net_->findNetRelative(top, "w1"); EXPECT_EQ(found, net1_); } // SdcNetwork: findNetsMatching forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkFindNetsMatching) { +TEST_F(NetworkAdapterTest, SdcNetworkFindNetsMatching) { Instance *top = sdc_net_->topInstance(); PatternMatch pattern("w*"); NetSeq nets = sdc_net_->findNetsMatching(top, &pattern); @@ -3422,7 +3422,7 @@ TEST_F(NetworkAdapterTest, R5_SdcNetworkFindNetsMatching) { } // SdcNetwork: findInstNetsMatching forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkFindInstNetsMatching) { +TEST_F(NetworkAdapterTest, SdcNetworkFindInstNetsMatching) { Instance *top = sdc_net_->topInstance(); PatternMatch pattern("w*"); NetSeq nets; @@ -3431,7 +3431,7 @@ TEST_F(NetworkAdapterTest, R5_SdcNetworkFindInstNetsMatching) { } // SdcNetwork: findInstancesMatching forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkFindInstancesMatching) { +TEST_F(NetworkAdapterTest, SdcNetworkFindInstancesMatching) { Instance *top = sdc_net_->topInstance(); PatternMatch pattern("b*"); InstanceSeq insts = sdc_net_->findInstancesMatching(top, &pattern); @@ -3439,28 +3439,28 @@ TEST_F(NetworkAdapterTest, R5_SdcNetworkFindInstancesMatching) { } // SdcNetwork: findPinsMatching forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkFindPinsMatching) { +TEST_F(NetworkAdapterTest, SdcNetworkFindPinsMatching) { PatternMatch pattern("b1/A"); PinSeq pins = sdc_net_->findPinsMatching(network_.topInstance(), &pattern); EXPECT_GE(pins.size(), 1u); } // SdcNetwork: findInstanceRelative forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkFindInstanceRelative) { +TEST_F(NetworkAdapterTest, SdcNetworkFindInstanceRelative) { Instance *top = sdc_net_->topInstance(); Instance *found = sdc_net_->findInstanceRelative(top, "b1"); EXPECT_EQ(found, u1_); } // SdcNetwork: makeNet forwarding -TEST_F(NetworkAdapterTest, R5_SdcNetworkMakeNet) { +TEST_F(NetworkAdapterTest, SdcNetworkMakeNet) { Instance *top = sdc_net_->topInstance(); Net *new_net = sdc_net_->makeNet("sdc_net_new", top); EXPECT_NE(new_net, nullptr); } // NetworkNameAdapter: location forwarding -TEST_F(NetworkAdapterTest, R5_AdapterLocation) { +TEST_F(NetworkAdapterTest, AdapterLocation) { double x, y; bool exists; sdc_net_->location(pin_b1_a_, x, y, exists); @@ -3468,7 +3468,7 @@ TEST_F(NetworkAdapterTest, R5_AdapterLocation) { } // NetworkNameAdapter: libertyPort forwarding (non-liberty port) -TEST_F(NetworkAdapterTest, R5_AdapterLibertyPort) { +TEST_F(NetworkAdapterTest, AdapterLibertyPort) { LibertyPort *lp = sdc_net_->libertyPort(port_a_); EXPECT_EQ(lp, nullptr); } @@ -3478,7 +3478,7 @@ TEST_F(NetworkAdapterTest, R5_AdapterLibertyPort) { //////////////////////////////////////////////////////////////// // ConcreteNetwork: addConstantNet then verify iteration -TEST_F(ConcreteNetworkLinkedTest, R6_AddConstantAndIterate) { +TEST_F(ConcreteNetworkLinkedTest, AddConstantAndIterate) { network_.addConstantNet(net1_, LogicValue::one); ConstantPinIterator *iter = network_.constantPinIterator(); EXPECT_NE(iter, nullptr); @@ -3495,21 +3495,21 @@ TEST_F(ConcreteNetworkLinkedTest, R6_AddConstantAndIterate) { } // ConcreteInstance: cell() accessor -TEST_F(ConcreteNetworkLinkedTest, R6_ConcreteInstanceCell) { +TEST_F(ConcreteNetworkLinkedTest, ConcreteInstanceCell) { Cell *cell = network_.cell(u1_); EXPECT_NE(cell, nullptr); EXPECT_STREQ(network_.name(cell), "INV"); } // ConcreteInstance: findChild returns nullptr on leaf -TEST_F(ConcreteNetworkLinkedTest, R6_FindChildOnLeaf) { +TEST_F(ConcreteNetworkLinkedTest, FindChildOnLeaf) { // u1_ is a leaf instance, should have no children Instance *child = network_.findChild(u1_, "nonexistent"); EXPECT_EQ(child, nullptr); } // ConcreteInstance: findPin(Port) with existing port -TEST_F(ConcreteNetworkLinkedTest, R6_FindPinByPortDirect) { +TEST_F(ConcreteNetworkLinkedTest, FindPinByPortDirect) { Cell *cell = network_.cell(u1_); Port *port_a = network_.findPort(cell, "A"); Pin *pin = network_.findPin(u1_, port_a); @@ -3517,7 +3517,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_FindPinByPortDirect) { } // ConcreteInstance: deleteChild -TEST_F(ConcreteNetworkLinkedTest, R6_DeleteChild) { +TEST_F(ConcreteNetworkLinkedTest, DeleteChild) { Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *top = network_.topInstance(); Instance *temp = network_.makeInstance(inv_cell, "temp_child", top); @@ -3528,7 +3528,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_DeleteChild) { } // ConcreteInstance: addNet and deleteNet (via network) -TEST_F(ConcreteNetworkLinkedTest, R6_AddAndDeleteNet) { +TEST_F(ConcreteNetworkLinkedTest, AddAndDeleteNet) { Instance *top = network_.topInstance(); Net *new_net = network_.makeNet("r6_net", top); EXPECT_NE(new_net, nullptr); @@ -3538,7 +3538,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_AddAndDeleteNet) { } // ConcreteInstance: setCell (replaceCell exercises setCell) -TEST_F(ConcreteNetworkLinkedTest, R6_SetCellViaReplace) { +TEST_F(ConcreteNetworkLinkedTest, SetCellViaReplace) { Cell *buf_cell = network_.makeCell(lib_, "BUF_R6", true, "test.lib"); network_.makePort(buf_cell, "A"); network_.makePort(buf_cell, "Y"); @@ -3554,7 +3554,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_SetCellViaReplace) { } // ConcretePin: name() via Network base class -TEST_F(ConcreteNetworkLinkedTest, R6_ConcretePinName) { +TEST_F(ConcreteNetworkLinkedTest, ConcretePinName) { const Network &net = network_; const char *name = net.name(pin_u1_a_); EXPECT_NE(name, nullptr); @@ -3564,7 +3564,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_ConcretePinName) { } // ConcretePin: setVertexId -TEST_F(ConcreteNetworkLinkedTest, R6_PinSetVertexIdMultiple) { +TEST_F(ConcreteNetworkLinkedTest, PinSetVertexIdMultiple) { network_.setVertexId(pin_u1_a_, 100); EXPECT_EQ(network_.vertexId(pin_u1_a_), 100u); network_.setVertexId(pin_u1_a_, 200); @@ -3574,7 +3574,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_PinSetVertexIdMultiple) { } // ConcreteTerm: name() via Network base class -TEST_F(ConcreteNetworkLinkedTest, R6_ConcreteTermName) { +TEST_F(ConcreteNetworkLinkedTest, ConcreteTermName) { Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *u3 = network_.makeInstance(inv_cell, "u3_term", network_.topInstance()); Port *port_a = network_.findPort(inv_cell, "A"); @@ -3588,7 +3588,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_ConcreteTermName) { } // Network: name(Term), pathName(Term), portName(Term) -TEST_F(ConcreteNetworkLinkedTest, R6_TermPathAndPortName) { +TEST_F(ConcreteNetworkLinkedTest, TermPathAndPortName) { Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *u4 = network_.makeInstance(inv_cell, "u4_term", network_.topInstance()); Port *port_a = network_.findPort(inv_cell, "A"); @@ -3609,7 +3609,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_TermPathAndPortName) { } // Network: id(Term) -TEST_F(ConcreteNetworkLinkedTest, R6_TermId) { +TEST_F(ConcreteNetworkLinkedTest, TermId2) { Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *u5 = network_.makeInstance(inv_cell, "u5_term", network_.topInstance()); Port *port_a = network_.findPort(inv_cell, "A"); @@ -3621,7 +3621,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_TermId) { } // Network: findPin by string name on instance -TEST_F(ConcreteNetworkLinkedTest, R6_FindPinByStringName) { +TEST_F(ConcreteNetworkLinkedTest, FindPinByStringName) { Pin *found = network_.findPin(u1_, "A"); EXPECT_EQ(found, pin_u1_a_); Pin *found_y = network_.findPin(u1_, "Y"); @@ -3631,7 +3631,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_FindPinByStringName) { } // Network: findNet by instance and name -TEST_F(ConcreteNetworkLinkedTest, R6_FindNetByInstanceName) { +TEST_F(ConcreteNetworkLinkedTest, FindNetByInstanceName) { Instance *top = network_.topInstance(); Net *found = network_.findNet(top, "n1"); EXPECT_EQ(found, net1_); @@ -3642,7 +3642,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_FindNetByInstanceName) { } // Network: findNetsMatching comprehensive -TEST_F(ConcreteNetworkLinkedTest, R6_FindNetsMatchingComprehensive) { +TEST_F(ConcreteNetworkLinkedTest, FindNetsMatchingComprehensive) { Instance *top = network_.topInstance(); PatternMatch pattern_all("*"); NetSeq all_matches = network_.findNetsMatching(top, &pattern_all); @@ -3650,14 +3650,14 @@ TEST_F(ConcreteNetworkLinkedTest, R6_FindNetsMatchingComprehensive) { } // Network: hasMembersOnScalarPort -TEST_F(ConcreteNetworkLinkedTest, R6_HasMembersScalar) { +TEST_F(ConcreteNetworkLinkedTest, HasMembersScalar) { Cell *inv_cell = network_.findCell(lib_, "INV"); Port *port_a = network_.findPort(inv_cell, "A"); EXPECT_FALSE(network_.hasMembers(port_a)); } // Network: hasMembersOnBusPort -TEST_F(ConcreteNetworkLinkedTest, R6_HasMembersBusPort) { +TEST_F(ConcreteNetworkLinkedTest, HasMembersBusPort) { ConcreteLibrary *clib = reinterpret_cast(lib_); clib->setBusBrkts('[', ']'); Cell *cell = network_.makeCell(lib_, "R6_BUS_TEST", true, "test.lib"); @@ -3666,7 +3666,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_HasMembersBusPort) { } // Network: libertyCell from const cell -TEST_F(ConcreteNetworkLinkedTest, R6_LibertyCellFromConstCell) { +TEST_F(ConcreteNetworkLinkedTest, LibertyCellFromConstCell) { Cell *inv_cell = network_.findCell(lib_, "INV"); const Cell *cc = inv_cell; const LibertyCell *lcell = network_.libertyCell(cc); @@ -3674,7 +3674,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_LibertyCellFromConstCell) { } // ConcreteNet: destructor (via deleteNet which calls ~ConcreteNet) -TEST_F(ConcreteNetworkLinkedTest, R6_NetDestructor) { +TEST_F(ConcreteNetworkLinkedTest, NetDestructor) { Instance *top = network_.topInstance(); Net *temp_net = network_.makeNet("r6_temp_net", top); EXPECT_NE(network_.findNet(top, "r6_temp_net"), nullptr); @@ -3683,7 +3683,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_NetDestructor) { } // ConcreteNet: addPin, addTerm via connect and makeTerm -TEST_F(ConcreteNetworkLinkedTest, R6_NetAddPinAndTerm) { +TEST_F(ConcreteNetworkLinkedTest, NetAddPinAndTerm) { Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *u6 = network_.makeInstance(inv_cell, "u6", network_.topInstance()); Port *port_a = network_.findPort(inv_cell, "A"); @@ -3700,7 +3700,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_NetAddPinAndTerm) { } // ConcreteNet: deleteTerm (via disconnect which removes term) -TEST_F(ConcreteNetworkLinkedTest, R6_NetTermIteratorAfterConnect) { +TEST_F(ConcreteNetworkLinkedTest, NetTermIteratorAfterConnect) { Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *u7 = network_.makeInstance(inv_cell, "u7", network_.topInstance()); Port *port_a = network_.findPort(inv_cell, "A"); @@ -3721,7 +3721,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_NetTermIteratorAfterConnect) { } // ConcreteInstancePinIterator constructor exercise -TEST_F(ConcreteNetworkLinkedTest, R6_InstancePinIteratorExercise) { +TEST_F(ConcreteNetworkLinkedTest, InstancePinIteratorExercise) { InstancePinIterator *iter = network_.pinIterator(u1_); ASSERT_NE(iter, nullptr); PinSeq pins; @@ -3733,7 +3733,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_InstancePinIteratorExercise) { } // ConcreteNetPinIterator constructor -TEST_F(ConcreteNetworkLinkedTest, R6_NetPinIteratorExercise) { +TEST_F(ConcreteNetworkLinkedTest, NetPinIteratorExercise) { // net1_ has 1 pin (u1_A) NetPinIterator *iter = network_.pinIterator(net1_); ASSERT_NE(iter, nullptr); @@ -3747,7 +3747,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_NetPinIteratorExercise) { } // ConcreteNetTermIterator -TEST_F(ConcreteNetworkLinkedTest, R6_NetTermIteratorEmpty) { +TEST_F(ConcreteNetworkLinkedTest, NetTermIteratorEmpty) { // net3_ has pins but no terms (leaf connections) NetTermIterator *iter = network_.termIterator(net3_); ASSERT_NE(iter, nullptr); @@ -3761,7 +3761,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_NetTermIteratorEmpty) { } // ConcreteLibertyLibraryIterator (exercises constructor and destructor) -TEST(ConcreteNetworkExtraTest, R6_LibertyLibIteratorEmpty) { +TEST(ConcreteNetworkExtraTest, LibertyLibIteratorEmpty) { ConcreteNetwork network; LibertyLibraryIterator *iter = network.libertyLibraryIterator(); ASSERT_NE(iter, nullptr); @@ -3770,7 +3770,7 @@ TEST(ConcreteNetworkExtraTest, R6_LibertyLibIteratorEmpty) { } // ConcreteLibertyLibraryIterator with one liberty library -TEST(ConcreteNetworkExtraTest, R6_LibertyLibIteratorWithLib) { +TEST(ConcreteNetworkExtraTest, LibertyLibIteratorWithLib) { ConcreteNetwork network; network.makeLibertyLibrary("r6_lib", "r6.lib"); LibertyLibraryIterator *iter = network.libertyLibraryIterator(); @@ -3785,7 +3785,7 @@ TEST(ConcreteNetworkExtraTest, R6_LibertyLibIteratorWithLib) { } // ConcreteLibraryIterator1 (exercises constructor) -TEST(ConcreteNetworkExtraTest, R6_LibraryIteratorMultiple) { +TEST(ConcreteNetworkExtraTest, LibraryIteratorMultiple) { ConcreteNetwork network; network.makeLibrary("r6_lib1", "r6_1.lib"); network.makeLibrary("r6_lib2", "r6_2.lib"); @@ -3801,7 +3801,7 @@ TEST(ConcreteNetworkExtraTest, R6_LibraryIteratorMultiple) { } // ConcreteCellPortIterator1 (exercises constructor) -TEST(ConcreteCellTest, R6_PortIterator1) { +TEST(ConcreteCellTest, PortIterator1) { ConcreteLibrary lib("test_lib", "test.lib", false); ConcreteCell *cell = lib.makeCell("R6_AND3", true, ""); cell->makePort("A"); @@ -3820,7 +3820,7 @@ TEST(ConcreteCellTest, R6_PortIterator1) { } // ConcreteCellPortBitIterator (with bus ports) -TEST(ConcreteCellTest, R6_PortBitIteratorWithBus) { +TEST(ConcreteCellTest, PortBitIteratorWithBus) { ConcreteLibrary lib("test_lib", "test.lib", false); lib.setBusBrkts('[', ']'); ConcreteCell *cell = lib.makeCell("R6_REG8", true, ""); @@ -3840,7 +3840,7 @@ TEST(ConcreteCellTest, R6_PortBitIteratorWithBus) { } // ConcreteCellPortBitIterator1 exercise -TEST(ConcreteCellTest, R6_PortBitIterator1Simple) { +TEST(ConcreteCellTest, PortBitIterator1Simple) { ConcreteLibrary lib("test_lib", "test.lib", false); ConcreteCell *cell = lib.makeCell("R6_INV2", true, ""); cell->makePort("A"); @@ -3857,7 +3857,7 @@ TEST(ConcreteCellTest, R6_PortBitIterator1Simple) { } // ConcretePortMemberIterator1 exercise -TEST(ConcretePortTest, R6_MemberIteratorBus) { +TEST(ConcretePortTest, MemberIteratorBus) { ConcreteLibrary lib("test_lib", "test.lib", false); lib.setBusBrkts('[', ']'); ConcreteCell *cell = lib.makeCell("R6_REG4", true, ""); @@ -3874,7 +3874,7 @@ TEST(ConcretePortTest, R6_MemberIteratorBus) { } // ConcreteInstanceChildIterator exercise -TEST_F(ConcreteNetworkLinkedTest, R6_ChildIteratorExercise) { +TEST_F(ConcreteNetworkLinkedTest, ChildIteratorExercise) { Instance *top = network_.topInstance(); InstanceChildIterator *iter = network_.childIterator(top); ASSERT_NE(iter, nullptr); @@ -3887,7 +3887,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_ChildIteratorExercise) { } // Network: connect with LibertyPort (null liberty port variant) -TEST_F(ConcreteNetworkLinkedTest, R6_ConnectWithPort) { +TEST_F(ConcreteNetworkLinkedTest, ConnectWithPort) { Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *u8 = network_.makeInstance(inv_cell, "u8_conn", network_.topInstance()); Port *port_y = network_.findPort(inv_cell, "Y"); @@ -3898,7 +3898,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_ConnectWithPort) { } // Network: deletePin (exercises ConcreteInstance::deletePin) -TEST_F(ConcreteNetworkLinkedTest, R6_DeletePinExercise) { +TEST_F(ConcreteNetworkLinkedTest, DeletePinExercise) { Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *u9 = network_.makeInstance(inv_cell, "u9_delpin", network_.topInstance()); Port *port_a = network_.findPort(inv_cell, "A"); @@ -3912,7 +3912,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_DeletePinExercise) { } // BusPort: default constructor exercises (via makeBusPort) -TEST(ConcretePortTest, R6_BusPortDefaultCtor) { +TEST(ConcretePortTest, BusPortDefaultCtor) { ConcreteLibrary lib("test_lib", "test.lib", false); lib.setBusBrkts('[', ']'); ConcreteCell *cell = lib.makeCell("R6_BUSTEST", true, ""); @@ -3925,7 +3925,7 @@ TEST(ConcretePortTest, R6_BusPortDefaultCtor) { } // BusPort: setDirection propagates to members -TEST(ConcretePortTest, R6_BusPortSetDirection) { +TEST(ConcretePortTest, BusPortSetDirection) { PortDirection::init(); ConcreteLibrary lib("test_lib", "test.lib", false); lib.setBusBrkts('[', ']'); @@ -3940,20 +3940,20 @@ TEST(ConcretePortTest, R6_BusPortSetDirection) { } // NetworkNameAdapter: makeLibertyLibrary forwarding -TEST_F(NetworkAdapterTest, R6_AdapterMakeLibertyLibrary) { +TEST_F(NetworkAdapterTest, AdapterMakeLibertyLibrary) { LibertyLibrary *lib = sdc_net_->makeLibertyLibrary("r6_lib", "r6.lib"); EXPECT_NE(lib, nullptr); } // NetworkNameAdapter: findCellsMatching forwarding -TEST_F(NetworkAdapterTest, R6_AdapterFindCellsMatching) { +TEST_F(NetworkAdapterTest, AdapterFindCellsMatching) { PatternMatch pattern("BUF*"); CellSeq cells = sdc_net_->findCellsMatching(lib_, &pattern); EXPECT_GE(cells.size(), 1u); } // NetworkNameAdapter: isLinked forwarding -TEST_F(NetworkAdapterTest, R6_AdapterIsLinked) { +TEST_F(NetworkAdapterTest, AdapterIsLinked) { EXPECT_TRUE(sdc_net_->isLinked()); } @@ -3961,7 +3961,7 @@ TEST_F(NetworkAdapterTest, R6_AdapterIsLinked) { // without an actual LibertyPort, so skip. // Network: findPin(Instance, Port) with non-matching port -TEST_F(ConcreteNetworkLinkedTest, R6_FindPinNonMatchingPort) { +TEST_F(ConcreteNetworkLinkedTest, FindPinNonMatchingPort) { Cell *inv_cell = network_.findCell(lib_, "INV"); Port *port_y = network_.findPort(inv_cell, "Y"); // u1_ is connected on A and Y, find Y pin @@ -3970,7 +3970,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_FindPinNonMatchingPort) { } // Network: findPinsMatching with no match -TEST_F(ConcreteNetworkLinkedTest, R6_FindPinsMatchingNoMatch) { +TEST_F(ConcreteNetworkLinkedTest, FindPinsMatchingNoMatch) { Instance *top = network_.topInstance(); PatternMatch pattern("nonexistent/*"); PinSeq pins = network_.findPinsMatching(top, &pattern); @@ -3978,7 +3978,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_FindPinsMatchingNoMatch) { } // Network: findNetsMatching with no match -TEST_F(ConcreteNetworkLinkedTest, R6_FindNetsMatchingNoMatch) { +TEST_F(ConcreteNetworkLinkedTest, FindNetsMatchingNoMatch) { Instance *top = network_.topInstance(); PatternMatch pattern("zzz*"); NetSeq matches = network_.findNetsMatching(top, &pattern); @@ -3986,7 +3986,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_FindNetsMatchingNoMatch) { } // Network: findInstancesMatching with no match -TEST_F(ConcreteNetworkLinkedTest, R6_FindInstancesMatchingNoMatch) { +TEST_F(ConcreteNetworkLinkedTest, FindInstancesMatchingNoMatch) { Instance *top = network_.topInstance(); PatternMatch pattern("zzz*"); InstanceSeq matches = network_.findInstancesMatching(top, &pattern); @@ -3994,7 +3994,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_FindInstancesMatchingNoMatch) { } // ConcreteNetwork: initPins via makePins on new instance -TEST_F(ConcreteNetworkLinkedTest, R6_InitPinsExercise) { +TEST_F(ConcreteNetworkLinkedTest, InitPinsExercise) { Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *u10 = network_.makeInstance(inv_cell, "u10_init", network_.topInstance()); network_.makePins(u10); @@ -4005,7 +4005,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_InitPinsExercise) { } // ConcreteNetwork: mergeInto and mergedInto cycle -TEST_F(ConcreteNetworkLinkedTest, R6_MergeIntoCycle) { +TEST_F(ConcreteNetworkLinkedTest, MergeIntoCycle) { Instance *top = network_.topInstance(); Net *na = network_.makeNet("r6_merge_a", top); Net *nb = network_.makeNet("r6_merge_b", top); @@ -4019,7 +4019,7 @@ TEST_F(ConcreteNetworkLinkedTest, R6_MergeIntoCycle) { // Can't easily test without real LibertyPort, skip. // PatternMatch: exercise findPortsMatching with wildcard -TEST_F(ConcreteNetworkLinkedTest, R6_FindPortsMatchingWildcard) { +TEST_F(ConcreteNetworkLinkedTest, FindPortsMatchingWildcard) { Cell *inv_cell = network_.findCell(lib_, "INV"); PatternMatch pattern("?"); PortSeq ports = network_.findPortsMatching(inv_cell, &pattern); @@ -4028,20 +4028,20 @@ TEST_F(ConcreteNetworkLinkedTest, R6_FindPortsMatchingWildcard) { } // ConcreteNetwork: findCellsMatching with no match -TEST_F(ConcreteNetworkLinkedTest, R6_FindCellsMatchingNoMatch) { +TEST_F(ConcreteNetworkLinkedTest, FindCellsMatchingNoMatch) { PatternMatch pattern("ZZZZ*"); CellSeq cells = network_.findCellsMatching(lib_, &pattern); EXPECT_EQ(cells.size(), 0u); } // Network: isInsideNet with non-top instance -TEST_F(ConcreteNetworkLinkedTest, R6_IsInsideNetNonTop) { +TEST_F(ConcreteNetworkLinkedTest, IsInsideNetNonTop) { // net1_ is in top, not inside u1_ EXPECT_FALSE(network_.isInside(net1_, u1_)); } // ConcreteNetwork: multiple connect/disconnect cycles -TEST_F(ConcreteNetworkLinkedTest, R6_ConnectDisconnectCycle) { +TEST_F(ConcreteNetworkLinkedTest, ConnectDisconnectCycle) { Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *u11 = network_.makeInstance(inv_cell, "u11_cycle", network_.topInstance()); Port *port_a = network_.findPort(inv_cell, "A"); @@ -4067,33 +4067,33 @@ TEST_F(ConcreteNetworkLinkedTest, R6_ConnectDisconnectCycle) { // is complex. Skip direct testing. // SdcNetwork: findChild forwarding with non-existent -TEST_F(NetworkAdapterTest, R6_SdcFindChildNonexistent) { +TEST_F(NetworkAdapterTest, SdcFindChildNonexistent) { Instance *top = sdc_net_->topInstance(); Instance *child = sdc_net_->findChild(top, "nonexistent"); EXPECT_EQ(child, nullptr); } // SdcNetwork: findNet with non-existent -TEST_F(NetworkAdapterTest, R6_SdcFindNetNonexistent) { +TEST_F(NetworkAdapterTest, SdcFindNetNonexistent) { Instance *top = sdc_net_->topInstance(); Net *found = sdc_net_->findNet(top, "nonexistent"); EXPECT_EQ(found, nullptr); } // SdcNetwork: findPin with non-existent path -TEST_F(NetworkAdapterTest, R6_SdcFindPinNonexistent) { +TEST_F(NetworkAdapterTest, SdcFindPinNonexistent) { Pin *found = sdc_net_->findPin("nonexistent/X"); EXPECT_EQ(found, nullptr); } // SdcNetwork: findInstance with non-existent path -TEST_F(NetworkAdapterTest, R6_SdcFindInstanceNonexistent) { +TEST_F(NetworkAdapterTest, SdcFindInstanceNonexistent) { Instance *found = sdc_net_->findInstance("nonexistent_inst"); EXPECT_EQ(found, nullptr); } // SdcNetwork: deleteNet forwarding -TEST_F(NetworkAdapterTest, R6_SdcDeleteNet) { +TEST_F(NetworkAdapterTest, SdcDeleteNet) { Instance *top = sdc_net_->topInstance(); Net *n = sdc_net_->makeNet("r6_sdc_delnet", top); EXPECT_NE(n, nullptr); @@ -4103,13 +4103,13 @@ TEST_F(NetworkAdapterTest, R6_SdcDeleteNet) { } // SdcNetwork: libertyCell on cell (no liberty cell) -TEST_F(NetworkAdapterTest, R6_SdcLibertyCellFromCell) { +TEST_F(NetworkAdapterTest, SdcLibertyCellFromCell) { LibertyCell *lc = sdc_net_->libertyCell(inv_cell_); EXPECT_EQ(lc, nullptr); } // SdcNetwork: libertyPort from port -TEST_F(NetworkAdapterTest, R6_SdcLibertyPortFromPort) { +TEST_F(NetworkAdapterTest, SdcLibertyPortFromPort) { LibertyPort *lp = sdc_net_->libertyPort(port_a_); EXPECT_EQ(lp, nullptr); } @@ -4119,14 +4119,14 @@ TEST_F(NetworkAdapterTest, R6_SdcLibertyPortFromPort) { //////////////////////////////////////////////////////////////// // ConcreteInstance::findChild on instance with no children -TEST_F(ConcreteNetworkLinkedTest, R7_FindChildNonexistent) { +TEST_F(ConcreteNetworkLinkedTest, FindChildNonexistent) { // u1_ is a leaf instance, should have no children Instance *child = network_.findChild(u1_, "nonexistent"); EXPECT_EQ(child, nullptr); } // ConcreteInstance::findPin(Port) - exercise via Network::findPin(Instance*, Port*) -TEST_F(ConcreteNetworkLinkedTest, R7_FindPinByPort) { +TEST_F(ConcreteNetworkLinkedTest, FindPinByPort3) { Cell *inv_cell = network_.findCell(lib_, "INV"); Port *port_a = network_.findPort(inv_cell, "A"); Pin *pin = network_.findPin(u1_, port_a); @@ -4135,14 +4135,14 @@ TEST_F(ConcreteNetworkLinkedTest, R7_FindPinByPort) { } // ConcretePin::name() - exercises the name() method on concrete pins -TEST_F(ConcreteNetworkLinkedTest, R7_PinName) { +TEST_F(ConcreteNetworkLinkedTest, PinName2) { const char *name = network_.name(network_.port(pin_u1_a_)); EXPECT_NE(name, nullptr); EXPECT_STREQ(name, "A"); } // ConcretePin::setVertexId - exercises via Network::setVertexId -TEST_F(ConcreteNetworkLinkedTest, R7_PinVertexId) { +TEST_F(ConcreteNetworkLinkedTest, PinVertexId2) { VertexId orig = network_.vertexId(pin_u1_a_); network_.setVertexId(pin_u1_a_, 42); EXPECT_EQ(network_.vertexId(pin_u1_a_), 42u); @@ -4151,7 +4151,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_PinVertexId) { } // ConcreteNet: term iterator (exercises ConcreteNetTermIterator) -TEST_F(ConcreteNetworkLinkedTest, R7_NetTermIterator) { +TEST_F(ConcreteNetworkLinkedTest, NetTermIterator2) { NetTermIterator *iter = network_.termIterator(net1_); ASSERT_NE(iter, nullptr); int count = 0; @@ -4165,7 +4165,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_NetTermIterator) { } // ConcreteNet: pin iterator (exercises ConcreteNetPinIterator) -TEST_F(ConcreteNetworkLinkedTest, R7_NetPinIterator) { +TEST_F(ConcreteNetworkLinkedTest, NetPinIterator2) { NetPinIterator *iter = network_.pinIterator(net2_); ASSERT_NE(iter, nullptr); int count = 0; @@ -4179,7 +4179,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_NetPinIterator) { } // Network::makeTerm (exercises ConcreteTerm constructor and ConcreteNet::addTerm) -TEST_F(ConcreteNetworkLinkedTest, R7_MakeTermAndTermName) { +TEST_F(ConcreteNetworkLinkedTest, MakeTermAndTermName) { // Make a top-level pin to create a term Instance *top = network_.topInstance(); Cell *top_cell = network_.cell(top); @@ -4206,7 +4206,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_MakeTermAndTermName) { } // Network::findPinLinear - exercises the linear search fallback -TEST_F(ConcreteNetworkLinkedTest, R7_FindPinLinear) { +TEST_F(ConcreteNetworkLinkedTest, FindPinLinear) { // findPinLinear is a fallback used when there's no hash lookup Pin *pin = network_.findPin(u1_, "A"); EXPECT_NE(pin, nullptr); @@ -4216,7 +4216,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_FindPinLinear) { } // Network::findNetLinear - exercises linear net search -TEST_F(ConcreteNetworkLinkedTest, R7_FindNetLinear) { +TEST_F(ConcreteNetworkLinkedTest, FindNetLinear) { Instance *top = network_.topInstance(); Net *net = network_.findNet(top, "n1"); EXPECT_NE(net, nullptr); @@ -4225,7 +4225,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_FindNetLinear) { } // Network::hasMembers on scalar port and bus port -TEST(ConcretePortTest, R7_HasMembersScalar) { +TEST(ConcretePortTest, HasMembersScalar) { ConcreteLibrary lib("test_lib", "test.lib", false); lib.setBusBrkts('[', ']'); ConcreteCell *cell = lib.makeCell("R7_HAS", true, ""); @@ -4240,7 +4240,7 @@ TEST(ConcretePortTest, R7_HasMembersScalar) { // R7_LibertyLibraryFromCell removed (segfault) // ConcreteInstance::initPins - exercised when making a new instance -TEST_F(ConcreteNetworkLinkedTest, R7_InitPinsNewInstance) { +TEST_F(ConcreteNetworkLinkedTest, InitPinsNewInstance) { Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *new_inst = network_.makeInstance(inv_cell, "r7_initpins", network_.topInstance()); EXPECT_NE(new_inst, nullptr); @@ -4260,7 +4260,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_InitPinsNewInstance) { } // ConcreteNetwork::deleteInstance (exercises deleteChild, deletePin) -TEST_F(ConcreteNetworkLinkedTest, R7_DeleteInstance) { +TEST_F(ConcreteNetworkLinkedTest, DeleteInstance2) { Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *del_inst = network_.makeInstance(inv_cell, "r7_del", network_.topInstance()); EXPECT_NE(del_inst, nullptr); @@ -4272,7 +4272,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_DeleteInstance) { } // ConcreteNetwork: deleteNet (exercises ConcreteNet destructor, ConcreteInstance::deleteNet) -TEST_F(ConcreteNetworkLinkedTest, R7_DeleteNet) { +TEST_F(ConcreteNetworkLinkedTest, DeleteNet2) { Instance *top = network_.topInstance(); Net *del_net = network_.makeNet("r7_del_net", top); EXPECT_NE(del_net, nullptr); @@ -4284,7 +4284,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_DeleteNet) { } // ConcreteInstance::setCell (indirect via replaceCell) -TEST_F(ConcreteNetworkLinkedTest, R7_ReplaceCell) { +TEST_F(ConcreteNetworkLinkedTest, ReplaceCell2) { Cell *inv_cell = network_.findCell(lib_, "INV"); // Create a second cell type Cell *buf_cell = network_.makeCell(lib_, "R7_BUF", true, "test.lib"); @@ -4297,7 +4297,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_ReplaceCell) { } // ConcreteInstance::addNet via makeNet and findNet on child instance -TEST_F(ConcreteNetworkLinkedTest, R7_InstanceNet) { +TEST_F(ConcreteNetworkLinkedTest, InstanceNet) { // Make net on a non-top instance (exercises ConcreteInstance::addNet(name, net)) Cell *sub_cell = network_.makeCell(lib_, "R7_SUB", false, "test.lib"); network_.makePort(sub_cell, "in1"); @@ -4309,28 +4309,28 @@ TEST_F(ConcreteNetworkLinkedTest, R7_InstanceNet) { } // NetworkNameAdapter: findPort forwarding -TEST_F(NetworkAdapterTest, R7_AdapterFindPort) { +TEST_F(NetworkAdapterTest, AdapterFindPort2) { Port *port = sdc_net_->findPort(inv_cell_, "A"); EXPECT_NE(port, nullptr); EXPECT_EQ(port, port_a_); } // NetworkNameAdapter: findPortsMatching forwarding -TEST_F(NetworkAdapterTest, R7_AdapterFindPortsMatching) { +TEST_F(NetworkAdapterTest, AdapterFindPortsMatching2) { PatternMatch pattern("*"); PortSeq ports = sdc_net_->findPortsMatching(inv_cell_, &pattern); EXPECT_GE(ports.size(), 2u); } // NetworkNameAdapter: name(Port) forwarding -TEST_F(NetworkAdapterTest, R7_AdapterPortName) { +TEST_F(NetworkAdapterTest, AdapterPortName2) { const char *name = sdc_net_->name(port_a_); EXPECT_NE(name, nullptr); EXPECT_STREQ(name, "A"); } // NetworkNameAdapter: busName(Port) forwarding -TEST_F(NetworkAdapterTest, R7_AdapterPortBusName) { +TEST_F(NetworkAdapterTest, AdapterPortBusName2) { const char *bname = sdc_net_->busName(port_a_); EXPECT_NE(bname, nullptr); } @@ -4342,7 +4342,7 @@ TEST_F(NetworkAdapterTest, R7_AdapterPortBusName) { // R7_AdapterFindPinLibertyPort removed (segfault) // NetworkNameAdapter: id(Term) forwarding -TEST_F(NetworkAdapterTest, R7_AdapterTermId) { +TEST_F(NetworkAdapterTest, AdapterTermId) { // Make a top-level pin to get a term Instance *top = sdc_net_->topInstance(); Cell *top_cell = sdc_net_->cell(top); @@ -4358,14 +4358,14 @@ TEST_F(NetworkAdapterTest, R7_AdapterTermId) { } // NetworkNameAdapter: makeNet forwarding -TEST_F(NetworkAdapterTest, R7_AdapterMakeNet) { +TEST_F(NetworkAdapterTest, AdapterMakeNet2) { Instance *top = sdc_net_->topInstance(); Net *net = sdc_net_->makeNet("r7_adapter_net", top); EXPECT_NE(net, nullptr); } // NetworkNameAdapter: connect(Instance, Port, Net) forwarding -TEST_F(NetworkAdapterTest, R7_AdapterConnect) { +TEST_F(NetworkAdapterTest, AdapterConnect2) { Instance *top = sdc_net_->topInstance(); Net *net = sdc_net_->makeNet("r7_adapter_conn_net", top); // makeInstance requires LibertyCell, get it from the network @@ -4377,7 +4377,7 @@ TEST_F(NetworkAdapterTest, R7_AdapterConnect) { } // Network::findNetsMatchingLinear exercises -TEST_F(ConcreteNetworkLinkedTest, R7_FindNetsMatchingLinear) { +TEST_F(ConcreteNetworkLinkedTest, FindNetsMatchingLinear) { Instance *top = network_.topInstance(); PatternMatch pattern("n*"); NetSeq matches = network_.findNetsMatching(top, &pattern); @@ -4386,7 +4386,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_FindNetsMatchingLinear) { } // ConcreteNetwork: addConstantNet and clearConstantNets -TEST_F(ConcreteNetworkLinkedTest, R7_ConstantNets) { +TEST_F(ConcreteNetworkLinkedTest, ConstantNets) { Instance *top = network_.topInstance(); Net *const_net = network_.makeNet("r7_const", top); network_.addConstantNet(const_net, LogicValue::one); @@ -4399,7 +4399,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_ConstantNets) { } // ConcreteLibertyLibraryIterator exercise -TEST(ConcreteNetworkTest, R7_LibertyLibraryIterator) { +TEST(ConcreteNetworkTest, LibertyLibraryIterator) { ConcreteNetwork network; LibertyLibraryIterator *iter = network.libertyLibraryIterator(); ASSERT_NE(iter, nullptr); @@ -4408,7 +4408,7 @@ TEST(ConcreteNetworkTest, R7_LibertyLibraryIterator) { } // ConcreteLibraryIterator1 exercise -TEST(ConcreteNetworkTest, R7_LibraryIteratorEmpty) { +TEST(ConcreteNetworkTest, LibraryIteratorEmpty) { ConcreteNetwork network; LibraryIterator *iter = network.libraryIterator(); ASSERT_NE(iter, nullptr); @@ -4417,7 +4417,7 @@ TEST(ConcreteNetworkTest, R7_LibraryIteratorEmpty) { } // ConcreteInstancePinIterator exercise -TEST_F(ConcreteNetworkLinkedTest, R7_InstancePinIterator) { +TEST_F(ConcreteNetworkLinkedTest, InstancePinIterator2) { InstancePinIterator *iter = network_.pinIterator(u1_); ASSERT_NE(iter, nullptr); int count = 0; @@ -4432,7 +4432,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_InstancePinIterator) { } // Network: mergeInto exercises (ConcreteNet::mergeInto path) -TEST_F(ConcreteNetworkLinkedTest, R7_MergeNets) { +TEST_F(ConcreteNetworkLinkedTest, MergeNets) { Instance *top = network_.topInstance(); Net *na = network_.makeNet("r7_merge_a", top); Net *nb = network_.makeNet("r7_merge_b", top); @@ -4442,7 +4442,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_MergeNets) { } // BusPort: setDirection exercises BusPort::setDirection -TEST(ConcretePortTest, R7_BusPortSetDirectionInput) { +TEST(ConcretePortTest, BusPortSetDirectionInput) { PortDirection::init(); ConcreteLibrary lib("test_lib", "test.lib", false); lib.setBusBrkts('[', ']'); @@ -4464,7 +4464,7 @@ TEST(ConcretePortTest, R7_BusPortSetDirectionInput) { // R7_AdapterLinkNetwork removed (segfault) // ConcreteNetwork: findAnyCell -TEST_F(ConcreteNetworkLinkedTest, R7_FindAnyCell) { +TEST_F(ConcreteNetworkLinkedTest, FindAnyCell) { Cell *cell = network_.findAnyCell("INV"); EXPECT_NE(cell, nullptr); Cell *no_cell = network_.findAnyCell("NONEXISTENT_R7"); @@ -4472,38 +4472,38 @@ TEST_F(ConcreteNetworkLinkedTest, R7_FindAnyCell) { } // ConcreteNetwork: isPower/isGround on net -TEST_F(ConcreteNetworkLinkedTest, R7_NetPowerGround) { +TEST_F(ConcreteNetworkLinkedTest, NetPowerGround) { EXPECT_FALSE(network_.isPower(net1_)); EXPECT_FALSE(network_.isGround(net1_)); } // ConcreteNetwork: net instance -TEST_F(ConcreteNetworkLinkedTest, R7_NetInstance) { +TEST_F(ConcreteNetworkLinkedTest, NetInstance2) { Instance *inst = network_.instance(net1_); EXPECT_EQ(inst, network_.topInstance()); } // Network: cellName convenience -TEST_F(ConcreteNetworkLinkedTest, R7_CellNameConvenience) { +TEST_F(ConcreteNetworkLinkedTest, CellNameConvenience) { const char *name = network_.cellName(u2_); EXPECT_STREQ(name, "INV"); } // ConcreteNetwork: pin direction -TEST_F(ConcreteNetworkLinkedTest, R7_PinDirection) { +TEST_F(ConcreteNetworkLinkedTest, PinDirection2) { PortDirection *dir = network_.direction(pin_u1_a_); EXPECT_NE(dir, nullptr); EXPECT_TRUE(dir->isInput()); } // NetworkNameAdapter: hasMembers on scalar port -TEST_F(NetworkAdapterTest, R7_AdapterHasMembers) { +TEST_F(NetworkAdapterTest, AdapterHasMembers) { bool has = sdc_net_->hasMembers(port_a_); EXPECT_FALSE(has); } // ConcreteNetwork: disconnectPin and reconnect cycle -TEST_F(ConcreteNetworkLinkedTest, R7_DisconnectReconnect) { +TEST_F(ConcreteNetworkLinkedTest, DisconnectReconnect) { Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *inst = network_.makeInstance(inv_cell, "r7_disc", network_.topInstance()); Port *port_a = network_.findPort(inv_cell, "A"); @@ -4521,7 +4521,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_DisconnectReconnect) { } // ConcreteNetwork: instance attribute -TEST_F(ConcreteNetworkLinkedTest, R7_InstanceAttribute) { +TEST_F(ConcreteNetworkLinkedTest, InstanceAttribute) { network_.setAttribute(u1_, "r7_key", "r7_value"); std::string val = network_.getAttribute(u1_, "r7_key"); EXPECT_EQ(val, "r7_value"); @@ -4530,7 +4530,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_InstanceAttribute) { } // ConcreteNetwork: instance net iterator -TEST_F(ConcreteNetworkLinkedTest, R7_InstanceNetIterator) { +TEST_F(ConcreteNetworkLinkedTest, InstanceNetIterator2) { // Net iterator on a child instance with local nets Cell *sub_cell = network_.makeCell(lib_, "R7_SUBC", false, "test.lib"); network_.makePort(sub_cell, "p1"); @@ -4549,7 +4549,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_InstanceNetIterator) { } // Network: visitConnectedPins exercises (through connectedPins API) -TEST_F(ConcreteNetworkLinkedTest, R7_ConnectedPins) { +TEST_F(ConcreteNetworkLinkedTest, ConnectedPins) { // Exercise connectedPinIterator as an alternative ConnectedPinIterator *iter = network_.connectedPinIterator(pin_u1_a_); int count = 0; @@ -4562,7 +4562,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_ConnectedPins) { } // ConcreteNetwork: portBitCount -TEST_F(ConcreteNetworkLinkedTest, R7_PortBitCount) { +TEST_F(ConcreteNetworkLinkedTest, PortBitCount) { Cell *cell = network_.cell(u1_); int count = network_.portBitCount(cell); // INV has A and Y = 2 bit ports @@ -4570,7 +4570,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_PortBitCount) { } // ConcreteNetwork: setCellNetworkView / cellNetworkView -TEST_F(ConcreteNetworkLinkedTest, R7_CellNetworkView) { +TEST_F(ConcreteNetworkLinkedTest, CellNetworkView) { Cell *inv_cell = network_.findCell(lib_, "INV"); // Initially null Instance *view = network_.cellNetworkView(inv_cell); @@ -4592,7 +4592,7 @@ TEST_F(ConcreteNetworkLinkedTest, R7_CellNetworkView) { //////////////////////////////////////////////////////////////// // ConcreteNetwork::connect(Instance*, LibertyPort*, Net*) - uncovered overload -TEST_F(ConcreteNetworkLinkedTest, R8_ConnectWithLibertyPort) { +TEST_F(ConcreteNetworkLinkedTest, ConnectWithLibertyPort) { // connect with LibertyPort* just forwards to connect with Port* // Since we don't have a real LibertyPort, test the Port-based connect path Instance *top = network_.topInstance(); @@ -4610,7 +4610,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_ConnectWithLibertyPort) { } // ConcreteNetwork::clearConstantNets -TEST_F(ConcreteNetworkLinkedTest, R8_ClearConstantNets) { +TEST_F(ConcreteNetworkLinkedTest, ClearConstantNets) { // Add constant nets and clear them network_.addConstantNet(net1_, LogicValue::zero); network_.addConstantNet(net2_, LogicValue::one); @@ -4625,7 +4625,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_ClearConstantNets) { } // ConcreteInstance::cell() const - uncovered -TEST_F(ConcreteNetworkLinkedTest, R8_InstanceCell) { +TEST_F(ConcreteNetworkLinkedTest, InstanceCell2) { Cell *cell = network_.cell(u1_); EXPECT_NE(cell, nullptr); // Verify it's the INV cell @@ -4633,7 +4633,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_InstanceCell) { } // ConcreteInstance::findChild - exercise child lookup -TEST_F(ConcreteNetworkLinkedTest, R8_FindChildInstance) { +TEST_F(ConcreteNetworkLinkedTest, FindChildInstance) { Instance *top = network_.topInstance(); Instance *child = network_.findChild(top, "u1"); EXPECT_EQ(child, u1_); @@ -4642,7 +4642,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_FindChildInstance) { } // ConcreteInstance::findPin(Port*) - uncovered overload -TEST_F(ConcreteNetworkLinkedTest, R8_FindPinByPortDirect) { +TEST_F(ConcreteNetworkLinkedTest, FindPinByPortDirect2) { Cell *inv_cell = network_.findCell(lib_, "INV"); Port *port_a = network_.findPort(inv_cell, "A"); Pin *pin = network_.findPin(u1_, port_a); @@ -4651,7 +4651,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_FindPinByPortDirect) { } // ConcreteInstance::deleteChild - exercise child deletion -TEST_F(ConcreteNetworkLinkedTest, R8_DeleteChildInstance) { +TEST_F(ConcreteNetworkLinkedTest, DeleteChildInstance) { Instance *top = network_.topInstance(); Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *temp = network_.makeInstance(inv_cell, "temp_child", top); @@ -4664,7 +4664,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_DeleteChildInstance) { } // ConcreteInstance::addNet / deleteNet through ConcreteNetwork -TEST_F(ConcreteNetworkLinkedTest, R8_AddDeleteNet) { +TEST_F(ConcreteNetworkLinkedTest, AddDeleteNet) { Instance *top = network_.topInstance(); Net *new_net = network_.makeNet("test_net_r8", top); EXPECT_NE(new_net, nullptr); @@ -4676,7 +4676,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_AddDeleteNet) { } // ConcreteInstance::setCell -TEST_F(ConcreteNetworkLinkedTest, R8_SetInstanceCell) { +TEST_F(ConcreteNetworkLinkedTest, SetInstanceCell) { Cell *inv_cell = network_.findCell(lib_, "INV"); // Replace u1 cell with same cell (exercises the path) network_.replaceCell(u1_, inv_cell); @@ -4685,7 +4685,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_SetInstanceCell) { } // ConcreteInstance::initPins - exercise pin initialization -TEST_F(ConcreteNetworkLinkedTest, R8_InstanceInitPins) { +TEST_F(ConcreteNetworkLinkedTest, InstanceInitPins) { Instance *top = network_.topInstance(); Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *u_new = network_.makeInstance(inv_cell, "u_init", top); @@ -4704,7 +4704,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_InstanceInitPins) { } // ConcretePin: port and instance accessors -TEST_F(ConcreteNetworkLinkedTest, R8_PinPortAndInstance) { +TEST_F(ConcreteNetworkLinkedTest, PinPortAndInstance) { Port *port = network_.port(pin_u1_a_); EXPECT_NE(port, nullptr); Instance *inst = network_.instance(pin_u1_a_); @@ -4712,7 +4712,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_PinPortAndInstance) { } // ConcretePin::setVertexId - uncovered -TEST_F(ConcreteNetworkLinkedTest, R8_PinSetVertexId) { +TEST_F(ConcreteNetworkLinkedTest, PinSetVertexId) { VertexId orig = network_.vertexId(pin_u1_a_); network_.setVertexId(pin_u1_a_, 999); EXPECT_EQ(network_.vertexId(pin_u1_a_), 999u); @@ -4720,7 +4720,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_PinSetVertexId) { } // ConcreteNet::addPin / deletePin (through connect/disconnect) -TEST_F(ConcreteNetworkLinkedTest, R8_NetPinManipulation) { +TEST_F(ConcreteNetworkLinkedTest, NetPinManipulation) { Instance *top = network_.topInstance(); Net *test_net = network_.makeNet("r8_net", top); Cell *inv_cell = network_.findCell(lib_, "INV"); @@ -4755,7 +4755,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_NetPinManipulation) { } // ConcreteNet::addTerm / deleteTerm (through makeTerm) -TEST_F(ConcreteNetworkLinkedTest, R8_TermManipulation) { +TEST_F(ConcreteNetworkLinkedTest, TermManipulation) { Instance *top = network_.topInstance(); Cell *top_cell = network_.cell(top); Port *clk_port = network_.findPort(top_cell, "clk"); @@ -4794,7 +4794,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_TermManipulation) { } // ConcreteNetPinIterator - uncovered constructor -TEST_F(ConcreteNetworkLinkedTest, R8_NetPinIteratorEmpty) { +TEST_F(ConcreteNetworkLinkedTest, NetPinIteratorEmpty) { Instance *top = network_.topInstance(); Net *empty_net = network_.makeNet("empty_r8", top); NetPinIterator *iter = network_.pinIterator(empty_net); @@ -4805,7 +4805,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_NetPinIteratorEmpty) { } // ConcreteNetTermIterator - uncovered constructor -TEST_F(ConcreteNetworkLinkedTest, R8_NetTermIteratorEmpty) { +TEST_F(ConcreteNetworkLinkedTest, NetTermIteratorEmpty2) { Instance *top = network_.topInstance(); Net *empty_net = network_.makeNet("empty_term_r8", top); NetTermIterator *iter = network_.termIterator(empty_net); @@ -4816,7 +4816,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_NetTermIteratorEmpty) { } // ConcreteLibraryIterator1 - uncovered -TEST_F(ConcreteNetworkLinkedTest, R8_LibraryIterator) { +TEST_F(ConcreteNetworkLinkedTest, LibraryIterator) { LibraryIterator *iter = network_.libraryIterator(); int count = 0; while (iter->hasNext()) { @@ -4829,7 +4829,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_LibraryIterator) { } // ConcreteLibertyLibraryIterator - uncovered -TEST_F(ConcreteNetworkLinkedTest, R8_LibertyLibraryIterator) { +TEST_F(ConcreteNetworkLinkedTest, LibertyLibraryIterator) { LibertyLibraryIterator *iter = network_.libertyLibraryIterator(); EXPECT_NE(iter, nullptr); // No liberty libraries in our simple network, so it may be empty @@ -4844,7 +4844,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_LibertyLibraryIterator) { } // ConcreteCellPortIterator1 - uncovered -TEST_F(ConcreteNetworkLinkedTest, R8_CellPortIterator) { +TEST_F(ConcreteNetworkLinkedTest, CellPortIterator) { Cell *inv_cell = network_.findCell(lib_, "INV"); CellPortIterator *iter = network_.portIterator(inv_cell); int count = 0; @@ -4858,7 +4858,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_CellPortIterator) { } // ConcreteCellPortBitIterator / ConcreteCellPortBitIterator1 - uncovered -TEST_F(ConcreteNetworkLinkedTest, R8_CellPortBitIterator) { +TEST_F(ConcreteNetworkLinkedTest, CellPortBitIterator2) { Cell *inv_cell = network_.findCell(lib_, "INV"); CellPortBitIterator *iter = network_.portBitIterator(inv_cell); int count = 0; @@ -4872,7 +4872,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_CellPortBitIterator) { } // ConcreteInstanceChildIterator - uncovered -TEST_F(ConcreteNetworkLinkedTest, R8_InstanceChildIterator) { +TEST_F(ConcreteNetworkLinkedTest, InstanceChildIterator) { Instance *top = network_.topInstance(); InstanceChildIterator *iter = network_.childIterator(top); int count = 0; @@ -4886,7 +4886,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_InstanceChildIterator) { } // ConcreteInstancePinIterator - uncovered constructor -TEST_F(ConcreteNetworkLinkedTest, R8_InstancePinIteratorCount) { +TEST_F(ConcreteNetworkLinkedTest, InstancePinIteratorCount) { InstancePinIterator *iter = network_.pinIterator(u1_); int count = 0; while (iter->hasNext()) { @@ -4902,7 +4902,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_InstancePinIteratorCount) { // R8_LibertyLibraryOfCell removed (segfault - no liberty in simple network) // Network::hasMembers - uncovered -TEST_F(ConcreteNetworkLinkedTest, R8_HasMembers) { +TEST_F(ConcreteNetworkLinkedTest, HasMembers) { Cell *inv_cell = network_.findCell(lib_, "INV"); Port *port_a = network_.findPort(inv_cell, "A"); bool has = network_.hasMembers(port_a); @@ -4910,7 +4910,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_HasMembers) { } // Network::findPin with port name string -TEST_F(ConcreteNetworkLinkedTest, R8_FindPinByName) { +TEST_F(ConcreteNetworkLinkedTest, FindPinByName2) { Pin *pin = network_.findPin(u1_, "A"); EXPECT_NE(pin, nullptr); EXPECT_EQ(pin, pin_u1_a_); @@ -4919,7 +4919,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_FindPinByName) { } // Network::findPin(Instance*, Port*) - uncovered overload -TEST_F(ConcreteNetworkLinkedTest, R8_FindPinByPortOverload) { +TEST_F(ConcreteNetworkLinkedTest, FindPinByPortOverload) { Cell *inv_cell = network_.findCell(lib_, "INV"); Port *port_a = network_.findPort(inv_cell, "A"); Pin *pin = network_.findPin(u1_, port_a); @@ -4928,7 +4928,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_FindPinByPortOverload) { } // Network::findNet by name -TEST_F(ConcreteNetworkLinkedTest, R8_FindNetByName) { +TEST_F(ConcreteNetworkLinkedTest, FindNetByName2) { Instance *top = network_.topInstance(); Net *net = network_.findNet(top, "n1"); EXPECT_NE(net, nullptr); @@ -4938,7 +4938,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_FindNetByName) { } // Network::findNetsMatching pattern -TEST_F(ConcreteNetworkLinkedTest, R8_FindNetsMatching) { +TEST_F(ConcreteNetworkLinkedTest, FindNetsMatching2) { Instance *top = network_.topInstance(); PatternMatch pat("n*", false, false, nullptr); NetSeq matches; @@ -4947,7 +4947,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_FindNetsMatching) { } // ConcreteNetwork::mergeNets exercise -TEST_F(ConcreteNetworkLinkedTest, R8_MergeNetsExercise) { +TEST_F(ConcreteNetworkLinkedTest, MergeNetsExercise) { Instance *top = network_.topInstance(); Net *a = network_.makeNet("merge_a", top); Net *b = network_.makeNet("merge_b", top); @@ -4971,7 +4971,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_MergeNetsExercise) { // NetworkNameAdapter forwarding tests via SdcNetwork // NetworkNameAdapter::findPort -TEST_F(NetworkAdapterTest, R8_AdapterFindPortByName) { +TEST_F(NetworkAdapterTest, AdapterFindPortByName) { Port *port = sdc_net_->findPort(inv_cell_, "A"); EXPECT_NE(port, nullptr); EXPECT_EQ(port, port_a_); @@ -4980,20 +4980,20 @@ TEST_F(NetworkAdapterTest, R8_AdapterFindPortByName) { } // NetworkNameAdapter::findPortsMatching -TEST_F(NetworkAdapterTest, R8_AdapterFindPortsMatching) { +TEST_F(NetworkAdapterTest, AdapterFindPortsMatching3) { PatternMatch pat("*", false, false, nullptr); PortSeq ports = sdc_net_->findPortsMatching(inv_cell_, &pat); EXPECT_EQ(ports.size(), 2u); // A and Y } // NetworkNameAdapter::name(Port*) forwarding -TEST_F(NetworkAdapterTest, R8_AdapterPortNameForward) { +TEST_F(NetworkAdapterTest, AdapterPortNameForward) { const char *name = sdc_net_->name(port_a_); EXPECT_STREQ(name, "A"); } // NetworkNameAdapter::busName(Port*) forwarding -TEST_F(NetworkAdapterTest, R8_AdapterBusNameForward) { +TEST_F(NetworkAdapterTest, AdapterBusNameForward) { const char *bname = sdc_net_->busName(port_a_); EXPECT_STREQ(bname, "A"); // scalar port } @@ -5005,7 +5005,7 @@ TEST_F(NetworkAdapterTest, R8_AdapterBusNameForward) { // R8_AdapterMakeInstanceNull removed (segfault) // NetworkNameAdapter::makeNet forwarding -TEST_F(NetworkAdapterTest, R8_AdapterMakeNetForward) { +TEST_F(NetworkAdapterTest, AdapterMakeNetForward) { Instance *top = sdc_net_->topInstance(); Net *net = sdc_net_->makeNet("adapter_net_r8", top); EXPECT_NE(net, nullptr); @@ -5014,7 +5014,7 @@ TEST_F(NetworkAdapterTest, R8_AdapterMakeNetForward) { } // NetworkNameAdapter::connect forwarding -TEST_F(NetworkAdapterTest, R8_AdapterConnectForward) { +TEST_F(NetworkAdapterTest, AdapterConnectForward) { Instance *top = sdc_net_->topInstance(); Net *net = sdc_net_->makeNet("conn_r8", top); Port *port_y = network_.findPort(inv_cell_, "Y"); @@ -5025,7 +5025,7 @@ TEST_F(NetworkAdapterTest, R8_AdapterConnectForward) { } // NetworkEdit::connectPin exercises -TEST_F(ConcreteNetworkLinkedTest, R8_DisconnectAndReconnect) { +TEST_F(ConcreteNetworkLinkedTest, DisconnectAndReconnect) { // Disconnect pin and reconnect to different net Instance *top = network_.topInstance(); Net *alt_net = network_.makeNet("alt_r8", top); @@ -5093,7 +5093,7 @@ TEST(ConcretePortR8Test, BusPortSetDirection) { } // ConcreteNetwork: multiple nets and find -TEST_F(ConcreteNetworkLinkedTest, R8_MultipleNetsFind) { +TEST_F(ConcreteNetworkLinkedTest, MultipleNetsFind) { Instance *top = network_.topInstance(); for (int i = 0; i < 10; i++) { std::string name = "multi_net_" + std::to_string(i); @@ -5115,7 +5115,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_MultipleNetsFind) { } // ConcreteNetwork: instance with many children -TEST_F(ConcreteNetworkLinkedTest, R8_ManyChildren) { +TEST_F(ConcreteNetworkLinkedTest, ManyChildren) { Instance *top = network_.topInstance(); Cell *inv_cell = network_.findCell(lib_, "INV"); for (int i = 0; i < 5; i++) { @@ -5141,7 +5141,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_ManyChildren) { } // ConcreteNetwork: deletePin through disconnect -TEST_F(ConcreteNetworkLinkedTest, R8_DeletePinPath) { +TEST_F(ConcreteNetworkLinkedTest, DeletePinPath) { Instance *top = network_.topInstance(); Cell *inv_cell = network_.findCell(lib_, "INV"); Instance *u_del = network_.makeInstance(inv_cell, "u_del_r8", top); @@ -5163,7 +5163,7 @@ TEST_F(ConcreteNetworkLinkedTest, R8_DeletePinPath) { // R8_CheckLibertyCorners removed (segfault - no liberty in simple network) // ConnectedPinIterator1 - uncovered through connectedPinIterator -TEST_F(ConcreteNetworkLinkedTest, R8_ConnectedPinIteratorMultiPin) { +TEST_F(ConcreteNetworkLinkedTest, ConnectedPinIteratorMultiPin) { // net2_ has u1_y and u2_a connected ConnectedPinIterator *iter = network_.connectedPinIterator(pin_u1_y_); int count = 0; @@ -5177,98 +5177,98 @@ TEST_F(ConcreteNetworkLinkedTest, R8_ConnectedPinIteratorMultiPin) { } // NetworkNameAdapter: various forwarding methods -TEST_F(NetworkAdapterTest, R8_AdapterCellName) { +TEST_F(NetworkAdapterTest, AdapterCellName2) { const char *name = sdc_net_->name(inv_cell_); EXPECT_STREQ(name, "BUF"); } -TEST_F(NetworkAdapterTest, R8_AdapterCellId) { +TEST_F(NetworkAdapterTest, AdapterCellId2) { ObjectId aid = sdc_net_->id(inv_cell_); ObjectId did = network_.id(inv_cell_); EXPECT_EQ(aid, did); } -TEST_F(NetworkAdapterTest, R8_AdapterCellLibrary) { +TEST_F(NetworkAdapterTest, AdapterCellLibrary2) { Library *lib = sdc_net_->library(inv_cell_); EXPECT_EQ(lib, lib_); } -TEST_F(NetworkAdapterTest, R8_AdapterCellIsLeaf) { +TEST_F(NetworkAdapterTest, AdapterCellIsLeaf2) { EXPECT_TRUE(sdc_net_->isLeaf(inv_cell_)); } -TEST_F(NetworkAdapterTest, R8_AdapterInstanceId) { +TEST_F(NetworkAdapterTest, AdapterInstanceId2) { ObjectId aid = sdc_net_->id(u1_); ObjectId did = network_.id(u1_); EXPECT_EQ(aid, did); } -TEST_F(NetworkAdapterTest, R8_AdapterInstanceCell) { +TEST_F(NetworkAdapterTest, AdapterInstanceCell2) { Cell *cell = sdc_net_->cell(u1_); EXPECT_EQ(cell, inv_cell_); } -TEST_F(NetworkAdapterTest, R8_AdapterInstanceParent) { +TEST_F(NetworkAdapterTest, AdapterInstanceParent2) { Instance *parent = sdc_net_->parent(u1_); EXPECT_EQ(parent, sdc_net_->topInstance()); } -TEST_F(NetworkAdapterTest, R8_AdapterInstanceIsLeaf) { +TEST_F(NetworkAdapterTest, AdapterInstanceIsLeaf2) { EXPECT_TRUE(sdc_net_->isLeaf(u1_)); } -TEST_F(NetworkAdapterTest, R8_AdapterPinId) { +TEST_F(NetworkAdapterTest, AdapterPinId2) { ObjectId aid = sdc_net_->id(pin_b1_a_); ObjectId did = network_.id(pin_b1_a_); EXPECT_EQ(aid, did); } -TEST_F(NetworkAdapterTest, R8_AdapterPinPort) { +TEST_F(NetworkAdapterTest, AdapterPinPort2) { Port *port = sdc_net_->port(pin_b1_a_); EXPECT_EQ(port, port_a_); } -TEST_F(NetworkAdapterTest, R8_AdapterPinInstance) { +TEST_F(NetworkAdapterTest, AdapterPinInstance2) { Instance *inst = sdc_net_->instance(pin_b1_a_); EXPECT_EQ(inst, u1_); } -TEST_F(NetworkAdapterTest, R8_AdapterPinNet) { +TEST_F(NetworkAdapterTest, AdapterPinNet2) { Net *net = sdc_net_->net(pin_b1_a_); EXPECT_EQ(net, net1_); } -TEST_F(NetworkAdapterTest, R8_AdapterPinDirection) { +TEST_F(NetworkAdapterTest, AdapterPinDirection2) { PortDirection *dir = sdc_net_->direction(pin_b1_a_); EXPECT_TRUE(dir->isInput()); } -TEST_F(NetworkAdapterTest, R8_AdapterPinVertexId) { +TEST_F(NetworkAdapterTest, AdapterPinVertexId2) { VertexId vid = sdc_net_->vertexId(pin_b1_a_); VertexId dvid = network_.vertexId(pin_b1_a_); EXPECT_EQ(vid, dvid); } -TEST_F(NetworkAdapterTest, R8_AdapterNetId) { +TEST_F(NetworkAdapterTest, AdapterNetId2) { ObjectId aid = sdc_net_->id(net1_); ObjectId did = network_.id(net1_); EXPECT_EQ(aid, did); } -TEST_F(NetworkAdapterTest, R8_AdapterNetInstance) { +TEST_F(NetworkAdapterTest, AdapterNetInstance2) { Instance *inst = sdc_net_->instance(net1_); EXPECT_EQ(inst, sdc_net_->topInstance()); } -TEST_F(NetworkAdapterTest, R8_AdapterNetIsPower) { +TEST_F(NetworkAdapterTest, AdapterNetIsPower2) { EXPECT_FALSE(sdc_net_->isPower(net1_)); } -TEST_F(NetworkAdapterTest, R8_AdapterNetIsGround) { +TEST_F(NetworkAdapterTest, AdapterNetIsGround2) { EXPECT_FALSE(sdc_net_->isGround(net1_)); } -TEST_F(NetworkAdapterTest, R8_AdapterNetPinIterator) { +TEST_F(NetworkAdapterTest, AdapterNetPinIterator2) { NetPinIterator *iter = sdc_net_->pinIterator(net1_); EXPECT_NE(iter, nullptr); int count = 0; @@ -5280,7 +5280,7 @@ TEST_F(NetworkAdapterTest, R8_AdapterNetPinIterator) { EXPECT_GE(count, 1); } -TEST_F(NetworkAdapterTest, R8_AdapterNetTermIterator) { +TEST_F(NetworkAdapterTest, AdapterNetTermIterator2) { NetTermIterator *iter = sdc_net_->termIterator(net1_); EXPECT_NE(iter, nullptr); delete iter; @@ -5292,7 +5292,7 @@ TEST_F(NetworkAdapterTest, R8_AdapterNetTermIterator) { // R10_ ConcreteNetwork: Bus port creation and direction setting // Covers: BusPort::BusPort, BusPort::setDirection -TEST_F(ConcreteNetworkLinkedTest, R10_BusPortCreation) { +TEST_F(ConcreteNetworkLinkedTest, BusPortCreation) { // Create bus port on a new cell (not one with existing instances) Cell *bus_cell = network_.makeCell(lib_, "BUS_TEST", true, "test.lib"); Port *bus = network_.makeBusPort(bus_cell, "bus_data", 0, 7); @@ -5309,7 +5309,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_BusPortCreation) { // R10_ ConcreteNetwork: multiple clear operations // Covers: ConcreteNetwork clear paths -TEST_F(ConcreteNetworkLinkedTest, R10_ClearAndRebuild) { +TEST_F(ConcreteNetworkLinkedTest, ClearAndRebuild) { // Verify we can query before clear Instance *top = network_.topInstance(); EXPECT_NE(top, nullptr); @@ -5319,7 +5319,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_ClearAndRebuild) { // R10_ ConcreteInstance: cell() accessor // Covers: ConcreteInstance::cell() const -TEST_F(ConcreteNetworkLinkedTest, R10_InstanceCellAccessor) { +TEST_F(ConcreteNetworkLinkedTest, InstanceCellAccessor) { Cell *cell = network_.cell(u1_); ASSERT_NE(cell, nullptr); EXPECT_STREQ(network_.name(cell), "INV"); @@ -5331,7 +5331,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_InstanceCellAccessor) { // R10_ ConcreteInstance: findChild via network interface // Covers: ConcreteInstance::findChild(const char*) const -TEST_F(ConcreteNetworkLinkedTest, R10_FindChildExhaustive) { +TEST_F(ConcreteNetworkLinkedTest, FindChildExhaustive) { Instance *top = network_.topInstance(); Instance *c1 = network_.findChild(top, "u1"); Instance *c2 = network_.findChild(top, "u2"); @@ -5346,7 +5346,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_FindChildExhaustive) { // R10_ ConcreteInstance: findPin(Port*) via network interface // Covers: ConcreteInstance::findPin(Port const*) const -TEST_F(ConcreteNetworkLinkedTest, R10_FindPinByPort) { +TEST_F(ConcreteNetworkLinkedTest, FindPinByPort4) { Cell *inv_cell = network_.cell(u1_); Port *port_a = network_.findPort(inv_cell, "A"); Port *port_y = network_.findPort(inv_cell, "Y"); @@ -5361,7 +5361,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_FindPinByPort) { // R10_ ConcreteInstance: deleteChild then verify // Covers: ConcreteInstance::deleteChild(ConcreteInstance*) -TEST_F(ConcreteNetworkLinkedTest, R10_DeleteChildAndVerify) { +TEST_F(ConcreteNetworkLinkedTest, DeleteChildAndVerify) { Instance *top = network_.topInstance(); Cell *inv_cell = network_.cell(u1_); Instance *extra = network_.makeInstance(inv_cell, "extra", top); @@ -5381,7 +5381,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_DeleteChildAndVerify) { // R10_ ConcreteInstance: addNet and deleteNet // Covers: ConcreteInstance::addNet, ConcreteInstance::deleteNet, ConcreteNet::~ConcreteNet -TEST_F(ConcreteNetworkLinkedTest, R10_AddDeleteNetExhaustive) { +TEST_F(ConcreteNetworkLinkedTest, AddDeleteNetExhaustive) { Instance *top = network_.topInstance(); Net *n4 = network_.makeNet("n4", top); ASSERT_NE(n4, nullptr); @@ -5400,7 +5400,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_AddDeleteNetExhaustive) { // R10_ ConcreteInstance: setCell // Covers: ConcreteInstance::setCell(ConcreteCell*) -TEST_F(ConcreteNetworkLinkedTest, R10_SetCellOnInstance) { +TEST_F(ConcreteNetworkLinkedTest, SetCellOnInstance) { // Create a second cell type Cell *buf_cell = network_.makeCell(lib_, "BUF2", true, "test.lib"); network_.makePort(buf_cell, "A"); @@ -5416,7 +5416,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_SetCellOnInstance) { // R10_ ConcretePin: port name via port accessor // Covers: ConcretePin internal paths -TEST_F(ConcreteNetworkLinkedTest, R10_PinPortName) { +TEST_F(ConcreteNetworkLinkedTest, PinPortName2) { Port *port = network_.port(pin_u1_a_); ASSERT_NE(port, nullptr); const char *name = network_.name(port); @@ -5425,7 +5425,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_PinPortName) { // R10_ ConcretePin: setVertexId // Covers: ConcretePin::setVertexId(unsigned int) -TEST_F(ConcreteNetworkLinkedTest, R10_PinSetVertexIdMultiple) { +TEST_F(ConcreteNetworkLinkedTest, PinSetVertexIdMultiple2) { network_.setVertexId(pin_u1_a_, 100); EXPECT_EQ(network_.vertexId(pin_u1_a_), 100u); network_.setVertexId(pin_u1_a_, 200); @@ -5436,7 +5436,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_PinSetVertexIdMultiple) { // R10_ ConcreteNet: pin iteration and manipulation // Covers: ConcreteNet::addPin, ConcreteNetPinIterator ctor -TEST_F(ConcreteNetworkLinkedTest, R10_NetPinIteration) { +TEST_F(ConcreteNetworkLinkedTest, NetPinIteration) { // net2_ connects u1.Y and u2.A NetPinIterator *iter = network_.pinIterator(net2_); ASSERT_NE(iter, nullptr); @@ -5452,7 +5452,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_NetPinIteration) { // R10_ ConcreteNet: term iteration // Covers: ConcreteNet::addTerm, ConcreteNetTermIterator ctor -TEST_F(ConcreteNetworkLinkedTest, R10_NetTermIteration) { +TEST_F(ConcreteNetworkLinkedTest, NetTermIteration) { // Leaf-level nets don't have terms, but let's verify the iterator works NetTermIterator *iter = network_.termIterator(net1_); ASSERT_NE(iter, nullptr); @@ -5468,7 +5468,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_NetTermIteration) { // R10_ Iterators: library iterator // Covers: ConcreteLibraryIterator1 ctor -TEST_F(ConcreteNetworkLinkedTest, R10_LibraryIteratorMultiple) { +TEST_F(ConcreteNetworkLinkedTest, LibraryIteratorMultiple) { // Create a second library Library *lib2 = network_.makeLibrary("test_lib2", "test2.lib"); ASSERT_NE(lib2, nullptr); @@ -5487,7 +5487,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_LibraryIteratorMultiple) { // R10_ Iterators: liberty library iterator // Covers: ConcreteLibertyLibraryIterator ctor/dtor -TEST_F(ConcreteNetworkLinkedTest, R10_LibertyLibraryIterator) { +TEST_F(ConcreteNetworkLinkedTest, LibertyLibraryIterator2) { LibertyLibraryIterator *iter = network_.libertyLibraryIterator(); ASSERT_NE(iter, nullptr); // No liberty libs in this test fixture @@ -5497,7 +5497,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_LibertyLibraryIterator) { // R10_ Iterators: cell port iterator // Covers: ConcreteCellPortIterator1 ctor -TEST_F(ConcreteNetworkLinkedTest, R10_CellPortIteratorOnTopCell) { +TEST_F(ConcreteNetworkLinkedTest, CellPortIteratorOnTopCell) { Cell *top_cell = network_.cell(network_.topInstance()); CellPortIterator *iter = network_.portIterator(top_cell); ASSERT_NE(iter, nullptr); @@ -5513,7 +5513,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_CellPortIteratorOnTopCell) { // R10_ Iterators: cell port bit iterator // Covers: ConcreteCellPortBitIterator ctor, ConcreteCellPortBitIterator1 ctor -TEST_F(ConcreteNetworkLinkedTest, R10_CellPortBitIteratorOnTopCell) { +TEST_F(ConcreteNetworkLinkedTest, CellPortBitIteratorOnTopCell) { Cell *top_cell = network_.cell(network_.topInstance()); CellPortBitIterator *iter = network_.portBitIterator(top_cell); ASSERT_NE(iter, nullptr); @@ -5529,7 +5529,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_CellPortBitIteratorOnTopCell) { // R10_ Iterators: instance child iterator // Covers: ConcreteInstanceChildIterator ctor -TEST_F(ConcreteNetworkLinkedTest, R10_InstanceChildIteratorCount) { +TEST_F(ConcreteNetworkLinkedTest, InstanceChildIteratorCount) { Instance *top = network_.topInstance(); InstanceChildIterator *iter = network_.childIterator(top); ASSERT_NE(iter, nullptr); @@ -5545,7 +5545,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_InstanceChildIteratorCount) { // R10_ Iterators: instance pin iterator // Covers: ConcreteInstancePinIterator ctor -TEST_F(ConcreteNetworkLinkedTest, R10_InstancePinIteratorOnU2) { +TEST_F(ConcreteNetworkLinkedTest, InstancePinIteratorOnU2) { InstancePinIterator *iter = network_.pinIterator(u2_); ASSERT_NE(iter, nullptr); int count = 0; @@ -5560,7 +5560,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_InstancePinIteratorOnU2) { // R10_ Iterators: port member iterator (for bus port) // Covers: ConcretePortMemberIterator1 ctor -TEST_F(ConcreteNetworkLinkedTest, R10_PortMemberIterator) { +TEST_F(ConcreteNetworkLinkedTest, PortMemberIterator) { // Create on a new cell to avoid instance pin mismatch Cell *bus_cell2 = network_.makeCell(lib_, "BUS_TEST2", true, "test.lib"); Port *bus = network_.makeBusPort(bus_cell2, "test_bus", 0, 3); @@ -5580,7 +5580,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_PortMemberIterator) { // R10_ Network: hasMembers for scalar port // Covers: Network::hasMembers(Port const*) const -TEST_F(ConcreteNetworkLinkedTest, R10_HasMembersScalar) { +TEST_F(ConcreteNetworkLinkedTest, HasMembersScalar2) { Cell *inv_cell = network_.cell(u1_); Port *port_a = network_.findPort(inv_cell, "A"); EXPECT_FALSE(network_.hasMembers(port_a)); @@ -5588,7 +5588,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_HasMembersScalar) { // R10_ Network: findPinLinear // Covers: Network::findPinLinear(Instance const*, char const*) const -TEST_F(ConcreteNetworkLinkedTest, R10_FindPinLinear) { +TEST_F(ConcreteNetworkLinkedTest, FindPinLinear2) { Pin *pin = network_.findPin(u1_, "A"); EXPECT_EQ(pin, pin_u1_a_); Pin *null_pin = network_.findPin(u1_, "nonexistent"); @@ -5597,7 +5597,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_FindPinLinear) { // R10_ Network: findNetLinear // Covers: Network::findNetLinear(Instance const*, char const*) const -TEST_F(ConcreteNetworkLinkedTest, R10_FindNetByNameLinear) { +TEST_F(ConcreteNetworkLinkedTest, FindNetByNameLinear) { Instance *top = network_.topInstance(); Net *net = network_.findNet(top, "n1"); EXPECT_EQ(net, net1_); @@ -5607,7 +5607,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_FindNetByNameLinear) { // R10_ Network: findNetsMatchingLinear with wildcard // Covers: Network::findNetsMatchingLinear(Instance const*, PatternMatch const*) const -TEST_F(ConcreteNetworkLinkedTest, R10_FindNetsMatchingWildcard) { +TEST_F(ConcreteNetworkLinkedTest, FindNetsMatchingWildcard) { Instance *top = network_.topInstance(); PatternMatch pattern("n*"); NetSeq matches; @@ -5616,7 +5616,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_FindNetsMatchingWildcard) { } // R10_ Network: findNetsMatchingLinear with exact match -TEST_F(ConcreteNetworkLinkedTest, R10_FindNetsMatchingExact) { +TEST_F(ConcreteNetworkLinkedTest, FindNetsMatchingExact) { Instance *top = network_.topInstance(); PatternMatch pattern("n2"); NetSeq matches; @@ -5626,7 +5626,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_FindNetsMatchingExact) { // R10_ NetworkEdit: connectPin(Pin*, Net*) // Covers: NetworkEdit::connectPin(Pin*, Net*) -TEST_F(ConcreteNetworkLinkedTest, R10_ConnectPinReconnect) { +TEST_F(ConcreteNetworkLinkedTest, ConnectPinReconnect) { // Disconnect pin_u1_a_ from net1_ and reconnect to net3_ network_.disconnectPin(pin_u1_a_); Pin *reconnected = network_.connect(u1_, @@ -5636,7 +5636,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_ConnectPinReconnect) { } // R10_ NetworkEdit: disconnect and verify iteration -TEST_F(ConcreteNetworkLinkedTest, R10_DisconnectPinVerifyNet) { +TEST_F(ConcreteNetworkLinkedTest, DisconnectPinVerifyNet) { // Count pins on net2_ before disconnect NetPinIterator *iter = network_.pinIterator(net2_); int before_count = 0; @@ -5657,7 +5657,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_DisconnectPinVerifyNet) { // R10_ NetworkAdapter: hasMembers forwarding on scalar port // Covers: NetworkNameAdapter hasMembers path -TEST_F(NetworkAdapterTest, R10_AdapterHasMembersScalar) { +TEST_F(NetworkAdapterTest, AdapterHasMembersScalar) { EXPECT_FALSE(sdc_net_->hasMembers(port_a_)); EXPECT_FALSE(sdc_net_->isBus(port_a_)); EXPECT_FALSE(sdc_net_->isBundle(port_a_)); @@ -5665,21 +5665,21 @@ TEST_F(NetworkAdapterTest, R10_AdapterHasMembersScalar) { // R10_ NetworkAdapter: port size forwarding // Covers: NetworkNameAdapter size path -TEST_F(NetworkAdapterTest, R10_AdapterPortSize) { +TEST_F(NetworkAdapterTest, AdapterPortSize2) { int size = sdc_net_->size(port_a_); EXPECT_EQ(size, 1); // Scalar port has size 1 } // R10_ NetworkAdapter: name(Port) forwarding // Covers: NetworkNameAdapter::name(Port const*) const -TEST_F(NetworkAdapterTest, R10_AdapterPortName) { +TEST_F(NetworkAdapterTest, AdapterPortName3) { const char *name = sdc_net_->name(port_a_); EXPECT_STREQ(name, "A"); } // R10_ NetworkAdapter: busName forwarding // Covers: NetworkNameAdapter::busName(Port const*) const -TEST_F(NetworkAdapterTest, R10_AdapterBusName) { +TEST_F(NetworkAdapterTest, AdapterBusName) { const char *name = sdc_net_->busName(port_a_); // Scalar port busName is nullptr (void)name; @@ -5687,7 +5687,7 @@ TEST_F(NetworkAdapterTest, R10_AdapterBusName) { // R10_ NetworkAdapter: makeNet forwarding // Covers: NetworkNameAdapter::makeNet(char const*, Instance*) -TEST_F(NetworkAdapterTest, R10_AdapterMakeNet) { +TEST_F(NetworkAdapterTest, AdapterMakeNet3) { Instance *top = sdc_net_->topInstance(); Net *net = sdc_net_->makeNet("adapter_net", top); ASSERT_NE(net, nullptr); @@ -5697,7 +5697,7 @@ TEST_F(NetworkAdapterTest, R10_AdapterMakeNet) { // R10_ NetworkAdapter: findPort forwarding // Covers: NetworkNameAdapter::findPort(Cell const*, char const*) const -TEST_F(NetworkAdapterTest, R10_AdapterFindPortByName) { +TEST_F(NetworkAdapterTest, AdapterFindPortByName2) { Port *found = sdc_net_->findPort(inv_cell_, "A"); EXPECT_EQ(found, port_a_); Port *not_found = sdc_net_->findPort(inv_cell_, "nonexistent"); @@ -5706,7 +5706,7 @@ TEST_F(NetworkAdapterTest, R10_AdapterFindPortByName) { // R10_ NetworkAdapter: findPortsMatching forwarding // Covers: NetworkNameAdapter::findPortsMatching(Cell const*, PatternMatch const*) const -TEST_F(NetworkAdapterTest, R10_AdapterFindPortsMatchingWild) { +TEST_F(NetworkAdapterTest, AdapterFindPortsMatchingWild) { PatternMatch pattern("*"); PortSeq ports = sdc_net_->findPortsMatching(inv_cell_, &pattern); EXPECT_EQ(ports.size(), 2u); // A, Y @@ -5714,14 +5714,14 @@ TEST_F(NetworkAdapterTest, R10_AdapterFindPortsMatchingWild) { // R10_ NetworkAdapter: findPin(Instance, Port) forwarding // Covers: NetworkNameAdapter::findPin(Instance const*, Port const*) const -TEST_F(NetworkAdapterTest, R10_AdapterFindPinByPort) { +TEST_F(NetworkAdapterTest, AdapterFindPinByPort2) { Pin *pin = sdc_net_->findPin(u1_, port_a_); EXPECT_EQ(pin, pin_b1_a_); } // R10_ ConcreteNetwork: merge nets exercise // Covers: ConcreteNet pin/term manipulation, mergeInto -TEST_F(ConcreteNetworkLinkedTest, R10_MergeNetsAndVerify) { +TEST_F(ConcreteNetworkLinkedTest, MergeNetsAndVerify) { Instance *top = network_.topInstance(); Net *merge_src = network_.makeNet("merge_src", top); Net *merge_dst = network_.makeNet("merge_dst", top); @@ -5746,7 +5746,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_MergeNetsAndVerify) { // R10_ ConcreteInstance: initPins explicit exercise // Covers: ConcreteInstance::initPins -TEST_F(ConcreteNetworkLinkedTest, R10_InitPinsExercise) { +TEST_F(ConcreteNetworkLinkedTest, InitPinsExercise2) { // makeInstance already calls initPins, but let's create a new instance // and verify pins are initialized properly Instance *top = network_.topInstance(); @@ -5769,7 +5769,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_InitPinsExercise) { // R10_ ConcreteInstance: disconnect pin exercises internal paths // Covers: disconnect/connect paths for pins -TEST_F(ConcreteNetworkLinkedTest, R10_DisconnectPinExercise) { +TEST_F(ConcreteNetworkLinkedTest, DisconnectPinExercise) { Instance *top = network_.topInstance(); Cell *inv_cell = network_.cell(u1_); Instance *dp_inst = network_.makeInstance(inv_cell, "dp_test", top); @@ -5787,7 +5787,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_DisconnectPinExercise) { } // R10_ Network: multiple libraries and find -TEST_F(ConcreteNetworkLinkedTest, R10_MultipleCellsAndFind) { +TEST_F(ConcreteNetworkLinkedTest, MultipleCellsAndFind) { // Create cells in a new library Library *lib2 = network_.makeLibrary("other_lib", "other.lib"); Cell *nand = network_.makeCell(lib2, "NAND2", true, "other.lib"); @@ -5803,7 +5803,7 @@ TEST_F(ConcreteNetworkLinkedTest, R10_MultipleCellsAndFind) { } // R10_ ConcreteNetwork: findPin across multiple instances -TEST_F(ConcreteNetworkLinkedTest, R10_FindPinAllInstances) { +TEST_F(ConcreteNetworkLinkedTest, FindPinAllInstances) { // Check all instances Pin *u1a = network_.findPin(u1_, "A"); Pin *u1y = network_.findPin(u1_, "Y"); diff --git a/parasitics/test/cpp/TestParasitics.cc b/parasitics/test/cpp/TestParasitics.cc index e7aebbad..898b8f3c 100644 --- a/parasitics/test/cpp/TestParasitics.cc +++ b/parasitics/test/cpp/TestParasitics.cc @@ -2285,7 +2285,7 @@ TEST_F(DesignParasiticsTest, DeleteParasiticsAllNets) { // Test NetIdPairLess comparator construction // Covers: NetIdPairLess::NetIdPairLess(const Network*) -TEST_F(DesignParasiticsTest, R5_NetIdPairLessConstruct) { +TEST_F(DesignParasiticsTest, NetIdPairLessConstruct) { ASSERT_TRUE(design_loaded_); const Network *network = sta_->network(); // Construct the comparator - this covers the constructor @@ -2317,7 +2317,7 @@ TEST_F(DesignParasiticsTest, R5_NetIdPairLessConstruct) { // Test ConcreteParasitic virtual destructor via delete (D0 variant) // Covers: ConcreteParasitic::~ConcreteParasiticD0Ev -TEST_F(DesignParasiticsTest, R5_ConcreteParasiticDeleteViaPtr) { +TEST_F(DesignParasiticsTest, ConcreteParasiticDeleteViaPtr) { ASSERT_TRUE(design_loaded_); ConcreteParasitic *p = new ConcretePiElmore(1e-12f, 100.0f, 2e-12f); // Deleting via base pointer exercises the D0 destructor variant @@ -2326,7 +2326,7 @@ TEST_F(DesignParasiticsTest, R5_ConcreteParasiticDeleteViaPtr) { // Test ConcreteParasiticDevice construction with id, value, nodes // Covers: ConcreteParasiticDevice::ConcreteParasiticDevice(size_t, float, node*, node*) -TEST_F(DesignParasiticsTest, R5_ConcreteParasiticDeviceConstruct) { +TEST_F(DesignParasiticsTest, ConcreteParasiticDeviceConstruct) { ASSERT_TRUE(design_loaded_); ConcreteParasiticNode node1(static_cast(nullptr), 1, false); ConcreteParasiticNode node2(static_cast(nullptr), 2, false); @@ -2340,7 +2340,7 @@ TEST_F(DesignParasiticsTest, R5_ConcreteParasiticDeviceConstruct) { // Test ConcreteParasiticDevice base class constructor // Covers: ConcreteParasiticDevice::ConcreteParasiticDevice(size_t, float, Node*, Node*) -TEST_F(StaParasiticsTest, R6_ConcreteParasiticDeviceConstruction) { +TEST_F(StaParasiticsTest, ConcreteParasiticDeviceConstruction) { ConcreteParasiticNode node1(static_cast(nullptr), 1, false); ConcreteParasiticNode node2(static_cast(nullptr), 2, false); // ConcreteParasiticDevice is the base of Resistor/Capacitor @@ -2354,7 +2354,7 @@ TEST_F(StaParasiticsTest, R6_ConcreteParasiticDeviceConstruction) { // Test ConcreteParasitic D0 destructor via delete through base pointer // Covers: ConcreteParasitic::~ConcreteParasitic() D0 -TEST_F(StaParasiticsTest, R6_ConcreteParasiticD0Destructor) { +TEST_F(StaParasiticsTest, ConcreteParasiticD0Destructor) { ConcreteParasitic *p = new ConcretePiElmore(1e-12f, 100.0f, 2e-12f); EXPECT_TRUE(p->isPiElmore()); delete p; @@ -2363,7 +2363,7 @@ TEST_F(StaParasiticsTest, R6_ConcreteParasiticD0Destructor) { // Test ConcreteParasitic D0 destructor for PoleResidue // Covers: ConcreteParasitic::~ConcreteParasitic() D0 via ConcretePoleResidue -TEST_F(StaParasiticsTest, R6_ConcretePoleResidueD0Destructor) { +TEST_F(StaParasiticsTest, ConcretePoleResidueD0Destructor) { ConcreteParasitic *p = new ConcretePoleResidue(); EXPECT_TRUE(p->isPoleResidue()); delete p; @@ -2371,7 +2371,7 @@ TEST_F(StaParasiticsTest, R6_ConcretePoleResidueD0Destructor) { // Test ConcreteParasitic D0 destructor for PiPoleResidue // Covers: ConcreteParasitic::~ConcreteParasitic() D0 via ConcretePiPoleResidue -TEST_F(StaParasiticsTest, R6_ConcretePiPoleResidueD0Destructor) { +TEST_F(StaParasiticsTest, ConcretePiPoleResidueD0Destructor) { ConcreteParasitic *p = new ConcretePiPoleResidue(1e-12f, 100.0f, 2e-12f); EXPECT_TRUE(p->isPiPoleResidue()); delete p; @@ -2379,7 +2379,7 @@ TEST_F(StaParasiticsTest, R6_ConcretePiPoleResidueD0Destructor) { // Test ConcreteParasiticNetwork creation and methods // Covers: ConcreteParasiticNetwork::nodes, resistors, capacitors, capacitance -TEST_F(StaParasiticsTest, R6_ParasiticNetworkCreation) { +TEST_F(StaParasiticsTest, ParasiticNetworkCreation) { const Network *network = sta_->network(); ConcreteParasiticNetwork pnet(nullptr, false, network); EXPECT_TRUE(pnet.isParasiticNetwork()); @@ -2393,7 +2393,7 @@ TEST_F(StaParasiticsTest, R6_ParasiticNetworkCreation) { // Test ConcreteParasiticNetwork with includesPinCaps flag // Covers: ConcreteParasiticNetwork constructor with includes_pin_caps=true -TEST_F(StaParasiticsTest, R6_ParasiticNetworkIncludesPinCaps) { +TEST_F(StaParasiticsTest, ParasiticNetworkIncludesPinCaps2) { const Network *network = sta_->network(); ConcreteParasiticNetwork pnet(nullptr, true, network); EXPECT_TRUE(pnet.includesPinCaps()); @@ -2401,7 +2401,7 @@ TEST_F(StaParasiticsTest, R6_ParasiticNetworkIncludesPinCaps) { // Test ConcreteParasiticNetwork findParasiticNode returns nullptr for missing // Covers: ConcreteParasiticNetwork::findParasiticNode -TEST_F(StaParasiticsTest, R6_ParasiticNetworkFindNodeMissing) { +TEST_F(StaParasiticsTest, ParasiticNetworkFindNodeMissing) { const Network *network = sta_->network(); ConcreteParasiticNetwork pnet(nullptr, false, network); ConcreteParasiticNode *node = pnet.findParasiticNode(static_cast(nullptr)); @@ -2410,7 +2410,7 @@ TEST_F(StaParasiticsTest, R6_ParasiticNetworkFindNodeMissing) { // Test ConcreteParasiticNetwork addResistor with standalone nodes // Covers: ConcreteParasiticNetwork::addResistor -TEST_F(StaParasiticsTest, R6_ParasiticNetworkAddResistorStandalone) { +TEST_F(StaParasiticsTest, ParasiticNetworkAddResistorStandalone) { const Network *network = sta_->network(); ConcreteParasiticNetwork pnet(nullptr, false, network); ConcreteParasiticNode node1(static_cast(nullptr), 1, false); @@ -2422,7 +2422,7 @@ TEST_F(StaParasiticsTest, R6_ParasiticNetworkAddResistorStandalone) { // Test ConcreteParasiticNetwork addCapacitor with standalone nodes // Covers: ConcreteParasiticNetwork::addCapacitor -TEST_F(StaParasiticsTest, R6_ParasiticNetworkAddCapacitorStandalone) { +TEST_F(StaParasiticsTest, ParasiticNetworkAddCapacitorStandalone) { const Network *network = sta_->network(); ConcreteParasiticNetwork pnet(nullptr, false, network); ConcreteParasiticNode node1(static_cast(nullptr), 1, false); @@ -2434,7 +2434,7 @@ TEST_F(StaParasiticsTest, R6_ParasiticNetworkAddCapacitorStandalone) { // Test parasiticAnalysisPtIndex with a real corner // Covers: ConcreteParasitics::parasiticAnalysisPtIndex -TEST_F(StaParasiticsTest, R6_ParasiticAnalysisPtIndexWithCorner) { +TEST_F(StaParasiticsTest, ParasiticAnalysisPtIndexWithCorner) { Parasitics *parasitics = sta_->parasitics(); Corner *corner = sta_->cmdCorner(); ASSERT_NE(corner, nullptr); @@ -2448,7 +2448,7 @@ TEST_F(StaParasiticsTest, R6_ParasiticAnalysisPtIndexWithCorner) { // Test ConcreteParasiticNetwork resistors/capacitors empty by default // Covers: ConcreteParasiticNetwork::resistors, ConcreteParasiticNetwork::capacitors -TEST_F(StaParasiticsTest, R6_ParasiticNetworkEmptyLists) { +TEST_F(StaParasiticsTest, ParasiticNetworkEmptyLists) { const Network *network = sta_->network(); ConcreteParasiticNetwork pnet(nullptr, false, network); EXPECT_TRUE(pnet.resistors().empty()); @@ -2457,7 +2457,7 @@ TEST_F(StaParasiticsTest, R6_ParasiticNetworkEmptyLists) { // Test ConcretePiElmore with zero values // Covers: ConcretePiElmore constructor, accessors -TEST_F(StaParasiticsTest, R6_PiElmoreZeroValues) { +TEST_F(StaParasiticsTest, PiElmoreZeroValues) { ConcretePiElmore pe(0.0f, 0.0f, 0.0f); EXPECT_TRUE(pe.isPiElmore()); EXPECT_FALSE(pe.isPoleResidue()); @@ -2466,7 +2466,7 @@ TEST_F(StaParasiticsTest, R6_PiElmoreZeroValues) { // Test parasiticAnalysisPtIndex indirectly by reading SPEF for specific rf // Covers: ConcreteParasitics::parasiticAnalysisPtIndex -TEST_F(DesignParasiticsTest, R5_ParasiticAnalysisPtIndex) { +TEST_F(DesignParasiticsTest, ParasiticAnalysisPtIndex) { ASSERT_TRUE(design_loaded_); Corner *corner = sta_->cmdCorner(); // Read SPEF with reduction to exercise analysis pt indexing @@ -2484,7 +2484,7 @@ TEST_F(DesignParasiticsTest, R5_ParasiticAnalysisPtIndex) { // Test ReportParasiticAnnotation report // Covers: ReportParasiticAnnotation::report -TEST_F(DesignParasiticsTest, R5_ReportParasiticAnnotation) { +TEST_F(DesignParasiticsTest, ReportParasiticAnnotation2) { ASSERT_TRUE(design_loaded_); // Ensure the graph is built first @@ -2505,7 +2505,7 @@ TEST_F(DesignParasiticsTest, R5_ReportParasiticAnnotation) { // Test ConcreteParasiticDevice constructor directly // Covers: ConcreteParasiticDevice::ConcreteParasiticDevice(size_t, float, node*, node*) -TEST_F(ConcreteParasiticDeviceTest, R8_DirectDeviceConstruction) { +TEST_F(ConcreteParasiticDeviceTest, DirectDeviceConstruction) { ConcreteParasiticNode node1(static_cast(nullptr), 1, false); ConcreteParasiticNode node2(static_cast(nullptr), 2, false); // Construct via ConcreteParasiticCapacitor (which calls base ConcreteParasiticDevice ctor) @@ -2518,7 +2518,7 @@ TEST_F(ConcreteParasiticDeviceTest, R8_DirectDeviceConstruction) { // Test ConcreteParasiticDevice via resistor with large id // Covers: ConcreteParasiticDevice::ConcreteParasiticDevice -TEST_F(ConcreteParasiticDeviceTest, R8_LargeIdDevice) { +TEST_F(ConcreteParasiticDeviceTest, LargeIdDevice) { ConcreteParasiticNode n1(static_cast(nullptr), 100, false); ConcreteParasiticNode n2(static_cast(nullptr), 200, false); ConcreteParasiticResistor res(999999, 1.5e3f, &n1, &n2); @@ -2528,7 +2528,7 @@ TEST_F(ConcreteParasiticDeviceTest, R8_LargeIdDevice) { // Test ConcreteParasitic destructor via delete on base pointer // Covers: ConcreteParasitic::~ConcreteParasitic() -TEST_F(ConcretePiElmoreTest, R8_DestructorViaBasePointer) { +TEST_F(ConcretePiElmoreTest, DestructorViaBasePointer) { ConcreteParasitic *p = new ConcretePiElmore(1e-12f, 50.0f, 2e-12f); EXPECT_TRUE(p->isPiElmore()); delete p; // calls ConcreteParasitic::~ConcreteParasitic() @@ -2536,7 +2536,7 @@ TEST_F(ConcretePiElmoreTest, R8_DestructorViaBasePointer) { // Test ConcreteParasitic destructor via ConcretePoleResidue // Covers: ConcreteParasitic::~ConcreteParasitic() -TEST_F(ConcretePoleResidueTest, R8_DestructorViaBasePointer) { +TEST_F(ConcretePoleResidueTest, DestructorViaBasePointer) { ConcreteParasitic *p = new ConcretePoleResidue(); EXPECT_TRUE(p->isPoleResidue()); delete p; @@ -2544,7 +2544,7 @@ TEST_F(ConcretePoleResidueTest, R8_DestructorViaBasePointer) { // Test ConcreteParasitic destructor via ConcretePiPoleResidue // Covers: ConcreteParasitic::~ConcreteParasitic() -TEST_F(ConcretePiPoleResidueTest, R8_DestructorViaBasePointer) { +TEST_F(ConcretePiPoleResidueTest, DestructorViaBasePointer) { ConcreteParasitic *p = new ConcretePiPoleResidue(1e-12f, 100.0f, 2e-12f); EXPECT_TRUE(p->isPiPoleResidue()); delete p; @@ -2552,7 +2552,7 @@ TEST_F(ConcretePiPoleResidueTest, R8_DestructorViaBasePointer) { // Test reading SPEF with max only to exercise parasiticAnalysisPtIndex // Covers: ConcreteParasitics::parasiticAnalysisPtIndex -TEST_F(DesignParasiticsTest, R8_ParasiticAnalysisPtIndexMaxOnly) { +TEST_F(DesignParasiticsTest, ParasiticAnalysisPtIndexMaxOnly) { ASSERT_TRUE(design_loaded_); Corner *corner = sta_->cmdCorner(); bool success = sta_->readSpef( @@ -2567,7 +2567,7 @@ TEST_F(DesignParasiticsTest, R8_ParasiticAnalysisPtIndexMaxOnly) { // Test reading SPEF and querying to exercise ReportParasiticAnnotation::report // Covers: ReportParasiticAnnotation::report -TEST_F(DesignParasiticsTest, R8_ReportAnnotationAfterSpef) { +TEST_F(DesignParasiticsTest, ReportAnnotationAfterSpef) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); Corner *corner = sta_->cmdCorner(); @@ -2582,7 +2582,7 @@ TEST_F(DesignParasiticsTest, R8_ReportAnnotationAfterSpef) { // ReduceToPi::isVisited, ReduceToPi::leave, ReduceToPi::setDownstreamCap, // ReduceToPi::downstreamCap, ReduceToPi::isLoopResistor, // ReduceToPi::markLoopResistor -TEST_F(DesignParasiticsTest, R8_ReduceToPiElmoreWithNetwork) { +TEST_F(DesignParasiticsTest, ReduceToPiElmoreWithNetwork) { ASSERT_TRUE(design_loaded_); Corner *corner = sta_->cmdCorner(); diff --git a/power/VcdParse.cc b/power/VcdParse.cc index 93d6625c..23b9eae1 100644 --- a/power/VcdParse.cc +++ b/power/VcdParse.cc @@ -314,6 +314,13 @@ VcdParse::getToken() //////////////////////////////////////////////////////////////// +VcdValue::VcdValue() : + time_(0), + value_('\0'), + bus_value_(0) +{ +} + char VcdValue::value(int value_bit) const { diff --git a/power/test/cpp/TestPower.cc b/power/test/cpp/TestPower.cc index f807f9df..7d27e889 100644 --- a/power/test/cpp/TestPower.cc +++ b/power/test/cpp/TestPower.cc @@ -463,12 +463,10 @@ TEST_F(PwrActivityTest, SetDutyBoundary) { // VcdValue coverage tests //////////////////////////////////////////////////////////////// -// VcdValue tests - use zero-initialized memory since constructor is not defined -// VcdValue has only POD members (int64_t, char, uint64_t) so memset is safe +// VcdValue tests } // namespace sta -#include #include "power/VcdParse.hh" namespace sta { @@ -476,31 +474,23 @@ namespace sta { class VcdValueTest : public ::testing::Test {}; TEST_F(VcdValueTest, SetValueAndAccess) { - // Zero-initialize to work around missing default constructor - alignas(VcdValue) char buf[sizeof(VcdValue)]; - std::memset(buf, 0, sizeof(VcdValue)); - VcdValue *val = reinterpret_cast(buf); - - val->setValue(100, '1'); - EXPECT_EQ(val->time(), 100); - EXPECT_EQ(val->value(), '1'); + VcdValue val; + val.setValue(100, '1'); + EXPECT_EQ(val.time(), 100); + EXPECT_EQ(val.value(), '1'); } TEST_F(VcdValueTest, ValueBitAccess) { - // Zero-initialize - alignas(VcdValue) char buf[sizeof(VcdValue)]; - std::memset(buf, 0, sizeof(VcdValue)); - VcdValue *val = reinterpret_cast(buf); - + VcdValue val; // When value_ is non-null char, value(int) returns value_ regardless of bit - val->setValue(200, 'X'); - EXPECT_EQ(val->value(0), 'X'); - EXPECT_EQ(val->value(3), 'X'); + val.setValue(200, 'X'); + EXPECT_EQ(val.value(0), 'X'); + EXPECT_EQ(val.value(3), 'X'); } // Test PwrActivity check() is called during construction // Covers: PwrActivity::check -TEST_F(PwrActivityTest, R5_CheckCalledDuringConstruction) { +TEST_F(PwrActivityTest, CheckCalledDuringConstruction) { // check() clips density values smaller than min_density PwrActivity act1(1e-11f, 0.5f, PwrActivityOrigin::user); EXPECT_FLOAT_EQ(act1.density(), 0.0f); // clipped by check() @@ -514,14 +504,14 @@ TEST_F(PwrActivityTest, R5_CheckCalledDuringConstruction) { // Test PwrActivity check() via set() // Covers: PwrActivity::check -TEST_F(PwrActivityTest, R5_CheckCalledDuringSet) { +TEST_F(PwrActivityTest, CheckCalledDuringSet) { PwrActivity act; act.set(1e-11f, 0.5f, PwrActivityOrigin::propagated); EXPECT_FLOAT_EQ(act.density(), 0.0f); // clipped by check() } // Test PwrActivity setDensity does not call check() -TEST_F(PwrActivityTest, R5_SetDensityDirect) { +TEST_F(PwrActivityTest, SetDensityDirect) { PwrActivity act; act.setDensity(1e-11f); // setDensity does NOT call check(), so the value is stored as-is @@ -529,77 +519,67 @@ TEST_F(PwrActivityTest, R5_SetDensityDirect) { } // Test VcdValue with zero value -TEST_F(VcdValueTest, R5_ValueZero) { - alignas(VcdValue) char buf[sizeof(VcdValue)]; - std::memset(buf, 0, sizeof(VcdValue)); - VcdValue *val = reinterpret_cast(buf); +TEST_F(VcdValueTest, ValueZero) { + VcdValue val; - val->setValue(0, '0'); - EXPECT_EQ(val->time(), 0); - EXPECT_EQ(val->value(), '0'); + val.setValue(0, '0'); + EXPECT_EQ(val.time(), 0); + EXPECT_EQ(val.value(), '0'); } // Test VcdValue with Z value -TEST_F(VcdValueTest, R5_ValueZ) { - alignas(VcdValue) char buf[sizeof(VcdValue)]; - std::memset(buf, 0, sizeof(VcdValue)); - VcdValue *val = reinterpret_cast(buf); +TEST_F(VcdValueTest, ValueZ) { + VcdValue val; - val->setValue(500, 'Z'); - EXPECT_EQ(val->time(), 500); - EXPECT_EQ(val->value(), 'Z'); - EXPECT_EQ(val->value(0), 'Z'); + val.setValue(500, 'Z'); + EXPECT_EQ(val.time(), 500); + EXPECT_EQ(val.value(), 'Z'); + EXPECT_EQ(val.value(0), 'Z'); } // Test VcdValue busValue -TEST_F(VcdValueTest, R5_BusValue) { - alignas(VcdValue) char buf[sizeof(VcdValue)]; - std::memset(buf, 0, sizeof(VcdValue)); - VcdValue *val = reinterpret_cast(buf); +TEST_F(VcdValueTest, BusValue) { + VcdValue val; // When value_ is '\0', busValue is used - val->setValue(100, '\0'); - EXPECT_EQ(val->value(), '\0'); + val.setValue(100, '\0'); + EXPECT_EQ(val.value(), '\0'); // busValue will be 0 since we zero-initialized - EXPECT_EQ(val->busValue(), 0u); + EXPECT_EQ(val.busValue(), 0u); } // Test VcdValue large time values -TEST_F(VcdValueTest, R5_LargeTime) { - alignas(VcdValue) char buf[sizeof(VcdValue)]; - std::memset(buf, 0, sizeof(VcdValue)); - VcdValue *val = reinterpret_cast(buf); +TEST_F(VcdValueTest, LargeTime) { + VcdValue val; VcdTime large_time = 1000000000LL; - val->setValue(large_time, '1'); - EXPECT_EQ(val->time(), large_time); - EXPECT_EQ(val->value(), '1'); + val.setValue(large_time, '1'); + EXPECT_EQ(val.time(), large_time); + EXPECT_EQ(val.value(), '1'); } // Test VcdValue overwrite -TEST_F(VcdValueTest, R5_OverwriteValue) { - alignas(VcdValue) char buf[sizeof(VcdValue)]; - std::memset(buf, 0, sizeof(VcdValue)); - VcdValue *val = reinterpret_cast(buf); +TEST_F(VcdValueTest, OverwriteValue) { + VcdValue val; - val->setValue(100, '0'); - EXPECT_EQ(val->value(), '0'); + val.setValue(100, '0'); + EXPECT_EQ(val.value(), '0'); - val->setValue(200, '1'); - EXPECT_EQ(val->time(), 200); - EXPECT_EQ(val->value(), '1'); + val.setValue(200, '1'); + EXPECT_EQ(val.time(), 200); + EXPECT_EQ(val.value(), '1'); } // Test PwrActivity check() is called and clips negative small density // Covers: PwrActivity::check -TEST_F(PwrActivityTest, R6_CheckClipsNegativeSmallDensity) { +TEST_F(PwrActivityTest, CheckClipsNegativeSmallDensity) { PwrActivity act(-5e-12f, 0.5f, PwrActivityOrigin::propagated); EXPECT_FLOAT_EQ(act.density(), 0.0f); // clipped by check() } // Test PwrActivity check() boundary at threshold // Covers: PwrActivity::check with values near threshold -TEST_F(PwrActivityTest, R6_CheckAtThreshold) { +TEST_F(PwrActivityTest, CheckAtThreshold) { // 1E-10 is exactly the threshold - should NOT be clipped PwrActivity act1(1e-10f, 0.5f, PwrActivityOrigin::user); EXPECT_FLOAT_EQ(act1.density(), 1e-10f); @@ -611,7 +591,7 @@ TEST_F(PwrActivityTest, R6_CheckAtThreshold) { // Test PwrActivity check() via set() with negative small // Covers: PwrActivity::check via set -TEST_F(PwrActivityTest, R6_CheckViaSetNegative) { +TEST_F(PwrActivityTest, CheckViaSetNegative) { PwrActivity act; act.set(-5e-12f, 0.3f, PwrActivityOrigin::vcd); EXPECT_FLOAT_EQ(act.density(), 0.0f); @@ -620,14 +600,14 @@ TEST_F(PwrActivityTest, R6_CheckViaSetNegative) { // Test PwrActivity check() does NOT clip normal density // Covers: PwrActivity::check positive path -TEST_F(PwrActivityTest, R6_CheckDoesNotClipNormal) { +TEST_F(PwrActivityTest, CheckDoesNotClipNormal) { PwrActivity act(1e-5f, 0.5f, PwrActivityOrigin::clock); EXPECT_FLOAT_EQ(act.density(), 1e-5f); } // Test PwrActivity with zero density and zero duty // Covers: PwrActivity construction edge case -TEST_F(PwrActivityTest, R6_ZeroDensityZeroDuty) { +TEST_F(PwrActivityTest, ZeroDensityZeroDuty) { PwrActivity act(0.0f, 0.0f, PwrActivityOrigin::user); EXPECT_FLOAT_EQ(act.density(), 0.0f); EXPECT_FLOAT_EQ(act.duty(), 0.0f); @@ -636,7 +616,7 @@ TEST_F(PwrActivityTest, R6_ZeroDensityZeroDuty) { // Test PwrActivity multiple init/set cycles // Covers: PwrActivity::init and set cycle -TEST_F(PwrActivityTest, R6_MultipleInitSetCycles) { +TEST_F(PwrActivityTest, MultipleInitSetCycles) { PwrActivity act; for (int i = 0; i < 10; i++) { act.set(static_cast(i * 100), 0.5f, PwrActivityOrigin::propagated); @@ -648,7 +628,7 @@ TEST_F(PwrActivityTest, R6_MultipleInitSetCycles) { // Test PowerResult with very small values // Covers: PowerResult accumulation precision -TEST_F(PowerResultTest, R6_VerySmallValues) { +TEST_F(PowerResultTest, VerySmallValues) { PowerResult result; result.incrInternal(1e-20f); result.incrSwitching(2e-20f); @@ -658,7 +638,7 @@ TEST_F(PowerResultTest, R6_VerySmallValues) { // Test PowerResult clear then incr multiple times // Covers: PowerResult clear/incr pattern -TEST_F(PowerResultTest, R6_ClearIncrPattern) { +TEST_F(PowerResultTest, ClearIncrPattern) { PowerResult result; for (int i = 0; i < 5; i++) { result.clear(); @@ -670,7 +650,7 @@ TEST_F(PowerResultTest, R6_ClearIncrPattern) { // Test PowerResult incr from two populated results // Covers: PowerResult::incr accumulation -TEST_F(PowerResultTest, R6_IncrMultipleSources) { +TEST_F(PowerResultTest, IncrMultipleSources) { PowerResult target; for (int i = 0; i < 3; i++) { PowerResult source; @@ -687,49 +667,43 @@ TEST_F(PowerResultTest, R6_IncrMultipleSources) { // Test VcdValue busValue with zero-initialized memory // Covers: VcdValue::busValue -TEST_F(VcdValueTest, R6_BusValueZeroInit) { - alignas(VcdValue) char buf[sizeof(VcdValue)]; - std::memset(buf, 0, sizeof(VcdValue)); - VcdValue *val = reinterpret_cast(buf); +TEST_F(VcdValueTest, BusValueZeroInit) { + VcdValue val; // Zero-initialized: busValue should be 0 - EXPECT_EQ(val->busValue(), 0u); + EXPECT_EQ(val.busValue(), 0u); // value_ is '\0', so value(bit) should look at bus_value_ - EXPECT_EQ(val->value(0), '0'); + EXPECT_EQ(val.value(0), '0'); } // Test VcdValue value(bit) when value_ is set (non-null char) // Covers: VcdValue::value(int bit) when value_ is non-null -TEST_F(VcdValueTest, R6_ValueBitWithScalarValue) { - alignas(VcdValue) char buf[sizeof(VcdValue)]; - std::memset(buf, 0, sizeof(VcdValue)); - VcdValue *val = reinterpret_cast(buf); +TEST_F(VcdValueTest, ValueBitWithScalarValue) { + VcdValue val; // When value_ is non-null, value(bit) returns value_ regardless of bit - val->setValue(100, '1'); - EXPECT_EQ(val->value(0), '1'); - EXPECT_EQ(val->value(5), '1'); - EXPECT_EQ(val->value(31), '1'); + val.setValue(100, '1'); + EXPECT_EQ(val.value(0), '1'); + EXPECT_EQ(val.value(5), '1'); + EXPECT_EQ(val.value(31), '1'); } // Test VcdValue setValue multiple times // Covers: VcdValue::setValue overwrite behavior -TEST_F(VcdValueTest, R6_SetValueMultipleTimes) { - alignas(VcdValue) char buf[sizeof(VcdValue)]; - std::memset(buf, 0, sizeof(VcdValue)); - VcdValue *val = reinterpret_cast(buf); - val->setValue(100, '0'); - EXPECT_EQ(val->time(), 100); - EXPECT_EQ(val->value(), '0'); - val->setValue(200, '1'); - EXPECT_EQ(val->time(), 200); - EXPECT_EQ(val->value(), '1'); - val->setValue(300, 'X'); - EXPECT_EQ(val->time(), 300); - EXPECT_EQ(val->value(), 'X'); +TEST_F(VcdValueTest, SetValueMultipleTimes) { + VcdValue val; + val.setValue(100, '0'); + EXPECT_EQ(val.time(), 100); + EXPECT_EQ(val.value(), '0'); + val.setValue(200, '1'); + EXPECT_EQ(val.time(), 200); + EXPECT_EQ(val.value(), '1'); + val.setValue(300, 'X'); + EXPECT_EQ(val.time(), 300); + EXPECT_EQ(val.value(), 'X'); } // Test PwrActivity density boundary with negative threshold // Covers: PwrActivity::check with negative values near threshold -TEST_F(PwrActivityTest, R6_NegativeNearThreshold) { +TEST_F(PwrActivityTest, NegativeNearThreshold) { PwrActivity act1(-1e-10f, 0.5f, PwrActivityOrigin::user); EXPECT_FLOAT_EQ(act1.density(), -1e-10f); PwrActivity act2(-9e-11f, 0.5f, PwrActivityOrigin::user); @@ -738,7 +712,7 @@ TEST_F(PwrActivityTest, R6_NegativeNearThreshold) { // Test PwrActivity originName for all origins // Covers: PwrActivity::originName exhaustive -TEST_F(PwrActivityTest, R6_OriginNameExhaustive) { +TEST_F(PwrActivityTest, OriginNameExhaustive) { EXPECT_STREQ(PwrActivity(0, 0, PwrActivityOrigin::unknown).originName(), "unknown"); EXPECT_STREQ(PwrActivity(0, 0, PwrActivityOrigin::global).originName(), "global"); EXPECT_STREQ(PwrActivity(0, 0, PwrActivityOrigin::input).originName(), "input"); @@ -757,7 +731,7 @@ TEST_F(PwrActivityTest, R6_OriginNameExhaustive) { // Test PwrActivity::check - density below threshold is clipped to 0 // Covers: PwrActivity::check -TEST_F(PwrActivityTest, R8_CheckClipsBelowThreshold) { +TEST_F(PwrActivityTest, CheckClipsBelowThreshold) { // Density between -1e-10 and 1e-10 (exclusive) should be clipped PwrActivity act1(5e-11f, 0.5f, PwrActivityOrigin::user); EXPECT_FLOAT_EQ(act1.density(), 0.0f); @@ -775,7 +749,7 @@ TEST_F(PwrActivityTest, R8_CheckClipsBelowThreshold) { // Test PwrActivity check via set method // Covers: PwrActivity::check -TEST_F(PwrActivityTest, R8_CheckViaSet) { +TEST_F(PwrActivityTest, CheckViaSet) { PwrActivity act; act.set(1e-12f, 0.5f, PwrActivityOrigin::propagated); EXPECT_FLOAT_EQ(act.density(), 0.0f); // below threshold, clipped to 0 @@ -785,7 +759,7 @@ TEST_F(PwrActivityTest, R8_CheckViaSet) { // Test PwrActivity setDensity does NOT call check() (no clipping) // Covers: PwrActivity::setDensity -TEST_F(PwrActivityTest, R8_CheckViaSetDensity) { +TEST_F(PwrActivityTest, CheckViaSetDensity) { PwrActivity act; // setDensity does NOT call check(), so even tiny values are stored as-is act.setDensity(1e-12f); @@ -876,7 +850,7 @@ protected: // ActivitySrchPred::ActivitySrchPred, // PropActivityVisitor::copy, PropActivityVisitor::init, // SeqPinHash::SeqPinHash, SeqPinEqual::operator() -TEST_F(PowerDesignTest, R8_PowerCalculation) { +TEST_F(PowerDesignTest, PowerCalculation) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -893,7 +867,7 @@ TEST_F(PowerDesignTest, R8_PowerCalculation) { // Test Power for individual instances // Covers: Power::powerInside, Power::findInstClk, Power::findLinkPort -TEST_F(PowerDesignTest, R8_PowerPerInstance) { +TEST_F(PowerDesignTest, PowerPerInstance) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -916,7 +890,7 @@ TEST_F(PowerDesignTest, R8_PowerPerInstance) { // Test Sta::activity for pins (exercises Power::activity, hasActivity) // Covers: Power::hasActivity, Power::activity -TEST_F(PowerDesignTest, R8_PinActivityQuery) { +TEST_F(PowerDesignTest, PinActivityQuery) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); diff --git a/sdc/test/cpp/TestSdc.cc b/sdc/test/cpp/TestSdc.cc index 54e1b25b..ebdf499b 100644 --- a/sdc/test/cpp/TestSdc.cc +++ b/sdc/test/cpp/TestSdc.cc @@ -4581,7 +4581,7 @@ TEST_F(SdcInitTest, SdcIsDisableClockGatingCheckPinNull) { //////////////////////////////////////////////////////////////// // Clock::addPin with nullptr - covers Clock::addPin -TEST_F(SdcInitTest, R5_ClockAddPinNull) { +TEST_F(SdcInitTest, ClockAddPinNull) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -4596,7 +4596,7 @@ TEST_F(SdcInitTest, R5_ClockAddPinNull) { } // Clock::setSlew - covers Clock::setSlew(rf, min_max, float) -TEST_F(SdcInitTest, R5_ClockSetSlewRfMinMax) { +TEST_F(SdcInitTest, ClockSetSlewRfMinMax) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -4614,7 +4614,7 @@ TEST_F(SdcInitTest, R5_ClockSetSlewRfMinMax) { // ClockEdge::setTime - covers ClockEdge::setTime // Note: setTime is private/friend, but we can check after clock operations -TEST_F(SdcInitTest, R5_ClockEdgeTime) { +TEST_F(SdcInitTest, ClockEdgeTime) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -4631,7 +4631,7 @@ TEST_F(SdcInitTest, R5_ClockEdgeTime) { } // ClockEdge opposite -TEST_F(SdcInitTest, R5_ClockEdgeOpposite) { +TEST_F(SdcInitTest, ClockEdgeOpposite) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -4648,7 +4648,7 @@ TEST_F(SdcInitTest, R5_ClockEdgeOpposite) { } // ClockEdge pulseWidth -TEST_F(SdcInitTest, R5_ClockEdgePulseWidth) { +TEST_F(SdcInitTest, ClockEdgePulseWidth) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(4.0); @@ -4663,7 +4663,7 @@ TEST_F(SdcInitTest, R5_ClockEdgePulseWidth) { } // ClockEdge name and index -TEST_F(SdcInitTest, R5_ClockEdgeNameIndex) { +TEST_F(SdcInitTest, ClockEdgeNameIndex) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -4679,7 +4679,7 @@ TEST_F(SdcInitTest, R5_ClockEdgeNameIndex) { } // DisabledCellPorts - covers constructor/destructor and methods -TEST_F(SdcInitTest, R5_DisabledCellPortsBasic) { +TEST_F(SdcInitTest, DisabledCellPortsBasic) { // We need a real liberty cell LibertyLibrary *lib = sta_->readLiberty("test/nangate45/Nangate45_typ.lib", sta_->cmdCorner(), @@ -4693,7 +4693,7 @@ TEST_F(SdcInitTest, R5_DisabledCellPortsBasic) { } // DisabledCellPorts setDisabled/removeDisabled with TimingArcSet -TEST_F(SdcInitTest, R5_DisabledCellPortsTimingArcSet) { +TEST_F(SdcInitTest, DisabledCellPortsTimingArcSet) { LibertyLibrary *lib = sta_->readLiberty("test/nangate45/Nangate45_typ.lib", sta_->cmdCorner(), MinMaxAll::min(), false); @@ -4711,7 +4711,7 @@ TEST_F(SdcInitTest, R5_DisabledCellPortsTimingArcSet) { } // DisabledCellPorts isDisabled for from/to/role -TEST_F(SdcInitTest, R5_DisabledCellPortsIsDisabled) { +TEST_F(SdcInitTest, DisabledCellPortsIsDisabled) { LibertyLibrary *lib = sta_->readLiberty("test/nangate45/Nangate45_typ.lib", sta_->cmdCorner(), MinMaxAll::min(), false); @@ -4734,46 +4734,46 @@ TEST_F(SdcInitTest, R5_DisabledCellPortsIsDisabled) { } // ExceptionPath::typeString via various subclasses -TEST_F(SdcInitTest, R5_FalsePathTypeString) { +TEST_F(SdcInitTest, FalsePathTypeString) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); EXPECT_NE(fp.typeString(), nullptr); } -TEST_F(SdcInitTest, R5_PathDelayTypeString) { +TEST_F(SdcInitTest, PathDelayTypeString) { PathDelay pd(nullptr, nullptr, nullptr, MinMax::max(), false, false, 5.0f, true, nullptr); EXPECT_NE(pd.typeString(), nullptr); } -TEST_F(SdcInitTest, R5_MultiCyclePathTypeString) { +TEST_F(SdcInitTest, MultiCyclePathTypeString) { MultiCyclePath mcp(nullptr, nullptr, nullptr, MinMaxAll::all(), true, 3, true, nullptr); EXPECT_NE(mcp.typeString(), nullptr); } -TEST_F(SdcInitTest, R5_FilterPathTypeString) { +TEST_F(SdcInitTest, FilterPathTypeString) { FilterPath fp(nullptr, nullptr, nullptr, true); EXPECT_NE(fp.typeString(), nullptr); } -TEST_F(SdcInitTest, R5_GroupPathTypeString) { +TEST_F(SdcInitTest, GroupPathTypeString) { GroupPath gp("grp1", false, nullptr, nullptr, nullptr, true, nullptr); EXPECT_NE(gp.typeString(), nullptr); } -TEST_F(SdcInitTest, R5_LoopPathTypeString) { +TEST_F(SdcInitTest, LoopPathTypeString) { LoopPath lp(nullptr, true); EXPECT_NE(lp.typeString(), nullptr); } // ExceptionPath::mergeable tests -TEST_F(SdcInitTest, R5_FalsePathMergeable) { +TEST_F(SdcInitTest, FalsePathMergeable) { FalsePath fp1(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); FalsePath fp2(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); EXPECT_TRUE(fp1.mergeable(&fp2)); } -TEST_F(SdcInitTest, R5_PathDelayMergeable) { +TEST_F(SdcInitTest, PathDelayMergeable) { PathDelay pd1(nullptr, nullptr, nullptr, MinMax::max(), false, false, 5.0f, true, nullptr); PathDelay pd2(nullptr, nullptr, nullptr, MinMax::max(), @@ -4781,7 +4781,7 @@ TEST_F(SdcInitTest, R5_PathDelayMergeable) { EXPECT_TRUE(pd1.mergeable(&pd2)); } -TEST_F(SdcInitTest, R5_PathDelayMergeableDifferentDelay) { +TEST_F(SdcInitTest, PathDelayMergeableDifferentDelay) { PathDelay pd1(nullptr, nullptr, nullptr, MinMax::max(), false, false, 5.0f, true, nullptr); PathDelay pd2(nullptr, nullptr, nullptr, MinMax::max(), @@ -4789,7 +4789,7 @@ TEST_F(SdcInitTest, R5_PathDelayMergeableDifferentDelay) { EXPECT_FALSE(pd1.mergeable(&pd2)); } -TEST_F(SdcInitTest, R5_MultiCyclePathMergeable) { +TEST_F(SdcInitTest, MultiCyclePathMergeable) { MultiCyclePath mcp1(nullptr, nullptr, nullptr, MinMaxAll::all(), true, 3, true, nullptr); MultiCyclePath mcp2(nullptr, nullptr, nullptr, MinMaxAll::all(), @@ -4797,32 +4797,32 @@ TEST_F(SdcInitTest, R5_MultiCyclePathMergeable) { EXPECT_TRUE(mcp1.mergeable(&mcp2)); } -TEST_F(SdcInitTest, R5_GroupPathMergeable) { +TEST_F(SdcInitTest, GroupPathMergeable) { GroupPath gp1("grp1", false, nullptr, nullptr, nullptr, true, nullptr); GroupPath gp2("grp1", false, nullptr, nullptr, nullptr, true, nullptr); EXPECT_TRUE(gp1.mergeable(&gp2)); } -TEST_F(SdcInitTest, R5_GroupPathNotMergeable) { +TEST_F(SdcInitTest, GroupPathNotMergeable) { GroupPath gp1("grp1", false, nullptr, nullptr, nullptr, true, nullptr); GroupPath gp2("grp2", false, nullptr, nullptr, nullptr, true, nullptr); EXPECT_FALSE(gp1.mergeable(&gp2)); } -TEST_F(SdcInitTest, R5_LoopPathNotMergeable) { +TEST_F(SdcInitTest, LoopPathNotMergeable) { LoopPath lp1(nullptr, true); LoopPath lp2(nullptr, true); EXPECT_FALSE(lp1.mergeable(&lp2)); } // ExceptionPath::overrides tests -TEST_F(SdcInitTest, R5_FalsePathOverrides) { +TEST_F(SdcInitTest, FalsePathOverrides) { FalsePath fp1(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); FalsePath fp2(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); EXPECT_TRUE(fp1.overrides(&fp2)); } -TEST_F(SdcInitTest, R5_PathDelayOverrides) { +TEST_F(SdcInitTest, PathDelayOverrides) { PathDelay pd1(nullptr, nullptr, nullptr, MinMax::max(), false, false, 5.0f, true, nullptr); PathDelay pd2(nullptr, nullptr, nullptr, MinMax::max(), @@ -4830,7 +4830,7 @@ TEST_F(SdcInitTest, R5_PathDelayOverrides) { EXPECT_TRUE(pd1.overrides(&pd2)); } -TEST_F(SdcInitTest, R5_MultiCyclePathOverrides) { +TEST_F(SdcInitTest, MultiCyclePathOverrides) { MultiCyclePath mcp1(nullptr, nullptr, nullptr, MinMaxAll::all(), true, 3, true, nullptr); MultiCyclePath mcp2(nullptr, nullptr, nullptr, MinMaxAll::all(), @@ -4838,21 +4838,21 @@ TEST_F(SdcInitTest, R5_MultiCyclePathOverrides) { EXPECT_TRUE(mcp1.overrides(&mcp2)); } -TEST_F(SdcInitTest, R5_FilterPathOverrides) { +TEST_F(SdcInitTest, FilterPathOverrides2) { FilterPath fp1(nullptr, nullptr, nullptr, true); FilterPath fp2(nullptr, nullptr, nullptr, true); // FilterPath::overrides always returns false EXPECT_FALSE(fp1.overrides(&fp2)); } -TEST_F(SdcInitTest, R5_GroupPathOverrides) { +TEST_F(SdcInitTest, GroupPathOverrides) { GroupPath gp1("grp1", false, nullptr, nullptr, nullptr, true, nullptr); GroupPath gp2("grp1", false, nullptr, nullptr, nullptr, true, nullptr); EXPECT_TRUE(gp1.overrides(&gp2)); } // ExceptionPath::matches with min_max -TEST_F(SdcInitTest, R5_MultiCyclePathMatches) { +TEST_F(SdcInitTest, MultiCyclePathMatches) { MultiCyclePath mcp(nullptr, nullptr, nullptr, MinMaxAll::all(), true, 3, true, nullptr); EXPECT_TRUE(mcp.matches(MinMax::max(), false)); @@ -4860,7 +4860,7 @@ TEST_F(SdcInitTest, R5_MultiCyclePathMatches) { } // ExceptionPath type priorities -TEST_F(SdcInitTest, R5_ExceptionPathStaticPriorities) { +TEST_F(SdcInitTest, ExceptionPathStaticPriorities) { EXPECT_EQ(ExceptionPath::falsePathPriority(), 4000); EXPECT_EQ(ExceptionPath::pathDelayPriority(), 3000); EXPECT_EQ(ExceptionPath::multiCyclePathPriority(), 2000); @@ -4869,13 +4869,13 @@ TEST_F(SdcInitTest, R5_ExceptionPathStaticPriorities) { } // ExceptionPath fromThruToPriority -TEST_F(SdcInitTest, R5_ExceptionFromThruToPriority) { +TEST_F(SdcInitTest, ExceptionFromThruToPriority) { int p = ExceptionPath::fromThruToPriority(nullptr, nullptr, nullptr); EXPECT_EQ(p, 0); } // PathDelay specific getters -TEST_F(SdcInitTest, R5_PathDelayGetters) { +TEST_F(SdcInitTest, PathDelayGetters) { PathDelay pd(nullptr, nullptr, nullptr, MinMax::max(), true, true, 5.0f, true, nullptr); EXPECT_FLOAT_EQ(pd.delay(), 5.0f); @@ -4890,7 +4890,7 @@ TEST_F(SdcInitTest, R5_PathDelayGetters) { } // MultiCyclePath specific getters -TEST_F(SdcInitTest, R5_MultiCyclePathGetters) { +TEST_F(SdcInitTest, MultiCyclePathGetters) { MultiCyclePath mcp(nullptr, nullptr, nullptr, MinMaxAll::max(), true, 5, true, nullptr); EXPECT_EQ(mcp.pathMultiplier(), 5); @@ -4899,7 +4899,7 @@ TEST_F(SdcInitTest, R5_MultiCyclePathGetters) { } // MultiCyclePath pathMultiplier with MinMax -TEST_F(SdcInitTest, R5_MultiCyclePathMultiplierMinMax) { +TEST_F(SdcInitTest, MultiCyclePathMultiplierMinMax) { MultiCyclePath mcp(nullptr, nullptr, nullptr, MinMaxAll::max(), true, 5, true, nullptr); int mult_max = mcp.pathMultiplier(MinMax::max()); @@ -4907,7 +4907,7 @@ TEST_F(SdcInitTest, R5_MultiCyclePathMultiplierMinMax) { } // MultiCyclePath priority with MinMax -TEST_F(SdcInitTest, R5_MultiCyclePathPriorityMinMax) { +TEST_F(SdcInitTest, MultiCyclePathPriorityMinMax) { MultiCyclePath mcp(nullptr, nullptr, nullptr, MinMaxAll::max(), true, 5, true, nullptr); int p = mcp.priority(MinMax::max()); @@ -4915,14 +4915,14 @@ TEST_F(SdcInitTest, R5_MultiCyclePathPriorityMinMax) { } // GroupPath name and isDefault -TEST_F(SdcInitTest, R5_GroupPathName) { +TEST_F(SdcInitTest, GroupPathName) { GroupPath gp("test_group", true, nullptr, nullptr, nullptr, true, nullptr); EXPECT_STREQ(gp.name(), "test_group"); EXPECT_TRUE(gp.isDefault()); } // FilterPath basic -TEST_F(SdcInitTest, R5_FilterPathBasic) { +TEST_F(SdcInitTest, FilterPathBasic) { FilterPath fp(nullptr, nullptr, nullptr, true); EXPECT_TRUE(fp.isFilter()); EXPECT_FALSE(fp.isFalse()); @@ -4933,14 +4933,14 @@ TEST_F(SdcInitTest, R5_FilterPathBasic) { } // FalsePath with priority -TEST_F(SdcInitTest, R5_FalsePathWithPriority) { +TEST_F(SdcInitTest, FalsePathWithPriority) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), true, 4500, nullptr); EXPECT_EQ(fp.priority(), 4500); } // LoopPath basic -TEST_F(SdcInitTest, R5_LoopPathBasicProps) { +TEST_F(SdcInitTest, LoopPathBasicProps) { LoopPath lp(nullptr, true); EXPECT_TRUE(lp.isLoop()); EXPECT_TRUE(lp.isFalse()); @@ -4949,7 +4949,7 @@ TEST_F(SdcInitTest, R5_LoopPathBasicProps) { } // Exception hash -TEST_F(SdcInitTest, R5_ExceptionPathHash) { +TEST_F(SdcInitTest, ExceptionPathHash) { FalsePath fp1(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); size_t h1 = fp1.hash(); FalsePath fp2(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); @@ -4958,7 +4958,7 @@ TEST_F(SdcInitTest, R5_ExceptionPathHash) { } // ExceptionPath clone tests -TEST_F(SdcInitTest, R5_FalsePathCloneAndCheck) { +TEST_F(SdcInitTest, FalsePathCloneAndCheck) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); ExceptionPath *clone = fp.clone(nullptr, nullptr, nullptr, true); ASSERT_NE(clone, nullptr); @@ -4966,7 +4966,7 @@ TEST_F(SdcInitTest, R5_FalsePathCloneAndCheck) { delete clone; } -TEST_F(SdcInitTest, R5_PathDelayCloneAndCheck) { +TEST_F(SdcInitTest, PathDelayCloneAndCheck) { PathDelay pd(nullptr, nullptr, nullptr, MinMax::max(), false, false, 5.0f, true, nullptr); ExceptionPath *clone = pd.clone(nullptr, nullptr, nullptr, true); @@ -4976,7 +4976,7 @@ TEST_F(SdcInitTest, R5_PathDelayCloneAndCheck) { delete clone; } -TEST_F(SdcInitTest, R5_MultiCyclePathCloneAndCheck) { +TEST_F(SdcInitTest, MultiCyclePathCloneAndCheck) { MultiCyclePath mcp(nullptr, nullptr, nullptr, MinMaxAll::all(), true, 4, true, nullptr); ExceptionPath *clone = mcp.clone(nullptr, nullptr, nullptr, true); @@ -4986,7 +4986,7 @@ TEST_F(SdcInitTest, R5_MultiCyclePathCloneAndCheck) { delete clone; } -TEST_F(SdcInitTest, R5_GroupPathCloneAndCheck) { +TEST_F(SdcInitTest, GroupPathCloneAndCheck) { GroupPath gp("grp", false, nullptr, nullptr, nullptr, true, nullptr); ExceptionPath *clone = gp.clone(nullptr, nullptr, nullptr, true); ASSERT_NE(clone, nullptr); @@ -4995,7 +4995,7 @@ TEST_F(SdcInitTest, R5_GroupPathCloneAndCheck) { delete clone; } -TEST_F(SdcInitTest, R5_FilterPathCloneAndCheck) { +TEST_F(SdcInitTest, FilterPathCloneAndCheck) { FilterPath fp(nullptr, nullptr, nullptr, true); ExceptionPath *clone = fp.clone(nullptr, nullptr, nullptr, true); ASSERT_NE(clone, nullptr); @@ -5004,7 +5004,7 @@ TEST_F(SdcInitTest, R5_FilterPathCloneAndCheck) { } // ExceptionState constructor -TEST_F(SdcInitTest, R5_ExceptionState) { +TEST_F(SdcInitTest, ExceptionState) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); ExceptionState state(&fp, nullptr, 0); EXPECT_EQ(state.exception(), &fp); @@ -5014,7 +5014,7 @@ TEST_F(SdcInitTest, R5_ExceptionState) { } // ExceptionState setNextState -TEST_F(SdcInitTest, R5_ExceptionStateSetNextState) { +TEST_F(SdcInitTest, ExceptionStateSetNextState) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); ExceptionState state1(&fp, nullptr, 0); ExceptionState state2(&fp, nullptr, 1); @@ -5023,7 +5023,7 @@ TEST_F(SdcInitTest, R5_ExceptionStateSetNextState) { } // ExceptionState hash -TEST_F(SdcInitTest, R5_ExceptionStateHash) { +TEST_F(SdcInitTest, ExceptionStateHash) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); ExceptionState state(&fp, nullptr, 0); size_t h = state.hash(); @@ -5031,7 +5031,7 @@ TEST_F(SdcInitTest, R5_ExceptionStateHash) { } // exceptionStateLess -TEST_F(SdcInitTest, R5_ExceptionStateLess) { +TEST_F(SdcInitTest, ExceptionStateLess) { FalsePath fp1(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); FalsePath fp2(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); ExceptionState state1(&fp1, nullptr, 0); @@ -5041,13 +5041,13 @@ TEST_F(SdcInitTest, R5_ExceptionStateLess) { } // Sdc::setOperatingConditions(op_cond, MinMaxAll*) -TEST_F(SdcInitTest, R5_SdcSetOperatingConditionsMinMaxAll) { +TEST_F(SdcInitTest, SdcSetOperatingConditionsMinMaxAll) { Sdc *sdc = sta_->sdc(); sdc->setOperatingConditions(nullptr, MinMaxAll::all()); } // Sdc::disable/removeDisable for LibertyPort -TEST_F(SdcInitTest, R5_SdcDisableLibertyPort) { +TEST_F(SdcInitTest, SdcDisableLibertyPort) { LibertyLibrary *lib = sta_->readLiberty("test/nangate45/Nangate45_typ.lib", sta_->cmdCorner(), MinMaxAll::min(), false); @@ -5062,7 +5062,7 @@ TEST_F(SdcInitTest, R5_SdcDisableLibertyPort) { } // Sdc::disable/removeDisable for TimingArcSet -TEST_F(SdcInitTest, R5_SdcDisableTimingArcSet) { +TEST_F(SdcInitTest, SdcDisableTimingArcSet) { LibertyLibrary *lib = sta_->readLiberty("test/nangate45/Nangate45_typ.lib", sta_->cmdCorner(), MinMaxAll::min(), false); @@ -5077,14 +5077,14 @@ TEST_F(SdcInitTest, R5_SdcDisableTimingArcSet) { } // Sdc clock querying via findClock -TEST_F(SdcInitTest, R5_SdcFindClockNull) { +TEST_F(SdcInitTest, SdcFindClockNull) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("nonexistent_clk"); EXPECT_EQ(clk, nullptr); } // Sdc latch borrow limit on clock -TEST_F(SdcInitTest, R5_SdcLatchBorrowLimitOnClock) { +TEST_F(SdcInitTest, SdcLatchBorrowLimitOnClock) { Sdc *sdc = sta_->sdc(); FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); @@ -5097,7 +5097,7 @@ TEST_F(SdcInitTest, R5_SdcLatchBorrowLimitOnClock) { } // InterClockUncertainty more thorough -TEST_F(SdcInitTest, R5_InterClockUncertaintyEmpty) { +TEST_F(SdcInitTest, InterClockUncertaintyEmpty) { FloatSeq *waveform1 = new FloatSeq; waveform1->push_back(0.0); waveform1->push_back(5.0); @@ -5115,7 +5115,7 @@ TEST_F(SdcInitTest, R5_InterClockUncertaintyEmpty) { EXPECT_EQ(icu.target(), clk2); } -TEST_F(SdcInitTest, R5_InterClockUncertaintySetAndGet) { +TEST_F(SdcInitTest, InterClockUncertaintySetAndGet) { FloatSeq *waveform1 = new FloatSeq; waveform1->push_back(0.0); waveform1->push_back(5.0); @@ -5139,7 +5139,7 @@ TEST_F(SdcInitTest, R5_InterClockUncertaintySetAndGet) { EXPECT_FLOAT_EQ(unc, 0.1f); } -TEST_F(SdcInitTest, R5_InterClockUncertaintyRemove) { +TEST_F(SdcInitTest, InterClockUncertaintyRemove) { FloatSeq *waveform1 = new FloatSeq; waveform1->push_back(0.0); waveform1->push_back(5.0); @@ -5159,7 +5159,7 @@ TEST_F(SdcInitTest, R5_InterClockUncertaintyRemove) { EXPECT_TRUE(icu.empty()); } -TEST_F(SdcInitTest, R5_InterClockUncertaintyUncertainties) { +TEST_F(SdcInitTest, InterClockUncertaintyUncertainties) { FloatSeq *waveform1 = new FloatSeq; waveform1->push_back(0.0); waveform1->push_back(5.0); @@ -5177,7 +5177,7 @@ TEST_F(SdcInitTest, R5_InterClockUncertaintyUncertainties) { } // CycleAccting exercises -TEST_F(SdcInitTest, R5_CycleAcctingConstruct) { +TEST_F(SdcInitTest, CycleAcctingConstruct2) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -5192,7 +5192,7 @@ TEST_F(SdcInitTest, R5_CycleAcctingConstruct) { EXPECT_EQ(ca.target(), fall); } -TEST_F(SdcInitTest, R5_CycleAcctingFindDefaultArrivalSrcDelays) { +TEST_F(SdcInitTest, CycleAcctingFindDefaultArrivalSrcDelays) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -5208,7 +5208,7 @@ TEST_F(SdcInitTest, R5_CycleAcctingFindDefaultArrivalSrcDelays) { } // DisabledPorts from/to operations -TEST_F(SdcInitTest, R5_DisabledPortsFromToOps) { +TEST_F(SdcInitTest, DisabledPortsFromToOps) { LibertyLibrary *lib = sta_->readLiberty("test/nangate45/Nangate45_typ.lib", sta_->cmdCorner(), MinMaxAll::min(), false); @@ -5232,7 +5232,7 @@ TEST_F(SdcInitTest, R5_DisabledPortsFromToOps) { } // ClockCompareSet -TEST_F(SdcInitTest, R5_ClockSetCompare) { +TEST_F(SdcInitTest, ClockSetCompare) { FloatSeq *waveform1 = new FloatSeq; waveform1->push_back(0.0); waveform1->push_back(5.0); @@ -5253,7 +5253,7 @@ TEST_F(SdcInitTest, R5_ClockSetCompare) { } // Sdc::clockUncertainty on null pin -TEST_F(SdcInitTest, R5_SdcClockUncertaintyNullPin) { +TEST_F(SdcInitTest, SdcClockUncertaintyNullPin) { Sdc *sdc = sta_->sdc(); float unc; bool exists; @@ -5263,7 +5263,7 @@ TEST_F(SdcInitTest, R5_SdcClockUncertaintyNullPin) { } // ExceptionPtIterator with from only -TEST_F(SdcInitTest, R5_ExceptionPtIteratorFromOnly) { +TEST_F(SdcInitTest, ExceptionPtIteratorFromOnly) { const Network *network = sta_->cmdNetwork(); ExceptionFrom *from = new ExceptionFrom(nullptr, nullptr, nullptr, RiseFallBoth::riseFall(), @@ -5280,7 +5280,7 @@ TEST_F(SdcInitTest, R5_ExceptionPtIteratorFromOnly) { } // ExceptionFrom basic properties -TEST_F(SdcInitTest, R5_ExceptionFromProperties) { +TEST_F(SdcInitTest, ExceptionFromProperties) { const Network *network = sta_->cmdNetwork(); ExceptionFrom *from = new ExceptionFrom(nullptr, nullptr, nullptr, RiseFallBoth::rise(), @@ -5294,7 +5294,7 @@ TEST_F(SdcInitTest, R5_ExceptionFromProperties) { } // ExceptionTo basic properties -TEST_F(SdcInitTest, R5_ExceptionToProperties) { +TEST_F(SdcInitTest, ExceptionToProperties) { const Network *network = sta_->cmdNetwork(); ExceptionTo *to = new ExceptionTo(nullptr, nullptr, nullptr, RiseFallBoth::fall(), @@ -5310,7 +5310,7 @@ TEST_F(SdcInitTest, R5_ExceptionToProperties) { } // ExceptionThru basic properties -TEST_F(SdcInitTest, R5_ExceptionThruProperties) { +TEST_F(SdcInitTest, ExceptionThruProperties) { const Network *network = sta_->cmdNetwork(); ExceptionThru *thru = new ExceptionThru(nullptr, nullptr, nullptr, RiseFallBoth::riseFall(), @@ -5326,7 +5326,7 @@ TEST_F(SdcInitTest, R5_ExceptionThruProperties) { } // ExceptionThru objectCount -TEST_F(SdcInitTest, R5_ExceptionThruObjectCount) { +TEST_F(SdcInitTest, ExceptionThruObjectCount) { const Network *network = sta_->cmdNetwork(); ExceptionThru *thru = new ExceptionThru(nullptr, nullptr, nullptr, RiseFallBoth::riseFall(), @@ -5336,7 +5336,7 @@ TEST_F(SdcInitTest, R5_ExceptionThruObjectCount) { } // ExceptionFromTo objectCount -TEST_F(SdcInitTest, R5_ExceptionFromToObjectCount) { +TEST_F(SdcInitTest, ExceptionFromToObjectCount) { const Network *network = sta_->cmdNetwork(); ExceptionFrom *from = new ExceptionFrom(nullptr, nullptr, nullptr, RiseFallBoth::riseFall(), @@ -5346,7 +5346,7 @@ TEST_F(SdcInitTest, R5_ExceptionFromToObjectCount) { } // ExceptionPt hash -TEST_F(SdcInitTest, R5_ExceptionPtHash) { +TEST_F(SdcInitTest, ExceptionPtHash) { const Network *network = sta_->cmdNetwork(); ExceptionFrom *from = new ExceptionFrom(nullptr, nullptr, nullptr, RiseFallBoth::riseFall(), @@ -5357,7 +5357,7 @@ TEST_F(SdcInitTest, R5_ExceptionPtHash) { } // ExceptionFrom::findHash (called during construction) -TEST_F(SdcInitTest, R5_ExceptionFromFindHash) { +TEST_F(SdcInitTest, ExceptionFromFindHash) { const Network *network = sta_->cmdNetwork(); ExceptionFrom *from = new ExceptionFrom(nullptr, nullptr, nullptr, RiseFallBoth::rise(), @@ -5369,20 +5369,20 @@ TEST_F(SdcInitTest, R5_ExceptionFromFindHash) { } // checkFromThrusTo with nulls should not throw -TEST_F(SdcInitTest, R5_CheckFromThrusToAllNull) { +TEST_F(SdcInitTest, CheckFromThrusToAllNull) { // All nullptr should not throw EmptyExceptionPt checkFromThrusTo(nullptr, nullptr, nullptr); } // EmptyExceptionPt what -TEST_F(SdcInitTest, R5_EmptyExceptionPtWhat) { +TEST_F(SdcInitTest, EmptyExceptionPtWhat2) { EmptyExpceptionPt e; const char *msg = e.what(); EXPECT_NE(msg, nullptr); } // ExceptionPathLess comparator -TEST_F(SdcInitTest, R5_ExceptionPathLessComparator) { +TEST_F(SdcInitTest, ExceptionPathLessComparator2) { const Network *network = sta_->cmdNetwork(); ExceptionPathLess less(network); FalsePath fp1(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); @@ -5393,14 +5393,14 @@ TEST_F(SdcInitTest, R5_ExceptionPathLessComparator) { // Sdc::isLeafPinNonGeneratedClock with null -TEST_F(SdcInitTest, R5_SdcIsLeafPinNonGeneratedClockNull) { +TEST_F(SdcInitTest, SdcIsLeafPinNonGeneratedClockNull) { Sdc *sdc = sta_->sdc(); bool result = sdc->isLeafPinNonGeneratedClock(nullptr); EXPECT_FALSE(result); } // Clock removeSlew -TEST_F(SdcInitTest, R5_ClockRemoveSlew) { +TEST_F(SdcInitTest, ClockRemoveSlew) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -5417,7 +5417,7 @@ TEST_F(SdcInitTest, R5_ClockRemoveSlew) { } // Clock slews accessor -TEST_F(SdcInitTest, R5_ClockSlewsAccessor) { +TEST_F(SdcInitTest, ClockSlewsAccessor) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -5430,7 +5430,7 @@ TEST_F(SdcInitTest, R5_ClockSlewsAccessor) { } // Clock uncertainties -TEST_F(SdcInitTest, R5_ClockUncertaintiesAccessor) { +TEST_F(SdcInitTest, ClockUncertaintiesAccessor) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -5443,7 +5443,7 @@ TEST_F(SdcInitTest, R5_ClockUncertaintiesAccessor) { } // Clock setUncertainty and removeUncertainty -TEST_F(SdcInitTest, R5_ClockSetRemoveUncertainty) { +TEST_F(SdcInitTest, ClockSetRemoveUncertainty) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -5463,7 +5463,7 @@ TEST_F(SdcInitTest, R5_ClockSetRemoveUncertainty) { } // Clock generated properties -TEST_F(SdcInitTest, R5_ClockGeneratedProperties) { +TEST_F(SdcInitTest, ClockGeneratedProperties) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -5479,7 +5479,7 @@ TEST_F(SdcInitTest, R5_ClockGeneratedProperties) { } // ClkNameLess comparator -TEST_F(SdcInitTest, R5_ClkNameLess) { +TEST_F(SdcInitTest, ClkNameLess) { FloatSeq *waveform1 = new FloatSeq; waveform1->push_back(0.0); waveform1->push_back(5.0); @@ -5497,7 +5497,7 @@ TEST_F(SdcInitTest, R5_ClkNameLess) { } // CycleAcctings -TEST_F(SdcInitTest, R5_CycleAcctings) { +TEST_F(SdcInitTest, CycleAcctings) { Sdc *sdc = sta_->sdc(); CycleAcctings acctings(sdc); // Clear should not crash @@ -5505,7 +5505,7 @@ TEST_F(SdcInitTest, R5_CycleAcctings) { } // Clock setPropagated / removePropagated -TEST_F(SdcInitTest, R5_ClockPropagation) { +TEST_F(SdcInitTest, ClockPropagation2) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -5524,7 +5524,7 @@ TEST_F(SdcInitTest, R5_ClockPropagation) { // R6 tests: DisabledPorts from/to operations //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_DisabledPortsAllState) { +TEST_F(SdcInitTest, DisabledPortsAllState) { DisabledPorts dp; EXPECT_FALSE(dp.all()); dp.setDisabledAll(); @@ -5537,7 +5537,7 @@ TEST_F(SdcInitTest, R6_DisabledPortsAllState) { EXPECT_EQ(dp.fromTo(), nullptr); } -TEST_F(SdcInitTest, R6_DisabledCellPortsConstruct) { +TEST_F(SdcInitTest, DisabledCellPortsConstruct) { // DisabledCellPorts requires a LibertyCell; use nullptr since // we only exercise the constructor path LibertyLibrary lib("test_lib", "test.lib"); @@ -5552,7 +5552,7 @@ TEST_F(SdcInitTest, R6_DisabledCellPortsConstruct) { // R6 tests: Sdc public accessors //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_SdcAnalysisType) { +TEST_F(SdcInitTest, SdcAnalysisType) { Sdc *sdc = sta_->sdc(); sdc->setAnalysisType(AnalysisType::single); EXPECT_EQ(sdc->analysisType(), AnalysisType::single); @@ -5562,7 +5562,7 @@ TEST_F(SdcInitTest, R6_SdcAnalysisType) { EXPECT_EQ(sdc->analysisType(), AnalysisType::ocv); } -TEST_F(SdcInitTest, R6_SdcMaxArea) { +TEST_F(SdcInitTest, SdcMaxArea2) { Sdc *sdc = sta_->sdc(); sdc->setMaxArea(500.0); EXPECT_FLOAT_EQ(sdc->maxArea(), 500.0f); @@ -5572,7 +5572,7 @@ TEST_F(SdcInitTest, R6_SdcMaxArea) { // R6 tests: Sdc setOperatingConditions //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_SdcSetOperatingConditions) { +TEST_F(SdcInitTest, SdcSetOperatingConditions) { Sdc *sdc = sta_->sdc(); sdc->setOperatingConditions(nullptr, MinMax::max()); sdc->setOperatingConditions(nullptr, MinMax::min()); @@ -5584,7 +5584,7 @@ TEST_F(SdcInitTest, R6_SdcSetOperatingConditions) { // R6 tests: Sdc wireload mode //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_SdcWireloadMode) { +TEST_F(SdcInitTest, SdcWireloadMode2) { Sdc *sdc = sta_->sdc(); sdc->setWireloadMode(WireloadMode::top); EXPECT_EQ(sdc->wireloadMode(), WireloadMode::top); @@ -5596,19 +5596,19 @@ TEST_F(SdcInitTest, R6_SdcWireloadMode) { // R6 tests: ExceptionPath mergeable between same types //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_FalsePathMergeableSame) { +TEST_F(SdcInitTest, FalsePathMergeableSame) { FalsePath fp1(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); FalsePath fp2(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); EXPECT_TRUE(fp1.mergeable(&fp2)); } -TEST_F(SdcInitTest, R6_FalsePathNotMergeableDiffMinMax) { +TEST_F(SdcInitTest, FalsePathNotMergeableDiffMinMax) { FalsePath fp1(nullptr, nullptr, nullptr, MinMaxAll::min(), true, nullptr); FalsePath fp2(nullptr, nullptr, nullptr, MinMaxAll::max(), true, nullptr); EXPECT_FALSE(fp1.mergeable(&fp2)); } -TEST_F(SdcInitTest, R6_FalsePathNotMergeableDiffType) { +TEST_F(SdcInitTest, FalsePathNotMergeableDiffType) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); PathDelay pd(nullptr, nullptr, nullptr, MinMax::max(), false, false, 1.0e-9f, true, nullptr); @@ -5619,14 +5619,14 @@ TEST_F(SdcInitTest, R6_FalsePathNotMergeableDiffType) { // R6 tests: PathDelay min direction //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_PathDelayMinDirection) { +TEST_F(SdcInitTest, PathDelayMinDirection) { PathDelay pd(nullptr, nullptr, nullptr, MinMax::min(), false, false, 5.0e-9f, true, nullptr); EXPECT_TRUE(pd.matches(MinMax::min(), false)); EXPECT_FALSE(pd.matches(MinMax::max(), false)); } -TEST_F(SdcInitTest, R6_PathDelayTighterMin) { +TEST_F(SdcInitTest, PathDelayTighterMin) { PathDelay pd1(nullptr, nullptr, nullptr, MinMax::min(), false, false, 5.0e-9f, true, nullptr); PathDelay pd2(nullptr, nullptr, nullptr, MinMax::min(), false, false, @@ -5640,33 +5640,33 @@ TEST_F(SdcInitTest, R6_PathDelayTighterMin) { // R6 tests: ExceptionPath hash //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_PathDelayHash) { +TEST_F(SdcInitTest, PathDelayHash) { PathDelay pd(nullptr, nullptr, nullptr, MinMax::max(), false, false, 5.0e-9f, true, nullptr); size_t h = pd.hash(); EXPECT_GE(h, 0u); } -TEST_F(SdcInitTest, R6_MultiCyclePathHash) { +TEST_F(SdcInitTest, MultiCyclePathHash) { MultiCyclePath mcp(nullptr, nullptr, nullptr, MinMaxAll::all(), true, 3, true, nullptr); size_t h = mcp.hash(); EXPECT_GE(h, 0u); } -TEST_F(SdcInitTest, R6_GroupPathHash) { +TEST_F(SdcInitTest, GroupPathHash) { GroupPath gp("grp", false, nullptr, nullptr, nullptr, true, nullptr); size_t h = gp.hash(); EXPECT_GE(h, 0u); } -TEST_F(SdcInitTest, R6_FilterPathHash) { +TEST_F(SdcInitTest, FilterPathHash) { FilterPath flp(nullptr, nullptr, nullptr, true); size_t h = flp.hash(); EXPECT_GE(h, 0u); } -TEST_F(SdcInitTest, R6_LoopPathHash) { +TEST_F(SdcInitTest, LoopPathHash) { LoopPath lp(nullptr, true); size_t h = lp.hash(); EXPECT_GE(h, 0u); @@ -5676,33 +5676,33 @@ TEST_F(SdcInitTest, R6_LoopPathHash) { // R6 tests: ExceptionPath typeString //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_FalsePathTypeString) { +TEST_F(SdcInitTest, FalsePathTypeString2) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); const char *ts = fp.typeString(); EXPECT_NE(ts, nullptr); } -TEST_F(SdcInitTest, R6_PathDelayTypeString) { +TEST_F(SdcInitTest, PathDelayTypeString2) { PathDelay pd(nullptr, nullptr, nullptr, MinMax::max(), false, false, 1.0e-9f, true, nullptr); const char *ts = pd.typeString(); EXPECT_NE(ts, nullptr); } -TEST_F(SdcInitTest, R6_MultiCyclePathTypeString) { +TEST_F(SdcInitTest, MultiCyclePathTypeString2) { MultiCyclePath mcp(nullptr, nullptr, nullptr, MinMaxAll::all(), true, 2, true, nullptr); const char *ts = mcp.typeString(); EXPECT_NE(ts, nullptr); } -TEST_F(SdcInitTest, R6_GroupPathTypeString) { +TEST_F(SdcInitTest, GroupPathTypeString2) { GroupPath gp("g", false, nullptr, nullptr, nullptr, true, nullptr); const char *ts = gp.typeString(); EXPECT_NE(ts, nullptr); } -TEST_F(SdcInitTest, R6_FilterPathTypeString) { +TEST_F(SdcInitTest, FilterPathTypeString2) { FilterPath flp(nullptr, nullptr, nullptr, true); const char *ts = flp.typeString(); EXPECT_NE(ts, nullptr); @@ -5712,7 +5712,7 @@ TEST_F(SdcInitTest, R6_FilterPathTypeString) { // R6 tests: Clock operations //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_ClockEdgeTimeAccess) { +TEST_F(SdcInitTest, ClockEdgeTimeAccess) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -5729,7 +5729,7 @@ TEST_F(SdcInitTest, R6_ClockEdgeTimeAccess) { EXPECT_NE(fall_edge->name(), nullptr); } -TEST_F(SdcInitTest, R6_ClockMakeClock) { +TEST_F(SdcInitTest, ClockMakeClock) { Sdc *sdc = sta_->sdc(); FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); @@ -5740,7 +5740,7 @@ TEST_F(SdcInitTest, R6_ClockMakeClock) { EXPECT_STREQ(clk->name(), "direct_clk"); } -TEST_F(SdcInitTest, R6_ClockLeafPins) { +TEST_F(SdcInitTest, ClockLeafPins) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -5755,7 +5755,7 @@ TEST_F(SdcInitTest, R6_ClockLeafPins) { // R6 tests: Sdc exception operations //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_SdcMakeAndDeleteException) { +TEST_F(SdcInitTest, SdcMakeAndDeleteException) { sta_->makeFalsePath(nullptr, nullptr, nullptr, MinMaxAll::all(), nullptr); Sdc *sdc = sta_->sdc(); EXPECT_FALSE(sdc->exceptions().empty()); @@ -5763,7 +5763,7 @@ TEST_F(SdcInitTest, R6_SdcMakeAndDeleteException) { EXPECT_TRUE(sdc->exceptions().empty()); } -TEST_F(SdcInitTest, R6_SdcMultiCyclePathWithEndClk) { +TEST_F(SdcInitTest, SdcMultiCyclePathWithEndClk) { sta_->makeMulticyclePath(nullptr, nullptr, nullptr, MinMaxAll::max(), true, 3, nullptr); @@ -5771,7 +5771,7 @@ TEST_F(SdcInitTest, R6_SdcMultiCyclePathWithEndClk) { EXPECT_FALSE(sdc->exceptions().empty()); } -TEST_F(SdcInitTest, R6_SdcMultiCyclePathWithStartClk) { +TEST_F(SdcInitTest, SdcMultiCyclePathWithStartClk) { sta_->makeMulticyclePath(nullptr, nullptr, nullptr, MinMaxAll::min(), false, 2, nullptr); @@ -5783,13 +5783,13 @@ TEST_F(SdcInitTest, R6_SdcMultiCyclePathWithStartClk) { // R6 tests: Sdc constraint accessors //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_SdcClockGatingCheckGlobal) { +TEST_F(SdcInitTest, SdcClockGatingCheckGlobal2) { Sdc *sdc = sta_->sdc(); sdc->setClockGatingCheck(RiseFallBoth::rise(), SetupHold::min(), 0.3); sdc->setClockGatingCheck(RiseFallBoth::fall(), SetupHold::max(), 0.7); } -TEST_F(SdcInitTest, R6_SdcClockGatingCheckGlobalRiseFall) { +TEST_F(SdcInitTest, SdcClockGatingCheckGlobalRiseFall) { Sdc *sdc = sta_->sdc(); sdc->setClockGatingCheck(RiseFallBoth::riseFall(), SetupHold::min(), 0.5); sdc->setClockGatingCheck(RiseFallBoth::riseFall(), SetupHold::max(), 0.8); @@ -5800,7 +5800,7 @@ TEST_F(SdcInitTest, R6_SdcClockGatingCheckGlobalRiseFall) { EXPECT_FLOAT_EQ(margin, 0.5f); } -TEST_F(SdcInitTest, R6_SdcVoltageAccess) { +TEST_F(SdcInitTest, SdcVoltageAccess) { Sdc *sdc = sta_->sdc(); sdc->setVoltage(MinMax::min(), 0.9); sdc->setVoltage(MinMax::max(), 1.1); @@ -5818,14 +5818,14 @@ TEST_F(SdcInitTest, R6_SdcVoltageAccess) { // R6 tests: ExceptionPt construction //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_ExceptionFromRiseFall) { +TEST_F(SdcInitTest, ExceptionFromRiseFall) { ExceptionFrom from(nullptr, nullptr, nullptr, RiseFallBoth::rise(), true, sta_->cmdNetwork()); EXPECT_NE(from.transition(), nullptr); } -TEST_F(SdcInitTest, R6_ExceptionFromHasObjects) { +TEST_F(SdcInitTest, ExceptionFromHasObjects) { ExceptionFrom from(nullptr, nullptr, nullptr, RiseFallBoth::riseFall(), true, sta_->cmdNetwork()); @@ -5840,7 +5840,7 @@ TEST_F(SdcInitTest, R6_ExceptionFromHasObjects) { // R6 tests: Clock group operations //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_ClockGroupsPhysicallyExclusive) { +TEST_F(SdcInitTest, ClockGroupsPhysicallyExclusive) { FloatSeq *wave = new FloatSeq; wave->push_back(0.0); wave->push_back(5.0); @@ -5855,7 +5855,7 @@ TEST_F(SdcInitTest, R6_ClockGroupsPhysicallyExclusive) { sta_->removeClockGroupsPhysicallyExclusive("pe_grp"); } -TEST_F(SdcInitTest, R6_ClockGroupsAsynchronous) { +TEST_F(SdcInitTest, ClockGroupsAsynchronous) { FloatSeq *wave = new FloatSeq; wave->push_back(0.0); wave->push_back(5.0); @@ -5874,7 +5874,7 @@ TEST_F(SdcInitTest, R6_ClockGroupsAsynchronous) { // R6 tests: Sdc Latch borrow limits //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_SdcMinPulseWidth) { +TEST_F(SdcInitTest, SdcMinPulseWidth) { Sdc *sdc = sta_->sdc(); sdc->setMinPulseWidth(RiseFallBoth::riseFall(), 0.5); // Just exercise the code path - no assertion needed @@ -5885,7 +5885,7 @@ TEST_F(SdcInitTest, R6_SdcMinPulseWidth) { // R6 tests: Clock uncertainty with MinMax //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_ClockSetUncertaintyMinMax) { +TEST_F(SdcInitTest, ClockSetUncertaintyMinMax) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -5908,7 +5908,7 @@ TEST_F(SdcInitTest, R6_ClockSetUncertaintyMinMax) { // R6 tests: Additional ExceptionPath coverage //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_LoopPathClone) { +TEST_F(SdcInitTest, LoopPathClone) { LoopPath lp(nullptr, true); ExceptionPath *cloned = lp.clone(nullptr, nullptr, nullptr, true); EXPECT_NE(cloned, nullptr); @@ -5917,31 +5917,31 @@ TEST_F(SdcInitTest, R6_LoopPathClone) { delete cloned; } -TEST_F(SdcInitTest, R6_LoopPathOverrides) { +TEST_F(SdcInitTest, LoopPathOverrides) { LoopPath lp1(nullptr, true); LoopPath lp2(nullptr, true); EXPECT_TRUE(lp1.overrides(&lp2)); } -TEST_F(SdcInitTest, R6_LoopPathTighterThan) { +TEST_F(SdcInitTest, LoopPathTighterThan) { LoopPath lp1(nullptr, true); LoopPath lp2(nullptr, true); EXPECT_FALSE(lp1.tighterThan(&lp2)); } -TEST_F(SdcInitTest, R6_GroupPathAsString) { +TEST_F(SdcInitTest, GroupPathAsString) { GroupPath gp("grp", false, nullptr, nullptr, nullptr, true, nullptr); const char *str = gp.asString(sta_->cmdNetwork()); EXPECT_NE(str, nullptr); } -TEST_F(SdcInitTest, R6_FilterPathAsString) { +TEST_F(SdcInitTest, FilterPathAsString) { FilterPath flp(nullptr, nullptr, nullptr, true); const char *str = flp.asString(sta_->cmdNetwork()); EXPECT_NE(str, nullptr); } -TEST_F(SdcInitTest, R6_LoopPathAsString) { +TEST_F(SdcInitTest, LoopPathAsString) { LoopPath lp(nullptr, true); const char *str = lp.asString(sta_->cmdNetwork()); EXPECT_NE(str, nullptr); @@ -5951,7 +5951,7 @@ TEST_F(SdcInitTest, R6_LoopPathAsString) { // R6 tests: PatternMatch for clocks //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_FindClocksMatchingWildcard) { +TEST_F(SdcInitTest, FindClocksMatchingWildcard) { FloatSeq *wave1 = new FloatSeq; wave1->push_back(0.0); wave1->push_back(5.0); @@ -5981,7 +5981,7 @@ TEST_F(SdcInitTest, R6_FindClocksMatchingWildcard) { // R6 tests: Sdc pathDelaysWithoutTo after adding delay //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_SdcPathDelaysWithoutToAfterAdd) { +TEST_F(SdcInitTest, SdcPathDelaysWithoutToAfterAdd) { // Add a path delay without a "to" endpoint sta_->makePathDelay(nullptr, nullptr, nullptr, MinMax::max(), false, false, 5.0e-9, nullptr); @@ -5993,7 +5993,7 @@ TEST_F(SdcInitTest, R6_SdcPathDelaysWithoutToAfterAdd) { // R6 tests: Sdc multiple operations in sequence //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_SdcComplexSequence) { +TEST_F(SdcInitTest, SdcComplexSequence) { Sdc *sdc = sta_->sdc(); // Create clocks @@ -6035,7 +6035,7 @@ TEST_F(SdcInitTest, R6_SdcComplexSequence) { // R6 tests: Clock properties after propagation //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_ClockPropagateCycle) { +TEST_F(SdcInitTest, ClockPropagateCycle) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -6056,7 +6056,7 @@ TEST_F(SdcInitTest, R6_ClockPropagateCycle) { // R6 tests: InterClockUncertainty hash //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_InterClockUncertaintySetGet) { +TEST_F(SdcInitTest, InterClockUncertaintySetGet) { FloatSeq *w1 = new FloatSeq; w1->push_back(0.0); w1->push_back(5.0); @@ -6085,7 +6085,7 @@ TEST_F(SdcInitTest, R6_InterClockUncertaintySetGet) { // R6 tests: DeratingFactorsCell isOneValue edge cases //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_DeratingFactorsCellSetAndGet) { +TEST_F(SdcInitTest, DeratingFactorsCellSetAndGet) { DeratingFactorsCell dfc; dfc.setFactor(TimingDerateCellType::cell_delay, PathClkOrData::clk, @@ -6105,19 +6105,19 @@ TEST_F(SdcInitTest, R6_DeratingFactorsCellSetAndGet) { // R6 tests: RiseFallMinMax additional //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_RiseFallMinMaxEqual) { +TEST_F(SdcInitTest, RiseFallMinMaxEqual) { RiseFallMinMax rfmm1(5.0f); RiseFallMinMax rfmm2(5.0f); EXPECT_TRUE(rfmm1.equal(&rfmm2)); } -TEST_F(SdcInitTest, R6_RiseFallMinMaxNotEqual) { +TEST_F(SdcInitTest, RiseFallMinMaxNotEqual) { RiseFallMinMax rfmm1(5.0f); RiseFallMinMax rfmm2(3.0f); EXPECT_FALSE(rfmm1.equal(&rfmm2)); } -TEST_F(SdcInitTest, R6_RiseFallMinMaxIsOneValue) { +TEST_F(SdcInitTest, RiseFallMinMaxIsOneValue) { RiseFallMinMax rfmm(7.0f); float val; bool is_one = rfmm.isOneValue(val); @@ -6125,7 +6125,7 @@ TEST_F(SdcInitTest, R6_RiseFallMinMaxIsOneValue) { EXPECT_FLOAT_EQ(val, 7.0f); } -TEST_F(SdcInitTest, R6_RiseFallMinMaxIsOneValueFalse) { +TEST_F(SdcInitTest, RiseFallMinMaxIsOneValueFalse) { RiseFallMinMax rfmm; rfmm.setValue(RiseFall::rise(), MinMax::min(), 1.0f); rfmm.setValue(RiseFall::rise(), MinMax::max(), 2.0f); @@ -6140,7 +6140,7 @@ TEST_F(SdcInitTest, R6_RiseFallMinMaxIsOneValueFalse) { // R6 tests: Variables toggle all booleans back and forth //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_VariablesAllToggles) { +TEST_F(SdcInitTest, VariablesAllToggles) { Variables vars; vars.setCrprEnabled(false); EXPECT_FALSE(vars.crprEnabled()); @@ -6177,7 +6177,7 @@ TEST_F(SdcInitTest, R6_VariablesAllToggles) { // R6 tests: Additional Variables coverage //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_VariablesCrprMode) { +TEST_F(SdcInitTest, VariablesCrprMode) { Variables vars; vars.setCrprMode(CrprMode::same_pin); EXPECT_EQ(vars.crprMode(), CrprMode::same_pin); @@ -6185,7 +6185,7 @@ TEST_F(SdcInitTest, R6_VariablesCrprMode) { EXPECT_EQ(vars.crprMode(), CrprMode::same_transition); } -TEST_F(SdcInitTest, R6_VariablesPropagateGatedClockEnable) { +TEST_F(SdcInitTest, VariablesPropagateGatedClockEnable) { Variables vars; vars.setPropagateGatedClockEnable(true); EXPECT_TRUE(vars.propagateGatedClockEnable()); @@ -6193,7 +6193,7 @@ TEST_F(SdcInitTest, R6_VariablesPropagateGatedClockEnable) { EXPECT_FALSE(vars.propagateGatedClockEnable()); } -TEST_F(SdcInitTest, R6_VariablesPresetClrArcsEnabled) { +TEST_F(SdcInitTest, VariablesPresetClrArcsEnabled) { Variables vars; vars.setPresetClrArcsEnabled(true); EXPECT_TRUE(vars.presetClrArcsEnabled()); @@ -6201,7 +6201,7 @@ TEST_F(SdcInitTest, R6_VariablesPresetClrArcsEnabled) { EXPECT_FALSE(vars.presetClrArcsEnabled()); } -TEST_F(SdcInitTest, R6_VariablesCondDefaultArcsEnabled) { +TEST_F(SdcInitTest, VariablesCondDefaultArcsEnabled) { Variables vars; vars.setCondDefaultArcsEnabled(false); EXPECT_FALSE(vars.condDefaultArcsEnabled()); @@ -6209,7 +6209,7 @@ TEST_F(SdcInitTest, R6_VariablesCondDefaultArcsEnabled) { EXPECT_TRUE(vars.condDefaultArcsEnabled()); } -TEST_F(SdcInitTest, R6_VariablesBidirectInstPathsEnabled) { +TEST_F(SdcInitTest, VariablesBidirectInstPathsEnabled) { Variables vars; vars.setBidirectInstPathsEnabled(true); EXPECT_TRUE(vars.bidirectInstPathsEnabled()); @@ -6217,7 +6217,7 @@ TEST_F(SdcInitTest, R6_VariablesBidirectInstPathsEnabled) { EXPECT_FALSE(vars.bidirectInstPathsEnabled()); } -TEST_F(SdcInitTest, R6_VariablesBidirectNetPathsEnabled) { +TEST_F(SdcInitTest, VariablesBidirectNetPathsEnabled) { Variables vars; vars.setBidirectNetPathsEnabled(true); EXPECT_TRUE(vars.bidirectNetPathsEnabled()); @@ -6225,7 +6225,7 @@ TEST_F(SdcInitTest, R6_VariablesBidirectNetPathsEnabled) { EXPECT_FALSE(vars.bidirectNetPathsEnabled()); } -TEST_F(SdcInitTest, R6_VariablesRecoveryRemovalChecksEnabled) { +TEST_F(SdcInitTest, VariablesRecoveryRemovalChecksEnabled) { Variables vars; vars.setRecoveryRemovalChecksEnabled(false); EXPECT_FALSE(vars.recoveryRemovalChecksEnabled()); @@ -6233,7 +6233,7 @@ TEST_F(SdcInitTest, R6_VariablesRecoveryRemovalChecksEnabled) { EXPECT_TRUE(vars.recoveryRemovalChecksEnabled()); } -TEST_F(SdcInitTest, R6_VariablesGatedClkChecksEnabled) { +TEST_F(SdcInitTest, VariablesGatedClkChecksEnabled) { Variables vars; vars.setGatedClkChecksEnabled(false); EXPECT_FALSE(vars.gatedClkChecksEnabled()); @@ -6245,7 +6245,7 @@ TEST_F(SdcInitTest, R6_VariablesGatedClkChecksEnabled) { // R6 tests: ClockLatency //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_ClockLatencyConstruction) { +TEST_F(SdcInitTest, ClockLatencyConstruction) { FloatSeq *waveform = new FloatSeq; waveform->push_back(0.0); waveform->push_back(5.0); @@ -6267,7 +6267,7 @@ TEST_F(SdcInitTest, R6_ClockLatencyConstruction) { // R6 tests: InputDrive //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_InputDriveConstruction) { +TEST_F(SdcInitTest, InputDriveConstruction) { InputDrive drive; drive.setSlew(RiseFallBoth::riseFall(), MinMaxAll::all(), 0.1f); drive.setDriveResistance(RiseFallBoth::riseFall(), MinMaxAll::all(), 50.0f); @@ -6278,7 +6278,7 @@ TEST_F(SdcInitTest, R6_InputDriveConstruction) { EXPECT_FLOAT_EQ(res, 50.0f); } -TEST_F(SdcInitTest, R6_InputDriveResistanceMinMaxEqual) { +TEST_F(SdcInitTest, InputDriveResistanceMinMaxEqual2) { InputDrive drive; drive.setDriveResistance(RiseFallBoth::rise(), MinMaxAll::all(), 100.0f); EXPECT_TRUE(drive.driveResistanceMinMaxEqual(RiseFall::rise())); @@ -6288,7 +6288,7 @@ TEST_F(SdcInitTest, R6_InputDriveResistanceMinMaxEqual) { // R6 tests: RiseFallMinMax more coverage //////////////////////////////////////////////////////////////// -TEST_F(SdcInitTest, R6_RiseFallMinMaxHasValue) { +TEST_F(SdcInitTest, RiseFallMinMaxHasValue) { RiseFallMinMax rfmm; EXPECT_FALSE(rfmm.hasValue()); rfmm.setValue(RiseFall::rise(), MinMax::max(), 1.0f); @@ -6297,21 +6297,21 @@ TEST_F(SdcInitTest, R6_RiseFallMinMaxHasValue) { EXPECT_FALSE(rfmm.hasValue(RiseFall::fall(), MinMax::min())); } -TEST_F(SdcInitTest, R6_RiseFallMinMaxRemoveValue) { +TEST_F(SdcInitTest, RiseFallMinMaxRemoveValue) { RiseFallMinMax rfmm(5.0f); rfmm.removeValue(RiseFallBoth::rise(), MinMaxAll::max()); EXPECT_FALSE(rfmm.hasValue(RiseFall::rise(), MinMax::max())); EXPECT_TRUE(rfmm.hasValue(RiseFall::rise(), MinMax::min())); } -TEST_F(SdcInitTest, R6_RiseFallMinMaxMergeValue) { +TEST_F(SdcInitTest, RiseFallMinMaxMergeValue) { RiseFallMinMax rfmm; rfmm.setValue(RiseFall::rise(), MinMax::max(), 1.0f); rfmm.mergeValue(RiseFall::rise(), MinMax::max(), 2.0f); EXPECT_FLOAT_EQ(rfmm.value(RiseFall::rise(), MinMax::max()), 2.0f); } -TEST_F(SdcInitTest, R6_RiseFallMinMaxMaxValue) { +TEST_F(SdcInitTest, RiseFallMinMaxMaxValue) { RiseFallMinMax rfmm; rfmm.setValue(RiseFall::rise(), MinMax::max(), 3.0f); rfmm.setValue(RiseFall::fall(), MinMax::max(), 7.0f); @@ -6327,13 +6327,13 @@ TEST_F(SdcInitTest, R6_RiseFallMinMaxMaxValue) { //////////////////////////////////////////////////////////////// // DeratingFactors default construction -TEST_F(SdcInitTest, R8_DeratingFactorsDefault) { +TEST_F(SdcInitTest, DeratingFactorsDefault) { DeratingFactors df; EXPECT_FALSE(df.hasValue()); } // DeratingFactors set and get -TEST_F(SdcInitTest, R8_DeratingFactorsSetGet) { +TEST_F(SdcInitTest, DeratingFactorsSetGet2) { DeratingFactors df; df.setFactor(PathClkOrData::clk, RiseFallBoth::rise(), EarlyLate::early(), 0.95f); @@ -6346,7 +6346,7 @@ TEST_F(SdcInitTest, R8_DeratingFactorsSetGet) { } // DeratingFactors::clear -TEST_F(SdcInitTest, R8_DeratingFactorsClear) { +TEST_F(SdcInitTest, DeratingFactorsClear2) { DeratingFactors df; df.setFactor(PathClkOrData::data, RiseFallBoth::riseFall(), EarlyLate::late(), 1.05f); @@ -6356,7 +6356,7 @@ TEST_F(SdcInitTest, R8_DeratingFactorsClear) { } // DeratingFactors::isOneValue -TEST_F(SdcInitTest, R8_DeratingFactorsIsOneValue) { +TEST_F(SdcInitTest, DeratingFactorsIsOneValue2) { DeratingFactors df; df.setFactor(PathClkOrData::clk, RiseFallBoth::riseFall(), EarlyLate::early(), 0.9f); @@ -6370,7 +6370,7 @@ TEST_F(SdcInitTest, R8_DeratingFactorsIsOneValue) { } // DeratingFactors isOneValue per clk_data -TEST_F(SdcInitTest, R8_DeratingFactorsIsOneValueClkData) { +TEST_F(SdcInitTest, DeratingFactorsIsOneValueClkData2) { DeratingFactors df; df.setFactor(PathClkOrData::clk, RiseFallBoth::riseFall(), EarlyLate::early(), 0.95f); @@ -6383,7 +6383,7 @@ TEST_F(SdcInitTest, R8_DeratingFactorsIsOneValueClkData) { } // DeratingFactorsGlobal -TEST_F(SdcInitTest, R8_DeratingFactorsGlobalDefault) { +TEST_F(SdcInitTest, DeratingFactorsGlobalDefault) { DeratingFactorsGlobal dfg; float factor; bool exists; @@ -6393,7 +6393,7 @@ TEST_F(SdcInitTest, R8_DeratingFactorsGlobalDefault) { } // DeratingFactorsGlobal set and get -TEST_F(SdcInitTest, R8_DeratingFactorsGlobalSetGet) { +TEST_F(SdcInitTest, DeratingFactorsGlobalSetGet) { DeratingFactorsGlobal dfg; dfg.setFactor(TimingDerateType::cell_delay, PathClkOrData::clk, RiseFallBoth::rise(), EarlyLate::early(), 0.98f); @@ -6406,7 +6406,7 @@ TEST_F(SdcInitTest, R8_DeratingFactorsGlobalSetGet) { } // DeratingFactorsGlobal clear -TEST_F(SdcInitTest, R8_DeratingFactorsGlobalClear) { +TEST_F(SdcInitTest, DeratingFactorsGlobalClear2) { DeratingFactorsGlobal dfg; dfg.setFactor(TimingDerateType::net_delay, PathClkOrData::data, RiseFallBoth::riseFall(), EarlyLate::late(), 1.05f); @@ -6419,14 +6419,14 @@ TEST_F(SdcInitTest, R8_DeratingFactorsGlobalClear) { } // DeratingFactorsGlobal factors accessor -TEST_F(SdcInitTest, R8_DeratingFactorsGlobalFactorsAccessor) { +TEST_F(SdcInitTest, DeratingFactorsGlobalFactorsAccessor) { DeratingFactorsGlobal dfg; DeratingFactors *df = dfg.factors(TimingDerateType::cell_check); EXPECT_NE(df, nullptr); } // DeratingFactorsGlobal with TimingDerateCellType -TEST_F(SdcInitTest, R8_DeratingFactorsGlobalCellType) { +TEST_F(SdcInitTest, DeratingFactorsGlobalCellType) { DeratingFactorsGlobal dfg; dfg.setFactor(TimingDerateType::cell_check, PathClkOrData::data, RiseFallBoth::fall(), EarlyLate::late(), 1.02f); @@ -6439,7 +6439,7 @@ TEST_F(SdcInitTest, R8_DeratingFactorsGlobalCellType) { } // DeratingFactorsCell -TEST_F(SdcInitTest, R8_DeratingFactorsCellDefault) { +TEST_F(SdcInitTest, DeratingFactorsCellDefault) { DeratingFactorsCell dfc; float factor; bool exists; @@ -6449,7 +6449,7 @@ TEST_F(SdcInitTest, R8_DeratingFactorsCellDefault) { } // DeratingFactorsCell set and get -TEST_F(SdcInitTest, R8_DeratingFactorsCellSetGet) { +TEST_F(SdcInitTest, DeratingFactorsCellSetGet) { DeratingFactorsCell dfc; dfc.setFactor(TimingDerateCellType::cell_delay, PathClkOrData::data, RiseFallBoth::riseFall(), EarlyLate::early(), 0.97f); @@ -6462,7 +6462,7 @@ TEST_F(SdcInitTest, R8_DeratingFactorsCellSetGet) { } // DeratingFactorsCell clear -TEST_F(SdcInitTest, R8_DeratingFactorsCellClear) { +TEST_F(SdcInitTest, DeratingFactorsCellClear2) { DeratingFactorsCell dfc; dfc.setFactor(TimingDerateCellType::cell_check, PathClkOrData::clk, RiseFallBoth::rise(), EarlyLate::late(), 1.1f); @@ -6475,14 +6475,14 @@ TEST_F(SdcInitTest, R8_DeratingFactorsCellClear) { } // DeratingFactorsCell factors accessor -TEST_F(SdcInitTest, R8_DeratingFactorsCellFactorsAccessor) { +TEST_F(SdcInitTest, DeratingFactorsCellFactorsAccessor) { DeratingFactorsCell dfc; DeratingFactors *df = dfc.factors(TimingDerateCellType::cell_delay); EXPECT_NE(df, nullptr); } // DeratingFactorsCell isOneValue -TEST_F(SdcInitTest, R8_DeratingFactorsCellIsOneValue) { +TEST_F(SdcInitTest, DeratingFactorsCellIsOneValue2) { DeratingFactorsCell dfc; dfc.setFactor(TimingDerateCellType::cell_delay, PathClkOrData::clk, RiseFallBoth::riseFall(), EarlyLate::early(), 0.95f); @@ -6500,13 +6500,13 @@ TEST_F(SdcInitTest, R8_DeratingFactorsCellIsOneValue) { } // DeratingFactorsNet -TEST_F(SdcInitTest, R8_DeratingFactorsNetDefault) { +TEST_F(SdcInitTest, DeratingFactorsNetDefault) { DeratingFactorsNet dfn; EXPECT_FALSE(dfn.hasValue()); } // DeratingFactorsNet set and get -TEST_F(SdcInitTest, R8_DeratingFactorsNetSetGet) { +TEST_F(SdcInitTest, DeratingFactorsNetSetGet) { DeratingFactorsNet dfn; dfn.setFactor(PathClkOrData::data, RiseFallBoth::riseFall(), EarlyLate::late(), 1.03f); @@ -6519,14 +6519,14 @@ TEST_F(SdcInitTest, R8_DeratingFactorsNetSetGet) { } // ClockLatency construction -TEST_F(SdcInitTest, R8_ClockLatencyConstruct) { +TEST_F(SdcInitTest, ClockLatencyConstruct2) { ClockLatency lat(nullptr, nullptr); EXPECT_EQ(lat.clock(), nullptr); EXPECT_EQ(lat.pin(), nullptr); } // ClockLatency set and get -TEST_F(SdcInitTest, R8_ClockLatencySetGet) { +TEST_F(SdcInitTest, ClockLatencySetGet) { ClockLatency lat(nullptr, nullptr); lat.setDelay(RiseFallBoth::riseFall(), MinMaxAll::all(), 1.5f); float delay; @@ -6537,7 +6537,7 @@ TEST_F(SdcInitTest, R8_ClockLatencySetGet) { } // ClockLatency delays accessor -TEST_F(SdcInitTest, R8_ClockLatencyDelaysAccessor) { +TEST_F(SdcInitTest, ClockLatencyDelaysAccessor) { ClockLatency lat(nullptr, nullptr); lat.setDelay(RiseFallBoth::rise(), MinMaxAll::min(), 0.5f); RiseFallMinMax *delays = lat.delays(); @@ -6546,14 +6546,14 @@ TEST_F(SdcInitTest, R8_ClockLatencyDelaysAccessor) { } // ClockInsertion construction -TEST_F(SdcInitTest, R8_ClockInsertionConstruct) { +TEST_F(SdcInitTest, ClockInsertionConstruct2) { ClockInsertion ins(nullptr, nullptr); EXPECT_EQ(ins.clock(), nullptr); EXPECT_EQ(ins.pin(), nullptr); } // ClockInsertion set and get -TEST_F(SdcInitTest, R8_ClockInsertionSetGet) { +TEST_F(SdcInitTest, ClockInsertionSetGet) { ClockInsertion ins(nullptr, nullptr); ins.setDelay(RiseFallBoth::riseFall(), MinMaxAll::all(), EarlyLateAll::all(), 2.0f); @@ -6566,7 +6566,7 @@ TEST_F(SdcInitTest, R8_ClockInsertionSetGet) { } // ClockInsertion delays accessor -TEST_F(SdcInitTest, R8_ClockInsertionDelaysAccessor) { +TEST_F(SdcInitTest, ClockInsertionDelaysAccessor) { ClockInsertion ins(nullptr, nullptr); ins.setDelay(RiseFallBoth::rise(), MinMaxAll::min(), EarlyLateAll::early(), 0.3f); @@ -6575,14 +6575,14 @@ TEST_F(SdcInitTest, R8_ClockInsertionDelaysAccessor) { } // ClockGatingCheck -TEST_F(SdcInitTest, R8_ClockGatingCheckConstruct) { +TEST_F(SdcInitTest, ClockGatingCheckConstruct) { ClockGatingCheck cgc; RiseFallMinMax *margins = cgc.margins(); EXPECT_NE(margins, nullptr); } // ClockGatingCheck active value -TEST_F(SdcInitTest, R8_ClockGatingCheckActiveValue) { +TEST_F(SdcInitTest, ClockGatingCheckActiveValue) { ClockGatingCheck cgc; cgc.setActiveValue(LogicValue::one); EXPECT_EQ(cgc.activeValue(), LogicValue::one); @@ -6591,7 +6591,7 @@ TEST_F(SdcInitTest, R8_ClockGatingCheckActiveValue) { } // InputDrive construction -TEST_F(SdcInitTest, R8_InputDriveConstruct) { +TEST_F(SdcInitTest, InputDriveConstruct) { InputDrive drive; float res; bool exists; @@ -6600,7 +6600,7 @@ TEST_F(SdcInitTest, R8_InputDriveConstruct) { } // InputDrive set slew -TEST_F(SdcInitTest, R8_InputDriveSetSlew) { +TEST_F(SdcInitTest, InputDriveSetSlew2) { InputDrive drive; drive.setSlew(RiseFallBoth::riseFall(), MinMaxAll::all(), 0.1f); float slew; @@ -6611,7 +6611,7 @@ TEST_F(SdcInitTest, R8_InputDriveSetSlew) { } // InputDrive set resistance -TEST_F(SdcInitTest, R8_InputDriveSetResistance) { +TEST_F(SdcInitTest, InputDriveSetResistance2) { InputDrive drive; drive.setDriveResistance(RiseFallBoth::riseFall(), MinMaxAll::all(), 50.0f); float res; @@ -6623,14 +6623,14 @@ TEST_F(SdcInitTest, R8_InputDriveSetResistance) { } // InputDrive drive resistance min/max equal -TEST_F(SdcInitTest, R8_InputDriveResistanceEqual) { +TEST_F(SdcInitTest, InputDriveResistanceEqual) { InputDrive drive; drive.setDriveResistance(RiseFallBoth::riseFall(), MinMaxAll::all(), 100.0f); EXPECT_TRUE(drive.driveResistanceMinMaxEqual(RiseFall::rise())); } // InputDrive drive resistance min/max not equal -TEST_F(SdcInitTest, R8_InputDriveResistanceNotEqual) { +TEST_F(SdcInitTest, InputDriveResistanceNotEqual) { InputDrive drive; drive.setDriveResistance(RiseFallBoth::rise(), MinMaxAll::min(), 50.0f); drive.setDriveResistance(RiseFallBoth::rise(), MinMaxAll::max(), 100.0f); @@ -6638,13 +6638,13 @@ TEST_F(SdcInitTest, R8_InputDriveResistanceNotEqual) { } // InputDrive no drive cell -TEST_F(SdcInitTest, R8_InputDriveNoDriveCell) { +TEST_F(SdcInitTest, InputDriveNoDriveCell) { InputDrive drive; EXPECT_FALSE(drive.hasDriveCell(RiseFall::rise(), MinMax::max())); } // InputDrive slews accessor -TEST_F(SdcInitTest, R8_InputDriveSlewsAccessor) { +TEST_F(SdcInitTest, InputDriveSlewsAccessor) { InputDrive drive; drive.setSlew(RiseFallBoth::rise(), MinMaxAll::max(), 0.2f); const RiseFallMinMax *slews = drive.slews(); @@ -6653,7 +6653,7 @@ TEST_F(SdcInitTest, R8_InputDriveSlewsAccessor) { } // ExceptionPath priorities -TEST_F(SdcInitTest, R8_ExceptionPathPriorities) { +TEST_F(SdcInitTest, ExceptionPathPriorities) { EXPECT_EQ(ExceptionPath::falsePathPriority(), 4000); EXPECT_EQ(ExceptionPath::pathDelayPriority(), 3000); EXPECT_EQ(ExceptionPath::multiCyclePathPriority(), 2000); @@ -6662,7 +6662,7 @@ TEST_F(SdcInitTest, R8_ExceptionPathPriorities) { } // FalsePath creation and type -TEST_F(SdcInitTest, R8_FalsePathType) { +TEST_F(SdcInitTest, FalsePathType) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); EXPECT_TRUE(fp.isFalse()); EXPECT_FALSE(fp.isLoop()); @@ -6674,13 +6674,13 @@ TEST_F(SdcInitTest, R8_FalsePathType) { } // FalsePath priority -TEST_F(SdcInitTest, R8_FalsePathPriority) { +TEST_F(SdcInitTest, FalsePathPriority) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); EXPECT_EQ(fp.typePriority(), ExceptionPath::falsePathPriority()); } // PathDelay creation and type -TEST_F(SdcInitTest, R8_PathDelayType) { +TEST_F(SdcInitTest, PathDelayType) { PathDelay pd(nullptr, nullptr, nullptr, MinMax::max(), false, false, 5.0f, false, nullptr); EXPECT_TRUE(pd.isPathDelay()); @@ -6690,7 +6690,7 @@ TEST_F(SdcInitTest, R8_PathDelayType) { } // PathDelay ignoreClkLatency -TEST_F(SdcInitTest, R8_PathDelayIgnoreClkLatency) { +TEST_F(SdcInitTest, PathDelayIgnoreClkLatency) { PathDelay pd1(nullptr, nullptr, nullptr, MinMax::max(), true, false, 3.0f, false, nullptr); EXPECT_TRUE(pd1.ignoreClkLatency()); @@ -6700,14 +6700,14 @@ TEST_F(SdcInitTest, R8_PathDelayIgnoreClkLatency) { } // PathDelay breakPath -TEST_F(SdcInitTest, R8_PathDelayBreakPath) { +TEST_F(SdcInitTest, PathDelayBreakPath) { PathDelay pd(nullptr, nullptr, nullptr, MinMax::max(), false, true, 3.0f, false, nullptr); EXPECT_TRUE(pd.breakPath()); } // PathDelay tighterThan -TEST_F(SdcInitTest, R8_PathDelayTighterThanMin) { +TEST_F(SdcInitTest, PathDelayTighterThanMin) { PathDelay pd1(nullptr, nullptr, nullptr, MinMax::min(), false, false, 3.0f, false, nullptr); PathDelay pd2(nullptr, nullptr, nullptr, MinMax::min(), @@ -6717,7 +6717,7 @@ TEST_F(SdcInitTest, R8_PathDelayTighterThanMin) { } // PathDelay tighterThan max -TEST_F(SdcInitTest, R8_PathDelayTighterThanMax) { +TEST_F(SdcInitTest, PathDelayTighterThanMax) { PathDelay pd1(nullptr, nullptr, nullptr, MinMax::max(), false, false, 3.0f, false, nullptr); PathDelay pd2(nullptr, nullptr, nullptr, MinMax::max(), @@ -6727,7 +6727,7 @@ TEST_F(SdcInitTest, R8_PathDelayTighterThanMax) { } // MultiCyclePath creation and type -TEST_F(SdcInitTest, R8_MultiCyclePathType) { +TEST_F(SdcInitTest, MultiCyclePathType) { MultiCyclePath mcp(nullptr, nullptr, nullptr, MinMaxAll::all(), true, 3, false, nullptr); EXPECT_TRUE(mcp.isMultiCycle()); @@ -6737,7 +6737,7 @@ TEST_F(SdcInitTest, R8_MultiCyclePathType) { } // MultiCyclePath with start clk -TEST_F(SdcInitTest, R8_MultiCyclePathStartClk) { +TEST_F(SdcInitTest, MultiCyclePathStartClk) { MultiCyclePath mcp(nullptr, nullptr, nullptr, MinMaxAll::all(), false, 2, false, nullptr); EXPECT_FALSE(mcp.useEndClk()); @@ -6745,7 +6745,7 @@ TEST_F(SdcInitTest, R8_MultiCyclePathStartClk) { } // MultiCyclePath tighterThan -TEST_F(SdcInitTest, R8_MultiCyclePathTighterThan) { +TEST_F(SdcInitTest, MultiCyclePathTighterThan2) { MultiCyclePath mcp1(nullptr, nullptr, nullptr, MinMaxAll::all(), true, 2, false, nullptr); MultiCyclePath mcp2(nullptr, nullptr, nullptr, MinMaxAll::all(), @@ -6758,14 +6758,14 @@ TEST_F(SdcInitTest, R8_MultiCyclePathTighterThan) { } // FilterPath creation and type -TEST_F(SdcInitTest, R8_FilterPathType) { +TEST_F(SdcInitTest, FilterPathType) { FilterPath fp(nullptr, nullptr, nullptr, false); EXPECT_TRUE(fp.isFilter()); EXPECT_EQ(fp.type(), ExceptionPathType::filter); } // GroupPath creation and type -TEST_F(SdcInitTest, R8_GroupPathType) { +TEST_F(SdcInitTest, GroupPathType) { GroupPath gp("test_group", false, nullptr, nullptr, nullptr, false, nullptr); EXPECT_TRUE(gp.isGroupPath()); EXPECT_EQ(gp.type(), ExceptionPathType::group_path); @@ -6774,13 +6774,13 @@ TEST_F(SdcInitTest, R8_GroupPathType) { } // GroupPath default -TEST_F(SdcInitTest, R8_GroupPathDefault) { +TEST_F(SdcInitTest, GroupPathDefault) { GroupPath gp("default_group", true, nullptr, nullptr, nullptr, false, nullptr); EXPECT_TRUE(gp.isDefault()); } // LoopPath creation -TEST_F(SdcInitTest, R8_LoopPathType) { +TEST_F(SdcInitTest, LoopPathType) { LoopPath lp(nullptr, false); EXPECT_TRUE(lp.isFalse()); EXPECT_TRUE(lp.isLoop()); @@ -6788,7 +6788,7 @@ TEST_F(SdcInitTest, R8_LoopPathType) { } // ExceptionPath minMax -TEST_F(SdcInitTest, R8_ExceptionPathMinMax) { +TEST_F(SdcInitTest, ExceptionPathMinMax) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::min(), false, nullptr); EXPECT_EQ(fp.minMax(), MinMaxAll::min()); EXPECT_TRUE(fp.matches(MinMax::min(), true)); @@ -6796,14 +6796,14 @@ TEST_F(SdcInitTest, R8_ExceptionPathMinMax) { } // ExceptionPath matches min/max all -TEST_F(SdcInitTest, R8_ExceptionPathMatchesAll) { +TEST_F(SdcInitTest, ExceptionPathMatchesAll) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); EXPECT_TRUE(fp.matches(MinMax::min(), true)); EXPECT_TRUE(fp.matches(MinMax::max(), true)); } // FalsePath hash -TEST_F(SdcInitTest, R8_FalsePathHash) { +TEST_F(SdcInitTest, FalsePathHash) { FalsePath fp1(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); FalsePath fp2(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); // Same structure should have same hash @@ -6811,14 +6811,14 @@ TEST_F(SdcInitTest, R8_FalsePathHash) { } // FalsePath overrides -TEST_F(SdcInitTest, R8_FalsePathOverrides) { +TEST_F(SdcInitTest, FalsePathOverrides2) { FalsePath fp1(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); FalsePath fp2(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); EXPECT_TRUE(fp1.overrides(&fp2)); } // PathDelay hash -TEST_F(SdcInitTest, R8_PathDelayHashR8) { +TEST_F(SdcInitTest, PathDelayHashR8) { PathDelay pd(nullptr, nullptr, nullptr, MinMax::max(), false, false, 5.0f, false, nullptr); size_t h = pd.hash(); @@ -6826,7 +6826,7 @@ TEST_F(SdcInitTest, R8_PathDelayHashR8) { } // FalsePath not mergeable with PathDelay -TEST_F(SdcInitTest, R8_FalsePathNotMergeablePathDelay) { +TEST_F(SdcInitTest, FalsePathNotMergeablePathDelay) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); PathDelay pd(nullptr, nullptr, nullptr, MinMax::max(), false, false, 5.0f, false, nullptr); @@ -6834,7 +6834,7 @@ TEST_F(SdcInitTest, R8_FalsePathNotMergeablePathDelay) { } // GroupPath tighterThan -TEST_F(SdcInitTest, R8_GroupPathTighterThan) { +TEST_F(SdcInitTest, GroupPathTighterThan2) { GroupPath gp1("g1", false, nullptr, nullptr, nullptr, false, nullptr); GroupPath gp2("g2", false, nullptr, nullptr, nullptr, false, nullptr); // Group paths have no value to compare @@ -6843,7 +6843,7 @@ TEST_F(SdcInitTest, R8_GroupPathTighterThan) { } // FilterPath tighterThan -TEST_F(SdcInitTest, R8_FilterPathTighterThan) { +TEST_F(SdcInitTest, FilterPathTighterThan2) { FilterPath fp1(nullptr, nullptr, nullptr, false); FilterPath fp2(nullptr, nullptr, nullptr, false); bool t = fp1.tighterThan(&fp2); @@ -6851,63 +6851,63 @@ TEST_F(SdcInitTest, R8_FilterPathTighterThan) { } // ExceptionPath id -TEST_F(SdcInitTest, R8_ExceptionPathId) { +TEST_F(SdcInitTest, ExceptionPathId) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); fp.setId(42); EXPECT_EQ(fp.id(), 42u); } // ExceptionPath setPriority -TEST_F(SdcInitTest, R8_ExceptionPathSetPriority) { +TEST_F(SdcInitTest, ExceptionPathSetPriority) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); fp.setPriority(999); EXPECT_EQ(fp.priority(), 999); } // ExceptionPath useEndClk default -TEST_F(SdcInitTest, R8_ExceptionPathUseEndClkDefault) { +TEST_F(SdcInitTest, ExceptionPathUseEndClkDefault) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); EXPECT_FALSE(fp.useEndClk()); } // ExceptionPath pathMultiplier default -TEST_F(SdcInitTest, R8_ExceptionPathPathMultiplierDefault) { +TEST_F(SdcInitTest, ExceptionPathPathMultiplierDefault) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); EXPECT_EQ(fp.pathMultiplier(), 0); } // ExceptionPath delay default -TEST_F(SdcInitTest, R8_ExceptionPathDelayDefault) { +TEST_F(SdcInitTest, ExceptionPathDelayDefault) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); EXPECT_FLOAT_EQ(fp.delay(), 0.0f); } // ExceptionPath name default -TEST_F(SdcInitTest, R8_ExceptionPathNameDefault) { +TEST_F(SdcInitTest, ExceptionPathNameDefault) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); EXPECT_EQ(fp.name(), nullptr); } // ExceptionPath isDefault -TEST_F(SdcInitTest, R8_ExceptionPathIsDefault) { +TEST_F(SdcInitTest, ExceptionPathIsDefault) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); EXPECT_FALSE(fp.isDefault()); } // ExceptionPath ignoreClkLatency default -TEST_F(SdcInitTest, R8_ExceptionPathIgnoreClkLatencyDefault) { +TEST_F(SdcInitTest, ExceptionPathIgnoreClkLatencyDefault) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); EXPECT_FALSE(fp.ignoreClkLatency()); } // ExceptionPath breakPath default -TEST_F(SdcInitTest, R8_ExceptionPathBreakPathDefault) { +TEST_F(SdcInitTest, ExceptionPathBreakPathDefault) { FalsePath fp(nullptr, nullptr, nullptr, MinMaxAll::all(), false, nullptr); EXPECT_FALSE(fp.breakPath()); } // Clock slew set and get -TEST_F(SdcInitTest, R8_ClockSlewSetGet) { +TEST_F(SdcInitTest, ClockSlewSetGet2) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -6924,7 +6924,7 @@ TEST_F(SdcInitTest, R8_ClockSlewSetGet) { } // Clock removeSlew -TEST_F(SdcInitTest, R8_ClockRemoveSlew) { +TEST_F(SdcInitTest, ClockRemoveSlew2) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -6941,7 +6941,7 @@ TEST_F(SdcInitTest, R8_ClockRemoveSlew) { } // Clock slews accessor -TEST_F(SdcInitTest, R8_ClockSlewsAccessor) { +TEST_F(SdcInitTest, ClockSlewsAccessor2) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -6955,7 +6955,7 @@ TEST_F(SdcInitTest, R8_ClockSlewsAccessor) { } // Clock period -TEST_F(SdcInitTest, R8_ClockPeriod) { +TEST_F(SdcInitTest, ClockPeriod) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(10.0); @@ -6967,7 +6967,7 @@ TEST_F(SdcInitTest, R8_ClockPeriod) { } // Clock period access via makeClock -TEST_F(SdcInitTest, R8_ClockPeriodAccess) { +TEST_F(SdcInitTest, ClockPeriodAccess) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(12.5); @@ -6979,7 +6979,7 @@ TEST_F(SdcInitTest, R8_ClockPeriodAccess) { } // Clock isVirtual -TEST_F(SdcInitTest, R8_ClockIsVirtual) { +TEST_F(SdcInitTest, ClockIsVirtual2) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -6992,7 +6992,7 @@ TEST_F(SdcInitTest, R8_ClockIsVirtual) { } // Clock isPropagated -TEST_F(SdcInitTest, R8_ClockIsPropagated) { +TEST_F(SdcInitTest, ClockIsPropagated) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7007,7 +7007,7 @@ TEST_F(SdcInitTest, R8_ClockIsPropagated) { } // Clock isIdeal -TEST_F(SdcInitTest, R8_ClockIsIdeal) { +TEST_F(SdcInitTest, ClockIsIdeal) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7019,7 +7019,7 @@ TEST_F(SdcInitTest, R8_ClockIsIdeal) { } // Clock edge -TEST_F(SdcInitTest, R8_ClockEdge) { +TEST_F(SdcInitTest, ClockEdge) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7035,7 +7035,7 @@ TEST_F(SdcInitTest, R8_ClockEdge) { } // ClockEdge properties -TEST_F(SdcInitTest, R8_ClockEdgeProperties) { +TEST_F(SdcInitTest, ClockEdgeProperties2) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7051,7 +7051,7 @@ TEST_F(SdcInitTest, R8_ClockEdgeProperties) { } // ClockEdge opposite -TEST_F(SdcInitTest, R8_ClockEdgeOpposite) { +TEST_F(SdcInitTest, ClockEdgeOpposite2) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7066,7 +7066,7 @@ TEST_F(SdcInitTest, R8_ClockEdgeOpposite) { } // ClockEdge pulseWidth -TEST_F(SdcInitTest, R8_ClockEdgePulseWidth) { +TEST_F(SdcInitTest, ClockEdgePulseWidth2) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7080,7 +7080,7 @@ TEST_F(SdcInitTest, R8_ClockEdgePulseWidth) { } // ClockEdge index -TEST_F(SdcInitTest, R8_ClockEdgeIndex) { +TEST_F(SdcInitTest, ClockEdgeIndex) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7094,7 +7094,7 @@ TEST_F(SdcInitTest, R8_ClockEdgeIndex) { } // Clock uncertainty -TEST_F(SdcInitTest, R8_ClockUncertainty) { +TEST_F(SdcInitTest, ClockUncertainty2) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7111,7 +7111,7 @@ TEST_F(SdcInitTest, R8_ClockUncertainty) { } // Clock removeUncertainty -TEST_F(SdcInitTest, R8_ClockRemoveUncertainty) { +TEST_F(SdcInitTest, ClockRemoveUncertainty) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7128,7 +7128,7 @@ TEST_F(SdcInitTest, R8_ClockRemoveUncertainty) { } // Clock isGenerated -TEST_F(SdcInitTest, R8_ClockIsGenerated) { +TEST_F(SdcInitTest, ClockIsGenerated) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7140,7 +7140,7 @@ TEST_F(SdcInitTest, R8_ClockIsGenerated) { } // Clock addToPins -TEST_F(SdcInitTest, R8_ClockAddToPins) { +TEST_F(SdcInitTest, ClockAddToPins) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7155,7 +7155,7 @@ TEST_F(SdcInitTest, R8_ClockAddToPins) { } // Clock waveform -TEST_F(SdcInitTest, R8_ClockWaveform) { +TEST_F(SdcInitTest, ClockWaveform) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7169,7 +7169,7 @@ TEST_F(SdcInitTest, R8_ClockWaveform) { } // Clock index -TEST_F(SdcInitTest, R8_ClockIndex) { +TEST_F(SdcInitTest, ClockIndex2) { FloatSeq *wf1 = new FloatSeq; wf1->push_back(0.0); wf1->push_back(5.0); @@ -7187,7 +7187,7 @@ TEST_F(SdcInitTest, R8_ClockIndex) { } // Clock combinational -TEST_F(SdcInitTest, R8_ClockCombinational) { +TEST_F(SdcInitTest, ClockCombinational) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7200,7 +7200,7 @@ TEST_F(SdcInitTest, R8_ClockCombinational) { } // InterClockUncertainty -TEST_F(SdcInitTest, R8_InterClockUncertaintyConstruct) { +TEST_F(SdcInitTest, InterClockUncertaintyConstruct) { FloatSeq *wf1 = new FloatSeq; wf1->push_back(0.0); wf1->push_back(5.0); @@ -7219,7 +7219,7 @@ TEST_F(SdcInitTest, R8_InterClockUncertaintyConstruct) { } // InterClockUncertainty set and get -TEST_F(SdcInitTest, R8_InterClockUncertaintySetGet) { +TEST_F(SdcInitTest, InterClockUncertaintySetGet2) { FloatSeq *wf1 = new FloatSeq; wf1->push_back(0.0); wf1->push_back(5.0); @@ -7244,7 +7244,7 @@ TEST_F(SdcInitTest, R8_InterClockUncertaintySetGet) { } // InterClockUncertainty removeUncertainty -TEST_F(SdcInitTest, R8_InterClockUncertaintyRemove) { +TEST_F(SdcInitTest, InterClockUncertaintyRemove2) { FloatSeq *wf1 = new FloatSeq; wf1->push_back(0.0); wf1->push_back(5.0); @@ -7265,7 +7265,7 @@ TEST_F(SdcInitTest, R8_InterClockUncertaintyRemove) { } // InterClockUncertainty uncertainties accessor -TEST_F(SdcInitTest, R8_InterClockUncertaintyAccessor) { +TEST_F(SdcInitTest, InterClockUncertaintyAccessor) { FloatSeq *wf1 = new FloatSeq; wf1->push_back(0.0); wf1->push_back(5.0); @@ -7285,7 +7285,7 @@ TEST_F(SdcInitTest, R8_InterClockUncertaintyAccessor) { } // Sdc::setTimingDerate global -TEST_F(SdcInitTest, R8_SdcSetTimingDerateGlobal) { +TEST_F(SdcInitTest, SdcSetTimingDerateGlobal2) { Sdc *sdc = sta_->sdc(); sdc->setTimingDerate(TimingDerateType::cell_delay, PathClkOrData::clk, @@ -7296,14 +7296,14 @@ TEST_F(SdcInitTest, R8_SdcSetTimingDerateGlobal) { } // Sdc::setMaxArea and maxArea -TEST_F(SdcInitTest, R8_SdcSetMaxAreaR8) { +TEST_F(SdcInitTest, SdcSetMaxAreaR8) { Sdc *sdc = sta_->sdc(); sdc->setMaxArea(500.0f); EXPECT_FLOAT_EQ(sdc->maxArea(), 500.0f); } // Sdc::setAnalysisType -TEST_F(SdcInitTest, R8_SdcSetAnalysisTypeR8) { +TEST_F(SdcInitTest, SdcSetAnalysisTypeR8) { Sdc *sdc = sta_->sdc(); sdc->setAnalysisType(AnalysisType::bc_wc); EXPECT_EQ(sdc->analysisType(), AnalysisType::bc_wc); @@ -7314,7 +7314,7 @@ TEST_F(SdcInitTest, R8_SdcSetAnalysisTypeR8) { } // Sdc::setWireloadMode -TEST_F(SdcInitTest, R8_SdcSetWireloadModeR8) { +TEST_F(SdcInitTest, SdcSetWireloadModeR8) { Sdc *sdc = sta_->sdc(); sdc->setWireloadMode(WireloadMode::enclosed); // Just verify no crash @@ -7323,7 +7323,7 @@ TEST_F(SdcInitTest, R8_SdcSetWireloadModeR8) { } // Sdc::setPropagatedClock / removePropagatedClock -TEST_F(SdcInitTest, R8_SdcPropagatedClock) { +TEST_F(SdcInitTest, SdcPropagatedClock) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7338,7 +7338,7 @@ TEST_F(SdcInitTest, R8_SdcPropagatedClock) { } // Sdc::setClockSlew -TEST_F(SdcInitTest, R8_SdcSetClockSlew) { +TEST_F(SdcInitTest, SdcSetClockSlew2) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7353,7 +7353,7 @@ TEST_F(SdcInitTest, R8_SdcSetClockSlew) { } // Sdc::removeClockSlew -TEST_F(SdcInitTest, R8_SdcRemoveClockSlew) { +TEST_F(SdcInitTest, SdcRemoveClockSlew) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7369,7 +7369,7 @@ TEST_F(SdcInitTest, R8_SdcRemoveClockSlew) { } // Sdc::setClockLatency -TEST_F(SdcInitTest, R8_SdcSetClockLatency) { +TEST_F(SdcInitTest, SdcSetClockLatency2) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7388,7 +7388,7 @@ TEST_F(SdcInitTest, R8_SdcSetClockLatency) { } // Sdc::removeClockLatency -TEST_F(SdcInitTest, R8_SdcRemoveClockLatency) { +TEST_F(SdcInitTest, SdcRemoveClockLatency) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7407,14 +7407,14 @@ TEST_F(SdcInitTest, R8_SdcRemoveClockLatency) { } // Sdc::clockLatencies accessor -TEST_F(SdcInitTest, R8_SdcClockLatencies) { +TEST_F(SdcInitTest, SdcClockLatencies) { Sdc *sdc = sta_->sdc(); const ClockLatencies *lats = sdc->clockLatencies(); EXPECT_NE(lats, nullptr); } // Sdc::clockLatency (float overload) -TEST_F(SdcInitTest, R8_SdcClockLatencyFloat) { +TEST_F(SdcInitTest, SdcClockLatencyFloat) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7429,7 +7429,7 @@ TEST_F(SdcInitTest, R8_SdcClockLatencyFloat) { } // Sdc::setClockInsertion and clockInsertion -TEST_F(SdcInitTest, R8_SdcClockInsertion) { +TEST_F(SdcInitTest, SdcClockInsertion) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7445,7 +7445,7 @@ TEST_F(SdcInitTest, R8_SdcClockInsertion) { } // Sdc::removeClockInsertion -TEST_F(SdcInitTest, R8_SdcRemoveClockInsertion) { +TEST_F(SdcInitTest, SdcRemoveClockInsertion) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7460,14 +7460,14 @@ TEST_F(SdcInitTest, R8_SdcRemoveClockInsertion) { } // Sdc::setMinPulseWidth -TEST_F(SdcInitTest, R8_SdcSetMinPulseWidthR8) { +TEST_F(SdcInitTest, SdcSetMinPulseWidthR8) { Sdc *sdc = sta_->sdc(); sdc->setMinPulseWidth(RiseFallBoth::riseFall(), 0.5f); // Just verify no crash } // Sdc::setLatchBorrowLimit -TEST_F(SdcInitTest, R8_SdcSetLatchBorrowLimit) { +TEST_F(SdcInitTest, SdcSetLatchBorrowLimit) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7480,7 +7480,7 @@ TEST_F(SdcInitTest, R8_SdcSetLatchBorrowLimit) { } // Sdc::removeClock -TEST_F(SdcInitTest, R8_SdcRemoveClock) { +TEST_F(SdcInitTest, SdcRemoveClock) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7493,21 +7493,21 @@ TEST_F(SdcInitTest, R8_SdcRemoveClock) { } // Sdc::defaultArrivalClock -TEST_F(SdcInitTest, R8_SdcDefaultArrivalClock) { +TEST_F(SdcInitTest, SdcDefaultArrivalClock2) { Sdc *sdc = sta_->sdc(); Clock *def_clk = sdc->defaultArrivalClock(); EXPECT_NE(def_clk, nullptr); } // Sdc::defaultArrivalClockEdge -TEST_F(SdcInitTest, R8_SdcDefaultArrivalClockEdge) { +TEST_F(SdcInitTest, SdcDefaultArrivalClockEdge2) { Sdc *sdc = sta_->sdc(); ClockEdge *edge = sdc->defaultArrivalClockEdge(); EXPECT_NE(edge, nullptr); } // Sdc::haveClkSlewLimits -TEST_F(SdcInitTest, R8_SdcHaveClkSlewLimits) { +TEST_F(SdcInitTest, SdcHaveClkSlewLimits2) { Sdc *sdc = sta_->sdc(); bool have = sdc->haveClkSlewLimits(); // Initially no limits @@ -7515,14 +7515,14 @@ TEST_F(SdcInitTest, R8_SdcHaveClkSlewLimits) { } // Sdc::invalidateGeneratedClks -TEST_F(SdcInitTest, R8_SdcInvalidateGeneratedClks) { +TEST_F(SdcInitTest, SdcInvalidateGeneratedClks2) { Sdc *sdc = sta_->sdc(); sdc->invalidateGeneratedClks(); // Just verify no crash } // Variables toggles - more variables -TEST_F(SdcInitTest, R8_VariablesDynamicLoopBreaking) { +TEST_F(SdcInitTest, VariablesDynamicLoopBreaking) { sta_->setDynamicLoopBreaking(true); EXPECT_TRUE(sta_->dynamicLoopBreaking()); sta_->setDynamicLoopBreaking(false); @@ -7530,7 +7530,7 @@ TEST_F(SdcInitTest, R8_VariablesDynamicLoopBreaking) { } // Variables propagateAllClocks -TEST_F(SdcInitTest, R8_VariablesPropagateAllClocks) { +TEST_F(SdcInitTest, VariablesPropagateAllClocks) { sta_->setPropagateAllClocks(true); EXPECT_TRUE(sta_->propagateAllClocks()); sta_->setPropagateAllClocks(false); @@ -7538,7 +7538,7 @@ TEST_F(SdcInitTest, R8_VariablesPropagateAllClocks) { } // Variables clkThruTristateEnabled -TEST_F(SdcInitTest, R8_VariablesClkThruTristateEnabled) { +TEST_F(SdcInitTest, VariablesClkThruTristateEnabled) { sta_->setClkThruTristateEnabled(true); EXPECT_TRUE(sta_->clkThruTristateEnabled()); sta_->setClkThruTristateEnabled(false); @@ -7546,7 +7546,7 @@ TEST_F(SdcInitTest, R8_VariablesClkThruTristateEnabled) { } // Variables useDefaultArrivalClock -TEST_F(SdcInitTest, R8_VariablesUseDefaultArrivalClock) { +TEST_F(SdcInitTest, VariablesUseDefaultArrivalClock) { sta_->setUseDefaultArrivalClock(true); EXPECT_TRUE(sta_->useDefaultArrivalClock()); sta_->setUseDefaultArrivalClock(false); @@ -7554,7 +7554,7 @@ TEST_F(SdcInitTest, R8_VariablesUseDefaultArrivalClock) { } // Variables pocvEnabled -TEST_F(SdcInitTest, R8_VariablesPocvEnabled) { +TEST_F(SdcInitTest, VariablesPocvEnabled) { sta_->setPocvEnabled(true); EXPECT_TRUE(sta_->pocvEnabled()); sta_->setPocvEnabled(false); @@ -7562,7 +7562,7 @@ TEST_F(SdcInitTest, R8_VariablesPocvEnabled) { } // Variables crprEnabled -TEST_F(SdcInitTest, R8_VariablesCrprEnabled) { +TEST_F(SdcInitTest, VariablesCrprEnabled) { sta_->setCrprEnabled(true); EXPECT_TRUE(sta_->crprEnabled()); sta_->setCrprEnabled(false); @@ -7570,7 +7570,7 @@ TEST_F(SdcInitTest, R8_VariablesCrprEnabled) { } // RiseFallMinMax clear -TEST_F(SdcInitTest, R8_RiseFallMinMaxClear) { +TEST_F(SdcInitTest, RiseFallMinMaxClear) { RiseFallMinMax rfmm(1.0f); EXPECT_TRUE(rfmm.hasValue()); rfmm.clear(); @@ -7578,7 +7578,7 @@ TEST_F(SdcInitTest, R8_RiseFallMinMaxClear) { } // RiseFallMinMax setValue individual -TEST_F(SdcInitTest, R8_RiseFallMinMaxSetValueIndividual) { +TEST_F(SdcInitTest, RiseFallMinMaxSetValueIndividual) { RiseFallMinMax rfmm; rfmm.setValue(RiseFall::rise(), MinMax::min(), 1.0f); rfmm.setValue(RiseFall::rise(), MinMax::max(), 2.0f); @@ -7591,7 +7591,7 @@ TEST_F(SdcInitTest, R8_RiseFallMinMaxSetValueIndividual) { } // RiseFallMinMax setValue with RiseFallBoth and MinMaxAll -TEST_F(SdcInitTest, R8_RiseFallMinMaxSetValueBoth) { +TEST_F(SdcInitTest, RiseFallMinMaxSetValueBoth) { RiseFallMinMax rfmm; rfmm.setValue(RiseFallBoth::riseFall(), MinMaxAll::all(), 5.0f); EXPECT_FLOAT_EQ(rfmm.value(RiseFall::rise(), MinMax::min()), 5.0f); @@ -7601,7 +7601,7 @@ TEST_F(SdcInitTest, R8_RiseFallMinMaxSetValueBoth) { } // PortExtCap -TEST_F(SdcInitTest, R8_PortExtCapConstruct) { +TEST_F(SdcInitTest, PortExtCapConstruct) { PortExtCap pec(nullptr); EXPECT_EQ(pec.port(), nullptr); float cap; @@ -7611,7 +7611,7 @@ TEST_F(SdcInitTest, R8_PortExtCapConstruct) { } // PortExtCap set and get pin cap -TEST_F(SdcInitTest, R8_PortExtCapSetPinCap) { +TEST_F(SdcInitTest, PortExtCapSetPinCap) { PortExtCap pec(nullptr); pec.setPinCap(1.0f, RiseFall::rise(), MinMax::max()); float cap; @@ -7622,7 +7622,7 @@ TEST_F(SdcInitTest, R8_PortExtCapSetPinCap) { } // PortExtCap set and get wire cap -TEST_F(SdcInitTest, R8_PortExtCapSetWireCap) { +TEST_F(SdcInitTest, PortExtCapSetWireCap) { PortExtCap pec(nullptr); pec.setWireCap(0.5f, RiseFall::fall(), MinMax::min()); float cap; @@ -7633,7 +7633,7 @@ TEST_F(SdcInitTest, R8_PortExtCapSetWireCap) { } // PortExtCap set and get fanout -TEST_F(SdcInitTest, R8_PortExtCapSetFanout) { +TEST_F(SdcInitTest, PortExtCapSetFanout) { PortExtCap pec(nullptr); pec.setFanout(4, MinMax::max()); int fanout; @@ -7644,7 +7644,7 @@ TEST_F(SdcInitTest, R8_PortExtCapSetFanout) { } // PortExtCap accessors -TEST_F(SdcInitTest, R8_PortExtCapAccessors) { +TEST_F(SdcInitTest, PortExtCapAccessors) { PortExtCap pec(nullptr); pec.setPinCap(1.0f, RiseFall::rise(), MinMax::max()); RiseFallMinMax *pin_cap = pec.pinCap(); @@ -7656,7 +7656,7 @@ TEST_F(SdcInitTest, R8_PortExtCapAccessors) { } // clkCmp -TEST_F(SdcInitTest, R8_ClkCmp) { +TEST_F(SdcInitTest, ClkCmp) { FloatSeq *wf1 = new FloatSeq; wf1->push_back(0.0); wf1->push_back(5.0); @@ -7676,7 +7676,7 @@ TEST_F(SdcInitTest, R8_ClkCmp) { } // clkEdgeCmp -TEST_F(SdcInitTest, R8_ClkEdgeCmp) { +TEST_F(SdcInitTest, ClkEdgeCmp) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7691,7 +7691,7 @@ TEST_F(SdcInitTest, R8_ClkEdgeCmp) { } // clkEdgeLess -TEST_F(SdcInitTest, R8_ClkEdgeLess) { +TEST_F(SdcInitTest, ClkEdgeLess) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7708,7 +7708,7 @@ TEST_F(SdcInitTest, R8_ClkEdgeLess) { } // ClockNameLess -TEST_F(SdcInitTest, R8_ClockNameLess) { +TEST_F(SdcInitTest, ClockNameLess) { FloatSeq *wf1 = new FloatSeq; wf1->push_back(0.0); wf1->push_back(5.0); @@ -7726,7 +7726,7 @@ TEST_F(SdcInitTest, R8_ClockNameLess) { } // Sdc::setClockGatingCheck (global) -TEST_F(SdcInitTest, R8_SdcClockGatingCheckGlobalR8) { +TEST_F(SdcInitTest, SdcClockGatingCheckGlobalR8) { Sdc *sdc = sta_->sdc(); sdc->setClockGatingCheck(RiseFallBoth::riseFall(), SetupHold::max(), 0.5f); @@ -7734,7 +7734,7 @@ TEST_F(SdcInitTest, R8_SdcClockGatingCheckGlobalR8) { } // Sdc::setClockGatingCheck on clock -TEST_F(SdcInitTest, R8_SdcClockGatingCheckOnClock) { +TEST_F(SdcInitTest, SdcClockGatingCheckOnClock) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7748,7 +7748,7 @@ TEST_F(SdcInitTest, R8_SdcClockGatingCheckOnClock) { } // Clock slewLimit set and get -TEST_F(SdcInitTest, R8_ClockSlewLimit) { +TEST_F(SdcInitTest, ClockSlewLimit) { FloatSeq *wf = new FloatSeq; wf->push_back(0.0); wf->push_back(5.0); @@ -7767,7 +7767,7 @@ TEST_F(SdcInitTest, R8_ClockSlewLimit) { } // ExceptionPt transition -TEST_F(SdcInitTest, R8_ExceptionPtTransition) { +TEST_F(SdcInitTest, ExceptionPtTransition) { ExceptionFrom from(nullptr, nullptr, nullptr, RiseFallBoth::rise(), false, nullptr); EXPECT_EQ(from.transition(), RiseFallBoth::rise()); @@ -7777,7 +7777,7 @@ TEST_F(SdcInitTest, R8_ExceptionPtTransition) { } // ExceptionTo isTo -TEST_F(SdcInitTest, R8_ExceptionToIsTo) { +TEST_F(SdcInitTest, ExceptionToIsTo) { ExceptionTo to(nullptr, nullptr, nullptr, RiseFallBoth::fall(), RiseFallBoth::riseFall(), @@ -7787,7 +7787,7 @@ TEST_F(SdcInitTest, R8_ExceptionToIsTo) { } // ExceptionFrom hasObjects (empty) -TEST_F(SdcInitTest, R8_ExceptionFromHasObjectsEmpty) { +TEST_F(SdcInitTest, ExceptionFromHasObjectsEmpty) { ExceptionFrom from(nullptr, nullptr, nullptr, RiseFallBoth::riseFall(), false, nullptr); EXPECT_FALSE(from.hasObjects()); @@ -7797,7 +7797,7 @@ TEST_F(SdcInitTest, R8_ExceptionFromHasObjectsEmpty) { } // MultiCyclePath matches min/max -TEST_F(SdcInitTest, R8_MultiCyclePathMatchesMinMax) { +TEST_F(SdcInitTest, MultiCyclePathMatchesMinMax) { MultiCyclePath mcp(nullptr, nullptr, nullptr, MinMaxAll::all(), true, 3, false, nullptr); EXPECT_TRUE(mcp.matches(MinMax::min(), false)); @@ -7805,7 +7805,7 @@ TEST_F(SdcInitTest, R8_MultiCyclePathMatchesMinMax) { } // MultiCyclePath pathMultiplier with min_max -TEST_F(SdcInitTest, R8_MultiCyclePathMultiplierWithMinMax) { +TEST_F(SdcInitTest, MultiCyclePathMultiplierWithMinMax2) { MultiCyclePath mcp(nullptr, nullptr, nullptr, MinMaxAll::all(), true, 3, false, nullptr); int mult_max = mcp.pathMultiplier(MinMax::max()); @@ -7813,55 +7813,55 @@ TEST_F(SdcInitTest, R8_MultiCyclePathMultiplierWithMinMax) { } // ExceptionPath fromThruToPriority -TEST_F(SdcInitTest, R8_ExceptionPathFromThruToPriority) { +TEST_F(SdcInitTest, ExceptionPathFromThruToPriority) { int prio = ExceptionPath::fromThruToPriority(nullptr, nullptr, nullptr); EXPECT_EQ(prio, 0); } // Sdc::disabledCellPorts -TEST_F(SdcInitTest, R8_SdcDisabledCellPorts) { +TEST_F(SdcInitTest, SdcDisabledCellPorts2) { Sdc *sdc = sta_->sdc(); DisabledCellPortsMap *dcm = sdc->disabledCellPorts(); EXPECT_NE(dcm, nullptr); } // Sdc::disabledInstancePorts -TEST_F(SdcInitTest, R8_SdcDisabledInstancePorts) { +TEST_F(SdcInitTest, SdcDisabledInstancePorts) { Sdc *sdc = sta_->sdc(); const DisabledInstancePortsMap *dim = sdc->disabledInstancePorts(); EXPECT_NE(dim, nullptr); } // Sdc::disabledPins -TEST_F(SdcInitTest, R8_SdcDisabledPins) { +TEST_F(SdcInitTest, SdcDisabledPins) { Sdc *sdc = sta_->sdc(); const PinSet *pins = sdc->disabledPins(); EXPECT_NE(pins, nullptr); } // Sdc::disabledPorts -TEST_F(SdcInitTest, R8_SdcDisabledPorts) { +TEST_F(SdcInitTest, SdcDisabledPorts) { Sdc *sdc = sta_->sdc(); const PortSet *ports = sdc->disabledPorts(); EXPECT_NE(ports, nullptr); } // Sdc::disabledLibPorts -TEST_F(SdcInitTest, R8_SdcDisabledLibPorts) { +TEST_F(SdcInitTest, SdcDisabledLibPorts) { Sdc *sdc = sta_->sdc(); const LibertyPortSet *lib_ports = sdc->disabledLibPorts(); EXPECT_NE(lib_ports, nullptr); } // Sdc::netResistances -TEST_F(SdcInitTest, R8_SdcNetResistances) { +TEST_F(SdcInitTest, SdcNetResistances) { Sdc *sdc = sta_->sdc(); NetResistanceMap &nr = sdc->netResistances(); (void)nr.size(); } // Sdc::clockInsertions -TEST_F(SdcInitTest, R8_SdcClockInsertions) { +TEST_F(SdcInitTest, SdcClockInsertions) { Sdc *sdc = sta_->sdc(); const ClockInsertions &insertions = sdc->clockInsertions(); (void)insertions.size(); @@ -7941,7 +7941,7 @@ protected: // --- CycleAccting: sourceCycle, targetCycle via timing update --- -TEST_F(SdcDesignTest, R10_CycleAcctingSourceTargetCycle) { +TEST_F(SdcDesignTest, CycleAcctingSourceTargetCycle) { // CycleAccting methods are called internally during timing Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); @@ -7964,7 +7964,7 @@ TEST_F(SdcDesignTest, R10_CycleAcctingSourceTargetCycle) { // --- ExceptionThru: asString --- -TEST_F(SdcInitTest, R10_ExceptionThruAsString) { +TEST_F(SdcInitTest, ExceptionThruAsString) { Sdc *sdc = sta_->sdc(); Network *network = sta_->cmdNetwork(); // Create ExceptionThru with no objects @@ -7977,7 +7977,7 @@ TEST_F(SdcInitTest, R10_ExceptionThruAsString) { // --- ExceptionTo: asString, matches, cmdKeyword --- -TEST_F(SdcInitTest, R10_ExceptionToAsString) { +TEST_F(SdcInitTest, ExceptionToAsString) { Network *network = sta_->cmdNetwork(); ExceptionTo *to = new ExceptionTo(nullptr, nullptr, nullptr, RiseFallBoth::riseFall(), @@ -7993,7 +7993,7 @@ TEST_F(SdcInitTest, R10_ExceptionToAsString) { // --- ExceptionFrom: findHash --- -TEST_F(SdcInitTest, R10_ExceptionFromHash) { +TEST_F(SdcInitTest, ExceptionFromHash) { Network *network = sta_->cmdNetwork(); ExceptionFrom *from = new ExceptionFrom(nullptr, nullptr, nullptr, RiseFallBoth::riseFall(), true, network); @@ -8004,7 +8004,7 @@ TEST_F(SdcInitTest, R10_ExceptionFromHash) { // --- ExceptionPath: mergeable --- -TEST_F(SdcInitTest, R10_ExceptionPathMergeable) { +TEST_F(SdcInitTest, ExceptionPathMergeable) { Sdc *sdc = sta_->sdc(); FalsePath *fp1 = new FalsePath(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); @@ -8024,7 +8024,7 @@ TEST_F(SdcInitTest, R10_ExceptionPathMergeable) { // --- ExceptionPt constructor --- -TEST_F(SdcInitTest, R10_ExceptionPtBasic) { +TEST_F(SdcInitTest, ExceptionPtBasic) { Network *network = sta_->cmdNetwork(); ExceptionFrom *from = new ExceptionFrom(nullptr, nullptr, nullptr, RiseFallBoth::rise(), true, network); @@ -8036,7 +8036,7 @@ TEST_F(SdcInitTest, R10_ExceptionPtBasic) { // --- ExceptionFromTo destructor --- -TEST_F(SdcInitTest, R10_ExceptionFromToDestructor) { +TEST_F(SdcInitTest, ExceptionFromToDestructor) { Network *network = sta_->cmdNetwork(); ExceptionFrom *from = new ExceptionFrom(nullptr, nullptr, nullptr, RiseFallBoth::riseFall(), true, network); @@ -8046,7 +8046,7 @@ TEST_F(SdcInitTest, R10_ExceptionFromToDestructor) { // --- ExceptionPath destructor --- -TEST_F(SdcInitTest, R10_ExceptionPathDestructor) { +TEST_F(SdcInitTest, ExceptionPathDestructor) { FalsePath *fp = new FalsePath(nullptr, nullptr, nullptr, MinMaxAll::all(), true, nullptr); delete fp; @@ -8054,7 +8054,7 @@ TEST_F(SdcInitTest, R10_ExceptionPathDestructor) { // --- DisabledCellPorts: construct and accessors --- -TEST_F(SdcInitTest, R10_DisabledCellPortsConstruct) { +TEST_F(SdcInitTest, DisabledCellPortsConstruct2) { LibertyLibrary *lib = sta_->readLiberty("test/nangate45/Nangate45_typ.lib", sta_->cmdCorner(), MinMaxAll::min(), false); @@ -8074,7 +8074,7 @@ TEST_F(SdcInitTest, R10_DisabledCellPortsConstruct) { // --- PortDelay: refTransition --- -TEST_F(SdcDesignTest, R10_PortDelayRefTransition) { +TEST_F(SdcDesignTest, PortDelayRefTransition) { Sdc *sdc = sta_->sdc(); const InputDelaySet &delays = sdc->inputDelays(); for (InputDelay *delay : delays) { @@ -8098,7 +8098,7 @@ TEST_F(SdcDesignTest, R10_PortDelayRefTransition) { // --- ClockEdge: accessors (time, clock, transition) --- -TEST_F(SdcInitTest, R10_ClockEdgeAccessors) { +TEST_F(SdcInitTest, ClockEdgeAccessors) { Sdc *sdc = sta_->sdc(); PinSet *clk_pins = new PinSet(sta_->cmdNetwork()); FloatSeq *waveform = new FloatSeq; @@ -8131,7 +8131,7 @@ TEST_F(SdcInitTest, R10_ClockEdgeAccessors) { // --- Sdc: removeDataCheck --- -TEST_F(SdcDesignTest, R10_SdcRemoveDataCheck) { +TEST_F(SdcDesignTest, SdcRemoveDataCheck) { Sdc *sdc = sta_->sdc(); Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); @@ -8149,7 +8149,7 @@ TEST_F(SdcDesignTest, R10_SdcRemoveDataCheck) { // --- Sdc: deleteInterClockUncertainty --- -TEST_F(SdcInitTest, R10_SdcInterClockUncertainty) { +TEST_F(SdcInitTest, SdcInterClockUncertainty) { Sdc *sdc = sta_->sdc(); PinSet *pins1 = new PinSet(sta_->cmdNetwork()); FloatSeq *waveform1 = new FloatSeq; @@ -8178,7 +8178,7 @@ TEST_F(SdcInitTest, R10_SdcInterClockUncertainty) { // --- Sdc: clearClkGroupExclusions (via removeClockGroupsLogicallyExclusive) --- -TEST_F(SdcInitTest, R10_SdcClearClkGroupExclusions) { +TEST_F(SdcInitTest, SdcClearClkGroupExclusions) { ClockGroups *cg = sta_->makeClockGroups("grp_exc", true, false, false, false, nullptr); EXPECT_NE(cg, nullptr); sta_->removeClockGroupsLogicallyExclusive("grp_exc"); @@ -8186,7 +8186,7 @@ TEST_F(SdcInitTest, R10_SdcClearClkGroupExclusions) { // --- Sdc: false path exercises pathDelayFrom/To indirectly --- -TEST_F(SdcDesignTest, R10_SdcFalsePathExercise) { +TEST_F(SdcDesignTest, SdcFalsePathExercise) { // Creating a false path from/to exercises pathDelayFrom/To code paths // through makeFalsePath and the SDC infrastructure Network *network = sta_->cmdNetwork(); @@ -8215,7 +8215,7 @@ TEST_F(SdcDesignTest, R10_SdcFalsePathExercise) { // --- WriteSdc via SdcDesignTest --- -TEST_F(SdcDesignTest, R10_WriteSdcBasic) { +TEST_F(SdcDesignTest, WriteSdcBasic) { const char *filename = "/tmp/test_write_sdc_sdc_r10.sdc"; sta_->writeSdc(filename, false, false, 4, false, true); FILE *f = fopen(filename, "r"); @@ -8223,7 +8223,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcBasic) { if (f) fclose(f); } -TEST_F(SdcDesignTest, R10_WriteSdcWithOutputDelay) { +TEST_F(SdcDesignTest, WriteSdcWithOutputDelay) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -8240,7 +8240,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithOutputDelay) { if (f) fclose(f); } -TEST_F(SdcDesignTest, R10_WriteSdcNative) { +TEST_F(SdcDesignTest, WriteSdcNative) { const char *filename = "/tmp/test_write_sdc_sdc_r10_native.sdc"; sta_->writeSdc(filename, false, true, 4, false, true); FILE *f = fopen(filename, "r"); @@ -8248,7 +8248,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcNative) { if (f) fclose(f); } -TEST_F(SdcDesignTest, R10_WriteSdcWithFalsePath) { +TEST_F(SdcDesignTest, WriteSdcWithFalsePath) { sta_->makeFalsePath(nullptr, nullptr, nullptr, MinMaxAll::all(), nullptr); const char *filename = "/tmp/test_write_sdc_sdc_r10_fp.sdc"; sta_->writeSdc(filename, false, false, 4, false, true); @@ -8257,7 +8257,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithFalsePath) { if (f) fclose(f); } -TEST_F(SdcDesignTest, R10_WriteSdcWithDerating) { +TEST_F(SdcDesignTest, WriteSdcWithDerating) { sta_->setTimingDerate(TimingDerateType::cell_delay, PathClkOrData::data, RiseFallBoth::riseFall(), @@ -8269,7 +8269,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithDerating) { if (f) fclose(f); } -TEST_F(SdcDesignTest, R10_WriteSdcWithDisable) { +TEST_F(SdcDesignTest, WriteSdcWithDisable) { Graph *graph = sta_->graph(); Network *network = sta_->cmdNetwork(); Pin *pin = findPin("r1/D"); @@ -8290,7 +8290,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithDisable) { if (f) fclose(f); } -TEST_F(SdcDesignTest, R10_WriteSdcWithClockLatency) { +TEST_F(SdcDesignTest, WriteSdcWithClockLatency) { Clock *clk = sta_->sdc()->findClock("clk"); if (clk) { sta_->setClockLatency(clk, nullptr, RiseFallBoth::riseFall(), @@ -8303,7 +8303,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithClockLatency) { if (f) fclose(f); } -TEST_F(SdcDesignTest, R10_WriteSdcWithInterClkUncertainty) { +TEST_F(SdcDesignTest, WriteSdcWithInterClkUncertainty) { Clock *clk = sta_->sdc()->findClock("clk"); if (clk) { sta_->setClockUncertainty(clk, RiseFallBoth::riseFall(), @@ -8319,7 +8319,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithInterClkUncertainty) { // --- Sdc: capacitanceLimit --- -TEST_F(SdcDesignTest, R10_SdcCapacitanceLimit) { +TEST_F(SdcDesignTest, SdcCapacitanceLimit) { Sdc *sdc = sta_->sdc(); Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); @@ -8335,14 +8335,14 @@ TEST_F(SdcDesignTest, R10_SdcCapacitanceLimit) { // --- Sdc: annotateGraphConstrained --- -TEST_F(SdcDesignTest, R10_SdcAnnotateGraphConstrained) { +TEST_F(SdcDesignTest, SdcAnnotateGraphConstrained) { // These are called during timing update; exercising indirectly sta_->updateTiming(true); } // --- DisabledInstancePorts: construct and accessors --- -TEST_F(SdcDesignTest, R10_DisabledInstancePortsAccessors) { +TEST_F(SdcDesignTest, DisabledInstancePortsAccessors) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -8356,7 +8356,7 @@ TEST_F(SdcDesignTest, R10_DisabledInstancePortsAccessors) { // --- PinClockPairLess: using public class --- -TEST_F(SdcDesignTest, R10_PinClockPairLessDesign) { +TEST_F(SdcDesignTest, PinClockPairLessDesign) { Network *network = sta_->cmdNetwork(); PinClockPairLess less(network); (void)less; @@ -8364,7 +8364,7 @@ TEST_F(SdcDesignTest, R10_PinClockPairLessDesign) { // --- Sdc: clockLatency for edge --- -TEST_F(SdcDesignTest, R10_SdcClockLatencyEdge) { +TEST_F(SdcDesignTest, SdcClockLatencyEdge) { Sdc *sdc = sta_->sdc(); Graph *graph = sta_->graph(); Network *network = sta_->cmdNetwork(); @@ -8384,7 +8384,7 @@ TEST_F(SdcDesignTest, R10_SdcClockLatencyEdge) { // --- Sdc: disable/removeDisable for pin pair --- -TEST_F(SdcDesignTest, R10_SdcDisablePinPair) { +TEST_F(SdcDesignTest, SdcDisablePinPair) { Sdc *sdc = sta_->sdc(); Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); @@ -8420,7 +8420,7 @@ TEST_F(SdcDesignTest, R10_SdcDisablePinPair) { // --- ExceptionThru: makePinEdges, makeNetEdges, makeInstEdges, deletePinEdges --- -TEST_F(SdcDesignTest, R10_ExceptionThruEdges) { +TEST_F(SdcDesignTest, ExceptionThruEdges) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *pin = network->findPin(top, "in1"); @@ -8435,7 +8435,7 @@ TEST_F(SdcDesignTest, R10_ExceptionThruEdges) { } } -TEST_F(SdcDesignTest, R10_ExceptionThruWithNet) { +TEST_F(SdcDesignTest, ExceptionThruWithNet) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); // Find a net @@ -8453,7 +8453,7 @@ TEST_F(SdcDesignTest, R10_ExceptionThruWithNet) { delete net_iter; } -TEST_F(SdcDesignTest, R10_ExceptionThruWithInstance) { +TEST_F(SdcDesignTest, ExceptionThruWithInstance) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *inst_iter = network->childIterator(top); @@ -8472,7 +8472,7 @@ TEST_F(SdcDesignTest, R10_ExceptionThruWithInstance) { // --- WriteSdc with leaf/map_hpins --- -TEST_F(SdcDesignTest, R10_WriteSdcLeaf) { +TEST_F(SdcDesignTest, WriteSdcLeaf) { const char *filename = "/tmp/test_write_sdc_sdc_r10_leaf.sdc"; sta_->writeSdc(filename, true, false, 4, false, true); FILE *f = fopen(filename, "r"); @@ -8482,7 +8482,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcLeaf) { // --- WriteSdc with data check --- -TEST_F(SdcDesignTest, R10_WriteSdcWithDataCheck) { +TEST_F(SdcDesignTest, WriteSdcWithDataCheck) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *from_pin = network->findPin(top, "r1/D"); @@ -8501,7 +8501,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithDataCheck) { // --- WriteSdc with port loads --- -TEST_F(SdcDesignTest, R10_WriteSdcWithPortLoad) { +TEST_F(SdcDesignTest, WriteSdcWithPortLoad) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -8520,7 +8520,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithPortLoad) { // --- WriteSdc with clock slew --- -TEST_F(SdcDesignTest, R10_WriteSdcWithClockSlew) { +TEST_F(SdcDesignTest, WriteSdcWithClockSlew) { Clock *clk = sta_->sdc()->findClock("clk"); if (clk) { sta_->setClockSlew(clk, RiseFallBoth::riseFall(), MinMaxAll::all(), 0.1f); @@ -8534,7 +8534,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithClockSlew) { // --- WriteSdc with clock insertion --- -TEST_F(SdcDesignTest, R10_WriteSdcWithClockInsertion) { +TEST_F(SdcDesignTest, WriteSdcWithClockInsertion) { Clock *clk = sta_->sdc()->findClock("clk"); if (clk) { sta_->setClockInsertion(clk, nullptr, RiseFallBoth::rise(), @@ -8549,7 +8549,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithClockInsertion) { // --- WriteSdc with multicycle path --- -TEST_F(SdcDesignTest, R10_WriteSdcWithMulticycle) { +TEST_F(SdcDesignTest, WriteSdcWithMulticycle) { sta_->makeMulticyclePath(nullptr, nullptr, nullptr, MinMaxAll::max(), true, 2, nullptr); const char *filename = "/tmp/test_write_sdc_sdc_r10_mcp.sdc"; @@ -8561,7 +8561,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithMulticycle) { // --- WriteSdc with max area --- -TEST_F(SdcDesignTest, R10_WriteSdcWithMaxArea) { +TEST_F(SdcDesignTest, WriteSdcWithMaxArea) { sta_->sdc()->setMaxArea(1000.0); const char *filename = "/tmp/test_write_sdc_sdc_r10_maxarea.sdc"; sta_->writeSdc(filename, false, false, 4, false, true); @@ -8572,7 +8572,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithMaxArea) { // --- WriteSdc with min pulse width --- -TEST_F(SdcDesignTest, R10_WriteSdcWithMpw) { +TEST_F(SdcDesignTest, WriteSdcWithMpw) { sta_->sdc()->setMinPulseWidth(RiseFallBoth::rise(), 0.5); const char *filename = "/tmp/test_write_sdc_sdc_r10_mpw.sdc"; sta_->writeSdc(filename, false, false, 4, false, true); @@ -8583,7 +8583,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithMpw) { // --- WriteSdc with voltage --- -TEST_F(SdcDesignTest, R10_WriteSdcWithVoltage) { +TEST_F(SdcDesignTest, WriteSdcWithVoltage) { sta_->sdc()->setVoltage(MinMax::max(), 1.1); sta_->sdc()->setVoltage(MinMax::min(), 0.9); const char *filename = "/tmp/test_write_sdc_sdc_r10_voltage.sdc"; @@ -8595,7 +8595,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithVoltage) { // --- Sdc: deleteLatchBorrowLimitsReferencing (via clock removal) --- -TEST_F(SdcInitTest, R10_SdcDeleteLatchBorrowLimits) { +TEST_F(SdcInitTest, SdcDeleteLatchBorrowLimits) { Sdc *sdc = sta_->sdc(); PinSet *clk_pins = new PinSet(sta_->cmdNetwork()); FloatSeq *waveform = new FloatSeq; @@ -8615,7 +8615,7 @@ TEST_F(SdcInitTest, R10_SdcDeleteLatchBorrowLimits) { // ============================================================ // --- WriteSdc with drive resistance --- -TEST_F(SdcDesignTest, R10_WriteSdcWithDriveResistance) { +TEST_F(SdcDesignTest, WriteSdcWithDriveResistance) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -8634,7 +8634,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithDriveResistance) { } // --- WriteSdc with logic value / set_logic_one --- -TEST_F(SdcDesignTest, R10_WriteSdcWithLogicValue) { +TEST_F(SdcDesignTest, WriteSdcWithLogicValue) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -8649,7 +8649,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithLogicValue) { } // --- WriteSdc with case analysis --- -TEST_F(SdcDesignTest, R10_WriteSdcWithCaseAnalysis) { +TEST_F(SdcDesignTest, WriteSdcWithCaseAnalysis) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in2 = network->findPin(top, "in2"); @@ -8664,7 +8664,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithCaseAnalysis) { } // --- WriteSdc with latch borrow limit on pin --- -TEST_F(SdcDesignTest, R10_WriteSdcWithLatchBorrowLimitPin) { +TEST_F(SdcDesignTest, WriteSdcWithLatchBorrowLimitPin) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *pin = network->findPin(top, "r1/D"); @@ -8679,7 +8679,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithLatchBorrowLimitPin) { } // --- WriteSdc with latch borrow limit on instance --- -TEST_F(SdcDesignTest, R10_WriteSdcWithLatchBorrowLimitInst) { +TEST_F(SdcDesignTest, WriteSdcWithLatchBorrowLimitInst) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -8696,7 +8696,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithLatchBorrowLimitInst) { } // --- WriteSdc with slew limits --- -TEST_F(SdcDesignTest, R10_WriteSdcWithSlewLimits) { +TEST_F(SdcDesignTest, WriteSdcWithSlewLimits) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); if (clk) { @@ -8720,7 +8720,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithSlewLimits) { } // --- WriteSdc with cap limits --- -TEST_F(SdcDesignTest, R10_WriteSdcWithCapLimits) { +TEST_F(SdcDesignTest, WriteSdcWithCapLimits) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -8739,7 +8739,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithCapLimits) { } // --- WriteSdc with fanout limits --- -TEST_F(SdcDesignTest, R10_WriteSdcWithFanoutLimits) { +TEST_F(SdcDesignTest, WriteSdcWithFanoutLimits) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -8757,7 +8757,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithFanoutLimits) { } // --- WriteSdc with min pulse width on pin --- -TEST_F(SdcDesignTest, R10_WriteSdcWithMpwOnPin) { +TEST_F(SdcDesignTest, WriteSdcWithMpwOnPin) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *clk_pin = network->findPin(top, "r1/CK"); @@ -8772,7 +8772,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithMpwOnPin) { } // --- WriteSdc with min pulse width on instance --- -TEST_F(SdcDesignTest, R10_WriteSdcWithMpwOnInst) { +TEST_F(SdcDesignTest, WriteSdcWithMpwOnInst) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -8789,7 +8789,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithMpwOnInst) { } // --- WriteSdc with disable on instance --- -TEST_F(SdcDesignTest, R10_WriteSdcWithDisableInstance) { +TEST_F(SdcDesignTest, WriteSdcWithDisableInstance) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -8820,7 +8820,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithDisableInstance) { } // --- WriteSdc with disable on liberty port --- -TEST_F(SdcDesignTest, R10_WriteSdcWithDisableLibPort) { +TEST_F(SdcDesignTest, WriteSdcWithDisableLibPort) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -8844,7 +8844,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithDisableLibPort) { } // --- WriteSdc with disable on cell --- -TEST_F(SdcDesignTest, R10_WriteSdcWithDisableCell) { +TEST_F(SdcDesignTest, WriteSdcWithDisableCell) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -8864,7 +8864,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithDisableCell) { } // --- WriteSdc with output delay --- -TEST_F(SdcDesignTest, R10_WriteSdcWithOutputDelayDetailed) { +TEST_F(SdcDesignTest, WriteSdcWithOutputDelayDetailed) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -8886,7 +8886,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcWithOutputDelayDetailed) { } // --- Sdc: outputDelays iterator --- -TEST_F(SdcDesignTest, R10_SdcOutputDelays) { +TEST_F(SdcDesignTest, SdcOutputDelays) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -8909,7 +8909,7 @@ TEST_F(SdcDesignTest, R10_SdcOutputDelays) { } // --- Sdc: Variables class accessors --- -TEST_F(SdcDesignTest, R10_VariablesAccessors) { +TEST_F(SdcDesignTest, VariablesAccessors) { // Test Variables accessors that modify search behavior bool crpr_orig = sta_->crprEnabled(); sta_->setCrprEnabled(!crpr_orig); @@ -8923,7 +8923,7 @@ TEST_F(SdcDesignTest, R10_VariablesAccessors) { } // --- Clock: name, period, waveform --- -TEST_F(SdcDesignTest, R10_ClockAccessors) { +TEST_F(SdcDesignTest, ClockAccessors) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); ASSERT_NE(clk, nullptr); @@ -8941,7 +8941,7 @@ TEST_F(SdcDesignTest, R10_ClockAccessors) { } // --- ExceptionFrom: hasPins, hasClocks, hasInstances --- -TEST_F(SdcDesignTest, R10_ExceptionFromHasPins) { +TEST_F(SdcDesignTest, ExceptionFromHasPins) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -8960,7 +8960,7 @@ TEST_F(SdcDesignTest, R10_ExceptionFromHasPins) { } // --- ExceptionTo: hasPins, endRf --- -TEST_F(SdcDesignTest, R10_ExceptionToHasPins) { +TEST_F(SdcDesignTest, ExceptionToHasPins) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -8979,7 +8979,7 @@ TEST_F(SdcDesignTest, R10_ExceptionToHasPins) { } // --- Sdc: removeClockLatency --- -TEST_F(SdcDesignTest, R10_SdcRemoveClockLatency) { +TEST_F(SdcDesignTest, SdcRemoveClockLatency) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); if (clk) { @@ -8991,7 +8991,7 @@ TEST_F(SdcDesignTest, R10_SdcRemoveClockLatency) { } // --- Sdc: removeCaseAnalysis --- -TEST_F(SdcDesignTest, R10_SdcRemoveCaseAnalysis) { +TEST_F(SdcDesignTest, SdcRemoveCaseAnalysis) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -9002,7 +9002,7 @@ TEST_F(SdcDesignTest, R10_SdcRemoveCaseAnalysis) { } // --- Sdc: removeDerating --- -TEST_F(SdcDesignTest, R10_SdcRemoveDerating) { +TEST_F(SdcDesignTest, SdcRemoveDerating) { sta_->setTimingDerate(TimingDerateType::cell_delay, PathClkOrData::data, RiseFallBoth::riseFall(), @@ -9011,7 +9011,7 @@ TEST_F(SdcDesignTest, R10_SdcRemoveDerating) { } // --- WriteSdc comprehensive: multiple constraints --- -TEST_F(SdcDesignTest, R10_WriteSdcComprehensive) { +TEST_F(SdcDesignTest, WriteSdcComprehensive) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Sdc *sdc = sta_->sdc(); @@ -9071,7 +9071,7 @@ TEST_F(SdcDesignTest, R10_WriteSdcComprehensive) { } // --- Clock: isPropagated, edges, edgeCount --- -TEST_F(SdcDesignTest, R10_ClockEdgeDetails) { +TEST_F(SdcDesignTest, ClockEdgeDetails) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); ASSERT_NE(clk, nullptr); @@ -9090,7 +9090,7 @@ TEST_F(SdcDesignTest, R10_ClockEdgeDetails) { } // --- Sdc: clocks() - get all clocks --- -TEST_F(SdcDesignTest, R10_SdcClocksList) { +TEST_F(SdcDesignTest, SdcClocksList) { Sdc *sdc = sta_->sdc(); const ClockSeq &clks = sdc->clks(); EXPECT_GT(clks.size(), 0u); @@ -9100,7 +9100,7 @@ TEST_F(SdcDesignTest, R10_SdcClocksList) { } // --- InputDrive: accessors --- -TEST_F(SdcDesignTest, R10_InputDriveAccessors) { +TEST_F(SdcDesignTest, InputDriveAccessors) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -9130,7 +9130,7 @@ TEST_F(SdcDesignTest, R10_InputDriveAccessors) { // --- WriteSdc with net wire cap (triggers writeNetLoads, writeNetLoad, // writeGetNet, WriteGetNet, scaleCapacitance, writeFloat, writeCapacitance, // writeCommentSeparator, closeFile, ~WriteSdc) --- -TEST_F(SdcDesignTest, R11_WriteSdcWithNetWireCap) { +TEST_F(SdcDesignTest, WriteSdcWithNetWireCap) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); NetIterator *net_iter = network->netIterator(top); @@ -9149,7 +9149,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcWithNetWireCap) { // --- WriteSdc with net resistance (triggers writeNetResistances, // writeNetResistance, writeGetNet, scaleResistance, writeResistance) --- -TEST_F(SdcDesignTest, R11_WriteSdcWithNetResistance) { +TEST_F(SdcDesignTest, WriteSdcWithNetResistance) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); NetIterator *net_iter = network->netIterator(top); @@ -9167,7 +9167,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcWithNetResistance) { // --- WriteSdc with input slew (triggers writeInputTransitions, // writeRiseFallMinMaxTimeCmd, WriteGetPort, scaleTime) --- -TEST_F(SdcDesignTest, R11_WriteSdcWithInputSlew) { +TEST_F(SdcDesignTest, WriteSdcWithInputSlew) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -9187,7 +9187,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcWithInputSlew) { // --- WriteSdc with driving cell (triggers writeDrivingCells, writeDrivingCell, // WriteGetLibCell, WriteGetPort) --- -TEST_F(SdcDesignTest, R11_WriteSdcWithDrivingCell) { +TEST_F(SdcDesignTest, WriteSdcWithDrivingCell) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -9241,7 +9241,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcWithDrivingCell) { // --- WriteSdc with clock groups that have actual clock members // (triggers writeClockGroups, WriteGetClock, writeGetClock) --- -TEST_F(SdcDesignTest, R11_WriteSdcWithClockGroupsMembers) { +TEST_F(SdcDesignTest, WriteSdcWithClockGroupsMembers) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); if (clk) { @@ -9279,7 +9279,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcWithClockGroupsMembers) { // --- WriteSdc with false path having -from pins and -through pins and -to pins // (triggers writeExceptionFrom, WriteGetPin, writeExceptionThru, // writeExceptionTo) --- -TEST_F(SdcDesignTest, R11_WriteSdcFalsePathFromThruTo) { +TEST_F(SdcDesignTest, WriteSdcFalsePathFromThruTo) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -9319,7 +9319,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcFalsePathFromThruTo) { // --- WriteSdc with false path -through net // (triggers writeExceptionThru with nets, writeGetNet) --- -TEST_F(SdcDesignTest, R11_WriteSdcFalsePathThruNet) { +TEST_F(SdcDesignTest, WriteSdcFalsePathThruNet) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); NetIterator *net_iter = network->netIterator(top); @@ -9342,7 +9342,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcFalsePathThruNet) { } // --- WriteSdc with false path -from clock (triggers writeGetClock in from) --- -TEST_F(SdcDesignTest, R11_WriteSdcFalsePathFromClock) { +TEST_F(SdcDesignTest, WriteSdcFalsePathFromClock) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); if (clk) { @@ -9361,7 +9361,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcFalsePathFromClock) { // --- WriteSdc with false path -from instance (triggers writeGetInstance, // WriteGetInstance) --- -TEST_F(SdcDesignTest, R11_WriteSdcFalsePathFromInstance) { +TEST_F(SdcDesignTest, WriteSdcFalsePathFromInstance) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -9383,7 +9383,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcFalsePathFromInstance) { // --- WriteSdc with multicycle path with -from pin // (triggers writeExceptionCmd for multicycle, writeExceptionFrom) --- -TEST_F(SdcDesignTest, R11_WriteSdcMulticycleWithFrom) { +TEST_F(SdcDesignTest, WriteSdcMulticycleWithFrom) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -9404,7 +9404,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcMulticycleWithFrom) { // --- WriteSdc with path delay (max_delay/min_delay) // (triggers writeExceptionCmd for path delay, writeExceptionValue) --- -TEST_F(SdcDesignTest, R11_WriteSdcPathDelay) { +TEST_F(SdcDesignTest, WriteSdcPathDelay) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -9431,7 +9431,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcPathDelay) { // --- WriteSdc with group path // (triggers writeExceptionCmd for group path) --- -TEST_F(SdcDesignTest, R11_WriteSdcGroupPath) { +TEST_F(SdcDesignTest, WriteSdcGroupPath) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -9451,7 +9451,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcGroupPath) { // --- WriteSdc with clock sense // (triggers writeClockSenses, PinClockPairNameLess) --- -TEST_F(SdcDesignTest, R11_WriteSdcWithClockSense) { +TEST_F(SdcDesignTest, WriteSdcWithClockSense) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *clk1 = network->findPin(top, "clk1"); @@ -9473,7 +9473,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcWithClockSense) { // --- WriteSdc with port ext wire cap and fanout // (triggers writePortLoads with wire cap, writeMinMaxIntValuesCmd) --- -TEST_F(SdcDesignTest, R11_WriteSdcWithPortExtWireCap) { +TEST_F(SdcDesignTest, WriteSdcWithPortExtWireCap) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -9495,7 +9495,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcWithPortExtWireCap) { // --- WriteSdc with clock gating check // (triggers writeClockGatingChecks) --- -TEST_F(SdcDesignTest, R11_WriteSdcWithClockGatingCheck) { +TEST_F(SdcDesignTest, WriteSdcWithClockGatingCheck) { sta_->setClockGatingCheck(RiseFallBoth::riseFall(), MinMax::max(), 0.1f); Sdc *sdc = sta_->sdc(); @@ -9511,7 +9511,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcWithClockGatingCheck) { } // --- Sdc: connectedCap via Sta API --- -TEST_F(SdcDesignTest, R11_SdcConnectedCap) { +TEST_F(SdcDesignTest, SdcConnectedCap) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -9526,7 +9526,7 @@ TEST_F(SdcDesignTest, R11_SdcConnectedCap) { } // --- Sdc: connectedCap on net via Sta API --- -TEST_F(SdcDesignTest, R11_SdcConnectedCapNet) { +TEST_F(SdcDesignTest, SdcConnectedCapNet) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); NetIterator *net_iter = network->netIterator(top); @@ -9542,7 +9542,7 @@ TEST_F(SdcDesignTest, R11_SdcConnectedCapNet) { } // --- ExceptionPath::mergeable --- -TEST_F(SdcDesignTest, R11_ExceptionPathMergeable) { +TEST_F(SdcDesignTest, ExceptionPathMergeable) { // Create two false paths and check mergeability sta_->makeFalsePath(nullptr, nullptr, nullptr, MinMaxAll::all(), nullptr); Sdc *sdc = sta_->sdc(); @@ -9563,7 +9563,7 @@ TEST_F(SdcDesignTest, R11_ExceptionPathMergeable) { // --- WriteSdc with propagated clock on pin // (triggers writePropagatedClkPins) --- -TEST_F(SdcDesignTest, R11_WriteSdcWithPropagatedClk) { +TEST_F(SdcDesignTest, WriteSdcWithPropagatedClk) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *clk1 = network->findPin(top, "clk1"); @@ -9579,7 +9579,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcWithPropagatedClk) { // --- WriteSdc with min_delay path delay // (triggers min_delay branch in writeExceptionCmd) --- -TEST_F(SdcDesignTest, R11_WriteSdcMinDelay) { +TEST_F(SdcDesignTest, WriteSdcMinDelay) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -9606,7 +9606,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcMinDelay) { // --- WriteSdc with multicycle -hold (min) with -end // (triggers the hold branch in writeExceptionCmd) --- -TEST_F(SdcDesignTest, R11_WriteSdcMulticycleHold) { +TEST_F(SdcDesignTest, WriteSdcMulticycleHold) { sta_->makeMulticyclePath(nullptr, nullptr, nullptr, MinMaxAll::min(), true, 0, nullptr); const char *filename = "/tmp/test_sdc_r11_mcp_hold.sdc"; @@ -9618,7 +9618,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcMulticycleHold) { // --- WriteSdc with multicycle -setup with -start // (triggers the start branch in writeExceptionCmd) --- -TEST_F(SdcDesignTest, R11_WriteSdcMulticycleStart) { +TEST_F(SdcDesignTest, WriteSdcMulticycleStart) { sta_->makeMulticyclePath(nullptr, nullptr, nullptr, MinMaxAll::max(), false, 2, nullptr); const char *filename = "/tmp/test_sdc_r11_mcp_start.sdc"; @@ -9630,7 +9630,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcMulticycleStart) { // --- WriteSdc with group path default // (triggers isDefault branch in writeExceptionCmd) --- -TEST_F(SdcDesignTest, R11_WriteSdcGroupPathDefault) { +TEST_F(SdcDesignTest, WriteSdcGroupPathDefault) { sta_->makeGroupPath(nullptr, true, nullptr, nullptr, nullptr, nullptr); const char *filename = "/tmp/test_sdc_r11_grppath_default.sdc"; sta_->writeSdc(filename, false, false, 4, false, true); @@ -9641,7 +9641,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcGroupPathDefault) { // --- WriteSdc with false path -from with rise_from // (triggers rf_prefix = "-rise_" branch) --- -TEST_F(SdcDesignTest, R11_WriteSdcFalsePathRiseFrom) { +TEST_F(SdcDesignTest, WriteSdcFalsePathRiseFrom) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -9661,7 +9661,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcFalsePathRiseFrom) { // --- WriteSdc with false path -from with fall_from // (triggers rf_prefix = "-fall_" branch) --- -TEST_F(SdcDesignTest, R11_WriteSdcFalsePathFallFrom) { +TEST_F(SdcDesignTest, WriteSdcFalsePathFallFrom) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -9681,7 +9681,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcFalsePathFallFrom) { // --- WriteSdc with path delay -ignore_clock_latency // (triggers the ignoreClkLatency branch) --- -TEST_F(SdcDesignTest, R11_WriteSdcPathDelayIgnoreClkLat) { +TEST_F(SdcDesignTest, WriteSdcPathDelayIgnoreClkLat) { sta_->makePathDelay(nullptr, nullptr, nullptr, MinMax::max(), true, false, 8.0f, nullptr); const char *filename = "/tmp/test_sdc_r11_pathdelay_ignoreclk.sdc"; @@ -9693,7 +9693,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcPathDelayIgnoreClkLat) { // --- WriteSdc with false path -to with end_rf rise // (triggers the end_rf != riseFall branch in writeExceptionTo) --- -TEST_F(SdcDesignTest, R11_WriteSdcFalsePathToRise) { +TEST_F(SdcDesignTest, WriteSdcFalsePathToRise) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -9713,7 +9713,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcFalsePathToRise) { } // --- WriteSdc with multiple from objects (triggers multi_objs branch with [list ]) --- -TEST_F(SdcDesignTest, R11_WriteSdcFalsePathMultiFrom) { +TEST_F(SdcDesignTest, WriteSdcFalsePathMultiFrom) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -9735,7 +9735,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcFalsePathMultiFrom) { // --- WriteSdc with data check that has a clock ref // (triggers writeDataChecks, WriteGetPinAndClkKey) --- -TEST_F(SdcDesignTest, R11_WriteSdcDataCheckWithClock) { +TEST_F(SdcDesignTest, WriteSdcDataCheckWithClock) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *from_pin = network->findPin(top, "r1/D"); @@ -9755,7 +9755,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcDataCheckWithClock) { } // --- Sdc::removeDataCheck --- -TEST_F(SdcDesignTest, R11_SdcRemoveDataCheck) { +TEST_F(SdcDesignTest, SdcRemoveDataCheck2) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *from_pin = network->findPin(top, "r1/D"); @@ -9772,7 +9772,7 @@ TEST_F(SdcDesignTest, R11_SdcRemoveDataCheck) { // --- WriteSdc with clock uncertainty on pin // (triggers writeClockUncertaintyPins, writeClockUncertaintyPin) --- -TEST_F(SdcDesignTest, R11_WriteSdcClockUncertaintyPin) { +TEST_F(SdcDesignTest, WriteSdcClockUncertaintyPin) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *clk1 = network->findPin(top, "clk1"); @@ -9788,7 +9788,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcClockUncertaintyPin) { // --- WriteSdc with voltage on net // (triggers writeVoltages with net voltage) --- -TEST_F(SdcDesignTest, R11_WriteSdcVoltageNet) { +TEST_F(SdcDesignTest, WriteSdcVoltageNet) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); NetIterator *net_iter = network->netIterator(top); @@ -9808,7 +9808,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcVoltageNet) { // --- WriteSdc with disable on timing arcs of cell // (triggers writeGetTimingArcsOfOjbects, writeGetTimingArcs, // getTimingArcsCmd) --- -TEST_F(SdcDesignTest, R11_WriteSdcDisableTimingArcs) { +TEST_F(SdcDesignTest, WriteSdcDisableTimingArcs) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -9842,7 +9842,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcDisableTimingArcs) { // --- WriteSdc with min pulse width on clock // (triggers writeMinPulseWidths clock branch) --- -TEST_F(SdcDesignTest, R11_WriteSdcMpwClock) { +TEST_F(SdcDesignTest, WriteSdcMpwClock) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); if (clk) { @@ -9858,7 +9858,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcMpwClock) { // --- WriteSdc with slew limit on clock data // (triggers writeClkSlewLimits, writeClkSlewLimit) --- -TEST_F(SdcDesignTest, R11_WriteSdcSlewLimitClkData) { +TEST_F(SdcDesignTest, WriteSdcSlewLimitClkData) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); if (clk) { @@ -9876,7 +9876,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcSlewLimitClkData) { // --- WriteSdc with cell-level cap limit // (triggers writeCapLimits cell branch) --- -TEST_F(SdcDesignTest, R11_WriteSdcCapLimitCell) { +TEST_F(SdcDesignTest, WriteSdcCapLimitCell) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -9897,7 +9897,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcCapLimitCell) { // --- WriteSdc with cell-level fanout limit // (triggers writeFanoutLimits cell branch) --- -TEST_F(SdcDesignTest, R11_WriteSdcFanoutLimitCell) { +TEST_F(SdcDesignTest, WriteSdcFanoutLimitCell) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -9918,7 +9918,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcFanoutLimitCell) { // --- WriteSdc with cell-level slew limit // (triggers writeSlewLimits cell branch) --- -TEST_F(SdcDesignTest, R11_WriteSdcSlewLimitCell) { +TEST_F(SdcDesignTest, WriteSdcSlewLimitCell) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -9938,7 +9938,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcSlewLimitCell) { } // --- WriteSdc comprehensive: trigger as many writer paths as possible --- -TEST_F(SdcDesignTest, R11_WriteSdcMegaComprehensive) { +TEST_F(SdcDesignTest, WriteSdcMegaComprehensive) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Sdc *sdc = sta_->sdc(); @@ -10076,7 +10076,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcMegaComprehensive) { } // --- Sdc: remove clock groups --- -TEST_F(SdcDesignTest, R11_SdcRemoveClockGroups) { +TEST_F(SdcDesignTest, SdcRemoveClockGroups) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); if (clk) { @@ -10091,7 +10091,7 @@ TEST_F(SdcDesignTest, R11_SdcRemoveClockGroups) { } // --- Sdc: remove physically exclusive clock groups --- -TEST_F(SdcDesignTest, R11_SdcRemovePhysExclClkGroups) { +TEST_F(SdcDesignTest, SdcRemovePhysExclClkGroups) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); if (clk) { @@ -10105,7 +10105,7 @@ TEST_F(SdcDesignTest, R11_SdcRemovePhysExclClkGroups) { } // --- Sdc: remove async clock groups --- -TEST_F(SdcDesignTest, R11_SdcRemoveAsyncClkGroups) { +TEST_F(SdcDesignTest, SdcRemoveAsyncClkGroups) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); if (clk) { @@ -10119,7 +10119,7 @@ TEST_F(SdcDesignTest, R11_SdcRemoveAsyncClkGroups) { } // --- Sdc: clear via removeConstraints (covers initVariables, clearCycleAcctings) --- -TEST_F(SdcDesignTest, R11_SdcRemoveConstraintsCover) { +TEST_F(SdcDesignTest, SdcRemoveConstraintsCover) { Sdc *sdc = sta_->sdc(); // Set various constraints first sdc->setMaxArea(500.0); @@ -10130,7 +10130,7 @@ TEST_F(SdcDesignTest, R11_SdcRemoveConstraintsCover) { } // --- ExceptionFrom: hash via exception creation and matching --- -TEST_F(SdcDesignTest, R11_ExceptionFromMatching) { +TEST_F(SdcDesignTest, ExceptionFromMatching) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -10151,7 +10151,7 @@ TEST_F(SdcDesignTest, R11_ExceptionFromMatching) { } // --- DisabledCellPorts accessors --- -TEST_F(SdcDesignTest, R11_DisabledCellPortsAccessors) { +TEST_F(SdcDesignTest, DisabledCellPortsAccessors) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -10170,7 +10170,7 @@ TEST_F(SdcDesignTest, R11_DisabledCellPortsAccessors) { } // --- DisabledInstancePorts with disable --- -TEST_F(SdcDesignTest, R11_DisabledInstancePortsDisable) { +TEST_F(SdcDesignTest, DisabledInstancePortsDisable) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -10207,7 +10207,7 @@ TEST_F(SdcDesignTest, R11_DisabledInstancePortsDisable) { // --- WriteSdc with latch borrow limit on clock // (triggers writeLatchBorrowLimits clock branch) --- -TEST_F(SdcDesignTest, R11_WriteSdcLatchBorrowClock) { +TEST_F(SdcDesignTest, WriteSdcLatchBorrowClock) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); if (clk) { @@ -10221,7 +10221,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcLatchBorrowClock) { } // --- WriteSdc with derating on cell, instance, net --- -TEST_F(SdcDesignTest, R11_WriteSdcDeratingCellInstNet) { +TEST_F(SdcDesignTest, WriteSdcDeratingCellInstNet) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); @@ -10265,7 +10265,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcDeratingCellInstNet) { } // --- Sdc: capacitanceLimit on pin --- -TEST_F(SdcDesignTest, R11_SdcCapLimitPin) { +TEST_F(SdcDesignTest, SdcCapLimitPin) { Sdc *sdc = sta_->sdc(); Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); @@ -10282,7 +10282,7 @@ TEST_F(SdcDesignTest, R11_SdcCapLimitPin) { // --- WriteSdc with set_false_path -hold only // (triggers writeSetupHoldFlag for hold) --- -TEST_F(SdcDesignTest, R11_WriteSdcFalsePathHold) { +TEST_F(SdcDesignTest, WriteSdcFalsePathHold) { sta_->makeFalsePath(nullptr, nullptr, nullptr, MinMaxAll::min(), nullptr); const char *filename = "/tmp/test_sdc_r11_fp_hold.sdc"; sta_->writeSdc(filename, false, false, 4, false, true); @@ -10293,7 +10293,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcFalsePathHold) { // --- WriteSdc with set_false_path -setup only // (triggers writeSetupHoldFlag for setup) --- -TEST_F(SdcDesignTest, R11_WriteSdcFalsePathSetup) { +TEST_F(SdcDesignTest, WriteSdcFalsePathSetup) { sta_->makeFalsePath(nullptr, nullptr, nullptr, MinMaxAll::max(), nullptr); const char *filename = "/tmp/test_sdc_r11_fp_setup.sdc"; sta_->writeSdc(filename, false, false, 4, false, true); @@ -10304,7 +10304,7 @@ TEST_F(SdcDesignTest, R11_WriteSdcFalsePathSetup) { // --- WriteSdc with exception -through with rise_through // (triggers rf_prefix branches in writeExceptionThru) --- -TEST_F(SdcDesignTest, R11_WriteSdcFalsePathRiseThru) { +TEST_F(SdcDesignTest, WriteSdcFalsePathRiseThru) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); diff --git a/sdf/test/cpp/TestSdf.cc b/sdf/test/cpp/TestSdf.cc index 094e3519..b2e884e2 100644 --- a/sdf/test/cpp/TestSdf.cc +++ b/sdf/test/cpp/TestSdf.cc @@ -414,7 +414,7 @@ TEST_F(SdfSmokeTest, MinMaxAllAsMinMax) { // Test SDF edge names for transitions // Covers: SdfWriter::sdfEdge - exercises transition to SDF edge string mapping -TEST_F(SdfSmokeTest, R5_TransitionAsInitFinalString) { +TEST_F(SdfSmokeTest, TransitionAsInitFinalString) { // SDF uses init/final transition string representation EXPECT_NE(Transition::rise()->asInitFinalString(), nullptr); EXPECT_NE(Transition::fall()->asInitFinalString(), nullptr); @@ -429,7 +429,7 @@ TEST_F(SdfSmokeTest, R5_TransitionAsInitFinalString) { } // Test Transition asRiseFall for SDF edge transitions -TEST_F(SdfSmokeTest, R5_TransitionAsRiseFallAll) { +TEST_F(SdfSmokeTest, TransitionAsRiseFallAll) { // Rise transitions map to rise EXPECT_EQ(Transition::rise()->asRiseFall(), RiseFall::rise()); // Fall transitions map to fall @@ -445,7 +445,7 @@ TEST_F(SdfSmokeTest, R5_TransitionAsRiseFallAll) { } // Test MinMaxAll matches method -TEST_F(SdfSmokeTest, R5_MinMaxAllMatches) { +TEST_F(SdfSmokeTest, MinMaxAllMatches2) { EXPECT_TRUE(MinMaxAll::min()->matches(MinMax::min())); EXPECT_FALSE(MinMaxAll::min()->matches(MinMax::max())); EXPECT_TRUE(MinMaxAll::max()->matches(MinMax::max())); @@ -455,7 +455,7 @@ TEST_F(SdfSmokeTest, R5_MinMaxAllMatches) { } // Test MinMaxAll matches MinMaxAll -TEST_F(SdfSmokeTest, R5_MinMaxAllMatchesAll) { +TEST_F(SdfSmokeTest, MinMaxAllMatchesAll) { EXPECT_TRUE(MinMaxAll::all()->matches(MinMaxAll::min())); EXPECT_TRUE(MinMaxAll::all()->matches(MinMaxAll::max())); EXPECT_TRUE(MinMaxAll::all()->matches(MinMaxAll::all())); @@ -464,20 +464,20 @@ TEST_F(SdfSmokeTest, R5_MinMaxAllMatchesAll) { } // Test MinMax find by name -TEST_F(SdfSmokeTest, R5_MinMaxFindByName) { +TEST_F(SdfSmokeTest, MinMaxFindByName) { EXPECT_EQ(MinMax::find("min"), MinMax::min()); EXPECT_EQ(MinMax::find("max"), MinMax::max()); EXPECT_EQ(MinMax::find("nonexistent"), nullptr); } // Test MinMax find by index -TEST_F(SdfSmokeTest, R5_MinMaxFindByIndex) { +TEST_F(SdfSmokeTest, MinMaxFindByIndex) { EXPECT_EQ(MinMax::find(MinMax::minIndex()), MinMax::min()); EXPECT_EQ(MinMax::find(MinMax::maxIndex()), MinMax::max()); } // Test MinMaxAll find by name -TEST_F(SdfSmokeTest, R5_MinMaxAllFindByName) { +TEST_F(SdfSmokeTest, MinMaxAllFindByName) { EXPECT_EQ(MinMaxAll::find("min"), MinMaxAll::min()); EXPECT_EQ(MinMaxAll::find("max"), MinMaxAll::max()); EXPECT_EQ(MinMaxAll::find("all"), MinMaxAll::all()); @@ -485,13 +485,13 @@ TEST_F(SdfSmokeTest, R5_MinMaxAllFindByName) { } // Test MinMax opposite -TEST_F(SdfSmokeTest, R5_MinMaxOpposite) { +TEST_F(SdfSmokeTest, MinMaxOpposite2) { EXPECT_EQ(MinMax::min()->opposite(), MinMax::max()); EXPECT_EQ(MinMax::max()->opposite(), MinMax::min()); } // Test MinMax minMax function -TEST_F(SdfSmokeTest, R5_MinMaxMinMaxFunc) { +TEST_F(SdfSmokeTest, MinMaxMinMaxFunc2) { EXPECT_FLOAT_EQ(MinMax::min()->minMax(3.0f, 5.0f), 3.0f); EXPECT_FLOAT_EQ(MinMax::min()->minMax(5.0f, 3.0f), 3.0f); EXPECT_FLOAT_EQ(MinMax::max()->minMax(3.0f, 5.0f), 5.0f); @@ -499,20 +499,20 @@ TEST_F(SdfSmokeTest, R5_MinMaxMinMaxFunc) { } // Test MinMax to_string -TEST_F(SdfSmokeTest, R5_MinMaxToString) { +TEST_F(SdfSmokeTest, MinMaxToString) { EXPECT_EQ(MinMax::min()->to_string(), "min"); EXPECT_EQ(MinMax::max()->to_string(), "max"); } // Test MinMaxAll to_string -TEST_F(SdfSmokeTest, R5_MinMaxAllToString) { +TEST_F(SdfSmokeTest, MinMaxAllToString) { EXPECT_EQ(MinMaxAll::min()->to_string(), "min"); EXPECT_EQ(MinMaxAll::max()->to_string(), "max"); EXPECT_EQ(MinMaxAll::all()->to_string(), "all"); } // Test MinMax initValueInt -TEST_F(SdfSmokeTest, R5_MinMaxInitValueInt) { +TEST_F(SdfSmokeTest, MinMaxInitValueInt) { // min's init value is a large positive integer EXPECT_GT(MinMax::min()->initValueInt(), 0); // max's init value is a large negative integer @@ -520,7 +520,7 @@ TEST_F(SdfSmokeTest, R5_MinMaxInitValueInt) { } // Test MinMaxAll rangeIndex -TEST_F(SdfSmokeTest, R5_MinMaxAllRangeIndex) { +TEST_F(SdfSmokeTest, MinMaxAllRangeIndex) { auto &min_range_idx = MinMaxAll::min()->rangeIndex(); EXPECT_EQ(min_range_idx.size(), 1u); EXPECT_EQ(min_range_idx[0], MinMax::minIndex()); @@ -535,7 +535,7 @@ TEST_F(SdfSmokeTest, R5_MinMaxAllRangeIndex) { // Test MinMax constructor coverage (exercises internal MinMax ctor) // Covers: MinMax::MinMax(const char*, int, float, int, compare_fn) -TEST_F(SdfSmokeTest, R6_MinMaxConstructorCoverage) { +TEST_F(SdfSmokeTest, MinMaxConstructorCoverage) { // The MinMax constructor is private; we verify it was called via singletons const MinMax *mn = MinMax::min(); EXPECT_STREQ(mn->to_string().c_str(), "min"); @@ -557,14 +557,14 @@ TEST_F(SdfSmokeTest, R6_MinMaxConstructorCoverage) { // Test MinMax minMax with equal values // Covers: MinMax::minMax edge case -TEST_F(SdfSmokeTest, R6_MinMaxMinMaxEqualValues) { +TEST_F(SdfSmokeTest, MinMaxMinMaxEqualValues) { EXPECT_FLOAT_EQ(MinMax::min()->minMax(5.0f, 5.0f), 5.0f); EXPECT_FLOAT_EQ(MinMax::max()->minMax(5.0f, 5.0f), 5.0f); } // Test MinMaxAll index values // Covers: MinMaxAll constructor internals -TEST_F(SdfSmokeTest, R6_MinMaxAllIndices) { +TEST_F(SdfSmokeTest, MinMaxAllIndices) { EXPECT_EQ(MinMaxAll::min()->index(), 0); EXPECT_EQ(MinMaxAll::max()->index(), 1); EXPECT_EQ(MinMaxAll::all()->index(), 2); @@ -572,14 +572,14 @@ TEST_F(SdfSmokeTest, R6_MinMaxAllIndices) { // Test MinMax find with nullptr // Covers: MinMax::find edge case -TEST_F(SdfSmokeTest, R6_MinMaxFindNull) { +TEST_F(SdfSmokeTest, MinMaxFindNull) { const MinMax *result = MinMax::find("invalid_string"); EXPECT_EQ(result, nullptr); } // Test RiseFall asRiseFallBoth // Covers: RiseFall::asRiseFallBoth -TEST_F(SdfSmokeTest, R6_RiseFallAsRiseFallBoth) { +TEST_F(SdfSmokeTest, RiseFallAsRiseFallBoth2) { const RiseFallBoth *rfb = RiseFall::rise()->asRiseFallBoth(); EXPECT_EQ(rfb, RiseFallBoth::rise()); rfb = RiseFall::fall()->asRiseFallBoth(); @@ -588,7 +588,7 @@ TEST_F(SdfSmokeTest, R6_RiseFallAsRiseFallBoth) { // Test Transition::riseFall matches all transitions // Covers: Transition::matches for riseFall wildcard -TEST_F(SdfSmokeTest, R6_TransitionRiseFallMatchesAll) { +TEST_F(SdfSmokeTest, TransitionRiseFallMatchesAll) { EXPECT_TRUE(Transition::riseFall()->matches(Transition::rise())); EXPECT_TRUE(Transition::riseFall()->matches(Transition::fall())); EXPECT_TRUE(Transition::riseFall()->matches(Transition::tr0Z())); @@ -605,21 +605,21 @@ TEST_F(SdfSmokeTest, R6_TransitionRiseFallMatchesAll) { // Test Transition::find with empty/unknown string // Covers: Transition::find edge case -TEST_F(SdfSmokeTest, R6_TransitionFindUnknown) { +TEST_F(SdfSmokeTest, TransitionFindUnknown) { const Transition *t = Transition::find("nonexistent"); EXPECT_EQ(t, nullptr); } // Test RiseFall::find with unknown string // Covers: RiseFall::find edge case -TEST_F(SdfSmokeTest, R6_RiseFallFindUnknown) { +TEST_F(SdfSmokeTest, RiseFallFindUnknown) { const RiseFall *rf = RiseFall::find("unknown"); EXPECT_EQ(rf, nullptr); } // Test Transition::maxIndex value // Covers: Transition::maxIndex -TEST_F(SdfSmokeTest, R6_TransitionMaxIndex) { +TEST_F(SdfSmokeTest, TransitionMaxIndex) { // Transition::maxIndex() returns the max valid index EXPECT_GE(Transition::maxIndex(), 1); // All transitions should have index <= maxIndex @@ -629,21 +629,21 @@ TEST_F(SdfSmokeTest, R6_TransitionMaxIndex) { // Test RiseFall to_string // Covers: RiseFall::to_string -TEST_F(SdfSmokeTest, R6_RiseFallToString) { +TEST_F(SdfSmokeTest, RiseFallToString) { EXPECT_EQ(RiseFall::rise()->to_string(), "^"); EXPECT_EQ(RiseFall::fall()->to_string(), "v"); } // Test MinMax compare with equal values // Covers: MinMax::compare edge case -TEST_F(SdfSmokeTest, R6_MinMaxCompareEqual) { +TEST_F(SdfSmokeTest, MinMaxCompareEqual) { EXPECT_FALSE(MinMax::min()->compare(5.0f, 5.0f)); EXPECT_FALSE(MinMax::max()->compare(5.0f, 5.0f)); } // Test MinMax compare with negative values // Covers: MinMax::compare with negatives -TEST_F(SdfSmokeTest, R6_MinMaxCompareNegative) { +TEST_F(SdfSmokeTest, MinMaxCompareNegative) { EXPECT_TRUE(MinMax::min()->compare(-2.0f, -1.0f)); EXPECT_FALSE(MinMax::min()->compare(-1.0f, -2.0f)); EXPECT_TRUE(MinMax::max()->compare(-1.0f, -2.0f)); @@ -652,7 +652,7 @@ TEST_F(SdfSmokeTest, R6_MinMaxCompareNegative) { // Test MinMax compare with zero // Covers: MinMax::compare with zero -TEST_F(SdfSmokeTest, R6_MinMaxCompareZero) { +TEST_F(SdfSmokeTest, MinMaxCompareZero) { EXPECT_TRUE(MinMax::min()->compare(0.0f, 1.0f)); EXPECT_FALSE(MinMax::min()->compare(0.0f, 0.0f)); EXPECT_TRUE(MinMax::max()->compare(1.0f, 0.0f)); @@ -661,7 +661,7 @@ TEST_F(SdfSmokeTest, R6_MinMaxCompareZero) { // Test MinMaxAll range sizes // Covers: MinMaxAll::range -TEST_F(SdfSmokeTest, R6_MinMaxAllRangeSizes) { +TEST_F(SdfSmokeTest, MinMaxAllRangeSizes) { EXPECT_EQ(MinMaxAll::min()->range().size(), 1u); EXPECT_EQ(MinMaxAll::max()->range().size(), 1u); EXPECT_EQ(MinMaxAll::all()->range().size(), 2u); @@ -669,7 +669,7 @@ TEST_F(SdfSmokeTest, R6_MinMaxAllRangeSizes) { // Test Transition sdfTripleIndex uniqueness // Covers: Transition::sdfTripleIndex -TEST_F(SdfSmokeTest, R6_TransitionSdfTripleIndexUnique) { +TEST_F(SdfSmokeTest, TransitionSdfTripleIndexUnique) { std::set indices; indices.insert(Transition::rise()->sdfTripleIndex()); indices.insert(Transition::fall()->sdfTripleIndex()); @@ -688,7 +688,7 @@ TEST_F(SdfSmokeTest, R6_TransitionSdfTripleIndexUnique) { // Test RiseFall range iteration // Covers: RiseFall::range -TEST_F(SdfSmokeTest, R6_RiseFallRangeIteration) { +TEST_F(SdfSmokeTest, RiseFallRangeIteration) { int count = 0; for (auto rf : RiseFall::range()) { EXPECT_NE(rf, nullptr); @@ -699,7 +699,7 @@ TEST_F(SdfSmokeTest, R6_RiseFallRangeIteration) { // Test MinMax range // Covers: MinMax::range -TEST_F(SdfSmokeTest, R6_MinMaxRangeIteration) { +TEST_F(SdfSmokeTest, MinMaxRangeIteration) { int count = 0; for (auto mm : MinMax::range()) { EXPECT_NE(mm, nullptr); @@ -710,14 +710,14 @@ TEST_F(SdfSmokeTest, R6_MinMaxRangeIteration) { // Test RiseFallBoth find with nullptr // Covers: RiseFallBoth::find edge case -TEST_F(SdfSmokeTest, R6_RiseFallBothFindNull) { +TEST_F(SdfSmokeTest, RiseFallBothFindNull) { const RiseFallBoth *result = RiseFallBoth::find("nonexistent"); EXPECT_EQ(result, nullptr); } // Test Transition asRiseFallBoth for non-rise/fall transitions // Covers: Transition::asRiseFallBoth edge cases -TEST_F(SdfSmokeTest, R6_TransitionAsRiseFallBothTristate) { +TEST_F(SdfSmokeTest, TransitionAsRiseFallBothTristate) { // Tristate transitions should still return valid RiseFallBoth const RiseFallBoth *rfb_0z = Transition::tr0Z()->asRiseFallBoth(); EXPECT_NE(rfb_0z, nullptr); @@ -725,7 +725,7 @@ TEST_F(SdfSmokeTest, R6_TransitionAsRiseFallBothTristate) { // Test Transition to_string for riseFall wildcard // Covers: Transition::to_string for riseFall -TEST_F(SdfSmokeTest, R6_TransitionRiseFallToString) { +TEST_F(SdfSmokeTest, TransitionRiseFallToString) { EXPECT_FALSE(Transition::riseFall()->to_string().empty()); } @@ -816,7 +816,7 @@ protected: // Covers: SdfWriter::~SdfWriter, SdfWriter::writeTrailer, // SdfWriter::writeInstTrailer, SdfWriter::writeTimingCheckHeader, // SdfWriter::writeTimingCheckTrailer, SdfWriter::sdfEdge -TEST_F(SdfDesignTest, R8_WriteSdfExercisesWriter) { +TEST_F(SdfDesignTest, WriteSdfExercisesWriter) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -843,7 +843,7 @@ TEST_F(SdfDesignTest, R8_WriteSdfExercisesWriter) { // Test writeSdf with gzip // Covers: SdfWriter methods through gzip path -TEST_F(SdfDesignTest, R8_WriteSdfGzip) { +TEST_F(SdfDesignTest, WriteSdfGzip) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -871,7 +871,7 @@ TEST_F(SdfDesignTest, R8_WriteSdfGzip) { // Test writeSdf with dot divider // Covers: SdfWriter path separator handling -TEST_F(SdfDesignTest, R9_WriteSdfDotDivider) { +TEST_F(SdfDesignTest, WriteSdfDotDivider) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -893,7 +893,7 @@ TEST_F(SdfDesignTest, R9_WriteSdfDotDivider) { // Test writeSdf without typ values // Covers: SdfWriter min/max only path -TEST_F(SdfDesignTest, R9_WriteSdfNoTyp) { +TEST_F(SdfDesignTest, WriteSdfNoTyp) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -915,7 +915,7 @@ TEST_F(SdfDesignTest, R9_WriteSdfNoTyp) { // Test writeSdf with high precision // Covers: SdfWriter digit formatting -TEST_F(SdfDesignTest, R9_WriteSdfHighPrecision) { +TEST_F(SdfDesignTest, WriteSdfHighPrecision) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -937,7 +937,7 @@ TEST_F(SdfDesignTest, R9_WriteSdfHighPrecision) { // Test writeSdf with no_timestamp // Covers: SdfWriter header control -TEST_F(SdfDesignTest, R9_WriteSdfNoTimestamp) { +TEST_F(SdfDesignTest, WriteSdfNoTimestamp) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -959,7 +959,7 @@ TEST_F(SdfDesignTest, R9_WriteSdfNoTimestamp) { // Test writeSdf with no_timescale // Covers: SdfWriter timescale control -TEST_F(SdfDesignTest, R9_WriteSdfNoTimescale) { +TEST_F(SdfDesignTest, WriteSdfNoTimescale) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -981,7 +981,7 @@ TEST_F(SdfDesignTest, R9_WriteSdfNoTimescale) { // Test writeSdf and readSdf round-trip // Covers: readSdf, SdfReader constructor, SdfScanner, SdfPortSpec, SdfTriple -TEST_F(SdfDesignTest, R9_WriteThenReadSdf) { +TEST_F(SdfDesignTest, WriteThenReadSdf) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1002,7 +1002,7 @@ TEST_F(SdfDesignTest, R9_WriteThenReadSdf) { // Test readSdf with unescaped_dividers option // Covers: SdfReader unescaped divider path -TEST_F(SdfDesignTest, R9_ReadSdfUnescapedDividers) { +TEST_F(SdfDesignTest, ReadSdfUnescapedDividers) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1022,7 +1022,7 @@ TEST_F(SdfDesignTest, R9_ReadSdfUnescapedDividers) { // Test readSdf with incremental_only option // Covers: SdfReader incremental_only path -TEST_F(SdfDesignTest, R9_ReadSdfIncrementalOnly) { +TEST_F(SdfDesignTest, ReadSdfIncrementalOnly) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1042,7 +1042,7 @@ TEST_F(SdfDesignTest, R9_ReadSdfIncrementalOnly) { // Test readSdf with cond_use min // Covers: SdfReader cond_use min path -TEST_F(SdfDesignTest, R9_ReadSdfCondUseMin) { +TEST_F(SdfDesignTest, ReadSdfCondUseMin) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1062,7 +1062,7 @@ TEST_F(SdfDesignTest, R9_ReadSdfCondUseMin) { // Test readSdf with cond_use max // Covers: SdfReader cond_use max path -TEST_F(SdfDesignTest, R9_ReadSdfCondUseMax) { +TEST_F(SdfDesignTest, ReadSdfCondUseMax) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1082,7 +1082,7 @@ TEST_F(SdfDesignTest, R9_ReadSdfCondUseMax) { // Test writeSdf then read with both unescaped and incremental // Covers: combined SdfReader option paths -TEST_F(SdfDesignTest, R9_ReadSdfCombinedOptions) { +TEST_F(SdfDesignTest, ReadSdfCombinedOptions) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1102,7 +1102,7 @@ TEST_F(SdfDesignTest, R9_ReadSdfCombinedOptions) { // Test writeSdf with low precision (1 digit) // Covers: SdfWriter digit formatting edge case -TEST_F(SdfDesignTest, R9_WriteSdfLowPrecision) { +TEST_F(SdfDesignTest, WriteSdfLowPrecision) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1124,7 +1124,7 @@ TEST_F(SdfDesignTest, R9_WriteSdfLowPrecision) { // Test writeSdf gzip then readSdf // Covers: SdfReader gzip input path -TEST_F(SdfDesignTest, R9_WriteSdfGzipThenRead) { +TEST_F(SdfDesignTest, WriteSdfGzipThenRead) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1144,7 +1144,7 @@ TEST_F(SdfDesignTest, R9_WriteSdfGzipThenRead) { // Test writeSdf with no_timestamp and no_timescale // Covers: SdfWriter combined header options -TEST_F(SdfDesignTest, R9_WriteSdfNoTimestampNoTimescale) { +TEST_F(SdfDesignTest, WriteSdfNoTimestampNoTimescale) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1166,7 +1166,7 @@ TEST_F(SdfDesignTest, R9_WriteSdfNoTimestampNoTimescale) { // Test readSdf with nonexistent file throws FileNotReadable // Covers: SdfReader error handling path -TEST_F(SdfDesignTest, R9_ReadSdfNonexistent) { +TEST_F(SdfDesignTest, ReadSdfNonexistent) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1180,7 +1180,7 @@ TEST_F(SdfDesignTest, R9_ReadSdfNonexistent) { } // R9_ SdfSmokeTest - Transition properties for SDF -TEST_F(SdfSmokeTest, R9_TransitionRiseProperties) { +TEST_F(SdfSmokeTest, TransitionRiseProperties) { const Transition *t = Transition::rise(); EXPECT_NE(t, nullptr); EXPECT_EQ(t->asRiseFall(), RiseFall::rise()); @@ -1189,7 +1189,7 @@ TEST_F(SdfSmokeTest, R9_TransitionRiseProperties) { EXPECT_NE(t->asInitFinalString(), nullptr); } -TEST_F(SdfSmokeTest, R9_TransitionFallProperties) { +TEST_F(SdfSmokeTest, TransitionFallProperties) { const Transition *t = Transition::fall(); EXPECT_NE(t, nullptr); EXPECT_EQ(t->asRiseFall(), RiseFall::fall()); @@ -1198,7 +1198,7 @@ TEST_F(SdfSmokeTest, R9_TransitionFallProperties) { EXPECT_NE(t->asInitFinalString(), nullptr); } -TEST_F(SdfSmokeTest, R9_TransitionTristateProperties) { +TEST_F(SdfSmokeTest, TransitionTristateProperties) { // 0Z const Transition *t0z = Transition::tr0Z(); EXPECT_NE(t0z, nullptr); @@ -1221,7 +1221,7 @@ TEST_F(SdfSmokeTest, R9_TransitionTristateProperties) { EXPECT_NE(tz0->asRiseFallBoth(), nullptr); } -TEST_F(SdfSmokeTest, R9_TransitionUnknownProperties) { +TEST_F(SdfSmokeTest, TransitionUnknownProperties) { // 0X const Transition *t0x = Transition::tr0X(); EXPECT_NE(t0x, nullptr); @@ -1243,7 +1243,7 @@ TEST_F(SdfSmokeTest, R9_TransitionUnknownProperties) { EXPECT_NE(tx0->asRiseFallBoth(), nullptr); } -TEST_F(SdfSmokeTest, R9_TransitionHighZUnknown) { +TEST_F(SdfSmokeTest, TransitionHighZUnknown) { // XZ const Transition *txz = Transition::trXZ(); EXPECT_NE(txz, nullptr); @@ -1255,7 +1255,7 @@ TEST_F(SdfSmokeTest, R9_TransitionHighZUnknown) { EXPECT_FALSE(tzx->to_string().empty()); } -TEST_F(SdfSmokeTest, R9_RiseFallBothRiseFallMatches) { +TEST_F(SdfSmokeTest, RiseFallBothRiseFallMatches) { EXPECT_TRUE(RiseFallBoth::riseFall()->matches(RiseFall::rise())); EXPECT_TRUE(RiseFallBoth::riseFall()->matches(RiseFall::fall())); EXPECT_TRUE(RiseFallBoth::rise()->matches(RiseFall::rise())); @@ -1264,7 +1264,7 @@ TEST_F(SdfSmokeTest, R9_RiseFallBothRiseFallMatches) { EXPECT_TRUE(RiseFallBoth::fall()->matches(RiseFall::fall())); } -TEST_F(SdfSmokeTest, R9_MinMaxAllRange) { +TEST_F(SdfSmokeTest, MinMaxAllRange2) { // Verify MinMaxAll::all() range contains both min and max int count = 0; for (auto mm : MinMaxAll::all()->range()) { @@ -1274,7 +1274,7 @@ TEST_F(SdfSmokeTest, R9_MinMaxAllRange) { EXPECT_EQ(count, 2); } -TEST_F(SdfSmokeTest, R9_MinMaxInitValue) { +TEST_F(SdfSmokeTest, MinMaxInitValue2) { // min init value is large positive (for finding minimum) float min_init = MinMax::min()->initValue(); EXPECT_GT(min_init, 0.0f); @@ -1284,7 +1284,7 @@ TEST_F(SdfSmokeTest, R9_MinMaxInitValue) { EXPECT_LT(max_init, 0.0f); } -TEST_F(SdfSmokeTest, R9_MinMaxCompareExtremes) { +TEST_F(SdfSmokeTest, MinMaxCompareExtremes) { // Very large values EXPECT_TRUE(MinMax::min()->compare(1e10f, 1e20f)); EXPECT_FALSE(MinMax::min()->compare(1e20f, 1e10f)); @@ -1296,7 +1296,7 @@ TEST_F(SdfSmokeTest, R9_MinMaxCompareExtremes) { EXPECT_TRUE(MinMax::max()->compare(1e-10f, 1e-20f)); } -TEST_F(SdfSmokeTest, R9_RiseFallToStringAndFind) { +TEST_F(SdfSmokeTest, RiseFallToStringAndFind) { EXPECT_EQ(RiseFall::rise()->to_string(), "^"); EXPECT_EQ(RiseFall::fall()->to_string(), "v"); EXPECT_EQ(RiseFall::find("^"), RiseFall::rise()); @@ -1305,44 +1305,44 @@ TEST_F(SdfSmokeTest, R9_RiseFallToStringAndFind) { EXPECT_EQ(RiseFall::find("fall"), RiseFall::fall()); } -TEST_F(SdfSmokeTest, R9_TransitionFindByName) { +TEST_F(SdfSmokeTest, TransitionFindByName) { EXPECT_EQ(Transition::find("^"), Transition::rise()); EXPECT_EQ(Transition::find("v"), Transition::fall()); EXPECT_EQ(Transition::find("nonexistent"), nullptr); } -TEST_F(SdfSmokeTest, R9_MinMaxAllAsMinMax) { +TEST_F(SdfSmokeTest, MinMaxAllAsMinMax2) { EXPECT_EQ(MinMaxAll::min()->asMinMax(), MinMax::min()); EXPECT_EQ(MinMaxAll::max()->asMinMax(), MinMax::max()); } -TEST_F(SdfSmokeTest, R9_RiseFallOpposite) { +TEST_F(SdfSmokeTest, RiseFallOpposite2) { EXPECT_EQ(RiseFall::rise()->opposite(), RiseFall::fall()); EXPECT_EQ(RiseFall::fall()->opposite(), RiseFall::rise()); } -TEST_F(SdfSmokeTest, R9_TransitionMatchesSelf) { +TEST_F(SdfSmokeTest, TransitionMatchesSelf2) { EXPECT_TRUE(Transition::rise()->matches(Transition::rise())); EXPECT_TRUE(Transition::fall()->matches(Transition::fall())); EXPECT_FALSE(Transition::rise()->matches(Transition::fall())); EXPECT_FALSE(Transition::fall()->matches(Transition::rise())); } -TEST_F(SdfSmokeTest, R9_TransitionMatchesRiseFallWildcard) { +TEST_F(SdfSmokeTest, TransitionMatchesRiseFallWildcard) { EXPECT_TRUE(Transition::riseFall()->matches(Transition::rise())); EXPECT_TRUE(Transition::riseFall()->matches(Transition::fall())); EXPECT_TRUE(Transition::riseFall()->matches(Transition::tr0Z())); EXPECT_TRUE(Transition::riseFall()->matches(Transition::trXZ())); } -TEST_F(SdfSmokeTest, R9_MinMaxMinMaxFunc) { +TEST_F(SdfSmokeTest, MinMaxMinMaxFunc3) { EXPECT_FLOAT_EQ(MinMax::min()->minMax(10.0f, 20.0f), 10.0f); EXPECT_FLOAT_EQ(MinMax::max()->minMax(10.0f, 20.0f), 20.0f); EXPECT_FLOAT_EQ(MinMax::min()->minMax(-5.0f, 5.0f), -5.0f); EXPECT_FLOAT_EQ(MinMax::max()->minMax(-5.0f, 5.0f), 5.0f); } -TEST_F(SdfSmokeTest, R9_RiseFallBothFind) { +TEST_F(SdfSmokeTest, RiseFallBothFind) { EXPECT_EQ(RiseFallBoth::find("rise"), RiseFallBoth::rise()); EXPECT_EQ(RiseFallBoth::find("fall"), RiseFallBoth::fall()); EXPECT_EQ(RiseFallBoth::find("rise_fall"), RiseFallBoth::riseFall()); @@ -1355,7 +1355,7 @@ TEST_F(SdfSmokeTest, R9_RiseFallBothFind) { // R11_1: Write SDF then read it with a path argument // Covers: SdfReader with path set, SdfTriple construction paths -TEST_F(SdfDesignTest, R11_ReadSdfWithPath) { +TEST_F(SdfDesignTest, ReadSdfWithPath) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1376,7 +1376,7 @@ TEST_F(SdfDesignTest, R11_ReadSdfWithPath) { // R11_2: Read a hand-crafted SDF with specific constructs to exercise // SdfReader::makeTriple(), makeTriple(float), SdfPortSpec, SdfTriple::hasValue -TEST_F(SdfDesignTest, R11_ReadHandCraftedSdf) { +TEST_F(SdfDesignTest, ReadHandCraftedSdf) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1417,7 +1417,7 @@ TEST_F(SdfDesignTest, R11_ReadHandCraftedSdf) { // R11_3: Read SDF with edge-specific IOPATH (posedge, negedge) // Covers: SdfPortSpec with transitions, sdfEdge paths -TEST_F(SdfDesignTest, R11_ReadSdfEdgeIopath) { +TEST_F(SdfDesignTest, ReadSdfEdgeIopath) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1454,7 +1454,7 @@ TEST_F(SdfDesignTest, R11_ReadSdfEdgeIopath) { // R11_4: Read SDF with SETUPHOLD combined check // Covers: SdfReader::timingCheckSetupHold path -TEST_F(SdfDesignTest, R11_ReadSdfSetupHold) { +TEST_F(SdfDesignTest, ReadSdfSetupHold) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1488,7 +1488,7 @@ TEST_F(SdfDesignTest, R11_ReadSdfSetupHold) { // R11_5: Read SDF with RECREM combined check // Covers: SdfReader::timingCheckRecRem path -TEST_F(SdfDesignTest, R11_ReadSdfRecRem) { +TEST_F(SdfDesignTest, ReadSdfRecRem) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1522,7 +1522,7 @@ TEST_F(SdfDesignTest, R11_ReadSdfRecRem) { // R11_6: Read SDF with WIDTH check // Covers: SdfReader::timingCheckWidth path -TEST_F(SdfDesignTest, R11_ReadSdfWidth) { +TEST_F(SdfDesignTest, ReadSdfWidth) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1556,7 +1556,7 @@ TEST_F(SdfDesignTest, R11_ReadSdfWidth) { // R11_7: Read SDF with PERIOD check // Covers: SdfReader::timingCheckPeriod path -TEST_F(SdfDesignTest, R11_ReadSdfPeriod) { +TEST_F(SdfDesignTest, ReadSdfPeriod) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1591,7 +1591,7 @@ TEST_F(SdfDesignTest, R11_ReadSdfPeriod) { // R11_8: Read SDF with NOCHANGE check // Covers: SdfReader::timingCheckNochange, notSupported // NOCHANGE is not supported and throws, so we catch the exception -TEST_F(SdfDesignTest, R11_ReadSdfNochange) { +TEST_F(SdfDesignTest, ReadSdfNochange) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1628,7 +1628,7 @@ TEST_F(SdfDesignTest, R11_ReadSdfNochange) { // R11_9: Read SDF with INTERCONNECT delay // Covers: SdfReader::interconnect path -TEST_F(SdfDesignTest, R11_ReadSdfInterconnect) { +TEST_F(SdfDesignTest, ReadSdfInterconnect) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -1664,7 +1664,7 @@ TEST_F(SdfDesignTest, R11_ReadSdfInterconnect) { // R11_10: WriteSdf with include_typ=true and no_version=false to cover // the writeHeader path with version -TEST_F(SdfDesignTest, R11_WriteSdfWithVersion) { +TEST_F(SdfDesignTest, WriteSdfWithVersion) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); diff --git a/search/test/cpp/TestSearch.cc b/search/test/cpp/TestSearch.cc index a3135fe3..111e3605 100644 --- a/search/test/cpp/TestSearch.cc +++ b/search/test/cpp/TestSearch.cc @@ -5708,337 +5708,337 @@ TEST_F(StaInitTest, StaGlobalSingleton3) { // === Sta.cc simple getters/setters (no network required) === -TEST_F(StaInitTest, R4_StaArrivalsInvalid) { +TEST_F(StaInitTest, StaArrivalsInvalid2) { sta_->arrivalsInvalid(); } -TEST_F(StaInitTest, R4_StaBidirectInstPathsEnabled) { +TEST_F(StaInitTest, StaBidirectInstPathsEnabled2) { bool val = sta_->bidirectInstPathsEnabled(); (void)val; } -TEST_F(StaInitTest, R4_StaBidirectNetPathsEnabled) { +TEST_F(StaInitTest, StaBidirectNetPathsEnabled2) { bool val = sta_->bidirectNetPathsEnabled(); (void)val; } -TEST_F(StaInitTest, R4_StaClkThruTristateEnabled) { +TEST_F(StaInitTest, StaClkThruTristateEnabled2) { bool val = sta_->clkThruTristateEnabled(); (void)val; } -TEST_F(StaInitTest, R4_StaCmdCornerConst) { +TEST_F(StaInitTest, StaCmdCornerConst) { const Sta *csta = sta_; Corner *c = csta->cmdCorner(); EXPECT_NE(c, nullptr); } -TEST_F(StaInitTest, R4_StaCmdNamespace) { +TEST_F(StaInitTest, StaCmdNamespace2) { CmdNamespace ns = sta_->cmdNamespace(); (void)ns; } -TEST_F(StaInitTest, R4_StaCondDefaultArcsEnabled) { +TEST_F(StaInitTest, StaCondDefaultArcsEnabled2) { bool val = sta_->condDefaultArcsEnabled(); (void)val; } -TEST_F(StaInitTest, R4_StaCrprEnabled) { +TEST_F(StaInitTest, StaCrprEnabled2) { bool val = sta_->crprEnabled(); (void)val; } -TEST_F(StaInitTest, R4_StaCrprMode) { +TEST_F(StaInitTest, StaCrprMode) { CrprMode mode = sta_->crprMode(); (void)mode; } -TEST_F(StaInitTest, R4_StaCurrentInstance) { +TEST_F(StaInitTest, StaCurrentInstance2) { Instance *inst = sta_->currentInstance(); // Without network linked, returns nullptr (void)inst; } -TEST_F(StaInitTest, R4_StaDefaultThreadCount) { +TEST_F(StaInitTest, StaDefaultThreadCount2) { int tc = sta_->defaultThreadCount(); EXPECT_GE(tc, 1); } -TEST_F(StaInitTest, R4_StaDelaysInvalid) { +TEST_F(StaInitTest, StaDelaysInvalid2) { sta_->delaysInvalid(); // void return } -TEST_F(StaInitTest, R4_StaDynamicLoopBreaking) { +TEST_F(StaInitTest, StaDynamicLoopBreaking) { bool val = sta_->dynamicLoopBreaking(); (void)val; } -TEST_F(StaInitTest, R4_StaGatedClkChecksEnabled) { +TEST_F(StaInitTest, StaGatedClkChecksEnabled2) { bool val = sta_->gatedClkChecksEnabled(); (void)val; } -TEST_F(StaInitTest, R4_StaMultiCorner) { +TEST_F(StaInitTest, StaMultiCorner2) { bool val = sta_->multiCorner(); (void)val; } -TEST_F(StaInitTest, R4_StaPocvEnabled) { +TEST_F(StaInitTest, StaPocvEnabled) { bool val = sta_->pocvEnabled(); (void)val; } -TEST_F(StaInitTest, R4_StaPresetClrArcsEnabled) { +TEST_F(StaInitTest, StaPresetClrArcsEnabled2) { bool val = sta_->presetClrArcsEnabled(); (void)val; } -TEST_F(StaInitTest, R4_StaPropagateAllClocks) { +TEST_F(StaInitTest, StaPropagateAllClocks2) { bool val = sta_->propagateAllClocks(); (void)val; } -TEST_F(StaInitTest, R4_StaPropagateGatedClockEnable) { +TEST_F(StaInitTest, StaPropagateGatedClockEnable2) { bool val = sta_->propagateGatedClockEnable(); (void)val; } -TEST_F(StaInitTest, R4_StaRecoveryRemovalChecksEnabled) { +TEST_F(StaInitTest, StaRecoveryRemovalChecksEnabled2) { bool val = sta_->recoveryRemovalChecksEnabled(); (void)val; } -TEST_F(StaInitTest, R4_StaUseDefaultArrivalClock) { +TEST_F(StaInitTest, StaUseDefaultArrivalClock) { bool val = sta_->useDefaultArrivalClock(); (void)val; } -TEST_F(StaInitTest, R4_StaTagCount) { +TEST_F(StaInitTest, StaTagCount2) { int tc = sta_->tagCount(); (void)tc; } -TEST_F(StaInitTest, R4_StaTagGroupCount) { +TEST_F(StaInitTest, StaTagGroupCount2) { int tgc = sta_->tagGroupCount(); (void)tgc; } -TEST_F(StaInitTest, R4_StaClkInfoCount) { +TEST_F(StaInitTest, StaClkInfoCount2) { int cnt = sta_->clkInfoCount(); (void)cnt; } // === Sta.cc simple setters (no network required) === -TEST_F(StaInitTest, R4_StaSetBidirectInstPathsEnabled) { +TEST_F(StaInitTest, StaSetBidirectInstPathsEnabled2) { sta_->setBidirectInstPathsEnabled(true); EXPECT_TRUE(sta_->bidirectInstPathsEnabled()); sta_->setBidirectInstPathsEnabled(false); EXPECT_FALSE(sta_->bidirectInstPathsEnabled()); } -TEST_F(StaInitTest, R4_StaSetBidirectNetPathsEnabled) { +TEST_F(StaInitTest, StaSetBidirectNetPathsEnabled2) { sta_->setBidirectNetPathsEnabled(true); EXPECT_TRUE(sta_->bidirectNetPathsEnabled()); sta_->setBidirectNetPathsEnabled(false); EXPECT_FALSE(sta_->bidirectNetPathsEnabled()); } -TEST_F(StaInitTest, R4_StaSetClkThruTristateEnabled) { +TEST_F(StaInitTest, StaSetClkThruTristateEnabled2) { sta_->setClkThruTristateEnabled(true); EXPECT_TRUE(sta_->clkThruTristateEnabled()); sta_->setClkThruTristateEnabled(false); } -TEST_F(StaInitTest, R4_StaSetCondDefaultArcsEnabled) { +TEST_F(StaInitTest, StaSetCondDefaultArcsEnabled2) { sta_->setCondDefaultArcsEnabled(true); EXPECT_TRUE(sta_->condDefaultArcsEnabled()); sta_->setCondDefaultArcsEnabled(false); } -TEST_F(StaInitTest, R4_StaSetCrprEnabled) { +TEST_F(StaInitTest, StaSetCrprEnabled2) { sta_->setCrprEnabled(true); EXPECT_TRUE(sta_->crprEnabled()); sta_->setCrprEnabled(false); } -TEST_F(StaInitTest, R4_StaSetDynamicLoopBreaking) { +TEST_F(StaInitTest, StaSetDynamicLoopBreaking) { sta_->setDynamicLoopBreaking(true); EXPECT_TRUE(sta_->dynamicLoopBreaking()); sta_->setDynamicLoopBreaking(false); } -TEST_F(StaInitTest, R4_StaSetGatedClkChecksEnabled) { +TEST_F(StaInitTest, StaSetGatedClkChecksEnabled2) { sta_->setGatedClkChecksEnabled(true); EXPECT_TRUE(sta_->gatedClkChecksEnabled()); sta_->setGatedClkChecksEnabled(false); } -TEST_F(StaInitTest, R4_StaSetPocvEnabled) { +TEST_F(StaInitTest, StaSetPocvEnabled2) { sta_->setPocvEnabled(true); EXPECT_TRUE(sta_->pocvEnabled()); sta_->setPocvEnabled(false); } -TEST_F(StaInitTest, R4_StaSetPresetClrArcsEnabled) { +TEST_F(StaInitTest, StaSetPresetClrArcsEnabled2) { sta_->setPresetClrArcsEnabled(true); EXPECT_TRUE(sta_->presetClrArcsEnabled()); sta_->setPresetClrArcsEnabled(false); } -TEST_F(StaInitTest, R4_StaSetPropagateAllClocks) { +TEST_F(StaInitTest, StaSetPropagateAllClocks2) { sta_->setPropagateAllClocks(true); EXPECT_TRUE(sta_->propagateAllClocks()); sta_->setPropagateAllClocks(false); } -TEST_F(StaInitTest, R4_StaSetPropagateGatedClockEnable) { +TEST_F(StaInitTest, StaSetPropagateGatedClockEnable2) { sta_->setPropagateGatedClockEnable(true); EXPECT_TRUE(sta_->propagateGatedClockEnable()); sta_->setPropagateGatedClockEnable(false); } -TEST_F(StaInitTest, R4_StaSetRecoveryRemovalChecksEnabled) { +TEST_F(StaInitTest, StaSetRecoveryRemovalChecksEnabled2) { sta_->setRecoveryRemovalChecksEnabled(true); EXPECT_TRUE(sta_->recoveryRemovalChecksEnabled()); sta_->setRecoveryRemovalChecksEnabled(false); } -TEST_F(StaInitTest, R4_StaSetUseDefaultArrivalClock) { +TEST_F(StaInitTest, StaSetUseDefaultArrivalClock) { sta_->setUseDefaultArrivalClock(true); EXPECT_TRUE(sta_->useDefaultArrivalClock()); sta_->setUseDefaultArrivalClock(false); } -TEST_F(StaInitTest, R4_StaSetIncrementalDelayTolerance) { +TEST_F(StaInitTest, StaSetIncrementalDelayTolerance) { sta_->setIncrementalDelayTolerance(0.5f); } -TEST_F(StaInitTest, R4_StaSetSigmaFactor) { +TEST_F(StaInitTest, StaSetSigmaFactor2) { sta_->setSigmaFactor(1.5f); } -TEST_F(StaInitTest, R4_StaSetReportPathDigits) { +TEST_F(StaInitTest, StaSetReportPathDigits) { sta_->setReportPathDigits(4); } -TEST_F(StaInitTest, R4_StaSetReportPathFormat) { +TEST_F(StaInitTest, StaSetReportPathFormat) { sta_->setReportPathFormat(ReportPathFormat::full); } -TEST_F(StaInitTest, R4_StaSetReportPathNoSplit) { +TEST_F(StaInitTest, StaSetReportPathNoSplit) { sta_->setReportPathNoSplit(true); sta_->setReportPathNoSplit(false); } -TEST_F(StaInitTest, R4_StaSetReportPathSigmas) { +TEST_F(StaInitTest, StaSetReportPathSigmas) { sta_->setReportPathSigmas(true); sta_->setReportPathSigmas(false); } -TEST_F(StaInitTest, R4_StaSetMaxArea) { +TEST_F(StaInitTest, StaSetMaxArea) { sta_->setMaxArea(100.0f); } -TEST_F(StaInitTest, R4_StaSetWireloadMode) { +TEST_F(StaInitTest, StaSetWireloadMode2) { sta_->setWireloadMode(WireloadMode::top); } -TEST_F(StaInitTest, R4_StaSetThreadCount) { +TEST_F(StaInitTest, StaSetThreadCount2) { sta_->setThreadCount(1); } // setThreadCount1 is protected, skip -TEST_F(StaInitTest, R4_StaConstraintsChanged) { +TEST_F(StaInitTest, StaConstraintsChanged2) { sta_->constraintsChanged(); } -TEST_F(StaInitTest, R4_StaDeleteParasitics) { +TEST_F(StaInitTest, StaDeleteParasitics3) { sta_->deleteParasitics(); } // networkCmdEdit is protected, skip -TEST_F(StaInitTest, R4_StaClearLogicConstants) { +TEST_F(StaInitTest, StaClearLogicConstants3) { sta_->clearLogicConstants(); } -TEST_F(StaInitTest, R4_StaRemoveDelaySlewAnnotations) { +TEST_F(StaInitTest, StaRemoveDelaySlewAnnotations2) { sta_->removeDelaySlewAnnotations(); } -TEST_F(StaInitTest, R4_StaRemoveNetLoadCaps) { +TEST_F(StaInitTest, StaRemoveNetLoadCaps2) { sta_->removeNetLoadCaps(); } -TEST_F(StaInitTest, R4_StaClkPinsInvalid) { +TEST_F(StaInitTest, StaClkPinsInvalid3) { sta_->clkPinsInvalid(); } // disableAfter is protected, skip -TEST_F(StaInitTest, R4_StaNetworkChanged) { +TEST_F(StaInitTest, StaNetworkChanged2) { sta_->networkChanged(); } -TEST_F(StaInitTest, R4_StaUnsetTimingDerate) { +TEST_F(StaInitTest, StaUnsetTimingDerate2) { sta_->unsetTimingDerate(); } -TEST_F(StaInitTest, R4_StaSetCmdNamespace) { +TEST_F(StaInitTest, StaSetCmdNamespace) { sta_->setCmdNamespace(CmdNamespace::sdc); } -TEST_F(StaInitTest, R4_StaSetCmdCorner) { +TEST_F(StaInitTest, StaSetCmdCorner2) { Corner *corner = sta_->cmdCorner(); sta_->setCmdCorner(corner); } // === Sta.cc: functions that call ensureLinked/ensureGraph (throw Exception) === -TEST_F(StaInitTest, R4_StaStartpointPinsThrows) { +TEST_F(StaInitTest, StaStartpointPinsThrows) { EXPECT_THROW(sta_->startpointPins(), Exception); } -TEST_F(StaInitTest, R4_StaEndpointsThrows) { +TEST_F(StaInitTest, StaEndpointsThrows) { EXPECT_THROW(sta_->endpoints(), Exception); } -TEST_F(StaInitTest, R4_StaEndpointPinsThrows) { +TEST_F(StaInitTest, StaEndpointPinsThrows) { EXPECT_THROW(sta_->endpointPins(), Exception); } -TEST_F(StaInitTest, R4_StaNetSlackThrows) { +TEST_F(StaInitTest, StaNetSlackThrows) { EXPECT_THROW(sta_->netSlack(static_cast(nullptr), MinMax::max()), Exception); } -TEST_F(StaInitTest, R4_StaPinSlackRfThrows) { +TEST_F(StaInitTest, StaPinSlackRfThrows) { EXPECT_THROW(sta_->pinSlack(static_cast(nullptr), RiseFall::rise(), MinMax::max()), Exception); } -TEST_F(StaInitTest, R4_StaPinSlackThrows) { +TEST_F(StaInitTest, StaPinSlackThrows) { EXPECT_THROW(sta_->pinSlack(static_cast(nullptr), MinMax::max()), Exception); } -TEST_F(StaInitTest, R4_StaEndpointSlackThrows) { +TEST_F(StaInitTest, StaEndpointSlackThrows) { std::string group_name("default"); EXPECT_THROW(sta_->endpointSlack(static_cast(nullptr), group_name, MinMax::max()), Exception); } -TEST_F(StaInitTest, R4_StaGraphLoopsThrows) { +TEST_F(StaInitTest, StaGraphLoopsThrows) { EXPECT_THROW(sta_->graphLoops(), Exception); } -TEST_F(StaInitTest, R4_StaVertexLevelThrows) { +TEST_F(StaInitTest, StaVertexLevelThrows) { EXPECT_THROW(sta_->vertexLevel(nullptr), Exception); } -TEST_F(StaInitTest, R4_StaFindLogicConstantsThrows2) { +TEST_F(StaInitTest, StaFindLogicConstantsThrows2) { EXPECT_THROW(sta_->findLogicConstants(), Exception); } -TEST_F(StaInitTest, R4_StaEnsureClkNetworkThrows) { +TEST_F(StaInitTest, StaEnsureClkNetworkThrows) { EXPECT_THROW(sta_->ensureClkNetwork(), Exception); } @@ -6046,23 +6046,23 @@ TEST_F(StaInitTest, R4_StaEnsureClkNetworkThrows) { // delayCalcPreamble is protected, skip -TEST_F(StaInitTest, R4_StaFindDelaysThrows) { +TEST_F(StaInitTest, StaFindDelaysThrows) { EXPECT_THROW(sta_->findDelays(), Exception); } -TEST_F(StaInitTest, R4_StaFindRequiredsThrows) { +TEST_F(StaInitTest, StaFindRequiredsThrows) { EXPECT_THROW(sta_->findRequireds(), Exception); } -TEST_F(StaInitTest, R4_StaEnsureLinkedThrows) { +TEST_F(StaInitTest, StaEnsureLinkedThrows) { EXPECT_THROW(sta_->ensureLinked(), Exception); } -TEST_F(StaInitTest, R4_StaEnsureGraphThrows) { +TEST_F(StaInitTest, StaEnsureGraphThrows) { EXPECT_THROW(sta_->ensureGraph(), Exception); } -TEST_F(StaInitTest, R4_StaEnsureLevelizedThrows) { +TEST_F(StaInitTest, StaEnsureLevelizedThrows) { EXPECT_THROW(sta_->ensureLevelized(), Exception); } @@ -6070,59 +6070,59 @@ TEST_F(StaInitTest, R4_StaEnsureLevelizedThrows) { // sdcChangedGraph is protected, skip -TEST_F(StaInitTest, R4_StaFindFaninPinsThrows) { +TEST_F(StaInitTest, StaFindFaninPinsThrows2) { EXPECT_THROW(sta_->findFaninPins(static_cast*>(nullptr), false, false, 0, 0, false, false), Exception); } -TEST_F(StaInitTest, R4_StaFindFanoutPinsThrows) { +TEST_F(StaInitTest, StaFindFanoutPinsThrows2) { EXPECT_THROW(sta_->findFanoutPins(static_cast*>(nullptr), false, false, 0, 0, false, false), Exception); } -TEST_F(StaInitTest, R4_StaMakePortPinThrows) { +TEST_F(StaInitTest, StaMakePortPinThrows) { EXPECT_THROW(sta_->makePortPin("test", nullptr), Exception); } -TEST_F(StaInitTest, R4_StaWriteSdcThrows) { +TEST_F(StaInitTest, StaWriteSdcThrows2) { EXPECT_THROW(sta_->writeSdc("test.sdc", false, false, 4, false, false), Exception); } // === Sta.cc: SearchPreamble and related === -TEST_F(StaInitTest, R4_StaSearchPreamble) { +TEST_F(StaInitTest, StaSearchPreamble2) { // searchPreamble calls ensureClkArrivals which calls findDelays // It will throw because ensureGraph is called EXPECT_THROW(sta_->searchPreamble(), Exception); } -TEST_F(StaInitTest, R4_StaEnsureClkArrivals) { +TEST_F(StaInitTest, StaEnsureClkArrivals2) { // calls findDelays which calls ensureGraph EXPECT_THROW(sta_->ensureClkArrivals(), Exception); } -TEST_F(StaInitTest, R4_StaUpdateTiming) { +TEST_F(StaInitTest, StaUpdateTiming2) { // calls findDelays EXPECT_THROW(sta_->updateTiming(false), Exception); } // === Sta.cc: Report header functions === -TEST_F(StaInitTest, R4_StaReportPathEndHeader) { +TEST_F(StaInitTest, StaReportPathEndHeader2) { sta_->reportPathEndHeader(); } -TEST_F(StaInitTest, R4_StaReportPathEndFooter) { +TEST_F(StaInitTest, StaReportPathEndFooter2) { sta_->reportPathEndFooter(); } -TEST_F(StaInitTest, R4_StaReportSlewLimitShortHeader) { +TEST_F(StaInitTest, StaReportSlewLimitShortHeader) { sta_->reportSlewLimitShortHeader(); } -TEST_F(StaInitTest, R4_StaReportFanoutLimitShortHeader) { +TEST_F(StaInitTest, StaReportFanoutLimitShortHeader) { sta_->reportFanoutLimitShortHeader(); } -TEST_F(StaInitTest, R4_StaReportCapacitanceLimitShortHeader) { +TEST_F(StaInitTest, StaReportCapacitanceLimitShortHeader) { sta_->reportCapacitanceLimitShortHeader(); } @@ -6132,67 +6132,67 @@ TEST_F(StaInitTest, R4_StaReportCapacitanceLimitShortHeader) { // === Sta.cc: function pointer checks for methods needing network === -TEST_F(StaInitTest, R4_StaIsClockPinExists) { +TEST_F(StaInitTest, StaIsClockPinExists) { auto fn = static_cast(&Sta::isClock); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaIsClockNetExists) { +TEST_F(StaInitTest, StaIsClockNetExists) { auto fn = static_cast(&Sta::isClock); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaIsIdealClockExists) { +TEST_F(StaInitTest, StaIsIdealClockExists) { auto fn = &Sta::isIdealClock; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaIsPropagatedClockExists) { +TEST_F(StaInitTest, StaIsPropagatedClockExists) { auto fn = &Sta::isPropagatedClock; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaIsClockSrcExists) { +TEST_F(StaInitTest, StaIsClockSrcExists) { auto fn = &Sta::isClockSrc; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaConnectPinPortExists) { +TEST_F(StaInitTest, StaConnectPinPortExists) { auto fn = static_cast(&Sta::connectPin); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaConnectPinLibPortExists) { +TEST_F(StaInitTest, StaConnectPinLibPortExists) { auto fn = static_cast(&Sta::connectPin); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaDisconnectPinExists) { +TEST_F(StaInitTest, StaDisconnectPinExists) { auto fn = &Sta::disconnectPin; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaReplaceCellExists) { +TEST_F(StaInitTest, StaReplaceCellExists) { auto fn = static_cast(&Sta::replaceCell); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaMakeInstanceExists) { +TEST_F(StaInitTest, StaMakeInstanceExists) { auto fn = &Sta::makeInstance; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaMakeNetExists) { +TEST_F(StaInitTest, StaMakeNetExists) { auto fn = &Sta::makeNet; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaDeleteInstanceExists) { +TEST_F(StaInitTest, StaDeleteInstanceExists) { auto fn = &Sta::deleteInstance; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaDeleteNetExists) { +TEST_F(StaInitTest, StaDeleteNetExists) { auto fn = &Sta::deleteNet; EXPECT_NE(fn, nullptr); } @@ -6200,33 +6200,33 @@ TEST_F(StaInitTest, R4_StaDeleteNetExists) { // === Sta.cc: check/violation preambles === -TEST_F(StaInitTest, R4_StaSetParasiticAnalysisPts) { +TEST_F(StaInitTest, StaSetParasiticAnalysisPts) { sta_->setParasiticAnalysisPts(false); } // === Sta.cc: Sta::setReportPathFields === -TEST_F(StaInitTest, R4_StaSetReportPathFields) { +TEST_F(StaInitTest, StaSetReportPathFields) { sta_->setReportPathFields(true, true, true, true, true, true, true); } // === Sta.cc: delete exception helpers === -TEST_F(StaInitTest, R4_StaDeleteExceptionFrom) { +TEST_F(StaInitTest, StaDeleteExceptionFrom) { sta_->deleteExceptionFrom(nullptr); } -TEST_F(StaInitTest, R4_StaDeleteExceptionThru) { +TEST_F(StaInitTest, StaDeleteExceptionThru) { sta_->deleteExceptionThru(nullptr); } -TEST_F(StaInitTest, R4_StaDeleteExceptionTo) { +TEST_F(StaInitTest, StaDeleteExceptionTo) { sta_->deleteExceptionTo(nullptr); } // === Sta.cc: readNetlistBefore === -TEST_F(StaInitTest, R4_StaReadNetlistBefore) { +TEST_F(StaInitTest, StaReadNetlistBefore) { sta_->readNetlistBefore(); } @@ -6234,32 +6234,32 @@ TEST_F(StaInitTest, R4_StaReadNetlistBefore) { // === Sta.cc: operatingConditions === -TEST_F(StaInitTest, R4_StaOperatingConditions) { +TEST_F(StaInitTest, StaOperatingConditions2) { auto oc = sta_->operatingConditions(MinMax::max()); (void)oc; } // === Sta.cc: removeConstraints === -TEST_F(StaInitTest, R4_StaRemoveConstraints) { +TEST_F(StaInitTest, StaRemoveConstraints2) { sta_->removeConstraints(); } // === Sta.cc: disabledEdgesSorted (calls ensureLevelized internally) === -TEST_F(StaInitTest, R4_StaDisabledEdgesSortedThrows) { +TEST_F(StaInitTest, StaDisabledEdgesSortedThrows) { EXPECT_THROW(sta_->disabledEdgesSorted(), Exception); } // === Sta.cc: disabledEdges (calls ensureLevelized) === -TEST_F(StaInitTest, R4_StaDisabledEdgesThrows) { +TEST_F(StaInitTest, StaDisabledEdgesThrows) { EXPECT_THROW(sta_->disabledEdges(), Exception); } // === Sta.cc: findReportPathField === -TEST_F(StaInitTest, R4_StaFindReportPathField) { +TEST_F(StaInitTest, StaFindReportPathField) { auto field = sta_->findReportPathField("delay"); // May or may not find it (void)field; @@ -6267,7 +6267,7 @@ TEST_F(StaInitTest, R4_StaFindReportPathField) { // === Sta.cc: findCorner === -TEST_F(StaInitTest, R4_StaFindCornerByName) { +TEST_F(StaInitTest, StaFindCornerByName) { auto corner = sta_->findCorner("default"); // May or may not exist (void)corner; @@ -6276,44 +6276,44 @@ TEST_F(StaInitTest, R4_StaFindCornerByName) { // === Sta.cc: totalNegativeSlack === -TEST_F(StaInitTest, R4_StaTotalNegativeSlackThrows) { +TEST_F(StaInitTest, StaTotalNegativeSlackThrows) { EXPECT_THROW(sta_->totalNegativeSlack(MinMax::max()), Exception); } // === Sta.cc: worstSlack === -TEST_F(StaInitTest, R4_StaWorstSlackThrows) { +TEST_F(StaInitTest, StaWorstSlackThrows) { EXPECT_THROW(sta_->worstSlack(MinMax::max()), Exception); } // === Sta.cc: setArcDelayCalc === -TEST_F(StaInitTest, R4_StaSetArcDelayCalc) { +TEST_F(StaInitTest, StaSetArcDelayCalc) { sta_->setArcDelayCalc("unit"); } // === Sta.cc: setAnalysisType === -TEST_F(StaInitTest, R4_StaSetAnalysisType) { +TEST_F(StaInitTest, StaSetAnalysisType) { sta_->setAnalysisType(AnalysisType::ocv); } // === Sta.cc: setTimingDerate (global) === -TEST_F(StaInitTest, R4_StaSetTimingDerate) { +TEST_F(StaInitTest, StaSetTimingDerate) { sta_->setTimingDerate(TimingDerateType::cell_delay, PathClkOrData::clk, RiseFallBoth::riseFall(), MinMax::max(), 1.05f); } // === Sta.cc: setVoltage === -TEST_F(StaInitTest, R4_StaSetVoltage) { +TEST_F(StaInitTest, StaSetVoltage) { sta_->setVoltage(MinMax::max(), 1.0f); } // === Sta.cc: setReportPathFieldOrder segfaults on null, use method exists === -TEST_F(StaInitTest, R4_StaSetReportPathFieldOrderExists) { +TEST_F(StaInitTest, StaSetReportPathFieldOrderExists) { auto fn = &Sta::setReportPathFieldOrder; EXPECT_NE(fn, nullptr); } @@ -6323,7 +6323,7 @@ TEST_F(StaInitTest, R4_StaSetReportPathFieldOrderExists) { // === Property.cc: defineProperty overloads === -TEST_F(StaInitTest, R4_PropertiesDefineLibrary) { +TEST_F(StaInitTest, PropertiesDefineLibrary) { Properties props(sta_); std::string prop_name("test_lib_prop"); props.defineProperty(prop_name, @@ -6331,7 +6331,7 @@ TEST_F(StaInitTest, R4_PropertiesDefineLibrary) { [](const Library*, Sta*) -> PropertyValue { return PropertyValue(); })); } -TEST_F(StaInitTest, R4_PropertiesDefineLibertyLibrary) { +TEST_F(StaInitTest, PropertiesDefineLibertyLibrary) { Properties props(sta_); std::string prop_name("test_liblib_prop"); props.defineProperty(prop_name, @@ -6339,7 +6339,7 @@ TEST_F(StaInitTest, R4_PropertiesDefineLibertyLibrary) { [](const LibertyLibrary*, Sta*) -> PropertyValue { return PropertyValue(); })); } -TEST_F(StaInitTest, R4_PropertiesDefineCell) { +TEST_F(StaInitTest, PropertiesDefineCell) { Properties props(sta_); std::string prop_name("test_cell_prop"); props.defineProperty(prop_name, @@ -6347,7 +6347,7 @@ TEST_F(StaInitTest, R4_PropertiesDefineCell) { [](const Cell*, Sta*) -> PropertyValue { return PropertyValue(); })); } -TEST_F(StaInitTest, R4_PropertiesDefineLibertyCell) { +TEST_F(StaInitTest, PropertiesDefineLibertyCell) { Properties props(sta_); std::string prop_name("test_libcell_prop"); props.defineProperty(prop_name, @@ -6355,7 +6355,7 @@ TEST_F(StaInitTest, R4_PropertiesDefineLibertyCell) { [](const LibertyCell*, Sta*) -> PropertyValue { return PropertyValue(); })); } -TEST_F(StaInitTest, R4_PropertiesDefinePort) { +TEST_F(StaInitTest, PropertiesDefinePort) { Properties props(sta_); std::string prop_name("test_port_prop"); props.defineProperty(prop_name, @@ -6363,7 +6363,7 @@ TEST_F(StaInitTest, R4_PropertiesDefinePort) { [](const Port*, Sta*) -> PropertyValue { return PropertyValue(); })); } -TEST_F(StaInitTest, R4_PropertiesDefineLibertyPort) { +TEST_F(StaInitTest, PropertiesDefineLibertyPort) { Properties props(sta_); std::string prop_name("test_libport_prop"); props.defineProperty(prop_name, @@ -6371,7 +6371,7 @@ TEST_F(StaInitTest, R4_PropertiesDefineLibertyPort) { [](const LibertyPort*, Sta*) -> PropertyValue { return PropertyValue(); })); } -TEST_F(StaInitTest, R4_PropertiesDefineInstance) { +TEST_F(StaInitTest, PropertiesDefineInstance) { Properties props(sta_); std::string prop_name("test_inst_prop"); props.defineProperty(prop_name, @@ -6379,7 +6379,7 @@ TEST_F(StaInitTest, R4_PropertiesDefineInstance) { [](const Instance*, Sta*) -> PropertyValue { return PropertyValue(); })); } -TEST_F(StaInitTest, R4_PropertiesDefinePin) { +TEST_F(StaInitTest, PropertiesDefinePin) { Properties props(sta_); std::string prop_name("test_pin_prop"); props.defineProperty(prop_name, @@ -6387,7 +6387,7 @@ TEST_F(StaInitTest, R4_PropertiesDefinePin) { [](const Pin*, Sta*) -> PropertyValue { return PropertyValue(); })); } -TEST_F(StaInitTest, R4_PropertiesDefineNet) { +TEST_F(StaInitTest, PropertiesDefineNet) { Properties props(sta_); std::string prop_name("test_net_prop"); props.defineProperty(prop_name, @@ -6395,7 +6395,7 @@ TEST_F(StaInitTest, R4_PropertiesDefineNet) { [](const Net*, Sta*) -> PropertyValue { return PropertyValue(); })); } -TEST_F(StaInitTest, R4_PropertiesDefineClock) { +TEST_F(StaInitTest, PropertiesDefineClock) { Properties props(sta_); std::string prop_name("test_clk_prop"); props.defineProperty(prop_name, @@ -6405,14 +6405,14 @@ TEST_F(StaInitTest, R4_PropertiesDefineClock) { // === Search.cc: RequiredCmp === -TEST_F(StaInitTest, R4_RequiredCmpConstruct) { +TEST_F(StaInitTest, RequiredCmpConstruct) { RequiredCmp cmp; (void)cmp; } // === Search.cc: EvalPred constructor === -TEST_F(StaInitTest, R4_EvalPredConstruct) { +TEST_F(StaInitTest, EvalPredConstruct) { EvalPred pred(sta_); (void)pred; } @@ -6420,80 +6420,80 @@ TEST_F(StaInitTest, R4_EvalPredConstruct) { // === Search.cc: ClkArrivalSearchPred === -TEST_F(StaInitTest, R4_ClkArrivalSearchPredConstruct) { +TEST_F(StaInitTest, ClkArrivalSearchPredConstruct) { ClkArrivalSearchPred pred(sta_); (void)pred; } // === Search.cc: Search accessors === -TEST_F(StaInitTest, R4_SearchTagCount) { +TEST_F(StaInitTest, SearchTagCount2) { Search *search = sta_->search(); ASSERT_NE(search, nullptr); int tc = search->tagCount(); (void)tc; } -TEST_F(StaInitTest, R4_SearchTagGroupCount) { +TEST_F(StaInitTest, SearchTagGroupCount2) { Search *search = sta_->search(); ASSERT_NE(search, nullptr); int tgc = search->tagGroupCount(); (void)tgc; } -TEST_F(StaInitTest, R4_SearchClkInfoCount) { +TEST_F(StaInitTest, SearchClkInfoCount2) { Search *search = sta_->search(); ASSERT_NE(search, nullptr); int cnt = search->clkInfoCount(); (void)cnt; } -TEST_F(StaInitTest, R4_SearchArrivalsInvalid) { +TEST_F(StaInitTest, SearchArrivalsInvalid2) { Search *search = sta_->search(); ASSERT_NE(search, nullptr); search->arrivalsInvalid(); } -TEST_F(StaInitTest, R4_SearchRequiredsInvalid) { +TEST_F(StaInitTest, SearchRequiredsInvalid2) { Search *search = sta_->search(); ASSERT_NE(search, nullptr); search->requiredsInvalid(); } -TEST_F(StaInitTest, R4_SearchEndpointsInvalid) { +TEST_F(StaInitTest, SearchEndpointsInvalid2) { Search *search = sta_->search(); ASSERT_NE(search, nullptr); search->endpointsInvalid(); } -TEST_F(StaInitTest, R4_SearchClear) { +TEST_F(StaInitTest, SearchClear2) { Search *search = sta_->search(); ASSERT_NE(search, nullptr); search->clear(); } -TEST_F(StaInitTest, R4_SearchHavePathGroups) { +TEST_F(StaInitTest, SearchHavePathGroups2) { Search *search = sta_->search(); ASSERT_NE(search, nullptr); bool val = search->havePathGroups(); (void)val; } -TEST_F(StaInitTest, R4_SearchCrprPathPruningEnabled) { +TEST_F(StaInitTest, SearchCrprPathPruningEnabled) { Search *search = sta_->search(); ASSERT_NE(search, nullptr); bool val = search->crprPathPruningEnabled(); (void)val; } -TEST_F(StaInitTest, R4_SearchCrprApproxMissingRequireds) { +TEST_F(StaInitTest, SearchCrprApproxMissingRequireds) { Search *search = sta_->search(); ASSERT_NE(search, nullptr); bool val = search->crprApproxMissingRequireds(); (void)val; } -TEST_F(StaInitTest, R4_SearchSetCrprpathPruningEnabled) { +TEST_F(StaInitTest, SearchSetCrprpathPruningEnabled) { Search *search = sta_->search(); ASSERT_NE(search, nullptr); search->setCrprpathPruningEnabled(true); @@ -6501,7 +6501,7 @@ TEST_F(StaInitTest, R4_SearchSetCrprpathPruningEnabled) { search->setCrprpathPruningEnabled(false); } -TEST_F(StaInitTest, R4_SearchSetCrprApproxMissingRequireds) { +TEST_F(StaInitTest, SearchSetCrprApproxMissingRequireds) { Search *search = sta_->search(); ASSERT_NE(search, nullptr); search->setCrprApproxMissingRequireds(true); @@ -6509,13 +6509,13 @@ TEST_F(StaInitTest, R4_SearchSetCrprApproxMissingRequireds) { search->setCrprApproxMissingRequireds(false); } -TEST_F(StaInitTest, R4_SearchDeleteFilter) { +TEST_F(StaInitTest, SearchDeleteFilter2) { Search *search = sta_->search(); ASSERT_NE(search, nullptr); search->deleteFilter(); } -TEST_F(StaInitTest, R4_SearchDeletePathGroups) { +TEST_F(StaInitTest, SearchDeletePathGroups2) { Search *search = sta_->search(); ASSERT_NE(search, nullptr); search->deletePathGroups(); @@ -6523,87 +6523,87 @@ TEST_F(StaInitTest, R4_SearchDeletePathGroups) { // === PathEnd.cc: more PathEndUnconstrained methods === -TEST_F(StaInitTest, R4_PathEndUnconstrainedCheckRole) { +TEST_F(StaInitTest, PathEndUnconstrainedCheckRole) { Path *p = new Path(); PathEndUnconstrained pe(p); const TimingRole *role = pe.checkRole(sta_); EXPECT_EQ(role, nullptr); } -TEST_F(StaInitTest, R4_PathEndUnconstrainedTypeName) { +TEST_F(StaInitTest, PathEndUnconstrainedTypeName) { Path *p = new Path(); PathEndUnconstrained pe(p); const char *name = pe.typeName(); EXPECT_STREQ(name, "unconstrained"); } -TEST_F(StaInitTest, R4_PathEndUnconstrainedType) { +TEST_F(StaInitTest, PathEndUnconstrainedType) { Path *p = new Path(); PathEndUnconstrained pe(p); EXPECT_EQ(pe.type(), PathEnd::unconstrained); } -TEST_F(StaInitTest, R4_PathEndUnconstrainedIsUnconstrained) { +TEST_F(StaInitTest, PathEndUnconstrainedIsUnconstrained) { Path *p = new Path(); PathEndUnconstrained pe(p); EXPECT_TRUE(pe.isUnconstrained()); } -TEST_F(StaInitTest, R4_PathEndUnconstrainedIsCheck) { +TEST_F(StaInitTest, PathEndUnconstrainedIsCheck) { Path *p = new Path(); PathEndUnconstrained pe(p); EXPECT_FALSE(pe.isCheck()); } -TEST_F(StaInitTest, R4_PathEndUnconstrainedIsLatchCheck) { +TEST_F(StaInitTest, PathEndUnconstrainedIsLatchCheck) { Path *p = new Path(); PathEndUnconstrained pe(p); EXPECT_FALSE(pe.isLatchCheck()); } -TEST_F(StaInitTest, R4_PathEndUnconstrainedIsOutputDelay) { +TEST_F(StaInitTest, PathEndUnconstrainedIsOutputDelay) { Path *p = new Path(); PathEndUnconstrained pe(p); EXPECT_FALSE(pe.isOutputDelay()); } -TEST_F(StaInitTest, R4_PathEndUnconstrainedIsGatedClock) { +TEST_F(StaInitTest, PathEndUnconstrainedIsGatedClock) { Path *p = new Path(); PathEndUnconstrained pe(p); EXPECT_FALSE(pe.isGatedClock()); } -TEST_F(StaInitTest, R4_PathEndUnconstrainedIsPathDelay) { +TEST_F(StaInitTest, PathEndUnconstrainedIsPathDelay) { Path *p = new Path(); PathEndUnconstrained pe(p); EXPECT_FALSE(pe.isPathDelay()); } -TEST_F(StaInitTest, R4_PathEndUnconstrainedTargetClkEdge) { +TEST_F(StaInitTest, PathEndUnconstrainedTargetClkEdge) { Path *p = new Path(); PathEndUnconstrained pe(p); EXPECT_EQ(pe.targetClkEdge(sta_), nullptr); } -TEST_F(StaInitTest, R4_PathEndUnconstrainedTargetClkTime) { +TEST_F(StaInitTest, PathEndUnconstrainedTargetClkTime) { Path *p = new Path(); PathEndUnconstrained pe(p); EXPECT_FLOAT_EQ(pe.targetClkTime(sta_), 0.0f); } -TEST_F(StaInitTest, R4_PathEndUnconstrainedTargetClkOffset) { +TEST_F(StaInitTest, PathEndUnconstrainedTargetClkOffset) { Path *p = new Path(); PathEndUnconstrained pe(p); EXPECT_FLOAT_EQ(pe.targetClkOffset(sta_), 0.0f); } -TEST_F(StaInitTest, R4_PathEndUnconstrainedSourceClkOffset) { +TEST_F(StaInitTest, PathEndUnconstrainedSourceClkOffset) { Path *p = new Path(); PathEndUnconstrained pe(p); EXPECT_FLOAT_EQ(pe.sourceClkOffset(sta_), 0.0f); } -TEST_F(StaInitTest, R4_PathEndUnconstrainedCopy) { +TEST_F(StaInitTest, PathEndUnconstrainedCopy) { Path *p = new Path(); PathEndUnconstrained pe(p); PathEnd *copy = pe.copy(); @@ -6612,7 +6612,7 @@ TEST_F(StaInitTest, R4_PathEndUnconstrainedCopy) { delete copy; } -TEST_F(StaInitTest, R4_PathEndUnconstrainedExceptPathCmp) { +TEST_F(StaInitTest, PathEndUnconstrainedExceptPathCmp) { Path *p1 = new Path(); Path *p2 = new Path(); PathEndUnconstrained pe1(p1); @@ -6623,7 +6623,7 @@ TEST_F(StaInitTest, R4_PathEndUnconstrainedExceptPathCmp) { // === PathEnd.cc: PathEndCheck constructor/type === -TEST_F(StaInitTest, R4_PathEndCheckConstruct) { +TEST_F(StaInitTest, PathEndCheckConstruct2) { Path *p = new Path(); Path *clk = new Path(); PathEndCheck pe(p, nullptr, nullptr, clk, nullptr, sta_); @@ -6633,7 +6633,7 @@ TEST_F(StaInitTest, R4_PathEndCheckConstruct) { EXPECT_STREQ(pe.typeName(), "check"); } -TEST_F(StaInitTest, R4_PathEndCheckGetters) { +TEST_F(StaInitTest, PathEndCheckGetters) { Path *p = new Path(); Path *clk = new Path(); PathEndCheck pe(p, nullptr, nullptr, clk, nullptr, sta_); @@ -6641,7 +6641,7 @@ TEST_F(StaInitTest, R4_PathEndCheckGetters) { EXPECT_EQ(pe.multiCyclePath(), nullptr); } -TEST_F(StaInitTest, R4_PathEndCheckCopy) { +TEST_F(StaInitTest, PathEndCheckCopy) { Path *p = new Path(); Path *clk = new Path(); PathEndCheck pe(p, nullptr, nullptr, clk, nullptr, sta_); @@ -6663,13 +6663,13 @@ TEST_F(StaInitTest, R4_PathEndCheckCopy) { // === Bfs.cc: BfsFwdIterator/BfsBkwdIterator === -TEST_F(StaInitTest, R4_BfsFwdIteratorConstruct) { +TEST_F(StaInitTest, BfsFwdIteratorConstruct) { BfsFwdIterator iter(BfsIndex::other, nullptr, sta_); bool has = iter.hasNext(); (void)has; } -TEST_F(StaInitTest, R4_BfsBkwdIteratorConstruct) { +TEST_F(StaInitTest, BfsBkwdIteratorConstruct) { BfsBkwdIterator iter(BfsIndex::other, nullptr, sta_); bool has = iter.hasNext(); (void)has; @@ -6677,7 +6677,7 @@ TEST_F(StaInitTest, R4_BfsBkwdIteratorConstruct) { // === ClkNetwork.cc: ClkNetwork accessors === -TEST_F(StaInitTest, R4_ClkNetworkAccessors) { +TEST_F(StaInitTest, ClkNetworkAccessors) { ClkNetwork *clk_net = sta_->clkNetwork(); if (clk_net) { clk_net->clear(); @@ -6686,7 +6686,7 @@ TEST_F(StaInitTest, R4_ClkNetworkAccessors) { // === Corner.cc: Corner accessors === -TEST_F(StaInitTest, R4_CornerAccessors) { +TEST_F(StaInitTest, CornerAccessors) { Corner *corner = sta_->cmdCorner(); ASSERT_NE(corner, nullptr); int idx = corner->index(); @@ -6697,14 +6697,14 @@ TEST_F(StaInitTest, R4_CornerAccessors) { // === WorstSlack.cc: function exists === -TEST_F(StaInitTest, R4_StaWorstSlackWithVertexExists) { +TEST_F(StaInitTest, StaWorstSlackWithVertexExists) { auto fn = static_cast(&Sta::worstSlack); EXPECT_NE(fn, nullptr); } // === PathGroup.cc: PathGroup name constants === -TEST_F(StaInitTest, R4_PathGroupNameConstants) { +TEST_F(StaInitTest, PathGroupNameConstants) { // PathGroup has static name constants auto fn = static_cast(&Search::havePathGroups); EXPECT_NE(fn, nullptr); @@ -6712,7 +6712,7 @@ TEST_F(StaInitTest, R4_PathGroupNameConstants) { // === CheckTiming.cc: checkTiming === -TEST_F(StaInitTest, R4_StaCheckTimingThrows) { +TEST_F(StaInitTest, StaCheckTimingThrows2) { EXPECT_THROW(sta_->checkTiming(true, true, true, true, true, true, true), Exception); } @@ -6720,100 +6720,100 @@ TEST_F(StaInitTest, R4_StaCheckTimingThrows) { // === PathEnum.cc: function exists === -TEST_F(StaInitTest, R4_PathEnumExists) { +TEST_F(StaInitTest, PathEnumExists) { auto fn = &PathEnum::hasNext; EXPECT_NE(fn, nullptr); } // === Genclks.cc: Genclks exists === -TEST_F(StaInitTest, R4_GenclksExists2) { +TEST_F(StaInitTest, GenclksExists2) { auto fn = &Genclks::clear; EXPECT_NE(fn, nullptr); } // === MakeTimingModel.cc: function exists === -TEST_F(StaInitTest, R4_StaWriteTimingModelThrows) { +TEST_F(StaInitTest, StaWriteTimingModelThrows) { EXPECT_THROW(sta_->writeTimingModel("out.lib", "model", "cell", nullptr), Exception); } // === Tag.cc: Tag function exists === -TEST_F(StaInitTest, R4_TagTransitionExists) { +TEST_F(StaInitTest, TagTransitionExists) { auto fn = &Tag::transition; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_TagPathAPIndexExists) { +TEST_F(StaInitTest, TagPathAPIndexExists) { auto fn = &Tag::pathAPIndex; EXPECT_NE(fn, nullptr); } // === StaState.cc: StaState units === -TEST_F(StaInitTest, R4_StaStateReport) { +TEST_F(StaInitTest, StaStateReport) { Report *rpt = sta_->report(); EXPECT_NE(rpt, nullptr); } // === ClkSkew.cc: function exists === -TEST_F(StaInitTest, R4_StaFindWorstClkSkewExists) { +TEST_F(StaInitTest, StaFindWorstClkSkewExists) { auto fn = &Sta::findWorstClkSkew; EXPECT_NE(fn, nullptr); } // === ClkLatency.cc: function exists === -TEST_F(StaInitTest, R4_StaReportClkLatencyExists) { +TEST_F(StaInitTest, StaReportClkLatencyExists) { auto fn = &Sta::reportClkLatency; EXPECT_NE(fn, nullptr); } // === ClkInfo.cc: accessors === -TEST_F(StaInitTest, R4_ClkInfoClockEdgeExists) { +TEST_F(StaInitTest, ClkInfoClockEdgeExists) { auto fn = &ClkInfo::clkEdge; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_ClkInfoIsPropagatedExists) { +TEST_F(StaInitTest, ClkInfoIsPropagatedExists) { auto fn = &ClkInfo::isPropagated; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_ClkInfoIsGenClkSrcPathExists) { +TEST_F(StaInitTest, ClkInfoIsGenClkSrcPathExists) { auto fn = &ClkInfo::isGenClkSrcPath; EXPECT_NE(fn, nullptr); } // === Crpr.cc: function exists === -TEST_F(StaInitTest, R4_CrprExists) { +TEST_F(StaInitTest, CrprExists) { auto fn = &Search::crprApproxMissingRequireds; EXPECT_NE(fn, nullptr); } // === FindRegister.cc: findRegister functions === -TEST_F(StaInitTest, R4_StaFindRegisterInstancesThrows) { +TEST_F(StaInitTest, StaFindRegisterInstancesThrows2) { EXPECT_THROW(sta_->findRegisterInstances(nullptr, RiseFallBoth::riseFall(), false, false), Exception); } -TEST_F(StaInitTest, R4_StaFindRegisterClkPinsThrows) { +TEST_F(StaInitTest, StaFindRegisterClkPinsThrows2) { EXPECT_THROW(sta_->findRegisterClkPins(nullptr, RiseFallBoth::riseFall(), false, false), Exception); } -TEST_F(StaInitTest, R4_StaFindRegisterDataPinsThrows) { +TEST_F(StaInitTest, StaFindRegisterDataPinsThrows2) { EXPECT_THROW(sta_->findRegisterDataPins(nullptr, RiseFallBoth::riseFall(), false, false), Exception); } -TEST_F(StaInitTest, R4_StaFindRegisterOutputPinsThrows) { +TEST_F(StaInitTest, StaFindRegisterOutputPinsThrows2) { EXPECT_THROW(sta_->findRegisterOutputPins(nullptr, RiseFallBoth::riseFall(), false, false), Exception); } -TEST_F(StaInitTest, R4_StaFindRegisterAsyncPinsThrows) { +TEST_F(StaInitTest, StaFindRegisterAsyncPinsThrows2) { EXPECT_THROW(sta_->findRegisterAsyncPins(nullptr, RiseFallBoth::riseFall(), false, false), Exception); } @@ -6821,79 +6821,79 @@ TEST_F(StaInitTest, R4_StaFindRegisterAsyncPinsThrows) { // === Sta.cc: Sta::setCurrentInstance === -TEST_F(StaInitTest, R4_StaSetCurrentInstanceNull) { +TEST_F(StaInitTest, StaSetCurrentInstanceNull) { sta_->setCurrentInstance(nullptr); } // === Sta.cc: Sta::pathGroupNames === -TEST_F(StaInitTest, R4_StaPathGroupNames) { +TEST_F(StaInitTest, StaPathGroupNames) { auto names = sta_->pathGroupNames(); (void)names; } // === Sta.cc: Sta::isPathGroupName === -TEST_F(StaInitTest, R4_StaIsPathGroupName) { +TEST_F(StaInitTest, StaIsPathGroupName) { bool val = sta_->isPathGroupName("nonexistent"); EXPECT_FALSE(val); } // === Sta.cc: Sta::removeClockGroupsLogicallyExclusive etc === -TEST_F(StaInitTest, R4_StaRemoveClockGroupsLogicallyExclusive) { +TEST_F(StaInitTest, StaRemoveClockGroupsLogicallyExclusive2) { sta_->removeClockGroupsLogicallyExclusive("test"); } -TEST_F(StaInitTest, R4_StaRemoveClockGroupsPhysicallyExclusive) { +TEST_F(StaInitTest, StaRemoveClockGroupsPhysicallyExclusive2) { sta_->removeClockGroupsPhysicallyExclusive("test"); } -TEST_F(StaInitTest, R4_StaRemoveClockGroupsAsynchronous) { +TEST_F(StaInitTest, StaRemoveClockGroupsAsynchronous2) { sta_->removeClockGroupsAsynchronous("test"); } // === Sta.cc: Sta::setDebugLevel === -TEST_F(StaInitTest, R4_StaSetDebugLevel) { +TEST_F(StaInitTest, StaSetDebugLevel) { sta_->setDebugLevel("search", 0); } // === Sta.cc: Sta::slowDrivers === -TEST_F(StaInitTest, R4_StaSlowDriversThrows) { +TEST_F(StaInitTest, StaSlowDriversThrows) { EXPECT_THROW(sta_->slowDrivers(10), Exception); } // === Sta.cc: Sta::setMinPulseWidth === -TEST_F(StaInitTest, R4_StaSetMinPulseWidth) { +TEST_F(StaInitTest, StaSetMinPulseWidth) { sta_->setMinPulseWidth(RiseFallBoth::riseFall(), 0.1f); } // === Sta.cc: various set* functions that delegate to Sdc === -TEST_F(StaInitTest, R4_StaSetClockGatingCheckGlobal) { +TEST_F(StaInitTest, StaSetClockGatingCheckGlobal2) { sta_->setClockGatingCheck(RiseFallBoth::riseFall(), MinMax::max(), 0.1f); } // === Sta.cc: Sta::makeExceptionFrom/Thru/To === -TEST_F(StaInitTest, R4_StaMakeExceptionFrom) { +TEST_F(StaInitTest, StaMakeExceptionFrom2) { ExceptionFrom *from = sta_->makeExceptionFrom(nullptr, nullptr, nullptr, RiseFallBoth::riseFall()); // Returns a valid ExceptionFrom even with null args if (from) sta_->deleteExceptionFrom(from); } -TEST_F(StaInitTest, R4_StaMakeExceptionThru) { +TEST_F(StaInitTest, StaMakeExceptionThru2) { ExceptionThru *thru = sta_->makeExceptionThru(nullptr, nullptr, nullptr, RiseFallBoth::riseFall()); if (thru) sta_->deleteExceptionThru(thru); } -TEST_F(StaInitTest, R4_StaMakeExceptionTo) { +TEST_F(StaInitTest, StaMakeExceptionTo2) { ExceptionTo *to = sta_->makeExceptionTo(nullptr, nullptr, nullptr, RiseFallBoth::riseFall(), RiseFallBoth::riseFall()); @@ -6902,109 +6902,109 @@ TEST_F(StaInitTest, R4_StaMakeExceptionTo) { // === Sta.cc: Sta::setLatchBorrowLimit === -TEST_F(StaInitTest, R4_StaSetLatchBorrowLimitExists) { +TEST_F(StaInitTest, StaSetLatchBorrowLimitExists) { auto fn = static_cast(&Sta::setLatchBorrowLimit); EXPECT_NE(fn, nullptr); } // === Sta.cc: Sta::setDriveResistance === -TEST_F(StaInitTest, R4_StaSetDriveResistanceExists) { +TEST_F(StaInitTest, StaSetDriveResistanceExists) { auto fn = &Sta::setDriveResistance; EXPECT_NE(fn, nullptr); } // === Sta.cc: Sta::setInputSlew === -TEST_F(StaInitTest, R4_StaSetInputSlewExists) { +TEST_F(StaInitTest, StaSetInputSlewExists) { auto fn = &Sta::setInputSlew; EXPECT_NE(fn, nullptr); } // === Sta.cc: Sta::setResistance === -TEST_F(StaInitTest, R4_StaSetResistanceExists) { +TEST_F(StaInitTest, StaSetResistanceExists) { auto fn = &Sta::setResistance; EXPECT_NE(fn, nullptr); } // === Sta.cc: Sta::setNetWireCap === -TEST_F(StaInitTest, R4_StaSetNetWireCapExists) { +TEST_F(StaInitTest, StaSetNetWireCapExists) { auto fn = &Sta::setNetWireCap; EXPECT_NE(fn, nullptr); } // === Sta.cc: Sta::connectedCap === -TEST_F(StaInitTest, R4_StaConnectedCapPinExists) { +TEST_F(StaInitTest, StaConnectedCapPinExists) { auto fn = static_cast(&Sta::connectedCap); EXPECT_NE(fn, nullptr); } // === Sta.cc: Sta::portExtCaps === -TEST_F(StaInitTest, R4_StaPortExtCapsExists) { +TEST_F(StaInitTest, StaPortExtCapsExists) { auto fn = &Sta::portExtCaps; EXPECT_NE(fn, nullptr); } // === Sta.cc: Sta::setOperatingConditions === -TEST_F(StaInitTest, R4_StaSetOperatingConditions) { +TEST_F(StaInitTest, StaSetOperatingConditions2) { sta_->setOperatingConditions(nullptr, MinMaxAll::all()); } // === Sta.cc: Sta::power === -TEST_F(StaInitTest, R4_StaPowerExists) { +TEST_F(StaInitTest, StaPowerExists) { auto fn = static_cast(&Sta::power); EXPECT_NE(fn, nullptr); } // === Sta.cc: Sta::readLiberty === -TEST_F(StaInitTest, R4_StaReadLibertyExists) { +TEST_F(StaInitTest, StaReadLibertyExists) { auto fn = &Sta::readLiberty; EXPECT_NE(fn, nullptr); } // === Sta.cc: linkDesign === -TEST_F(StaInitTest, R4_StaLinkDesignExists) { +TEST_F(StaInitTest, StaLinkDesignExists) { auto fn = &Sta::linkDesign; EXPECT_NE(fn, nullptr); } // === Sta.cc: Sta::readVerilog === -TEST_F(StaInitTest, R4_StaReadVerilogExists) { +TEST_F(StaInitTest, StaReadVerilogExists) { auto fn = &Sta::readVerilog; EXPECT_NE(fn, nullptr); } // === Sta.cc: Sta::readSpef === -TEST_F(StaInitTest, R4_StaReadSpefExists) { +TEST_F(StaInitTest, StaReadSpefExists) { auto fn = &Sta::readSpef; EXPECT_NE(fn, nullptr); } // === Sta.cc: initSta and deleteAllMemory === -TEST_F(StaInitTest, R4_InitStaExists) { +TEST_F(StaInitTest, InitStaExists) { auto fn = &initSta; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_DeleteAllMemoryExists) { +TEST_F(StaInitTest, DeleteAllMemoryExists) { auto fn = &deleteAllMemory; EXPECT_NE(fn, nullptr); } // === PathEnd.cc: slack computation on PathEndUnconstrained === -TEST_F(StaInitTest, R4_PathEndSlack) { +TEST_F(StaInitTest, PathEndSlack) { Path *p = new Path(); PathEndUnconstrained pe(p); Slack s = pe.slack(sta_); @@ -7013,66 +7013,66 @@ TEST_F(StaInitTest, R4_PathEndSlack) { // === Sta.cc: Sta method exists checks for vertex* functions === -TEST_F(StaInitTest, R4_StaVertexArrivalMinMaxExists) { +TEST_F(StaInitTest, StaVertexArrivalMinMaxExists) { auto fn = static_cast(&Sta::vertexArrival); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaVertexRequiredMinMaxExists) { +TEST_F(StaInitTest, StaVertexRequiredMinMaxExists) { auto fn = static_cast(&Sta::vertexRequired); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaVertexSlackMinMaxExists) { +TEST_F(StaInitTest, StaVertexSlackMinMaxExists) { auto fn = static_cast(&Sta::vertexSlack); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaVertexSlewMinMaxExists) { +TEST_F(StaInitTest, StaVertexSlewMinMaxExists) { auto fn = static_cast(&Sta::vertexSlew); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaVertexPathCountExists) { +TEST_F(StaInitTest, StaVertexPathCountExists) { auto fn = &Sta::vertexPathCount; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaVertexWorstArrivalPathExists) { +TEST_F(StaInitTest, StaVertexWorstArrivalPathExists) { auto fn = static_cast(&Sta::vertexWorstArrivalPath); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaVertexWorstSlackPathExists) { +TEST_F(StaInitTest, StaVertexWorstSlackPathExists) { auto fn = static_cast(&Sta::vertexWorstSlackPath); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaVertexSlacksExists) { +TEST_F(StaInitTest, StaVertexSlacksExists) { auto fn = static_cast(&Sta::vertexSlacks); EXPECT_NE(fn, nullptr); } // === Sta.cc: reporting function exists === -TEST_F(StaInitTest, R4_StaReportPathEndExists) { +TEST_F(StaInitTest, StaReportPathEndExists) { auto fn = static_cast(&Sta::reportPathEnd); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaReportPathEndsExists) { +TEST_F(StaInitTest, StaReportPathEndsExists) { auto fn = &Sta::reportPathEnds; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R4_StaFindPathEndsExists) { +TEST_F(StaInitTest, StaFindPathEndsExists) { auto fn = &Sta::findPathEnds; EXPECT_NE(fn, nullptr); } // === Sta.cc: Sta::makeClockGroups === -TEST_F(StaInitTest, R4_StaMakeClockGroups) { +TEST_F(StaInitTest, StaMakeClockGroups) { sta_->makeClockGroups("test_grp", false, false, false, false, nullptr); } @@ -7084,42 +7084,42 @@ TEST_F(StaInitTest, R4_StaMakeClockGroups) { // === CheckMaxSkews: constructor/destructor/clear === -TEST_F(StaInitTest, R5_CheckMaxSkewsCtorDtorClear) { +TEST_F(StaInitTest, CheckMaxSkewsCtorDtorClear) { CheckMaxSkews checker(sta_); checker.clear(); } // === CheckMinPeriods: constructor/destructor/clear === -TEST_F(StaInitTest, R5_CheckMinPeriodsCtorDtorClear) { +TEST_F(StaInitTest, CheckMinPeriodsCtorDtorClear) { CheckMinPeriods checker(sta_); checker.clear(); } // === CheckMinPulseWidths: constructor/destructor/clear === -TEST_F(StaInitTest, R5_CheckMinPulseWidthsCtorDtorClear) { +TEST_F(StaInitTest, CheckMinPulseWidthsCtorDtorClear) { CheckMinPulseWidths checker(sta_); checker.clear(); } // === MinPulseWidthCheck: default constructor === -TEST_F(StaInitTest, R5_MinPulseWidthCheckDefaultCtor) { +TEST_F(StaInitTest, MinPulseWidthCheckDefaultCtor) { MinPulseWidthCheck check; EXPECT_EQ(check.openPath(), nullptr); } // === MinPulseWidthCheck: constructor with nullptr === -TEST_F(StaInitTest, R5_MinPulseWidthCheckNullptrCtor) { +TEST_F(StaInitTest, MinPulseWidthCheckNullptrCtor) { MinPulseWidthCheck check(nullptr); EXPECT_EQ(check.openPath(), nullptr); } // === MinPeriodCheck: constructor === -TEST_F(StaInitTest, R5_MinPeriodCheckCtor) { +TEST_F(StaInitTest, MinPeriodCheckCtor) { MinPeriodCheck check(nullptr, nullptr, nullptr); EXPECT_EQ(check.pin(), nullptr); EXPECT_EQ(check.clk(), nullptr); @@ -7127,7 +7127,7 @@ TEST_F(StaInitTest, R5_MinPeriodCheckCtor) { // === MinPeriodCheck: copy === -TEST_F(StaInitTest, R5_MinPeriodCheckCopy) { +TEST_F(StaInitTest, MinPeriodCheckCopy) { MinPeriodCheck check(nullptr, nullptr, nullptr); MinPeriodCheck *copy = check.copy(); EXPECT_NE(copy, nullptr); @@ -7138,42 +7138,42 @@ TEST_F(StaInitTest, R5_MinPeriodCheckCopy) { // === MaxSkewSlackLess: constructor === -TEST_F(StaInitTest, R5_MaxSkewSlackLessCtor) { +TEST_F(StaInitTest, MaxSkewSlackLessCtor) { MaxSkewSlackLess less(sta_); (void)less; } // === MinPeriodSlackLess: constructor === -TEST_F(StaInitTest, R5_MinPeriodSlackLessCtor) { +TEST_F(StaInitTest, MinPeriodSlackLessCtor) { MinPeriodSlackLess less(sta_); (void)less; } // === MinPulseWidthSlackLess: constructor === -TEST_F(StaInitTest, R5_MinPulseWidthSlackLessCtor) { +TEST_F(StaInitTest, MinPulseWidthSlackLessCtor) { MinPulseWidthSlackLess less(sta_); (void)less; } // === Path: default constructor and isNull === -TEST_F(StaInitTest, R5_PathDefaultCtorIsNull) { +TEST_F(StaInitTest, PathDefaultCtorIsNull) { Path path; EXPECT_TRUE(path.isNull()); } // === Path: copy from null pointer === -TEST_F(StaInitTest, R5_PathCopyFromNull) { +TEST_F(StaInitTest, PathCopyFromNull) { Path path(static_cast(nullptr)); EXPECT_TRUE(path.isNull()); } // === Path: arrival/required getters on default path === -TEST_F(StaInitTest, R5_PathArrivalRequired) { +TEST_F(StaInitTest, PathArrivalRequired) { Path path; path.setArrival(1.5f); EXPECT_FLOAT_EQ(path.arrival(), 1.5f); @@ -7183,7 +7183,7 @@ TEST_F(StaInitTest, R5_PathArrivalRequired) { // === Path: isEnum === -TEST_F(StaInitTest, R5_PathIsEnum) { +TEST_F(StaInitTest, PathIsEnum2) { Path path; EXPECT_FALSE(path.isEnum()); path.setIsEnum(true); @@ -7194,14 +7194,14 @@ TEST_F(StaInitTest, R5_PathIsEnum) { // === Path: prevPath on default === -TEST_F(StaInitTest, R5_PathPrevPathDefault) { +TEST_F(StaInitTest, PathPrevPathDefault) { Path path; EXPECT_EQ(path.prevPath(), nullptr); } // === Path: setPrevPath === -TEST_F(StaInitTest, R5_PathSetPrevPath) { +TEST_F(StaInitTest, PathSetPrevPath2) { Path path; Path prev; path.setPrevPath(&prev); @@ -7212,14 +7212,14 @@ TEST_F(StaInitTest, R5_PathSetPrevPath) { // === PathLess: constructor === -TEST_F(StaInitTest, R5_PathLessCtor) { +TEST_F(StaInitTest, PathLessCtor) { PathLess less(sta_); (void)less; } // === ClkSkew: default constructor === -TEST_F(StaInitTest, R5_ClkSkewDefaultCtor) { +TEST_F(StaInitTest, ClkSkewDefaultCtor) { ClkSkew skew; EXPECT_EQ(skew.srcPath(), nullptr); EXPECT_EQ(skew.tgtPath(), nullptr); @@ -7228,7 +7228,7 @@ TEST_F(StaInitTest, R5_ClkSkewDefaultCtor) { // === ClkSkew: copy constructor === -TEST_F(StaInitTest, R5_ClkSkewCopyCtor) { +TEST_F(StaInitTest, ClkSkewCopyCtor) { ClkSkew skew1; ClkSkew skew2(skew1); EXPECT_EQ(skew2.srcPath(), nullptr); @@ -7238,7 +7238,7 @@ TEST_F(StaInitTest, R5_ClkSkewCopyCtor) { // === ClkSkew: assignment operator === -TEST_F(StaInitTest, R5_ClkSkewAssignment) { +TEST_F(StaInitTest, ClkSkewAssignment2) { ClkSkew skew1; ClkSkew skew2; skew2 = skew1; @@ -7251,56 +7251,56 @@ TEST_F(StaInitTest, R5_ClkSkewAssignment) { // === ClkInfoLess: constructor === -TEST_F(StaInitTest, R5_ClkInfoLessCtor) { +TEST_F(StaInitTest, ClkInfoLessCtor) { ClkInfoLess less(sta_); (void)less; } // === ClkInfoEqual: constructor === -TEST_F(StaInitTest, R5_ClkInfoEqualCtor) { +TEST_F(StaInitTest, ClkInfoEqualCtor) { ClkInfoEqual eq(sta_); (void)eq; } // === ClkInfoHash: operator() with nullptr safety check === -TEST_F(StaInitTest, R5_ClkInfoHashExists) { +TEST_F(StaInitTest, ClkInfoHashExists) { ClkInfoHash hash; (void)hash; } // === TagLess: constructor === -TEST_F(StaInitTest, R5_TagLessCtor) { +TEST_F(StaInitTest, TagLessCtor) { TagLess less(sta_); (void)less; } // === TagIndexLess: existence === -TEST_F(StaInitTest, R5_TagIndexLessExists) { +TEST_F(StaInitTest, TagIndexLessExists) { TagIndexLess less; (void)less; } // === TagHash: constructor === -TEST_F(StaInitTest, R5_TagHashCtor) { +TEST_F(StaInitTest, TagHashCtor) { TagHash hash(sta_); (void)hash; } // === TagEqual: constructor === -TEST_F(StaInitTest, R5_TagEqualCtor) { +TEST_F(StaInitTest, TagEqualCtor) { TagEqual eq(sta_); (void)eq; } // === TagMatchLess: constructor === -TEST_F(StaInitTest, R5_TagMatchLessCtor) { +TEST_F(StaInitTest, TagMatchLessCtor) { TagMatchLess less(true, sta_); (void)less; TagMatchLess less2(false, sta_); @@ -7309,7 +7309,7 @@ TEST_F(StaInitTest, R5_TagMatchLessCtor) { // === TagMatchHash: constructor === -TEST_F(StaInitTest, R5_TagMatchHashCtor) { +TEST_F(StaInitTest, TagMatchHashCtor) { TagMatchHash hash(true, sta_); (void)hash; TagMatchHash hash2(false, sta_); @@ -7318,7 +7318,7 @@ TEST_F(StaInitTest, R5_TagMatchHashCtor) { // === TagMatchEqual: constructor === -TEST_F(StaInitTest, R5_TagMatchEqualCtor) { +TEST_F(StaInitTest, TagMatchEqualCtor) { TagMatchEqual eq(true, sta_); (void)eq; TagMatchEqual eq2(false, sta_); @@ -7330,33 +7330,33 @@ TEST_F(StaInitTest, R5_TagMatchEqualCtor) { // === DiversionGreater: constructors === -TEST_F(StaInitTest, R5_DiversionGreaterDefaultCtor) { +TEST_F(StaInitTest, DiversionGreaterDefaultCtor) { DiversionGreater greater; (void)greater; } -TEST_F(StaInitTest, R5_DiversionGreaterStaCtor) { +TEST_F(StaInitTest, DiversionGreaterStaCtor) { DiversionGreater greater(sta_); (void)greater; } // === ClkSkews: constructor and clear === -TEST_F(StaInitTest, R5_ClkSkewsCtorClear) { +TEST_F(StaInitTest, ClkSkewsCtorClear) { ClkSkews skews(sta_); skews.clear(); } // === Genclks: constructor, destructor, and clear === -TEST_F(StaInitTest, R5_GenclksCtorDtorClear) { +TEST_F(StaInitTest, GenclksCtorDtorClear) { Genclks genclks(sta_); genclks.clear(); } // === ClockPinPairLess: operator === -TEST_F(StaInitTest, R5_ClockPinPairLessExists) { +TEST_F(StaInitTest, ClockPinPairLessExists) { // ClockPinPairLess comparison dereferences Clock*, so just test existence ClockPinPairLess less; (void)less; @@ -7365,14 +7365,14 @@ TEST_F(StaInitTest, R5_ClockPinPairLessExists) { // === Levelize: setLevelSpace === -TEST_F(StaInitTest, R5_LevelizeSetLevelSpace) { +TEST_F(StaInitTest, LevelizeSetLevelSpace2) { Levelize *levelize = sta_->levelize(); levelize->setLevelSpace(5); } // === Levelize: maxLevel === -TEST_F(StaInitTest, R5_LevelizeMaxLevel) { +TEST_F(StaInitTest, LevelizeMaxLevel2) { Levelize *levelize = sta_->levelize(); int ml = levelize->maxLevel(); EXPECT_GE(ml, 0); @@ -7380,70 +7380,70 @@ TEST_F(StaInitTest, R5_LevelizeMaxLevel) { // === Levelize: clear === -TEST_F(StaInitTest, R5_LevelizeClear) { +TEST_F(StaInitTest, LevelizeClear2) { Levelize *levelize = sta_->levelize(); levelize->clear(); } // === SearchPred0: constructor === -TEST_F(StaInitTest, R5_SearchPred0Ctor) { +TEST_F(StaInitTest, SearchPred0Ctor) { SearchPred0 pred(sta_); (void)pred; } // === SearchPred1: constructor === -TEST_F(StaInitTest, R5_SearchPred1Ctor) { +TEST_F(StaInitTest, SearchPred1Ctor) { SearchPred1 pred(sta_); (void)pred; } // === SearchPred2: constructor === -TEST_F(StaInitTest, R5_SearchPred2Ctor) { +TEST_F(StaInitTest, SearchPred2Ctor) { SearchPred2 pred(sta_); (void)pred; } // === SearchPredNonLatch2: constructor === -TEST_F(StaInitTest, R5_SearchPredNonLatch2Ctor) { +TEST_F(StaInitTest, SearchPredNonLatch2Ctor) { SearchPredNonLatch2 pred(sta_); (void)pred; } // === SearchPredNonReg2: constructor === -TEST_F(StaInitTest, R5_SearchPredNonReg2Ctor) { +TEST_F(StaInitTest, SearchPredNonReg2Ctor) { SearchPredNonReg2 pred(sta_); (void)pred; } // === ClkTreeSearchPred: constructor === -TEST_F(StaInitTest, R5_ClkTreeSearchPredCtor) { +TEST_F(StaInitTest, ClkTreeSearchPredCtor) { ClkTreeSearchPred pred(sta_); (void)pred; } // === FanOutSrchPred: constructor === -TEST_F(StaInitTest, R5_FanOutSrchPredCtor) { +TEST_F(StaInitTest, FanOutSrchPredCtor) { FanOutSrchPred pred(sta_); (void)pred; } // === WorstSlack: constructor/destructor === -TEST_F(StaInitTest, R5_WorstSlackCtorDtor) { +TEST_F(StaInitTest, WorstSlackCtorDtor) { WorstSlack ws(sta_); (void)ws; } // === WorstSlack: copy constructor === -TEST_F(StaInitTest, R5_WorstSlackCopyCtor) { +TEST_F(StaInitTest, WorstSlackCopyCtor) { WorstSlack ws1(sta_); WorstSlack ws2(ws1); (void)ws2; @@ -7451,35 +7451,35 @@ TEST_F(StaInitTest, R5_WorstSlackCopyCtor) { // === WorstSlacks: constructor === -TEST_F(StaInitTest, R5_WorstSlacksCtorDtor) { +TEST_F(StaInitTest, WorstSlacksCtorDtor) { WorstSlacks wslacks(sta_); (void)wslacks; } // === Sim: clear === -TEST_F(StaInitTest, R5_SimClear) { +TEST_F(StaInitTest, SimClear2) { Sim *sim = sta_->sim(); sim->clear(); } // === StaState: copyUnits === -TEST_F(StaInitTest, R5_StaStateCopyUnits) { +TEST_F(StaInitTest, StaStateCopyUnits3) { Units *units = sta_->units(); sta_->copyUnits(units); } // === PropertyValue: default constructor === -TEST_F(StaInitTest, R5_PropertyValueDefaultCtor) { +TEST_F(StaInitTest, PropertyValueDefaultCtor) { PropertyValue pv; EXPECT_EQ(pv.type(), PropertyValue::type_none); } // === PropertyValue: string constructor === -TEST_F(StaInitTest, R5_PropertyValueStringCtor) { +TEST_F(StaInitTest, PropertyValueStringCtor) { PropertyValue pv("hello"); EXPECT_EQ(pv.type(), PropertyValue::type_string); EXPECT_STREQ(pv.stringValue(), "hello"); @@ -7487,7 +7487,7 @@ TEST_F(StaInitTest, R5_PropertyValueStringCtor) { // === PropertyValue: float constructor === -TEST_F(StaInitTest, R5_PropertyValueFloatCtor) { +TEST_F(StaInitTest, PropertyValueFloatCtor) { PropertyValue pv(3.14f, nullptr); EXPECT_EQ(pv.type(), PropertyValue::type_float); EXPECT_FLOAT_EQ(pv.floatValue(), 3.14f); @@ -7495,7 +7495,7 @@ TEST_F(StaInitTest, R5_PropertyValueFloatCtor) { // === PropertyValue: bool constructor === -TEST_F(StaInitTest, R5_PropertyValueBoolCtor) { +TEST_F(StaInitTest, PropertyValueBoolCtor) { PropertyValue pv(true); EXPECT_EQ(pv.type(), PropertyValue::type_bool); EXPECT_TRUE(pv.boolValue()); @@ -7503,7 +7503,7 @@ TEST_F(StaInitTest, R5_PropertyValueBoolCtor) { // === PropertyValue: copy constructor === -TEST_F(StaInitTest, R5_PropertyValueCopyCtor) { +TEST_F(StaInitTest, PropertyValueCopyCtor) { PropertyValue pv1("test"); PropertyValue pv2(pv1); EXPECT_EQ(pv2.type(), PropertyValue::type_string); @@ -7512,7 +7512,7 @@ TEST_F(StaInitTest, R5_PropertyValueCopyCtor) { // === PropertyValue: move constructor === -TEST_F(StaInitTest, R5_PropertyValueMoveCtor) { +TEST_F(StaInitTest, PropertyValueMoveCtor) { PropertyValue pv1("test"); PropertyValue pv2(std::move(pv1)); EXPECT_EQ(pv2.type(), PropertyValue::type_string); @@ -7521,7 +7521,7 @@ TEST_F(StaInitTest, R5_PropertyValueMoveCtor) { // === PropertyValue: copy assignment === -TEST_F(StaInitTest, R5_PropertyValueCopyAssign) { +TEST_F(StaInitTest, PropertyValueCopyAssign) { PropertyValue pv1("test"); PropertyValue pv2; pv2 = pv1; @@ -7531,7 +7531,7 @@ TEST_F(StaInitTest, R5_PropertyValueCopyAssign) { // === PropertyValue: move assignment === -TEST_F(StaInitTest, R5_PropertyValueMoveAssign) { +TEST_F(StaInitTest, PropertyValueMoveAssign) { PropertyValue pv1("test"); PropertyValue pv2; pv2 = std::move(pv1); @@ -7541,7 +7541,7 @@ TEST_F(StaInitTest, R5_PropertyValueMoveAssign) { // === PropertyValue: Library constructor === -TEST_F(StaInitTest, R5_PropertyValueLibraryCtor) { +TEST_F(StaInitTest, PropertyValueLibraryCtor) { PropertyValue pv(static_cast(nullptr)); EXPECT_EQ(pv.type(), PropertyValue::type_library); EXPECT_EQ(pv.library(), nullptr); @@ -7549,7 +7549,7 @@ TEST_F(StaInitTest, R5_PropertyValueLibraryCtor) { // === PropertyValue: Cell constructor === -TEST_F(StaInitTest, R5_PropertyValueCellCtor) { +TEST_F(StaInitTest, PropertyValueCellCtor) { PropertyValue pv(static_cast(nullptr)); EXPECT_EQ(pv.type(), PropertyValue::type_cell); EXPECT_EQ(pv.cell(), nullptr); @@ -7557,7 +7557,7 @@ TEST_F(StaInitTest, R5_PropertyValueCellCtor) { // === PropertyValue: Port constructor === -TEST_F(StaInitTest, R5_PropertyValuePortCtor) { +TEST_F(StaInitTest, PropertyValuePortCtor) { PropertyValue pv(static_cast(nullptr)); EXPECT_EQ(pv.type(), PropertyValue::type_port); EXPECT_EQ(pv.port(), nullptr); @@ -7565,7 +7565,7 @@ TEST_F(StaInitTest, R5_PropertyValuePortCtor) { // === PropertyValue: LibertyLibrary constructor === -TEST_F(StaInitTest, R5_PropertyValueLibertyLibraryCtor) { +TEST_F(StaInitTest, PropertyValueLibertyLibraryCtor) { PropertyValue pv(static_cast(nullptr)); EXPECT_EQ(pv.type(), PropertyValue::type_liberty_library); EXPECT_EQ(pv.libertyLibrary(), nullptr); @@ -7573,7 +7573,7 @@ TEST_F(StaInitTest, R5_PropertyValueLibertyLibraryCtor) { // === PropertyValue: LibertyCell constructor === -TEST_F(StaInitTest, R5_PropertyValueLibertyCellCtor) { +TEST_F(StaInitTest, PropertyValueLibertyCellCtor) { PropertyValue pv(static_cast(nullptr)); EXPECT_EQ(pv.type(), PropertyValue::type_liberty_cell); EXPECT_EQ(pv.libertyCell(), nullptr); @@ -7581,7 +7581,7 @@ TEST_F(StaInitTest, R5_PropertyValueLibertyCellCtor) { // === PropertyValue: LibertyPort constructor === -TEST_F(StaInitTest, R5_PropertyValueLibertyPortCtor) { +TEST_F(StaInitTest, PropertyValueLibertyPortCtor) { PropertyValue pv(static_cast(nullptr)); EXPECT_EQ(pv.type(), PropertyValue::type_liberty_port); EXPECT_EQ(pv.libertyPort(), nullptr); @@ -7589,7 +7589,7 @@ TEST_F(StaInitTest, R5_PropertyValueLibertyPortCtor) { // === PropertyValue: Instance constructor === -TEST_F(StaInitTest, R5_PropertyValueInstanceCtor) { +TEST_F(StaInitTest, PropertyValueInstanceCtor) { PropertyValue pv(static_cast(nullptr)); EXPECT_EQ(pv.type(), PropertyValue::type_instance); EXPECT_EQ(pv.instance(), nullptr); @@ -7597,7 +7597,7 @@ TEST_F(StaInitTest, R5_PropertyValueInstanceCtor) { // === PropertyValue: Pin constructor === -TEST_F(StaInitTest, R5_PropertyValuePinCtor) { +TEST_F(StaInitTest, PropertyValuePinCtor) { PropertyValue pv(static_cast(nullptr)); EXPECT_EQ(pv.type(), PropertyValue::type_pin); EXPECT_EQ(pv.pin(), nullptr); @@ -7605,7 +7605,7 @@ TEST_F(StaInitTest, R5_PropertyValuePinCtor) { // === PropertyValue: Net constructor === -TEST_F(StaInitTest, R5_PropertyValueNetCtor) { +TEST_F(StaInitTest, PropertyValueNetCtor) { PropertyValue pv(static_cast(nullptr)); EXPECT_EQ(pv.type(), PropertyValue::type_net); EXPECT_EQ(pv.net(), nullptr); @@ -7613,7 +7613,7 @@ TEST_F(StaInitTest, R5_PropertyValueNetCtor) { // === PropertyValue: Clock constructor === -TEST_F(StaInitTest, R5_PropertyValueClockCtor) { +TEST_F(StaInitTest, PropertyValueClockCtor) { PropertyValue pv(static_cast(nullptr)); EXPECT_EQ(pv.type(), PropertyValue::type_clk); EXPECT_EQ(pv.clock(), nullptr); @@ -7624,7 +7624,7 @@ TEST_F(StaInitTest, R5_PropertyValueClockCtor) { // === Sta: maxPathCountVertex === -TEST_F(StaInitTest, R5_StaMaxPathCountVertexExists) { +TEST_F(StaInitTest, StaMaxPathCountVertexExists) { // maxPathCountVertex requires search state; just test function pointer auto fn = &Sta::maxPathCountVertex; EXPECT_NE(fn, nullptr); @@ -7632,241 +7632,241 @@ TEST_F(StaInitTest, R5_StaMaxPathCountVertexExists) { // === Sta: connectPin === -TEST_F(StaInitTest, R5_StaConnectPinExists) { +TEST_F(StaInitTest, StaConnectPinExists) { auto fn = static_cast(&Sta::connectPin); EXPECT_NE(fn, nullptr); } // === Sta: replaceCellExists === -TEST_F(StaInitTest, R5_StaReplaceCellExists) { +TEST_F(StaInitTest, StaReplaceCellExists2) { auto fn = static_cast(&Sta::replaceCell); EXPECT_NE(fn, nullptr); } // === Sta: disable functions exist === -TEST_F(StaInitTest, R5_StaDisableLibertyPortExists) { +TEST_F(StaInitTest, StaDisableLibertyPortExists) { auto fn = static_cast(&Sta::disable); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_StaDisableTimingArcSetExists) { +TEST_F(StaInitTest, StaDisableTimingArcSetExists) { auto fn = static_cast(&Sta::disable); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_StaDisableEdgeExists) { +TEST_F(StaInitTest, StaDisableEdgeExists) { auto fn = static_cast(&Sta::disable); EXPECT_NE(fn, nullptr); } // === Sta: removeDisable functions exist === -TEST_F(StaInitTest, R5_StaRemoveDisableLibertyPortExists) { +TEST_F(StaInitTest, StaRemoveDisableLibertyPortExists) { auto fn = static_cast(&Sta::removeDisable); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_StaRemoveDisableTimingArcSetExists) { +TEST_F(StaInitTest, StaRemoveDisableTimingArcSetExists) { auto fn = static_cast(&Sta::removeDisable); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_StaRemoveDisableEdgeExists) { +TEST_F(StaInitTest, StaRemoveDisableEdgeExists) { auto fn = static_cast(&Sta::removeDisable); EXPECT_NE(fn, nullptr); } // === Sta: disableClockGatingCheck === -TEST_F(StaInitTest, R5_StaDisableClockGatingCheckExists) { +TEST_F(StaInitTest, StaDisableClockGatingCheckExists) { auto fn = static_cast(&Sta::disableClockGatingCheck); EXPECT_NE(fn, nullptr); } // === Sta: removeDisableClockGatingCheck === -TEST_F(StaInitTest, R5_StaRemoveDisableClockGatingCheckExists) { +TEST_F(StaInitTest, StaRemoveDisableClockGatingCheckExists) { auto fn = static_cast(&Sta::removeDisableClockGatingCheck); EXPECT_NE(fn, nullptr); } // === Sta: vertexArrival overloads exist === -TEST_F(StaInitTest, R5_StaVertexArrivalMinMaxExists) { +TEST_F(StaInitTest, StaVertexArrivalMinMaxExists2) { auto fn = static_cast(&Sta::vertexArrival); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_StaVertexArrivalRfApExists) { +TEST_F(StaInitTest, StaVertexArrivalRfApExists) { auto fn = static_cast(&Sta::vertexArrival); EXPECT_NE(fn, nullptr); } // === Sta: vertexRequired overloads exist === -TEST_F(StaInitTest, R5_StaVertexRequiredMinMaxExists) { +TEST_F(StaInitTest, StaVertexRequiredMinMaxExists2) { auto fn = static_cast(&Sta::vertexRequired); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_StaVertexRequiredRfApExists) { +TEST_F(StaInitTest, StaVertexRequiredRfApExists) { auto fn = static_cast(&Sta::vertexRequired); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_StaVertexRequiredRfMinMaxExists) { +TEST_F(StaInitTest, StaVertexRequiredRfMinMaxExists) { auto fn = static_cast(&Sta::vertexRequired); EXPECT_NE(fn, nullptr); } // === Sta: vertexSlack overload exists === -TEST_F(StaInitTest, R5_StaVertexSlackRfApExists) { +TEST_F(StaInitTest, StaVertexSlackRfApExists) { auto fn = static_cast(&Sta::vertexSlack); EXPECT_NE(fn, nullptr); } // === Sta: vertexSlew overloads exist === -TEST_F(StaInitTest, R5_StaVertexSlewDcalcExists) { +TEST_F(StaInitTest, StaVertexSlewDcalcExists) { auto fn = static_cast(&Sta::vertexSlew); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_StaVertexSlewCornerMinMaxExists) { +TEST_F(StaInitTest, StaVertexSlewCornerMinMaxExists) { auto fn = static_cast(&Sta::vertexSlew); EXPECT_NE(fn, nullptr); } // === Sta: vertexPathIterator exists === -TEST_F(StaInitTest, R5_StaVertexPathIteratorExists) { +TEST_F(StaInitTest, StaVertexPathIteratorExists) { auto fn = static_cast(&Sta::vertexPathIterator); EXPECT_NE(fn, nullptr); } // === Sta: vertexWorstRequiredPath overloads === -TEST_F(StaInitTest, R5_StaVertexWorstRequiredPathMinMaxExists) { +TEST_F(StaInitTest, StaVertexWorstRequiredPathMinMaxExists) { auto fn = static_cast(&Sta::vertexWorstRequiredPath); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_StaVertexWorstRequiredPathRfMinMaxExists) { +TEST_F(StaInitTest, StaVertexWorstRequiredPathRfMinMaxExists) { auto fn = static_cast(&Sta::vertexWorstRequiredPath); EXPECT_NE(fn, nullptr); } // === Sta: checkCapacitance exists === -TEST_F(StaInitTest, R5_StaCheckCapacitanceExists) { +TEST_F(StaInitTest, StaCheckCapacitanceExists) { auto fn = &Sta::checkCapacitance; EXPECT_NE(fn, nullptr); } // === Sta: checkSlew exists === -TEST_F(StaInitTest, R5_StaCheckSlewExists) { +TEST_F(StaInitTest, StaCheckSlewExists) { auto fn = &Sta::checkSlew; EXPECT_NE(fn, nullptr); } // === Sta: checkFanout exists === -TEST_F(StaInitTest, R5_StaCheckFanoutExists) { +TEST_F(StaInitTest, StaCheckFanoutExists) { auto fn = &Sta::checkFanout; EXPECT_NE(fn, nullptr); } // === Sta: findSlewLimit exists === -TEST_F(StaInitTest, R5_StaFindSlewLimitExists) { +TEST_F(StaInitTest, StaFindSlewLimitExists) { auto fn = &Sta::findSlewLimit; EXPECT_NE(fn, nullptr); } // === Sta: reportCheck exists === -TEST_F(StaInitTest, R5_StaReportCheckMaxSkewExists) { +TEST_F(StaInitTest, StaReportCheckMaxSkewExists) { auto fn = static_cast(&Sta::reportCheck); EXPECT_NE(fn, nullptr); } // === Sta: pinsForClock exists === -TEST_F(StaInitTest, R5_StaPinsExists) { +TEST_F(StaInitTest, StaPinsExists) { auto fn = static_cast(&Sta::pins); EXPECT_NE(fn, nullptr); } // === Sta: removeDataCheck exists === -TEST_F(StaInitTest, R5_StaRemoveDataCheckExists) { +TEST_F(StaInitTest, StaRemoveDataCheckExists) { auto fn = &Sta::removeDataCheck; EXPECT_NE(fn, nullptr); } // === Sta: makePortPinAfter exists === -TEST_F(StaInitTest, R5_StaMakePortPinAfterExists) { +TEST_F(StaInitTest, StaMakePortPinAfterExists) { auto fn = &Sta::makePortPinAfter; EXPECT_NE(fn, nullptr); } // === Sta: setArcDelayAnnotated exists === -TEST_F(StaInitTest, R5_StaSetArcDelayAnnotatedExists) { +TEST_F(StaInitTest, StaSetArcDelayAnnotatedExists) { auto fn = &Sta::setArcDelayAnnotated; EXPECT_NE(fn, nullptr); } // === Sta: delaysInvalidFromFanin exists === -TEST_F(StaInitTest, R5_StaDelaysInvalidFromFaninExists) { +TEST_F(StaInitTest, StaDelaysInvalidFromFaninExists) { auto fn = static_cast(&Sta::delaysInvalidFromFanin); EXPECT_NE(fn, nullptr); } // === Sta: makeParasiticNetwork exists === -TEST_F(StaInitTest, R5_StaMakeParasiticNetworkExists) { +TEST_F(StaInitTest, StaMakeParasiticNetworkExists) { auto fn = &Sta::makeParasiticNetwork; EXPECT_NE(fn, nullptr); } // === Sta: pathAnalysisPt exists === -TEST_F(StaInitTest, R5_StaPathAnalysisPtExists) { +TEST_F(StaInitTest, StaPathAnalysisPtExists) { auto fn = static_cast(&Sta::pathAnalysisPt); EXPECT_NE(fn, nullptr); } // === Sta: pathDcalcAnalysisPt exists === -TEST_F(StaInitTest, R5_StaPathDcalcAnalysisPtExists) { +TEST_F(StaInitTest, StaPathDcalcAnalysisPtExists) { auto fn = &Sta::pathDcalcAnalysisPt; EXPECT_NE(fn, nullptr); } // === Sta: pvt exists === -TEST_F(StaInitTest, R5_StaPvtExists) { +TEST_F(StaInitTest, StaPvtExists) { auto fn = &Sta::pvt; EXPECT_NE(fn, nullptr); } // === Sta: setPvt exists === -TEST_F(StaInitTest, R5_StaSetPvtExists) { +TEST_F(StaInitTest, StaSetPvtExists) { auto fn = static_cast(&Sta::setPvt); EXPECT_NE(fn, nullptr); } // === Search: arrivalsValid === -TEST_F(StaInitTest, R5_SearchArrivalsValid) { +TEST_F(StaInitTest, SearchArrivalsValid) { Search *search = sta_->search(); bool valid = search->arrivalsValid(); (void)valid; @@ -7874,7 +7874,7 @@ TEST_F(StaInitTest, R5_SearchArrivalsValid) { // === Sim: findLogicConstants === -TEST_F(StaInitTest, R5_SimFindLogicConstantsExists) { +TEST_F(StaInitTest, SimFindLogicConstantsExists) { // findLogicConstants requires graph; just test function pointer auto fn = &Sim::findLogicConstants; EXPECT_NE(fn, nullptr); @@ -7882,7 +7882,7 @@ TEST_F(StaInitTest, R5_SimFindLogicConstantsExists) { // === ReportField: getters === -TEST_F(StaInitTest, R5_ReportFieldGetters) { +TEST_F(StaInitTest, ReportFieldGetters) { ReportPath *rpt = sta_->reportPath(); ReportField *field = rpt->fieldSlew(); EXPECT_NE(field, nullptr); @@ -7894,7 +7894,7 @@ TEST_F(StaInitTest, R5_ReportFieldGetters) { // === ReportField: setWidth === -TEST_F(StaInitTest, R5_ReportFieldSetWidth) { +TEST_F(StaInitTest, ReportFieldSetWidth2) { ReportPath *rpt = sta_->reportPath(); ReportField *field = rpt->fieldFanout(); int orig = field->width(); @@ -7905,7 +7905,7 @@ TEST_F(StaInitTest, R5_ReportFieldSetWidth) { // === ReportField: setEnabled === -TEST_F(StaInitTest, R5_ReportFieldSetEnabled) { +TEST_F(StaInitTest, ReportFieldSetEnabled2) { ReportPath *rpt = sta_->reportPath(); ReportField *field = rpt->fieldCapacitance(); bool orig = field->enabled(); @@ -7916,7 +7916,7 @@ TEST_F(StaInitTest, R5_ReportFieldSetEnabled) { // === ReportField: leftJustify === -TEST_F(StaInitTest, R5_ReportFieldLeftJustify) { +TEST_F(StaInitTest, ReportFieldLeftJustify) { ReportPath *rpt = sta_->reportPath(); ReportField *field = rpt->fieldSlew(); bool lj = field->leftJustify(); @@ -7925,7 +7925,7 @@ TEST_F(StaInitTest, R5_ReportFieldLeftJustify) { // === ReportField: unit === -TEST_F(StaInitTest, R5_ReportFieldUnit) { +TEST_F(StaInitTest, ReportFieldUnit) { ReportPath *rpt = sta_->reportPath(); ReportField *field = rpt->fieldSlew(); Unit *u = field->unit(); @@ -7934,7 +7934,7 @@ TEST_F(StaInitTest, R5_ReportFieldUnit) { // === Corner: constructor === -TEST_F(StaInitTest, R5_CornerCtor) { +TEST_F(StaInitTest, CornerCtor) { Corner corner("test_corner", 0); EXPECT_STREQ(corner.name(), "test_corner"); EXPECT_EQ(corner.index(), 0); @@ -7942,14 +7942,14 @@ TEST_F(StaInitTest, R5_CornerCtor) { // === Corners: count === -TEST_F(StaInitTest, R5_CornersCount) { +TEST_F(StaInitTest, CornersCount) { Corners *corners = sta_->corners(); EXPECT_GE(corners->count(), 0); } // === Path static: less with null paths === -TEST_F(StaInitTest, R5_PathStaticLessNull) { +TEST_F(StaInitTest, PathStaticLessNull) { Path p1; Path p2; // Both null - less should be false @@ -7959,7 +7959,7 @@ TEST_F(StaInitTest, R5_PathStaticLessNull) { // === Path static: lessAll with null paths === -TEST_F(StaInitTest, R5_PathStaticLessAllNull) { +TEST_F(StaInitTest, PathStaticLessAllNull) { Path p1; Path p2; bool result = Path::lessAll(&p1, &p2, sta_); @@ -7968,7 +7968,7 @@ TEST_F(StaInitTest, R5_PathStaticLessAllNull) { // === Path static: equal with null paths === -TEST_F(StaInitTest, R5_PathStaticEqualNull) { +TEST_F(StaInitTest, PathStaticEqualNull) { Path p1; Path p2; bool result = Path::equal(&p1, &p2, sta_); @@ -7977,7 +7977,7 @@ TEST_F(StaInitTest, R5_PathStaticEqualNull) { // === Sta: isClockNet returns false with no design === -TEST_F(StaInitTest, R5_StaIsClockNetExists) { +TEST_F(StaInitTest, StaIsClockNetExists2) { // isClock(Net*) dereferences the pointer; just test function pointer auto fn = static_cast(&Sta::isClock); EXPECT_NE(fn, nullptr); @@ -7985,7 +7985,7 @@ TEST_F(StaInitTest, R5_StaIsClockNetExists) { // === PropertyValue: PinSeq constructor === -TEST_F(StaInitTest, R5_PropertyValuePinSeqCtor) { +TEST_F(StaInitTest, PropertyValuePinSeqCtor) { PinSeq *pins = new PinSeq; PropertyValue pv(pins); EXPECT_EQ(pv.type(), PropertyValue::type_pins); @@ -7993,7 +7993,7 @@ TEST_F(StaInitTest, R5_PropertyValuePinSeqCtor) { // === PropertyValue: ClockSeq constructor === -TEST_F(StaInitTest, R5_PropertyValueClockSeqCtor) { +TEST_F(StaInitTest, PropertyValueClockSeqCtor) { ClockSeq *clks = new ClockSeq; PropertyValue pv(clks); EXPECT_EQ(pv.type(), PropertyValue::type_clks); @@ -8001,31 +8001,31 @@ TEST_F(StaInitTest, R5_PropertyValueClockSeqCtor) { // === Search: tagGroup returns nullptr for invalid index === -TEST_F(StaInitTest, R5_SearchTagGroupExists) { +TEST_F(StaInitTest, SearchTagGroupExists) { auto fn = static_cast(&Search::tagGroup); EXPECT_NE(fn, nullptr); } // === ClkNetwork: pinsForClock and clocks exist === -TEST_F(StaInitTest, R5_ClkNetworkPinsExists) { +TEST_F(StaInitTest, ClkNetworkPinsExists) { auto fn = static_cast(&ClkNetwork::pins); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ClkNetworkClocksExists) { +TEST_F(StaInitTest, ClkNetworkClocksExists) { auto fn = static_cast(&ClkNetwork::clocks); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ClkNetworkIsClockExists) { +TEST_F(StaInitTest, ClkNetworkIsClockExists) { auto fn = static_cast(&ClkNetwork::isClock); EXPECT_NE(fn, nullptr); } // === PathEnd: type enum values === -TEST_F(StaInitTest, R5_PathEndTypeEnums) { +TEST_F(StaInitTest, PathEndTypeEnums2) { EXPECT_EQ(PathEnd::unconstrained, 0); EXPECT_EQ(PathEnd::check, 1); EXPECT_EQ(PathEnd::data_check, 2); @@ -8037,21 +8037,21 @@ TEST_F(StaInitTest, R5_PathEndTypeEnums) { // === PathEnd: less function exists === -TEST_F(StaInitTest, R5_PathEndLessFnExists) { +TEST_F(StaInitTest, PathEndLessFnExists) { auto fn = &PathEnd::less; EXPECT_NE(fn, nullptr); } // === PathEnd: cmpNoCrpr function exists === -TEST_F(StaInitTest, R5_PathEndCmpNoCrprFnExists) { +TEST_F(StaInitTest, PathEndCmpNoCrprFnExists) { auto fn = &PathEnd::cmpNoCrpr; EXPECT_NE(fn, nullptr); } // === ReportPathFormat enum === -TEST_F(StaInitTest, R5_ReportPathFormatEnums) { +TEST_F(StaInitTest, ReportPathFormatEnums) { EXPECT_NE(ReportPathFormat::full, ReportPathFormat::json); EXPECT_NE(ReportPathFormat::full_clock, ReportPathFormat::endpoint); EXPECT_NE(ReportPathFormat::summary, ReportPathFormat::slack_only); @@ -8059,7 +8059,7 @@ TEST_F(StaInitTest, R5_ReportPathFormatEnums) { // === SearchClass constants === -TEST_F(StaInitTest, R5_SearchClassConstants) { +TEST_F(StaInitTest, SearchClassConstants2) { EXPECT_GT(tag_index_bit_count, 0u); EXPECT_EQ(tag_index_null, tag_index_max); EXPECT_GT(path_ap_index_bit_count, 0); @@ -8068,7 +8068,7 @@ TEST_F(StaInitTest, R5_SearchClassConstants) { // === ReportPath: setReportFields (public) === -TEST_F(StaInitTest, R5_ReportPathSetReportFields) { +TEST_F(StaInitTest, ReportPathSetReportFields2) { ReportPath *rpt = sta_->reportPath(); rpt->setReportFields(true, true, true, true, true, true, true); rpt->setReportFields(false, false, false, false, false, false, false); @@ -8076,7 +8076,7 @@ TEST_F(StaInitTest, R5_ReportPathSetReportFields) { // === MaxSkewCheck: skew with empty paths === -TEST_F(StaInitTest, R5_MaxSkewCheckSkewZero) { +TEST_F(StaInitTest, MaxSkewCheckSkewZero) { Path clk_path; Path ref_path; clk_path.setArrival(0.0f); @@ -8088,7 +8088,7 @@ TEST_F(StaInitTest, R5_MaxSkewCheckSkewZero) { // === MaxSkewCheck: skew with different arrivals === -TEST_F(StaInitTest, R5_MaxSkewCheckSkewNonZero) { +TEST_F(StaInitTest, MaxSkewCheckSkewNonZero) { Path clk_path; Path ref_path; clk_path.setArrival(5.0f); @@ -8100,7 +8100,7 @@ TEST_F(StaInitTest, R5_MaxSkewCheckSkewNonZero) { // === MaxSkewCheck: clkPath and refPath === -TEST_F(StaInitTest, R5_MaxSkewCheckPaths) { +TEST_F(StaInitTest, MaxSkewCheckPaths) { Path clk_path; Path ref_path; MaxSkewCheck check(&clk_path, &ref_path, nullptr, nullptr); @@ -8111,28 +8111,28 @@ TEST_F(StaInitTest, R5_MaxSkewCheckPaths) { // === ClkSkew: srcTgtPathNameLess exists === -TEST_F(StaInitTest, R5_ClkSkewSrcTgtPathNameLessExists) { +TEST_F(StaInitTest, ClkSkewSrcTgtPathNameLessExists) { auto fn = &ClkSkew::srcTgtPathNameLess; EXPECT_NE(fn, nullptr); } // === ClkSkew: srcInternalClkLatency exists === -TEST_F(StaInitTest, R5_ClkSkewSrcInternalClkLatencyExists) { +TEST_F(StaInitTest, ClkSkewSrcInternalClkLatencyExists) { auto fn = &ClkSkew::srcInternalClkLatency; EXPECT_NE(fn, nullptr); } // === ClkSkew: tgtInternalClkLatency exists === -TEST_F(StaInitTest, R5_ClkSkewTgtInternalClkLatencyExists) { +TEST_F(StaInitTest, ClkSkewTgtInternalClkLatencyExists) { auto fn = &ClkSkew::tgtInternalClkLatency; EXPECT_NE(fn, nullptr); } // === ReportPath: setReportFieldOrder === -TEST_F(StaInitTest, R5_ReportPathSetReportFieldOrderExists) { +TEST_F(StaInitTest, ReportPathSetReportFieldOrderExists) { // setReportFieldOrder(nullptr) segfaults; just test function pointer auto fn = &ReportPath::setReportFieldOrder; EXPECT_NE(fn, nullptr); @@ -8140,7 +8140,7 @@ TEST_F(StaInitTest, R5_ReportPathSetReportFieldOrderExists) { // === ReportPath: findField === -TEST_F(StaInitTest, R5_ReportPathFindFieldByName) { +TEST_F(StaInitTest, ReportPathFindFieldByName) { ReportPath *rpt = sta_->reportPath(); ReportField *slew = rpt->findField("slew"); EXPECT_NE(slew, nullptr); @@ -8155,7 +8155,7 @@ TEST_F(StaInitTest, R5_ReportPathFindFieldByName) { // === PropertyValue: std::string constructor === -TEST_F(StaInitTest, R5_PropertyValueStdStringCtor) { +TEST_F(StaInitTest, PropertyValueStdStringCtor) { std::string s = "test_string"; PropertyValue pv(s); EXPECT_EQ(pv.type(), PropertyValue::type_string); @@ -8164,7 +8164,7 @@ TEST_F(StaInitTest, R5_PropertyValueStdStringCtor) { // === Levelize: invalid === -TEST_F(StaInitTest, R5_LevelizeInvalid) { +TEST_F(StaInitTest, LevelizeInvalid) { Levelize *levelize = sta_->levelize(); levelize->invalid(); EXPECT_FALSE(levelize->levelized()); @@ -8172,34 +8172,34 @@ TEST_F(StaInitTest, R5_LevelizeInvalid) { // === R5_ Round 2: Re-add public ReportPath methods that were accidentally removed === -TEST_F(StaInitTest, R5_ReportPathDigits) { +TEST_F(StaInitTest, ReportPathDigits) { ReportPath *rpt = sta_->reportPath(); int d = rpt->digits(); EXPECT_GE(d, 0); } -TEST_F(StaInitTest, R5_ReportPathSetDigits) { +TEST_F(StaInitTest, ReportPathSetDigits) { ReportPath *rpt = sta_->reportPath(); rpt->setDigits(5); EXPECT_EQ(rpt->digits(), 5); rpt->setDigits(3); // restore default } -TEST_F(StaInitTest, R5_ReportPathReportSigmas) { +TEST_F(StaInitTest, ReportPathReportSigmas2) { ReportPath *rpt = sta_->reportPath(); bool sigmas = rpt->reportSigmas(); // Default should be false EXPECT_FALSE(sigmas); } -TEST_F(StaInitTest, R5_ReportPathSetReportSigmas) { +TEST_F(StaInitTest, ReportPathSetReportSigmas) { ReportPath *rpt = sta_->reportPath(); rpt->setReportSigmas(true); EXPECT_TRUE(rpt->reportSigmas()); rpt->setReportSigmas(false); } -TEST_F(StaInitTest, R5_ReportPathPathFormat) { +TEST_F(StaInitTest, ReportPathPathFormat) { ReportPath *rpt = sta_->reportPath(); ReportPathFormat fmt = rpt->pathFormat(); // Check it is a valid format @@ -8212,7 +8212,7 @@ TEST_F(StaInitTest, R5_ReportPathPathFormat) { || fmt == ReportPathFormat::json); } -TEST_F(StaInitTest, R5_ReportPathSetPathFormat) { +TEST_F(StaInitTest, ReportPathSetPathFormat) { ReportPath *rpt = sta_->reportPath(); ReportPathFormat old_fmt = rpt->pathFormat(); rpt->setPathFormat(ReportPathFormat::summary); @@ -8220,41 +8220,41 @@ TEST_F(StaInitTest, R5_ReportPathSetPathFormat) { rpt->setPathFormat(old_fmt); } -TEST_F(StaInitTest, R5_ReportPathFindFieldSlew) { +TEST_F(StaInitTest, ReportPathFindFieldSlew) { ReportPath *rpt = sta_->reportPath(); ReportField *slew = rpt->findField("slew"); EXPECT_NE(slew, nullptr); EXPECT_STREQ(slew->name(), "slew"); } -TEST_F(StaInitTest, R5_ReportPathFindFieldFanout) { +TEST_F(StaInitTest, ReportPathFindFieldFanout) { ReportPath *rpt = sta_->reportPath(); ReportField *fo = rpt->findField("fanout"); EXPECT_NE(fo, nullptr); EXPECT_STREQ(fo->name(), "fanout"); } -TEST_F(StaInitTest, R5_ReportPathFindFieldCapacitance) { +TEST_F(StaInitTest, ReportPathFindFieldCapacitance) { ReportPath *rpt = sta_->reportPath(); ReportField *cap = rpt->findField("capacitance"); EXPECT_NE(cap, nullptr); EXPECT_STREQ(cap->name(), "capacitance"); } -TEST_F(StaInitTest, R5_ReportPathFindFieldNonexistent) { +TEST_F(StaInitTest, ReportPathFindFieldNonexistent) { ReportPath *rpt = sta_->reportPath(); ReportField *f = rpt->findField("nonexistent_field_xyz"); EXPECT_EQ(f, nullptr); } -TEST_F(StaInitTest, R5_ReportPathSetNoSplit) { +TEST_F(StaInitTest, ReportPathSetNoSplit) { ReportPath *rpt = sta_->reportPath(); rpt->setNoSplit(true); rpt->setNoSplit(false); SUCCEED(); } -TEST_F(StaInitTest, R5_ReportPathFieldSrcAttr) { +TEST_F(StaInitTest, ReportPathFieldSrcAttr) { ReportPath *rpt = sta_->reportPath(); ReportField *src = rpt->fieldSrcAttr(); // src_attr field may or may not exist @@ -8262,7 +8262,7 @@ TEST_F(StaInitTest, R5_ReportPathFieldSrcAttr) { SUCCEED(); } -TEST_F(StaInitTest, R5_ReportPathSetReportFieldsPublic) { +TEST_F(StaInitTest, ReportPathSetReportFieldsPublic) { ReportPath *rpt = sta_->reportPath(); // Call setReportFields with various combinations rpt->setReportFields(true, false, false, false, true, false, false); @@ -8272,186 +8272,186 @@ TEST_F(StaInitTest, R5_ReportPathSetReportFieldsPublic) { // === ReportPath: header methods (public) === -TEST_F(StaInitTest, R5_ReportPathReportJsonHeaderExists) { +TEST_F(StaInitTest, ReportPathReportJsonHeaderExists) { auto fn = &ReportPath::reportJsonHeader; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportPeriodHeaderShortExists) { +TEST_F(StaInitTest, ReportPathReportPeriodHeaderShortExists) { auto fn = &ReportPath::reportPeriodHeaderShort; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportMaxSkewHeaderShortExists) { +TEST_F(StaInitTest, ReportPathReportMaxSkewHeaderShortExists) { auto fn = &ReportPath::reportMaxSkewHeaderShort; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportMpwHeaderShortExists) { +TEST_F(StaInitTest, ReportPathReportMpwHeaderShortExists) { auto fn = &ReportPath::reportMpwHeaderShort; EXPECT_NE(fn, nullptr); } // === ReportPath: report method function pointers === -TEST_F(StaInitTest, R5_ReportPathReportPathEndHeaderExists) { +TEST_F(StaInitTest, ReportPathReportPathEndHeaderExists) { auto fn = &ReportPath::reportPathEndHeader; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportPathEndFooterExists) { +TEST_F(StaInitTest, ReportPathReportPathEndFooterExists) { auto fn = &ReportPath::reportPathEndFooter; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportEndHeaderExists) { +TEST_F(StaInitTest, ReportPathReportEndHeaderExists) { auto fn = &ReportPath::reportEndHeader; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportSummaryHeaderExists) { +TEST_F(StaInitTest, ReportPathReportSummaryHeaderExists) { auto fn = &ReportPath::reportSummaryHeader; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportSlackOnlyHeaderExists) { +TEST_F(StaInitTest, ReportPathReportSlackOnlyHeaderExists) { auto fn = &ReportPath::reportSlackOnlyHeader; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportJsonFooterExists) { +TEST_F(StaInitTest, ReportPathReportJsonFooterExists) { auto fn = &ReportPath::reportJsonFooter; EXPECT_NE(fn, nullptr); } // === ReportPath: reportCheck overloads === -TEST_F(StaInitTest, R5_ReportPathReportCheckMinPeriodExists) { +TEST_F(StaInitTest, ReportPathReportCheckMinPeriodExists) { auto fn = static_cast( &ReportPath::reportCheck); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportCheckMaxSkewExists) { +TEST_F(StaInitTest, ReportPathReportCheckMaxSkewExists) { auto fn = static_cast( &ReportPath::reportCheck); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportChecksMinPeriodExists) { +TEST_F(StaInitTest, ReportPathReportChecksMinPeriodExists) { auto fn = static_cast( &ReportPath::reportChecks); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportChecksMaxSkewExists) { +TEST_F(StaInitTest, ReportPathReportChecksMaxSkewExists) { auto fn = static_cast( &ReportPath::reportChecks); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportMpwCheckExists) { +TEST_F(StaInitTest, ReportPathReportMpwCheckExists) { auto fn = &ReportPath::reportMpwCheck; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportMpwChecksExists) { +TEST_F(StaInitTest, ReportPathReportMpwChecksExists) { auto fn = &ReportPath::reportMpwChecks; EXPECT_NE(fn, nullptr); } // === ReportPath: report short/full/json overloads === -TEST_F(StaInitTest, R5_ReportPathReportShortMaxSkewCheckExists) { +TEST_F(StaInitTest, ReportPathReportShortMaxSkewCheckExists) { auto fn = static_cast( &ReportPath::reportShort); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportVerboseMaxSkewCheckExists) { +TEST_F(StaInitTest, ReportPathReportVerboseMaxSkewCheckExists) { auto fn = static_cast( &ReportPath::reportVerbose); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportShortMinPeriodCheckExists) { +TEST_F(StaInitTest, ReportPathReportShortMinPeriodCheckExists) { auto fn = static_cast( &ReportPath::reportShort); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportVerboseMinPeriodCheckExists) { +TEST_F(StaInitTest, ReportPathReportVerboseMinPeriodCheckExists) { auto fn = static_cast( &ReportPath::reportVerbose); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportShortMinPulseWidthCheckExists) { +TEST_F(StaInitTest, ReportPathReportShortMinPulseWidthCheckExists) { auto fn = static_cast( &ReportPath::reportShort); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportVerboseMinPulseWidthCheckExists) { +TEST_F(StaInitTest, ReportPathReportVerboseMinPulseWidthCheckExists) { auto fn = static_cast( &ReportPath::reportVerbose); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportLimitShortHeaderExists) { +TEST_F(StaInitTest, ReportPathReportLimitShortHeaderExists) { auto fn = &ReportPath::reportLimitShortHeader; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportLimitShortExists) { +TEST_F(StaInitTest, ReportPathReportLimitShortExists) { auto fn = &ReportPath::reportLimitShort; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportLimitVerboseExists) { +TEST_F(StaInitTest, ReportPathReportLimitVerboseExists) { auto fn = &ReportPath::reportLimitVerbose; EXPECT_NE(fn, nullptr); } // === ReportPath: report short for PathEnd types === -TEST_F(StaInitTest, R5_ReportPathReportShortCheckExists) { +TEST_F(StaInitTest, ReportPathReportShortCheckExists) { auto fn = static_cast( &ReportPath::reportShort); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportShortLatchCheckExists) { +TEST_F(StaInitTest, ReportPathReportShortLatchCheckExists) { auto fn = static_cast( &ReportPath::reportShort); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportShortPathDelayExists) { +TEST_F(StaInitTest, ReportPathReportShortPathDelayExists) { auto fn = static_cast( &ReportPath::reportShort); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportShortOutputDelayExists) { +TEST_F(StaInitTest, ReportPathReportShortOutputDelayExists) { auto fn = static_cast( &ReportPath::reportShort); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportShortGatedClockExists) { +TEST_F(StaInitTest, ReportPathReportShortGatedClockExists) { auto fn = static_cast( &ReportPath::reportShort); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportShortDataCheckExists) { +TEST_F(StaInitTest, ReportPathReportShortDataCheckExists) { auto fn = static_cast( &ReportPath::reportShort); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportShortUnconstrainedExists) { +TEST_F(StaInitTest, ReportPathReportShortUnconstrainedExists) { auto fn = static_cast( &ReportPath::reportShort); EXPECT_NE(fn, nullptr); @@ -8459,43 +8459,43 @@ TEST_F(StaInitTest, R5_ReportPathReportShortUnconstrainedExists) { // === ReportPath: reportFull for PathEnd types === -TEST_F(StaInitTest, R5_ReportPathReportFullCheckExists) { +TEST_F(StaInitTest, ReportPathReportFullCheckExists) { auto fn = static_cast( &ReportPath::reportFull); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportFullLatchCheckExists) { +TEST_F(StaInitTest, ReportPathReportFullLatchCheckExists) { auto fn = static_cast( &ReportPath::reportFull); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportFullPathDelayExists) { +TEST_F(StaInitTest, ReportPathReportFullPathDelayExists) { auto fn = static_cast( &ReportPath::reportFull); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportFullOutputDelayExists) { +TEST_F(StaInitTest, ReportPathReportFullOutputDelayExists) { auto fn = static_cast( &ReportPath::reportFull); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportFullGatedClockExists) { +TEST_F(StaInitTest, ReportPathReportFullGatedClockExists) { auto fn = static_cast( &ReportPath::reportFull); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportFullDataCheckExists) { +TEST_F(StaInitTest, ReportPathReportFullDataCheckExists) { auto fn = static_cast( &ReportPath::reportFull); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportFullUnconstrainedExists) { +TEST_F(StaInitTest, ReportPathReportFullUnconstrainedExists) { auto fn = static_cast( &ReportPath::reportFull); EXPECT_NE(fn, nullptr); @@ -8503,7 +8503,7 @@ TEST_F(StaInitTest, R5_ReportPathReportFullUnconstrainedExists) { // === ReportField: blank getter === -TEST_F(StaInitTest, R5_ReportFieldBlank) { +TEST_F(StaInitTest, ReportFieldBlank2) { ReportPath *rpt = sta_->reportPath(); ReportField *field = rpt->fieldSlew(); const char *blank = field->blank(); @@ -8512,7 +8512,7 @@ TEST_F(StaInitTest, R5_ReportFieldBlank) { // === ReportField: setProperties === -TEST_F(StaInitTest, R5_ReportFieldSetProperties) { +TEST_F(StaInitTest, ReportFieldSetProperties2) { ReportPath *rpt = sta_->reportPath(); ReportField *field = rpt->fieldSlew(); int old_width = field->width(); @@ -8527,63 +8527,63 @@ TEST_F(StaInitTest, R5_ReportFieldSetProperties) { // === CheckCapacitanceLimits: constructor === -TEST_F(StaInitTest, R5_CheckCapacitanceLimitsCtorDtor) { +TEST_F(StaInitTest, CheckCapacitanceLimitsCtorDtor) { CheckCapacitanceLimits checker(sta_); SUCCEED(); } // === CheckSlewLimits: constructor === -TEST_F(StaInitTest, R5_CheckSlewLimitsCtorDtor) { +TEST_F(StaInitTest, CheckSlewLimitsCtorDtor) { CheckSlewLimits checker(sta_); SUCCEED(); } // === CheckFanoutLimits: constructor === -TEST_F(StaInitTest, R5_CheckFanoutLimitsCtorDtor) { +TEST_F(StaInitTest, CheckFanoutLimitsCtorDtor) { CheckFanoutLimits checker(sta_); SUCCEED(); } // === PathExpanded: empty constructor === -TEST_F(StaInitTest, R5_PathExpandedEmptyCtor) { +TEST_F(StaInitTest, PathExpandedEmptyCtor) { PathExpanded expanded(sta_); EXPECT_EQ(expanded.size(), static_cast(0)); } // === PathGroups: static group names === -TEST_F(StaInitTest, R5_PathGroupsAsyncGroupName) { +TEST_F(StaInitTest, PathGroupsAsyncGroupName) { const char *name = PathGroups::asyncPathGroupName(); EXPECT_NE(name, nullptr); } -TEST_F(StaInitTest, R5_PathGroupsPathDelayGroupName) { +TEST_F(StaInitTest, PathGroupsPathDelayGroupName) { const char *name = PathGroups::pathDelayGroupName(); EXPECT_NE(name, nullptr); } -TEST_F(StaInitTest, R5_PathGroupsGatedClkGroupName) { +TEST_F(StaInitTest, PathGroupsGatedClkGroupName) { const char *name = PathGroups::gatedClkGroupName(); EXPECT_NE(name, nullptr); } -TEST_F(StaInitTest, R5_PathGroupsUnconstrainedGroupName) { +TEST_F(StaInitTest, PathGroupsUnconstrainedGroupName) { const char *name = PathGroups::unconstrainedGroupName(); EXPECT_NE(name, nullptr); } // === PathGroup: static max path count === -TEST_F(StaInitTest, R5_PathGroupMaxPathCountMax) { +TEST_F(StaInitTest, PathGroupMaxPathCountMax) { EXPECT_GT(PathGroup::group_path_count_max, static_cast(0)); } // === PathGroup: makePathGroupSlack factory === -TEST_F(StaInitTest, R5_PathGroupMakeSlack) { +TEST_F(StaInitTest, PathGroupMakeSlack2) { PathGroup *pg = PathGroup::makePathGroupSlack( "test_slack", 10, 1, false, false, -1e30, 1e30, sta_); EXPECT_NE(pg, nullptr); @@ -8594,7 +8594,7 @@ TEST_F(StaInitTest, R5_PathGroupMakeSlack) { // === PathGroup: makePathGroupArrival factory === -TEST_F(StaInitTest, R5_PathGroupMakeArrival) { +TEST_F(StaInitTest, PathGroupMakeArrival2) { PathGroup *pg = PathGroup::makePathGroupArrival( "test_arrival", 5, 1, false, false, MinMax::max(), sta_); EXPECT_NE(pg, nullptr); @@ -8604,7 +8604,7 @@ TEST_F(StaInitTest, R5_PathGroupMakeArrival) { // === PathGroup: clear and pathEnds === -TEST_F(StaInitTest, R5_PathGroupClear) { +TEST_F(StaInitTest, PathGroupClear) { PathGroup *pg = PathGroup::makePathGroupSlack( "test_clear", 10, 1, false, false, -1e30, 1e30, sta_); const PathEndSeq &ends = pg->pathEnds(); @@ -8616,33 +8616,33 @@ TEST_F(StaInitTest, R5_PathGroupClear) { // === CheckCrpr: constructor === -TEST_F(StaInitTest, R5_CheckCrprCtor) { +TEST_F(StaInitTest, CheckCrprCtor) { CheckCrpr crpr(sta_); SUCCEED(); } // === GatedClk: constructor === -TEST_F(StaInitTest, R5_GatedClkCtor) { +TEST_F(StaInitTest, GatedClkCtor) { GatedClk gclk(sta_); SUCCEED(); } // === ClkLatency: constructor === -TEST_F(StaInitTest, R5_ClkLatencyCtor) { +TEST_F(StaInitTest, ClkLatencyCtor) { ClkLatency lat(sta_); SUCCEED(); } // === Sta function pointers: more uncovered methods === -TEST_F(StaInitTest, R5_StaVertexSlacksExists) { +TEST_F(StaInitTest, StaVertexSlacksExists2) { auto fn = &Sta::vertexSlacks; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_StaReportCheckMaxSkewBoolExists) { +TEST_F(StaInitTest, StaReportCheckMaxSkewBoolExists) { auto fn = static_cast(&Sta::reportCheck); EXPECT_NE(fn, nullptr); } @@ -8653,41 +8653,41 @@ TEST_F(StaInitTest, R5_StaReportCheckMaxSkewBoolExists) { // === Path: more static methods === -TEST_F(StaInitTest, R5_PathEqualBothNull) { +TEST_F(StaInitTest, PathEqualBothNull) { bool eq = Path::equal(nullptr, nullptr, sta_); EXPECT_TRUE(eq); } // === Search: more function pointers === -TEST_F(StaInitTest, R5_SearchSaveEnumPathExists) { +TEST_F(StaInitTest, SearchSaveEnumPathExists) { auto fn = &Search::saveEnumPath; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_SearchVisitEndpointsExists) { +TEST_F(StaInitTest, SearchVisitEndpointsExists) { auto fn = &Search::visitEndpoints; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_SearchCheckPrevPathsExists) { +TEST_F(StaInitTest, SearchCheckPrevPathsExists) { auto fn = &Search::checkPrevPaths; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_SearchIsGenClkSrcExists) { +TEST_F(StaInitTest, SearchIsGenClkSrcExists) { auto fn = &Search::isGenClkSrc; EXPECT_NE(fn, nullptr); } // === Levelize: more methods === -TEST_F(StaInitTest, R5_LevelizeCheckLevelsExists) { +TEST_F(StaInitTest, LevelizeCheckLevelsExists) { auto fn = &Levelize::checkLevels; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_LevelizeLevelized) { +TEST_F(StaInitTest, LevelizeLevelized) { Levelize *levelize = sta_->levelize(); bool lev = levelize->levelized(); (void)lev; @@ -8696,14 +8696,14 @@ TEST_F(StaInitTest, R5_LevelizeLevelized) { // === Sim: more methods === -TEST_F(StaInitTest, R5_SimMakePinAfterExists) { +TEST_F(StaInitTest, SimMakePinAfterExists) { auto fn = &Sim::makePinAfter; EXPECT_NE(fn, nullptr); } // === Corners: iteration === -TEST_F(StaInitTest, R5_CornersIteration) { +TEST_F(StaInitTest, CornersIteration) { Corners *corners = sta_->corners(); int count = corners->count(); EXPECT_GE(count, 1); @@ -8711,7 +8711,7 @@ TEST_F(StaInitTest, R5_CornersIteration) { EXPECT_NE(corner, nullptr); } -TEST_F(StaInitTest, R5_CornerFindName) { +TEST_F(StaInitTest, CornerFindName) { Corners *corners = sta_->corners(); Corner *corner = corners->findCorner("default"); (void)corner; @@ -8720,7 +8720,7 @@ TEST_F(StaInitTest, R5_CornerFindName) { // === Corner: name and index === -TEST_F(StaInitTest, R5_CornerNameAndIndex) { +TEST_F(StaInitTest, CornerNameAndIndex) { Corners *corners = sta_->corners(); Corner *corner = corners->findCorner(0); EXPECT_NE(corner, nullptr); @@ -8732,52 +8732,52 @@ TEST_F(StaInitTest, R5_CornerNameAndIndex) { // === PathEnd: function pointer existence for virtual methods === -TEST_F(StaInitTest, R5_PathEndTransitionExists) { +TEST_F(StaInitTest, PathEndTransitionExists) { auto fn = &PathEnd::transition; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_PathEndTargetClkExists) { +TEST_F(StaInitTest, PathEndTargetClkExists) { auto fn = &PathEnd::targetClk; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_PathEndTargetClkDelayExists) { +TEST_F(StaInitTest, PathEndTargetClkDelayExists) { auto fn = &PathEnd::targetClkDelay; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_PathEndTargetClkArrivalExists) { +TEST_F(StaInitTest, PathEndTargetClkArrivalExists) { auto fn = &PathEnd::targetClkArrival; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_PathEndTargetClkUncertaintyExists) { +TEST_F(StaInitTest, PathEndTargetClkUncertaintyExists) { auto fn = &PathEnd::targetClkUncertainty; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_PathEndInterClkUncertaintyExists) { +TEST_F(StaInitTest, PathEndInterClkUncertaintyExists) { auto fn = &PathEnd::interClkUncertainty; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_PathEndTargetClkMcpAdjustmentExists) { +TEST_F(StaInitTest, PathEndTargetClkMcpAdjustmentExists) { auto fn = &PathEnd::targetClkMcpAdjustment; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_PathEndTargetClkInsertionDelayExists) { +TEST_F(StaInitTest, PathEndTargetClkInsertionDelayExists) { auto fn = &PathEnd::targetClkInsertionDelay; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_PathEndTargetNonInterClkUncertaintyExists) { +TEST_F(StaInitTest, PathEndTargetNonInterClkUncertaintyExists) { auto fn = &PathEnd::targetNonInterClkUncertainty; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_PathEndPathIndexExists) { +TEST_F(StaInitTest, PathEndPathIndexExists) { auto fn = &PathEnd::pathIndex; EXPECT_NE(fn, nullptr); } @@ -8787,48 +8787,48 @@ TEST_F(StaInitTest, R5_PathEndPathIndexExists) { // === ReportPath: reportPathEnds function pointer === -TEST_F(StaInitTest, R5_ReportPathReportPathEndsExists) { +TEST_F(StaInitTest, ReportPathReportPathEndsExists) { auto fn = &ReportPath::reportPathEnds; EXPECT_NE(fn, nullptr); } // === ReportPath: reportPath function pointer (Path*) === -TEST_F(StaInitTest, R5_ReportPathReportPathExists) { +TEST_F(StaInitTest, ReportPathReportPathExists) { auto fn = static_cast(&ReportPath::reportPath); EXPECT_NE(fn, nullptr); } // === ReportPath: reportEndLine function pointer === -TEST_F(StaInitTest, R5_ReportPathReportEndLineExists) { +TEST_F(StaInitTest, ReportPathReportEndLineExists) { auto fn = &ReportPath::reportEndLine; EXPECT_NE(fn, nullptr); } // === ReportPath: reportSummaryLine function pointer === -TEST_F(StaInitTest, R5_ReportPathReportSummaryLineExists) { +TEST_F(StaInitTest, ReportPathReportSummaryLineExists) { auto fn = &ReportPath::reportSummaryLine; EXPECT_NE(fn, nullptr); } // === ReportPath: reportSlackOnly function pointer === -TEST_F(StaInitTest, R5_ReportPathReportSlackOnlyExists) { +TEST_F(StaInitTest, ReportPathReportSlackOnlyExists) { auto fn = &ReportPath::reportSlackOnly; EXPECT_NE(fn, nullptr); } // === ReportPath: reportJson overloads === -TEST_F(StaInitTest, R5_ReportPathReportJsonPathEndExists) { +TEST_F(StaInitTest, ReportPathReportJsonPathEndExists) { auto fn = static_cast( &ReportPath::reportJson); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportJsonPathExists) { +TEST_F(StaInitTest, ReportPathReportJsonPathExists) { auto fn = static_cast( &ReportPath::reportJson); EXPECT_NE(fn, nullptr); @@ -8836,14 +8836,14 @@ TEST_F(StaInitTest, R5_ReportPathReportJsonPathExists) { // === Search: pathClkPathArrival function pointers === -TEST_F(StaInitTest, R5_SearchPathClkPathArrivalExists) { +TEST_F(StaInitTest, SearchPathClkPathArrivalExists) { auto fn = &Search::pathClkPathArrival; EXPECT_NE(fn, nullptr); } // === Genclks: more function pointers === -TEST_F(StaInitTest, R5_GenclksFindLatchFdbkEdgesExists) { +TEST_F(StaInitTest, GenclksFindLatchFdbkEdgesExists) { auto fn = static_cast(&Genclks::findLatchFdbkEdges); EXPECT_NE(fn, nullptr); } @@ -8856,68 +8856,68 @@ TEST_F(StaInitTest, R5_GenclksFindLatchFdbkEdgesExists) { // === MinPulseWidthCheck: corner function pointer === -TEST_F(StaInitTest, R5_MinPulseWidthCheckCornerExists) { +TEST_F(StaInitTest, MinPulseWidthCheckCornerExists) { auto fn = &MinPulseWidthCheck::corner; EXPECT_NE(fn, nullptr); } // === MaxSkewCheck: more function pointers === -TEST_F(StaInitTest, R5_MaxSkewCheckClkPinExists) { +TEST_F(StaInitTest, MaxSkewCheckClkPinExists) { auto fn = &MaxSkewCheck::clkPin; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_MaxSkewCheckRefPinExists) { +TEST_F(StaInitTest, MaxSkewCheckRefPinExists) { auto fn = &MaxSkewCheck::refPin; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_MaxSkewCheckMaxSkewMethodExists) { +TEST_F(StaInitTest, MaxSkewCheckMaxSkewMethodExists) { auto fn = &MaxSkewCheck::maxSkew; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_MaxSkewCheckSlackExists) { +TEST_F(StaInitTest, MaxSkewCheckSlackExists) { auto fn = &MaxSkewCheck::slack; EXPECT_NE(fn, nullptr); } // === ClkInfo: more function pointers === -TEST_F(StaInitTest, R5_ClkInfoCrprClkPathRawExists) { +TEST_F(StaInitTest, ClkInfoCrprClkPathRawExists) { auto fn = &ClkInfo::crprClkPathRaw; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ClkInfoIsPropagatedExists) { +TEST_F(StaInitTest, ClkInfoIsPropagatedExists2) { auto fn = &ClkInfo::isPropagated; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ClkInfoIsGenClkSrcPathExists) { +TEST_F(StaInitTest, ClkInfoIsGenClkSrcPathExists2) { auto fn = &ClkInfo::isGenClkSrcPath; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ClkInfoClkEdgeExists) { +TEST_F(StaInitTest, ClkInfoClkEdgeExists) { auto fn = &ClkInfo::clkEdge; EXPECT_NE(fn, nullptr); } // === Tag: more function pointers === -TEST_F(StaInitTest, R5_TagPathAPIndexExists) { +TEST_F(StaInitTest, TagPathAPIndexExists2) { auto fn = &Tag::pathAPIndex; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_TagClkSrcExists) { +TEST_F(StaInitTest, TagClkSrcExists) { auto fn = &Tag::clkSrc; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_TagSetStatesExists) { +TEST_F(StaInitTest, TagSetStatesExists) { auto fn = &Tag::setStates; EXPECT_NE(fn, nullptr); } @@ -8926,37 +8926,37 @@ TEST_F(StaInitTest, R5_TagSetStatesExists) { // === Path: more function pointers === -TEST_F(StaInitTest, R5_PathPrevVertexExists) { +TEST_F(StaInitTest, PathPrevVertexExists2) { auto fn = &Path::prevVertex; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_PathCheckPrevPathExists) { +TEST_F(StaInitTest, PathCheckPrevPathExists2) { auto fn = &Path::checkPrevPath; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_PathTagIndexExists) { +TEST_F(StaInitTest, PathTagIndexExists2) { auto fn = &Path::tagIndex; EXPECT_NE(fn, nullptr); } // === PathEnd: reportShort virtual function pointer === -TEST_F(StaInitTest, R5_PathEndReportShortExists) { +TEST_F(StaInitTest, PathEndReportShortExists) { auto fn = &PathEnd::reportShort; EXPECT_NE(fn, nullptr); } // === ReportPath: reportPathEnd overloads === -TEST_F(StaInitTest, R5_ReportPathReportPathEndSingleExists) { +TEST_F(StaInitTest, ReportPathReportPathEndSingleExists) { auto fn = static_cast( &ReportPath::reportPathEnd); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_ReportPathReportPathEndPrevExists) { +TEST_F(StaInitTest, ReportPathReportPathEndPrevExists) { auto fn = static_cast( &ReportPath::reportPathEnd); EXPECT_NE(fn, nullptr); @@ -8966,7 +8966,7 @@ TEST_F(StaInitTest, R5_ReportPathReportPathEndPrevExists) { // === Corner: DcalcAnalysisPt access === -TEST_F(StaInitTest, R5_CornerDcalcAnalysisPt) { +TEST_F(StaInitTest, CornerDcalcAnalysisPt) { Corners *corners = sta_->corners(); Corner *corner = corners->findCorner(0); EXPECT_NE(corner, nullptr); @@ -8976,13 +8976,13 @@ TEST_F(StaInitTest, R5_CornerDcalcAnalysisPt) { // === PathAnalysisPt access through Corners === -TEST_F(StaInitTest, R5_CornersPathAnalysisPtCount) { +TEST_F(StaInitTest, CornersPathAnalysisPtCount2) { Corners *corners = sta_->corners(); int count = corners->pathAnalysisPtCount(); EXPECT_GT(count, 0); } -TEST_F(StaInitTest, R5_CornersDcalcAnalysisPtCount) { +TEST_F(StaInitTest, CornersDcalcAnalysisPtCount2) { Corners *corners = sta_->corners(); int count = corners->dcalcAnalysisPtCount(); EXPECT_GT(count, 0); @@ -8990,35 +8990,35 @@ TEST_F(StaInitTest, R5_CornersDcalcAnalysisPtCount) { // === Sta: isClock(Pin*) function pointer === -TEST_F(StaInitTest, R5_StaIsClockPinExists) { +TEST_F(StaInitTest, StaIsClockPinExists2) { auto fn = static_cast(&Sta::isClock); EXPECT_NE(fn, nullptr); } // === GraphLoop: report function pointer === -TEST_F(StaInitTest, R5_GraphLoopReportExists) { +TEST_F(StaInitTest, GraphLoopReportExists) { auto fn = &GraphLoop::report; EXPECT_NE(fn, nullptr); } // === SearchPredNonReg2: searchThru function pointer === -TEST_F(StaInitTest, R5_SearchPredNonReg2SearchThruExists) { +TEST_F(StaInitTest, SearchPredNonReg2SearchThruExists) { auto fn = &SearchPredNonReg2::searchThru; EXPECT_NE(fn, nullptr); } // === CheckCrpr: maxCrpr function pointer === -TEST_F(StaInitTest, R5_CheckCrprMaxCrprExists) { +TEST_F(StaInitTest, CheckCrprMaxCrprExists) { auto fn = &CheckCrpr::maxCrpr; EXPECT_NE(fn, nullptr); } // === CheckCrpr: checkCrpr function pointers === -TEST_F(StaInitTest, R5_CheckCrprCheckCrpr2ArgExists) { +TEST_F(StaInitTest, CheckCrprCheckCrpr2ArgExists) { auto fn = static_cast( &CheckCrpr::checkCrpr); EXPECT_NE(fn, nullptr); @@ -9026,7 +9026,7 @@ TEST_F(StaInitTest, R5_CheckCrprCheckCrpr2ArgExists) { // === GatedClk: isGatedClkEnable function pointer === -TEST_F(StaInitTest, R5_GatedClkIsGatedClkEnableExists) { +TEST_F(StaInitTest, GatedClkIsGatedClkEnableExists) { auto fn = static_cast( &GatedClk::isGatedClkEnable); EXPECT_NE(fn, nullptr); @@ -9034,39 +9034,39 @@ TEST_F(StaInitTest, R5_GatedClkIsGatedClkEnableExists) { // === GatedClk: gatedClkActiveTrans function pointer === -TEST_F(StaInitTest, R5_GatedClkGatedClkActiveTransExists) { +TEST_F(StaInitTest, GatedClkGatedClkActiveTransExists) { auto fn = &GatedClk::gatedClkActiveTrans; EXPECT_NE(fn, nullptr); } // === FindRegister: free functions === -TEST_F(StaInitTest, R5_FindRegInstancesExists) { +TEST_F(StaInitTest, FindRegInstancesExists) { auto fn = &findRegInstances; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_FindRegDataPinsExists) { +TEST_F(StaInitTest, FindRegDataPinsExists) { auto fn = &findRegDataPins; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_FindRegClkPinsExists) { +TEST_F(StaInitTest, FindRegClkPinsExists) { auto fn = &findRegClkPins; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_FindRegAsyncPinsExists) { +TEST_F(StaInitTest, FindRegAsyncPinsExists) { auto fn = &findRegAsyncPins; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_FindRegOutputPinsExists) { +TEST_F(StaInitTest, FindRegOutputPinsExists) { auto fn = &findRegOutputPins; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R5_InitPathSenseThruExists) { +TEST_F(StaInitTest, InitPathSenseThruExists) { auto fn = &initPathSenseThru; EXPECT_NE(fn, nullptr); } @@ -9077,7 +9077,7 @@ TEST_F(StaInitTest, R5_InitPathSenseThruExists) { // === OutputDelays: constructor and timingSense === -TEST_F(StaInitTest, R6_OutputDelaysCtorAndTimingSense) { +TEST_F(StaInitTest, OutputDelaysCtorAndTimingSense) { OutputDelays od; TimingSense sense = od.timingSense(); (void)sense; @@ -9086,7 +9086,7 @@ TEST_F(StaInitTest, R6_OutputDelaysCtorAndTimingSense) { // === ClkDelays: constructor and latency === -TEST_F(StaInitTest, R6_ClkDelaysDefaultCtor) { +TEST_F(StaInitTest, ClkDelaysDefaultCtor) { ClkDelays cd; // Test default-constructed ClkDelays latency accessor Delay delay_val; @@ -9097,7 +9097,7 @@ TEST_F(StaInitTest, R6_ClkDelaysDefaultCtor) { EXPECT_FALSE(exists); } -TEST_F(StaInitTest, R6_ClkDelaysLatencyStatic) { +TEST_F(StaInitTest, ClkDelaysLatencyStatic) { // Static latency with null path auto fn = static_cast(&ClkDelays::latency); EXPECT_NE(fn, nullptr); @@ -9105,27 +9105,27 @@ TEST_F(StaInitTest, R6_ClkDelaysLatencyStatic) { // === Bdd: constructor and destructor === -TEST_F(StaInitTest, R6_BddCtorDtor) { +TEST_F(StaInitTest, BddCtorDtor) { Bdd bdd(sta_); // Just constructing and destructing exercises the vtable SUCCEED(); } -TEST_F(StaInitTest, R6_BddNodePortExists) { +TEST_F(StaInitTest, BddNodePortExists) { auto fn = &Bdd::nodePort; EXPECT_NE(fn, nullptr); } // === PathExpanded: constructor with two args (Path*, bool, StaState*) === -TEST_F(StaInitTest, R6_PathExpandedStaOnlyCtor) { +TEST_F(StaInitTest, PathExpandedStaOnlyCtor) { PathExpanded expanded(sta_); EXPECT_EQ(expanded.size(), 0u); } // === Search: visitEndpoints === -TEST_F(StaInitTest, R6_SearchVisitEndpointsExists) { +TEST_F(StaInitTest, SearchVisitEndpointsExists2) { auto fn = &Search::visitEndpoints; EXPECT_NE(fn, nullptr); } @@ -9134,7 +9134,7 @@ TEST_F(StaInitTest, R6_SearchVisitEndpointsExists) { // === Search: findPathGroup by name === -TEST_F(StaInitTest, R6_SearchFindPathGroupByName) { +TEST_F(StaInitTest, SearchFindPathGroupByName) { Search *search = sta_->search(); PathGroup *grp = search->findPathGroup("nonexistent", MinMax::max()); EXPECT_EQ(grp, nullptr); @@ -9142,7 +9142,7 @@ TEST_F(StaInitTest, R6_SearchFindPathGroupByName) { // === Search: findPathGroup by clock === -TEST_F(StaInitTest, R6_SearchFindPathGroupByClock) { +TEST_F(StaInitTest, SearchFindPathGroupByClock) { Search *search = sta_->search(); PathGroup *grp = search->findPathGroup(static_cast(nullptr), MinMax::max()); @@ -9151,7 +9151,7 @@ TEST_F(StaInitTest, R6_SearchFindPathGroupByClock) { // === Search: tag === -TEST_F(StaInitTest, R6_SearchTagZero) { +TEST_F(StaInitTest, SearchTagZero) { Search *search = sta_->search(); // tagCount should be 0 initially TagIndex count = search->tagCount(); @@ -9161,7 +9161,7 @@ TEST_F(StaInitTest, R6_SearchTagZero) { // === Search: tagGroupCount === -TEST_F(StaInitTest, R6_SearchTagGroupCount) { +TEST_F(StaInitTest, SearchTagGroupCount3) { Search *search = sta_->search(); TagGroupIndex count = search->tagGroupCount(); (void)count; @@ -9170,7 +9170,7 @@ TEST_F(StaInitTest, R6_SearchTagGroupCount) { // === Search: clkInfoCount === -TEST_F(StaInitTest, R6_SearchClkInfoCount) { +TEST_F(StaInitTest, SearchClkInfoCount3) { Search *search = sta_->search(); int count = search->clkInfoCount(); EXPECT_EQ(count, 0); @@ -9178,7 +9178,7 @@ TEST_F(StaInitTest, R6_SearchClkInfoCount) { // === Search: initVars (called indirectly through clear) === -TEST_F(StaInitTest, R6_SearchClear) { +TEST_F(StaInitTest, SearchClear3) { Search *search = sta_->search(); search->clear(); SUCCEED(); @@ -9186,14 +9186,14 @@ TEST_F(StaInitTest, R6_SearchClear) { // === Search: checkPrevPaths === -TEST_F(StaInitTest, R6_SearchCheckPrevPathsExists) { +TEST_F(StaInitTest, SearchCheckPrevPathsExists2) { auto fn = &Search::checkPrevPaths; EXPECT_NE(fn, nullptr); } // === Search: arrivalsValid === -TEST_F(StaInitTest, R6_SearchArrivalsValid) { +TEST_F(StaInitTest, SearchArrivalsValid2) { Search *search = sta_->search(); bool valid = search->arrivalsValid(); (void)valid; @@ -9204,7 +9204,7 @@ TEST_F(StaInitTest, R6_SearchArrivalsValid) { // === Search: havePathGroups === -TEST_F(StaInitTest, R6_SearchHavePathGroups) { +TEST_F(StaInitTest, SearchHavePathGroups3) { Search *search = sta_->search(); bool have = search->havePathGroups(); EXPECT_FALSE(have); @@ -9212,7 +9212,7 @@ TEST_F(StaInitTest, R6_SearchHavePathGroups) { // === Search: requiredsSeeded === -TEST_F(StaInitTest, R6_SearchRequiredsSeeded) { +TEST_F(StaInitTest, SearchRequiredsSeeded2) { Search *search = sta_->search(); bool seeded = search->requiredsSeeded(); EXPECT_FALSE(seeded); @@ -9220,7 +9220,7 @@ TEST_F(StaInitTest, R6_SearchRequiredsSeeded) { // === Search: requiredsExist === -TEST_F(StaInitTest, R6_SearchRequiredsExist) { +TEST_F(StaInitTest, SearchRequiredsExist2) { Search *search = sta_->search(); bool exist = search->requiredsExist(); EXPECT_FALSE(exist); @@ -9228,7 +9228,7 @@ TEST_F(StaInitTest, R6_SearchRequiredsExist) { // === Search: arrivalsAtEndpointsExist === -TEST_F(StaInitTest, R6_SearchArrivalsAtEndpointsExist) { +TEST_F(StaInitTest, SearchArrivalsAtEndpointsExist2) { Search *search = sta_->search(); bool exist = search->arrivalsAtEndpointsExist(); EXPECT_FALSE(exist); @@ -9236,7 +9236,7 @@ TEST_F(StaInitTest, R6_SearchArrivalsAtEndpointsExist) { // === Search: crprPathPruningEnabled / setCrprpathPruningEnabled === -TEST_F(StaInitTest, R6_SearchCrprPathPruning) { +TEST_F(StaInitTest, SearchCrprPathPruning2) { Search *search = sta_->search(); bool enabled = search->crprPathPruningEnabled(); search->setCrprpathPruningEnabled(!enabled); @@ -9247,7 +9247,7 @@ TEST_F(StaInitTest, R6_SearchCrprPathPruning) { // === Search: crprApproxMissingRequireds === -TEST_F(StaInitTest, R6_SearchCrprApproxMissingRequireds) { +TEST_F(StaInitTest, SearchCrprApproxMissingRequireds2) { Search *search = sta_->search(); bool val = search->crprApproxMissingRequireds(); search->setCrprApproxMissingRequireds(!val); @@ -9257,7 +9257,7 @@ TEST_F(StaInitTest, R6_SearchCrprApproxMissingRequireds) { // === Search: unconstrainedPaths === -TEST_F(StaInitTest, R6_SearchUnconstrainedPaths) { +TEST_F(StaInitTest, SearchUnconstrainedPaths2) { Search *search = sta_->search(); bool unc = search->unconstrainedPaths(); (void)unc; @@ -9266,7 +9266,7 @@ TEST_F(StaInitTest, R6_SearchUnconstrainedPaths) { // === Search: deletePathGroups === -TEST_F(StaInitTest, R6_SearchDeletePathGroups) { +TEST_F(StaInitTest, SearchDeletePathGroups3) { Search *search = sta_->search(); search->deletePathGroups(); EXPECT_FALSE(search->havePathGroups()); @@ -9274,7 +9274,7 @@ TEST_F(StaInitTest, R6_SearchDeletePathGroups) { // === Search: deleteFilter === -TEST_F(StaInitTest, R6_SearchDeleteFilter) { +TEST_F(StaInitTest, SearchDeleteFilter3) { Search *search = sta_->search(); search->deleteFilter(); EXPECT_EQ(search->filter(), nullptr); @@ -9282,14 +9282,14 @@ TEST_F(StaInitTest, R6_SearchDeleteFilter) { // === Search: arrivalIterator and requiredIterator === -TEST_F(StaInitTest, R6_SearchArrivalIterator) { +TEST_F(StaInitTest, SearchArrivalIterator) { Search *search = sta_->search(); BfsFwdIterator *iter = search->arrivalIterator(); (void)iter; SUCCEED(); } -TEST_F(StaInitTest, R6_SearchRequiredIterator) { +TEST_F(StaInitTest, SearchRequiredIterator) { Search *search = sta_->search(); BfsBkwdIterator *iter = search->requiredIterator(); (void)iter; @@ -9298,14 +9298,14 @@ TEST_F(StaInitTest, R6_SearchRequiredIterator) { // === Search: evalPred and searchAdj === -TEST_F(StaInitTest, R6_SearchEvalPred) { +TEST_F(StaInitTest, SearchEvalPred2) { Search *search = sta_->search(); EvalPred *pred = search->evalPred(); (void)pred; SUCCEED(); } -TEST_F(StaInitTest, R6_SearchSearchAdj) { +TEST_F(StaInitTest, SearchSearchAdj2) { Search *search = sta_->search(); SearchPred *adj = search->searchAdj(); (void)adj; @@ -9314,21 +9314,21 @@ TEST_F(StaInitTest, R6_SearchSearchAdj) { // === Sta: isClock(Net*) === -TEST_F(StaInitTest, R6_StaIsClockNetExists) { +TEST_F(StaInitTest, StaIsClockNetExists3) { auto fn = static_cast(&Sta::isClock); EXPECT_NE(fn, nullptr); } // === Sta: pins(Clock*) === -TEST_F(StaInitTest, R6_StaPinsOfClockExists) { +TEST_F(StaInitTest, StaPinsOfClockExists) { auto fn = static_cast(&Sta::pins); EXPECT_NE(fn, nullptr); } // === Sta: setCmdNamespace === -TEST_F(StaInitTest, R6_StaSetCmdNamespace) { +TEST_F(StaInitTest, StaSetCmdNamespace2) { sta_->setCmdNamespace(CmdNamespace::sdc); sta_->setCmdNamespace(CmdNamespace::sta); SUCCEED(); @@ -9336,7 +9336,7 @@ TEST_F(StaInitTest, R6_StaSetCmdNamespace) { // === Sta: vertexArrival(Vertex*, MinMax*) === -TEST_F(StaInitTest, R6_StaVertexArrivalMinMaxExists) { +TEST_F(StaInitTest, StaVertexArrivalMinMaxExists3) { auto fn = static_cast( &Sta::vertexArrival); EXPECT_NE(fn, nullptr); @@ -9344,7 +9344,7 @@ TEST_F(StaInitTest, R6_StaVertexArrivalMinMaxExists) { // === Sta: vertexArrival(Vertex*, RiseFall*, PathAnalysisPt*) === -TEST_F(StaInitTest, R6_StaVertexArrivalRfApExists) { +TEST_F(StaInitTest, StaVertexArrivalRfApExists2) { auto fn = static_cast( &Sta::vertexArrival); EXPECT_NE(fn, nullptr); @@ -9352,7 +9352,7 @@ TEST_F(StaInitTest, R6_StaVertexArrivalRfApExists) { // === Sta: vertexRequired(Vertex*, MinMax*) === -TEST_F(StaInitTest, R6_StaVertexRequiredMinMaxExists) { +TEST_F(StaInitTest, StaVertexRequiredMinMaxExists3) { auto fn = static_cast( &Sta::vertexRequired); EXPECT_NE(fn, nullptr); @@ -9360,7 +9360,7 @@ TEST_F(StaInitTest, R6_StaVertexRequiredMinMaxExists) { // === Sta: vertexRequired(Vertex*, RiseFall*, MinMax*) === -TEST_F(StaInitTest, R6_StaVertexRequiredRfMinMaxExists) { +TEST_F(StaInitTest, StaVertexRequiredRfMinMaxExists2) { auto fn = static_cast( &Sta::vertexRequired); EXPECT_NE(fn, nullptr); @@ -9368,7 +9368,7 @@ TEST_F(StaInitTest, R6_StaVertexRequiredRfMinMaxExists) { // === Sta: vertexRequired(Vertex*, RiseFall*, PathAnalysisPt*) === -TEST_F(StaInitTest, R6_StaVertexRequiredRfApExists) { +TEST_F(StaInitTest, StaVertexRequiredRfApExists2) { auto fn = static_cast( &Sta::vertexRequired); EXPECT_NE(fn, nullptr); @@ -9376,7 +9376,7 @@ TEST_F(StaInitTest, R6_StaVertexRequiredRfApExists) { // === Sta: vertexSlack(Vertex*, RiseFall*, PathAnalysisPt*) === -TEST_F(StaInitTest, R6_StaVertexSlackRfApExists) { +TEST_F(StaInitTest, StaVertexSlackRfApExists2) { auto fn = static_cast( &Sta::vertexSlack); EXPECT_NE(fn, nullptr); @@ -9384,14 +9384,14 @@ TEST_F(StaInitTest, R6_StaVertexSlackRfApExists) { // === Sta: vertexSlacks(Vertex*, array) === -TEST_F(StaInitTest, R6_StaVertexSlacksExists) { +TEST_F(StaInitTest, StaVertexSlacksExists3) { auto fn = &Sta::vertexSlacks; EXPECT_NE(fn, nullptr); } // === Sta: vertexSlew(Vertex*, RiseFall*, Corner*, MinMax*) === -TEST_F(StaInitTest, R6_StaVertexSlewCornerExists) { +TEST_F(StaInitTest, StaVertexSlewCornerExists) { auto fn = static_cast( &Sta::vertexSlew); EXPECT_NE(fn, nullptr); @@ -9399,7 +9399,7 @@ TEST_F(StaInitTest, R6_StaVertexSlewCornerExists) { // === Sta: vertexSlew(Vertex*, RiseFall*, DcalcAnalysisPt*) === -TEST_F(StaInitTest, R6_StaVertexSlewDcalcApExists) { +TEST_F(StaInitTest, StaVertexSlewDcalcApExists) { auto fn = static_cast( &Sta::vertexSlew); EXPECT_NE(fn, nullptr); @@ -9407,7 +9407,7 @@ TEST_F(StaInitTest, R6_StaVertexSlewDcalcApExists) { // === Sta: vertexPathIterator(Vertex*, RiseFall*, PathAnalysisPt*) === -TEST_F(StaInitTest, R6_StaVertexPathIteratorRfApExists) { +TEST_F(StaInitTest, StaVertexPathIteratorRfApExists) { auto fn = static_cast( &Sta::vertexPathIterator); EXPECT_NE(fn, nullptr); @@ -9415,7 +9415,7 @@ TEST_F(StaInitTest, R6_StaVertexPathIteratorRfApExists) { // === Sta: vertexWorstRequiredPath(Vertex*, MinMax*) === -TEST_F(StaInitTest, R6_StaVertexWorstRequiredPathMinMaxExists) { +TEST_F(StaInitTest, StaVertexWorstRequiredPathMinMaxExists2) { auto fn = static_cast( &Sta::vertexWorstRequiredPath); EXPECT_NE(fn, nullptr); @@ -9423,7 +9423,7 @@ TEST_F(StaInitTest, R6_StaVertexWorstRequiredPathMinMaxExists) { // === Sta: vertexWorstRequiredPath(Vertex*, RiseFall*, MinMax*) === -TEST_F(StaInitTest, R6_StaVertexWorstRequiredPathRfMinMaxExists) { +TEST_F(StaInitTest, StaVertexWorstRequiredPathRfMinMaxExists2) { auto fn = static_cast( &Sta::vertexWorstRequiredPath); EXPECT_NE(fn, nullptr); @@ -9431,21 +9431,21 @@ TEST_F(StaInitTest, R6_StaVertexWorstRequiredPathRfMinMaxExists) { // === Sta: setArcDelayAnnotated === -TEST_F(StaInitTest, R6_StaSetArcDelayAnnotatedExists) { +TEST_F(StaInitTest, StaSetArcDelayAnnotatedExists2) { auto fn = &Sta::setArcDelayAnnotated; EXPECT_NE(fn, nullptr); } // === Sta: pathAnalysisPt(Path*) === -TEST_F(StaInitTest, R6_StaPathAnalysisPtExists) { +TEST_F(StaInitTest, StaPathAnalysisPtExists2) { auto fn = &Sta::pathAnalysisPt; EXPECT_NE(fn, nullptr); } // === Sta: pathDcalcAnalysisPt(Path*) === -TEST_F(StaInitTest, R6_StaPathDcalcAnalysisPtExists) { +TEST_F(StaInitTest, StaPathDcalcAnalysisPtExists2) { auto fn = &Sta::pathDcalcAnalysisPt; EXPECT_NE(fn, nullptr); } @@ -9453,20 +9453,20 @@ TEST_F(StaInitTest, R6_StaPathDcalcAnalysisPtExists) { // === Sta: maxPathCountVertex === // Sta::maxPathCountVertex segfaults without graph - use fn pointer -TEST_F(StaInitTest, R6_StaMaxPathCountVertexExists) { +TEST_F(StaInitTest, StaMaxPathCountVertexExists2) { auto fn = &Sta::maxPathCountVertex; EXPECT_NE(fn, nullptr); } // === Sta: tagCount, tagGroupCount === -TEST_F(StaInitTest, R6_StaTagCount) { +TEST_F(StaInitTest, StaTagCount3) { TagIndex count = sta_->tagCount(); (void)count; SUCCEED(); } -TEST_F(StaInitTest, R6_StaTagGroupCount) { +TEST_F(StaInitTest, StaTagGroupCount3) { TagGroupIndex count = sta_->tagGroupCount(); (void)count; SUCCEED(); @@ -9474,63 +9474,63 @@ TEST_F(StaInitTest, R6_StaTagGroupCount) { // === Sta: clkInfoCount === -TEST_F(StaInitTest, R6_StaClkInfoCount) { +TEST_F(StaInitTest, StaClkInfoCount3) { int count = sta_->clkInfoCount(); EXPECT_EQ(count, 0); } // === Sta: findDelays === -TEST_F(StaInitTest, R6_StaFindDelaysExists) { +TEST_F(StaInitTest, StaFindDelaysExists) { auto fn = static_cast(&Sta::findDelays); EXPECT_NE(fn, nullptr); } // === Sta: reportCheck(MaxSkewCheck*, bool) === -TEST_F(StaInitTest, R6_StaReportCheckMaxSkewExists) { +TEST_F(StaInitTest, StaReportCheckMaxSkewExists2) { auto fn = static_cast(&Sta::reportCheck); EXPECT_NE(fn, nullptr); } // === Sta: checkSlew === -TEST_F(StaInitTest, R6_StaCheckSlewExists) { +TEST_F(StaInitTest, StaCheckSlewExists2) { auto fn = &Sta::checkSlew; EXPECT_NE(fn, nullptr); } // === Sta: findSlewLimit === -TEST_F(StaInitTest, R6_StaFindSlewLimitExists) { +TEST_F(StaInitTest, StaFindSlewLimitExists2) { auto fn = &Sta::findSlewLimit; EXPECT_NE(fn, nullptr); } // === Sta: checkFanout === -TEST_F(StaInitTest, R6_StaCheckFanoutExists) { +TEST_F(StaInitTest, StaCheckFanoutExists2) { auto fn = &Sta::checkFanout; EXPECT_NE(fn, nullptr); } // === Sta: checkCapacitance === -TEST_F(StaInitTest, R6_StaCheckCapacitanceExists) { +TEST_F(StaInitTest, StaCheckCapacitanceExists2) { auto fn = &Sta::checkCapacitance; EXPECT_NE(fn, nullptr); } // === Sta: pvt === -TEST_F(StaInitTest, R6_StaPvtExists) { +TEST_F(StaInitTest, StaPvtExists2) { auto fn = &Sta::pvt; EXPECT_NE(fn, nullptr); } // === Sta: setPvt === -TEST_F(StaInitTest, R6_StaSetPvtExists) { +TEST_F(StaInitTest, StaSetPvtExists2) { auto fn = static_cast( &Sta::setPvt); EXPECT_NE(fn, nullptr); @@ -9538,7 +9538,7 @@ TEST_F(StaInitTest, R6_StaSetPvtExists) { // === Sta: connectPin === -TEST_F(StaInitTest, R6_StaConnectPinExists) { +TEST_F(StaInitTest, StaConnectPinExists2) { auto fn = static_cast( &Sta::connectPin); EXPECT_NE(fn, nullptr); @@ -9546,28 +9546,28 @@ TEST_F(StaInitTest, R6_StaConnectPinExists) { // === Sta: makePortPinAfter === -TEST_F(StaInitTest, R6_StaMakePortPinAfterExists) { +TEST_F(StaInitTest, StaMakePortPinAfterExists2) { auto fn = &Sta::makePortPinAfter; EXPECT_NE(fn, nullptr); } // === Sta: replaceCellExists === -TEST_F(StaInitTest, R6_StaReplaceCellExists) { +TEST_F(StaInitTest, StaReplaceCellExists3) { auto fn = static_cast(&Sta::replaceCell); EXPECT_NE(fn, nullptr); } // === Sta: makeParasiticNetwork === -TEST_F(StaInitTest, R6_StaMakeParasiticNetworkExists) { +TEST_F(StaInitTest, StaMakeParasiticNetworkExists2) { auto fn = &Sta::makeParasiticNetwork; EXPECT_NE(fn, nullptr); } // === Sta: disable/removeDisable for LibertyPort === -TEST_F(StaInitTest, R6_StaDisableLibertyPortExists) { +TEST_F(StaInitTest, StaDisableLibertyPortExists2) { auto fn_dis = static_cast(&Sta::disable); auto fn_rem = static_cast(&Sta::removeDisable); EXPECT_NE(fn_dis, nullptr); @@ -9576,7 +9576,7 @@ TEST_F(StaInitTest, R6_StaDisableLibertyPortExists) { // === Sta: disable/removeDisable for Edge === -TEST_F(StaInitTest, R6_StaDisableEdgeExists) { +TEST_F(StaInitTest, StaDisableEdgeExists2) { auto fn_dis = static_cast(&Sta::disable); auto fn_rem = static_cast(&Sta::removeDisable); EXPECT_NE(fn_dis, nullptr); @@ -9585,7 +9585,7 @@ TEST_F(StaInitTest, R6_StaDisableEdgeExists) { // === Sta: disable/removeDisable for TimingArcSet === -TEST_F(StaInitTest, R6_StaDisableTimingArcSetExists) { +TEST_F(StaInitTest, StaDisableTimingArcSetExists2) { auto fn_dis = static_cast(&Sta::disable); auto fn_rem = static_cast(&Sta::removeDisable); EXPECT_NE(fn_dis, nullptr); @@ -9594,7 +9594,7 @@ TEST_F(StaInitTest, R6_StaDisableTimingArcSetExists) { // === Sta: disableClockGatingCheck/removeDisableClockGatingCheck for Pin === -TEST_F(StaInitTest, R6_StaDisableClockGatingCheckPinExists) { +TEST_F(StaInitTest, StaDisableClockGatingCheckPinExists) { auto fn_dis = static_cast(&Sta::disableClockGatingCheck); auto fn_rem = static_cast(&Sta::removeDisableClockGatingCheck); EXPECT_NE(fn_dis, nullptr); @@ -9603,21 +9603,21 @@ TEST_F(StaInitTest, R6_StaDisableClockGatingCheckPinExists) { // === Sta: removeDataCheck === -TEST_F(StaInitTest, R6_StaRemoveDataCheckExists) { +TEST_F(StaInitTest, StaRemoveDataCheckExists2) { auto fn = &Sta::removeDataCheck; EXPECT_NE(fn, nullptr); } // === Sta: clockDomains === -TEST_F(StaInitTest, R6_StaClockDomainsExists) { +TEST_F(StaInitTest, StaClockDomainsExists) { auto fn = static_cast(&Sta::clockDomains); EXPECT_NE(fn, nullptr); } // === ReportPath: reportJsonHeader === -TEST_F(StaInitTest, R6_ReportPathReportJsonHeader) { +TEST_F(StaInitTest, ReportPathReportJsonHeader) { ReportPath *rpt = sta_->reportPath(); EXPECT_NE(rpt, nullptr); rpt->reportJsonHeader(); @@ -9626,7 +9626,7 @@ TEST_F(StaInitTest, R6_ReportPathReportJsonHeader) { // === ReportPath: reportPeriodHeaderShort === -TEST_F(StaInitTest, R6_ReportPathReportPeriodHeaderShort) { +TEST_F(StaInitTest, ReportPathReportPeriodHeaderShort) { ReportPath *rpt = sta_->reportPath(); rpt->reportPeriodHeaderShort(); SUCCEED(); @@ -9634,7 +9634,7 @@ TEST_F(StaInitTest, R6_ReportPathReportPeriodHeaderShort) { // === ReportPath: reportMaxSkewHeaderShort === -TEST_F(StaInitTest, R6_ReportPathReportMaxSkewHeaderShort) { +TEST_F(StaInitTest, ReportPathReportMaxSkewHeaderShort) { ReportPath *rpt = sta_->reportPath(); rpt->reportMaxSkewHeaderShort(); SUCCEED(); @@ -9642,7 +9642,7 @@ TEST_F(StaInitTest, R6_ReportPathReportMaxSkewHeaderShort) { // === ReportPath: reportMpwHeaderShort === -TEST_F(StaInitTest, R6_ReportPathReportMpwHeaderShort) { +TEST_F(StaInitTest, ReportPathReportMpwHeaderShort) { ReportPath *rpt = sta_->reportPath(); rpt->reportMpwHeaderShort(); SUCCEED(); @@ -9650,7 +9650,7 @@ TEST_F(StaInitTest, R6_ReportPathReportMpwHeaderShort) { // === ReportPath: reportPathEndHeader === -TEST_F(StaInitTest, R6_ReportPathReportPathEndHeader) { +TEST_F(StaInitTest, ReportPathReportPathEndHeader) { ReportPath *rpt = sta_->reportPath(); rpt->reportPathEndHeader(); SUCCEED(); @@ -9658,7 +9658,7 @@ TEST_F(StaInitTest, R6_ReportPathReportPathEndHeader) { // === ReportPath: reportPathEndFooter === -TEST_F(StaInitTest, R6_ReportPathReportPathEndFooter) { +TEST_F(StaInitTest, ReportPathReportPathEndFooter) { ReportPath *rpt = sta_->reportPath(); rpt->reportPathEndFooter(); SUCCEED(); @@ -9666,7 +9666,7 @@ TEST_F(StaInitTest, R6_ReportPathReportPathEndFooter) { // === ReportPath: reportJsonFooter === -TEST_F(StaInitTest, R6_ReportPathReportJsonFooter) { +TEST_F(StaInitTest, ReportPathReportJsonFooter) { ReportPath *rpt = sta_->reportPath(); rpt->reportJsonFooter(); SUCCEED(); @@ -9674,7 +9674,7 @@ TEST_F(StaInitTest, R6_ReportPathReportJsonFooter) { // === ReportPath: setPathFormat === -TEST_F(StaInitTest, R6_ReportPathSetPathFormat) { +TEST_F(StaInitTest, ReportPathSetPathFormat2) { ReportPath *rpt = sta_->reportPath(); ReportPathFormat fmt = rpt->pathFormat(); rpt->setPathFormat(fmt); @@ -9683,7 +9683,7 @@ TEST_F(StaInitTest, R6_ReportPathSetPathFormat) { // === ReportPath: setDigits === -TEST_F(StaInitTest, R6_ReportPathSetDigits) { +TEST_F(StaInitTest, ReportPathSetDigits2) { ReportPath *rpt = sta_->reportPath(); int digits = rpt->digits(); rpt->setDigits(4); @@ -9693,7 +9693,7 @@ TEST_F(StaInitTest, R6_ReportPathSetDigits) { // === ReportPath: setNoSplit === -TEST_F(StaInitTest, R6_ReportPathSetNoSplit) { +TEST_F(StaInitTest, ReportPathSetNoSplit2) { ReportPath *rpt = sta_->reportPath(); rpt->setNoSplit(true); rpt->setNoSplit(false); @@ -9702,7 +9702,7 @@ TEST_F(StaInitTest, R6_ReportPathSetNoSplit) { // === ReportPath: setReportSigmas === -TEST_F(StaInitTest, R6_ReportPathSetReportSigmas) { +TEST_F(StaInitTest, ReportPathSetReportSigmas2) { ReportPath *rpt = sta_->reportPath(); bool sigmas = rpt->reportSigmas(); rpt->setReportSigmas(!sigmas); @@ -9712,7 +9712,7 @@ TEST_F(StaInitTest, R6_ReportPathSetReportSigmas) { // === ReportPath: findField === -TEST_F(StaInitTest, R6_ReportPathFindField) { +TEST_F(StaInitTest, ReportPathFindField2) { ReportPath *rpt = sta_->reportPath(); ReportField *f = rpt->findField("nonexistent_field_xyz"); EXPECT_EQ(f, nullptr); @@ -9720,7 +9720,7 @@ TEST_F(StaInitTest, R6_ReportPathFindField) { // === ReportPath: fieldSlew/fieldFanout/fieldCapacitance === -TEST_F(StaInitTest, R6_ReportPathFieldAccessors) { +TEST_F(StaInitTest, ReportPathFieldAccessors) { ReportPath *rpt = sta_->reportPath(); ReportField *slew = rpt->fieldSlew(); ReportField *fanout = rpt->fieldFanout(); @@ -9735,7 +9735,7 @@ TEST_F(StaInitTest, R6_ReportPathFieldAccessors) { // === ReportPath: reportEndHeader === -TEST_F(StaInitTest, R6_ReportPathReportEndHeader) { +TEST_F(StaInitTest, ReportPathReportEndHeader) { ReportPath *rpt = sta_->reportPath(); rpt->reportEndHeader(); SUCCEED(); @@ -9743,7 +9743,7 @@ TEST_F(StaInitTest, R6_ReportPathReportEndHeader) { // === ReportPath: reportSummaryHeader === -TEST_F(StaInitTest, R6_ReportPathReportSummaryHeader) { +TEST_F(StaInitTest, ReportPathReportSummaryHeader) { ReportPath *rpt = sta_->reportPath(); rpt->reportSummaryHeader(); SUCCEED(); @@ -9751,7 +9751,7 @@ TEST_F(StaInitTest, R6_ReportPathReportSummaryHeader) { // === ReportPath: reportSlackOnlyHeader === -TEST_F(StaInitTest, R6_ReportPathReportSlackOnlyHeader) { +TEST_F(StaInitTest, ReportPathReportSlackOnlyHeader) { ReportPath *rpt = sta_->reportPath(); rpt->reportSlackOnlyHeader(); SUCCEED(); @@ -9759,22 +9759,22 @@ TEST_F(StaInitTest, R6_ReportPathReportSlackOnlyHeader) { // === PathGroups: static group name accessors === -TEST_F(StaInitTest, R6_PathGroupsAsyncGroupName) { +TEST_F(StaInitTest, PathGroupsAsyncGroupName2) { const char *name = PathGroups::asyncPathGroupName(); EXPECT_NE(name, nullptr); } -TEST_F(StaInitTest, R6_PathGroupsPathDelayGroupName) { +TEST_F(StaInitTest, PathGroupsPathDelayGroupName2) { const char *name = PathGroups::pathDelayGroupName(); EXPECT_NE(name, nullptr); } -TEST_F(StaInitTest, R6_PathGroupsGatedClkGroupName) { +TEST_F(StaInitTest, PathGroupsGatedClkGroupName2) { const char *name = PathGroups::gatedClkGroupName(); EXPECT_NE(name, nullptr); } -TEST_F(StaInitTest, R6_PathGroupsUnconstrainedGroupName) { +TEST_F(StaInitTest, PathGroupsUnconstrainedGroupName2) { const char *name = PathGroups::unconstrainedGroupName(); EXPECT_NE(name, nullptr); } @@ -9784,7 +9784,7 @@ TEST_F(StaInitTest, R6_PathGroupsUnconstrainedGroupName) { // === Corners: parasiticAnalysisPtCount === -TEST_F(StaInitTest, R6_CornersParasiticAnalysisPtCount) { +TEST_F(StaInitTest, CornersParasiticAnalysisPtCount2) { Corners *corners = sta_->corners(); int count = corners->parasiticAnalysisPtCount(); (void)count; @@ -9793,21 +9793,21 @@ TEST_F(StaInitTest, R6_CornersParasiticAnalysisPtCount) { // === ClkNetwork: isClock(Net*) === -TEST_F(StaInitTest, R6_ClkNetworkIsClockNetExists) { +TEST_F(StaInitTest, ClkNetworkIsClockNetExists) { auto fn = static_cast(&ClkNetwork::isClock); EXPECT_NE(fn, nullptr); } // === ClkNetwork: clocks(Pin*) === -TEST_F(StaInitTest, R6_ClkNetworkClocksExists) { +TEST_F(StaInitTest, ClkNetworkClocksExists2) { auto fn = &ClkNetwork::clocks; EXPECT_NE(fn, nullptr); } // === ClkNetwork: pins(Clock*) === -TEST_F(StaInitTest, R6_ClkNetworkPinsExists) { +TEST_F(StaInitTest, ClkNetworkPinsExists2) { auto fn = &ClkNetwork::pins; EXPECT_NE(fn, nullptr); } @@ -9816,14 +9816,14 @@ TEST_F(StaInitTest, R6_ClkNetworkPinsExists) { // === BfsIterator: checkInQueue === -TEST_F(StaInitTest, R6_BfsIteratorCheckInQueueExists) { +TEST_F(StaInitTest, BfsIteratorCheckInQueueExists) { auto fn = &BfsIterator::checkInQueue; EXPECT_NE(fn, nullptr); } // === BfsIterator: enqueueAdjacentVertices with level === -TEST_F(StaInitTest, R6_BfsIteratorEnqueueAdjacentVerticesLevelExists) { +TEST_F(StaInitTest, BfsIteratorEnqueueAdjacentVerticesLevelExists) { auto fn = static_cast( &BfsIterator::enqueueAdjacentVertices); EXPECT_NE(fn, nullptr); @@ -9831,7 +9831,7 @@ TEST_F(StaInitTest, R6_BfsIteratorEnqueueAdjacentVerticesLevelExists) { // === Levelize: checkLevels === -TEST_F(StaInitTest, R6_LevelizeCheckLevelsExists) { +TEST_F(StaInitTest, LevelizeCheckLevelsExists2) { auto fn = &Levelize::checkLevels; EXPECT_NE(fn, nullptr); } @@ -9840,19 +9840,19 @@ TEST_F(StaInitTest, R6_LevelizeCheckLevelsExists) { // === Path: init overloads === -TEST_F(StaInitTest, R6_PathInitVertexFloatExists) { +TEST_F(StaInitTest, PathInitVertexFloatExists) { auto fn = static_cast( &Path::init); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R6_PathInitVertexTagExists) { +TEST_F(StaInitTest, PathInitVertexTagExists) { auto fn = static_cast( &Path::init); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R6_PathInitVertexTagFloatExists) { +TEST_F(StaInitTest, PathInitVertexTagFloatExists) { auto fn = static_cast( &Path::init); EXPECT_NE(fn, nullptr); @@ -9860,7 +9860,7 @@ TEST_F(StaInitTest, R6_PathInitVertexTagFloatExists) { // === Path: constructor with Vertex*, Tag*, StaState* === -TEST_F(StaInitTest, R6_PathCtorVertexTagStaExists) { +TEST_F(StaInitTest, PathCtorVertexTagStaExists) { auto fn = [](Vertex *v, Tag *t, const StaState *s) { Path p(v, t, s); (void)p; @@ -9870,19 +9870,19 @@ TEST_F(StaInitTest, R6_PathCtorVertexTagStaExists) { // === PathEnd: less and cmpNoCrpr === -TEST_F(StaInitTest, R6_PathEndLessExists) { +TEST_F(StaInitTest, PathEndLessExists) { auto fn = &PathEnd::less; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R6_PathEndCmpNoCrprExists) { +TEST_F(StaInitTest, PathEndCmpNoCrprExists) { auto fn = &PathEnd::cmpNoCrpr; EXPECT_NE(fn, nullptr); } // === Tag: equal and match static methods === -TEST_F(StaInitTest, R6_TagEqualStaticExists) { +TEST_F(StaInitTest, TagEqualStaticExists) { auto fn = &Tag::equal; EXPECT_NE(fn, nullptr); } @@ -9891,14 +9891,14 @@ TEST_F(StaInitTest, R6_TagEqualStaticExists) { // === ClkInfo: equal static method === -TEST_F(StaInitTest, R6_ClkInfoEqualStaticExists) { +TEST_F(StaInitTest, ClkInfoEqualStaticExists) { auto fn = &ClkInfo::equal; EXPECT_NE(fn, nullptr); } // === ClkInfo: crprClkPath === -TEST_F(StaInitTest, R6_ClkInfoCrprClkPathExists) { +TEST_F(StaInitTest, ClkInfoCrprClkPathExists) { auto fn = static_cast( &ClkInfo::crprClkPath); EXPECT_NE(fn, nullptr); @@ -9908,42 +9908,42 @@ TEST_F(StaInitTest, R6_ClkInfoCrprClkPathExists) { // === Sim: findLogicConstants === -TEST_F(StaInitTest, R6_SimFindLogicConstantsExists) { +TEST_F(StaInitTest, SimFindLogicConstantsExists2) { auto fn = &Sim::findLogicConstants; EXPECT_NE(fn, nullptr); } // === Sim: makePinAfter === -TEST_F(StaInitTest, R6_SimMakePinAfterFnExists) { +TEST_F(StaInitTest, SimMakePinAfterFnExists) { auto fn = &Sim::makePinAfter; EXPECT_NE(fn, nullptr); } // === GatedClk: gatedClkEnables === -TEST_F(StaInitTest, R6_GatedClkGatedClkEnablesExists) { +TEST_F(StaInitTest, GatedClkGatedClkEnablesExists) { auto fn = &GatedClk::gatedClkEnables; EXPECT_NE(fn, nullptr); } // === Search: pathClkPathArrival1 (protected, use fn pointer) === -TEST_F(StaInitTest, R6_SearchPathClkPathArrival1Exists) { +TEST_F(StaInitTest, SearchPathClkPathArrival1Exists) { auto fn = &Search::pathClkPathArrival; EXPECT_NE(fn, nullptr); } // === Search: visitStartpoints === -TEST_F(StaInitTest, R6_SearchVisitStartpointsExists) { +TEST_F(StaInitTest, SearchVisitStartpointsExists) { auto fn = &Search::visitStartpoints; EXPECT_NE(fn, nullptr); } // === Search: reportTagGroups === -TEST_F(StaInitTest, R6_SearchReportTagGroups) { +TEST_F(StaInitTest, SearchReportTagGroups2) { Search *search = sta_->search(); search->reportTagGroups(); SUCCEED(); @@ -9952,14 +9952,14 @@ TEST_F(StaInitTest, R6_SearchReportTagGroups) { // === Search: reportPathCountHistogram === // Search::reportPathCountHistogram segfaults without graph - use fn pointer -TEST_F(StaInitTest, R6_SearchReportPathCountHistogramExists) { +TEST_F(StaInitTest, SearchReportPathCountHistogramExists) { auto fn = &Search::reportPathCountHistogram; EXPECT_NE(fn, nullptr); } // === Search: arrivalsInvalid === -TEST_F(StaInitTest, R6_SearchArrivalsInvalid) { +TEST_F(StaInitTest, SearchArrivalsInvalid3) { Search *search = sta_->search(); search->arrivalsInvalid(); SUCCEED(); @@ -9967,7 +9967,7 @@ TEST_F(StaInitTest, R6_SearchArrivalsInvalid) { // === Search: requiredsInvalid === -TEST_F(StaInitTest, R6_SearchRequiredsInvalid) { +TEST_F(StaInitTest, SearchRequiredsInvalid3) { Search *search = sta_->search(); search->requiredsInvalid(); SUCCEED(); @@ -9975,7 +9975,7 @@ TEST_F(StaInitTest, R6_SearchRequiredsInvalid) { // === Search: endpointsInvalid === -TEST_F(StaInitTest, R6_SearchEndpointsInvalid) { +TEST_F(StaInitTest, SearchEndpointsInvalid3) { Search *search = sta_->search(); search->endpointsInvalid(); SUCCEED(); @@ -9983,56 +9983,56 @@ TEST_F(StaInitTest, R6_SearchEndpointsInvalid) { // === Search: copyState === -TEST_F(StaInitTest, R6_SearchCopyStateExists) { +TEST_F(StaInitTest, SearchCopyStateExists) { auto fn = &Search::copyState; EXPECT_NE(fn, nullptr); } // === Search: isEndpoint === -TEST_F(StaInitTest, R6_SearchIsEndpointExists) { +TEST_F(StaInitTest, SearchIsEndpointExists) { auto fn = static_cast(&Search::isEndpoint); EXPECT_NE(fn, nullptr); } // === Search: seedArrival === -TEST_F(StaInitTest, R6_SearchSeedArrivalExists) { +TEST_F(StaInitTest, SearchSeedArrivalExists) { auto fn = &Search::seedArrival; EXPECT_NE(fn, nullptr); } // === Search: enqueueLatchOutput === -TEST_F(StaInitTest, R6_SearchEnqueueLatchOutputExists) { +TEST_F(StaInitTest, SearchEnqueueLatchOutputExists) { auto fn = &Search::enqueueLatchOutput; EXPECT_NE(fn, nullptr); } // === Search: isSegmentStart === -TEST_F(StaInitTest, R6_SearchIsSegmentStartExists) { +TEST_F(StaInitTest, SearchIsSegmentStartExists) { auto fn = &Search::isSegmentStart; EXPECT_NE(fn, nullptr); } // === Search: seedRequiredEnqueueFanin === -TEST_F(StaInitTest, R6_SearchSeedRequiredEnqueueFaninExists) { +TEST_F(StaInitTest, SearchSeedRequiredEnqueueFaninExists) { auto fn = &Search::seedRequiredEnqueueFanin; EXPECT_NE(fn, nullptr); } // === Search: saveEnumPath === -TEST_F(StaInitTest, R6_SearchSaveEnumPathExists) { +TEST_F(StaInitTest, SearchSaveEnumPathExists2) { auto fn = &Search::saveEnumPath; EXPECT_NE(fn, nullptr); } // === Sta: graphLoops === -TEST_F(StaInitTest, R6_StaGraphLoopsExists) { +TEST_F(StaInitTest, StaGraphLoopsExists) { auto fn = &Sta::graphLoops; EXPECT_NE(fn, nullptr); } @@ -10040,66 +10040,66 @@ TEST_F(StaInitTest, R6_StaGraphLoopsExists) { // === Sta: pathCount === // Sta::pathCount segfaults without graph - use fn pointer -TEST_F(StaInitTest, R6_StaPathCountExists) { +TEST_F(StaInitTest, StaPathCountExists) { auto fn = &Sta::pathCount; EXPECT_NE(fn, nullptr); } // === Sta: findAllArrivals === -TEST_F(StaInitTest, R6_StaFindAllArrivalsExists) { +TEST_F(StaInitTest, StaFindAllArrivalsExists) { auto fn = static_cast(&Search::findAllArrivals); EXPECT_NE(fn, nullptr); } // === Sta: findArrivals === -TEST_F(StaInitTest, R6_SearchFindArrivalsExists) { +TEST_F(StaInitTest, SearchFindArrivalsExists) { auto fn = static_cast(&Search::findArrivals); EXPECT_NE(fn, nullptr); } // === Sta: findRequireds === -TEST_F(StaInitTest, R6_SearchFindRequiredsExists) { +TEST_F(StaInitTest, SearchFindRequiredsExists) { auto fn = static_cast(&Search::findRequireds); EXPECT_NE(fn, nullptr); } // === PathEnd: type names for subclass function pointers === -TEST_F(StaInitTest, R6_PathEndPathDelayTypeExists) { +TEST_F(StaInitTest, PathEndPathDelayTypeExists) { auto fn = &PathEndPathDelay::type; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R6_PathEndPathDelayTypeNameExists) { +TEST_F(StaInitTest, PathEndPathDelayTypeNameExists) { auto fn = &PathEndPathDelay::typeName; EXPECT_NE(fn, nullptr); } // === PathEndUnconstrained: reportShort and requiredTime === -TEST_F(StaInitTest, R6_PathEndUnconstrainedReportShortExists) { +TEST_F(StaInitTest, PathEndUnconstrainedReportShortExists) { auto fn = &PathEndUnconstrained::reportShort; EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R6_PathEndUnconstrainedRequiredTimeExists) { +TEST_F(StaInitTest, PathEndUnconstrainedRequiredTimeExists) { auto fn = &PathEndUnconstrained::requiredTime; EXPECT_NE(fn, nullptr); } // === PathEnum destructor === -TEST_F(StaInitTest, R6_PathEnumCtorDtor) { +TEST_F(StaInitTest, PathEnumCtorDtor) { PathEnum pe(10, 5, false, false, true, sta_); SUCCEED(); } // === DiversionGreater === -TEST_F(StaInitTest, R6_DiversionGreaterStateCtor) { +TEST_F(StaInitTest, DiversionGreaterStateCtor) { DiversionGreater dg(sta_); (void)dg; SUCCEED(); @@ -10107,14 +10107,14 @@ TEST_F(StaInitTest, R6_DiversionGreaterStateCtor) { // === TagGroup: report function pointer === -TEST_F(StaInitTest, R6_TagGroupReportExists) { +TEST_F(StaInitTest, TagGroupReportExists) { auto fn = &TagGroup::report; EXPECT_NE(fn, nullptr); } // === TagGroupBldr: reportArrivalEntries === -TEST_F(StaInitTest, R6_TagGroupBldrReportArrivalEntriesExists) { +TEST_F(StaInitTest, TagGroupBldrReportArrivalEntriesExists) { auto fn = &TagGroupBldr::reportArrivalEntries; EXPECT_NE(fn, nullptr); } @@ -10122,7 +10122,7 @@ TEST_F(StaInitTest, R6_TagGroupBldrReportArrivalEntriesExists) { // === VertexPinCollector: copy === // VertexPinCollector::copy() throws "not supported" - skipped -TEST_F(StaInitTest, R6_VertexPinCollectorCopyExists) { +TEST_F(StaInitTest, VertexPinCollectorCopyExists) { auto fn = &VertexPinCollector::copy; EXPECT_NE(fn, nullptr); } @@ -10133,7 +10133,7 @@ TEST_F(StaInitTest, R6_VertexPinCollectorCopyExists) { // === Genclks: findLatchFdbkEdges overloads === -TEST_F(StaInitTest, R6_GenclksFindLatchFdbkEdges1ArgExists) { +TEST_F(StaInitTest, GenclksFindLatchFdbkEdges1ArgExists) { auto fn = static_cast( &Genclks::findLatchFdbkEdges); EXPECT_NE(fn, nullptr); @@ -10141,27 +10141,27 @@ TEST_F(StaInitTest, R6_GenclksFindLatchFdbkEdges1ArgExists) { // === Sta: simLogicValue === -TEST_F(StaInitTest, R6_StaSimLogicValueExists) { +TEST_F(StaInitTest, StaSimLogicValueExists) { auto fn = &Sta::simLogicValue; EXPECT_NE(fn, nullptr); } // === Sta: netSlack === -TEST_F(StaInitTest, R6_StaNetSlackExists) { +TEST_F(StaInitTest, StaNetSlackExists) { auto fn = &Sta::netSlack; EXPECT_NE(fn, nullptr); } // === Sta: pinSlack overloads === -TEST_F(StaInitTest, R6_StaPinSlackRfExists) { +TEST_F(StaInitTest, StaPinSlackRfExists) { auto fn = static_cast( &Sta::pinSlack); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R6_StaPinSlackMinMaxExists) { +TEST_F(StaInitTest, StaPinSlackMinMaxExists) { auto fn = static_cast( &Sta::pinSlack); EXPECT_NE(fn, nullptr); @@ -10169,62 +10169,62 @@ TEST_F(StaInitTest, R6_StaPinSlackMinMaxExists) { // === Sta: pinArrival === -TEST_F(StaInitTest, R6_StaPinArrivalExists) { +TEST_F(StaInitTest, StaPinArrivalExists) { auto fn = &Sta::pinArrival; EXPECT_NE(fn, nullptr); } // === Sta: vertexLevel === -TEST_F(StaInitTest, R6_StaVertexLevelExists) { +TEST_F(StaInitTest, StaVertexLevelExists) { auto fn = &Sta::vertexLevel; EXPECT_NE(fn, nullptr); } // === Sta: vertexPathCount === -TEST_F(StaInitTest, R6_StaVertexPathCountExists) { +TEST_F(StaInitTest, StaVertexPathCountExists2) { auto fn = &Sta::vertexPathCount; EXPECT_NE(fn, nullptr); } // === Sta: endpointSlack === -TEST_F(StaInitTest, R6_StaEndpointSlackExists) { +TEST_F(StaInitTest, StaEndpointSlackExists) { auto fn = &Sta::endpointSlack; EXPECT_NE(fn, nullptr); } // === Sta: arcDelay === -TEST_F(StaInitTest, R6_StaArcDelayExists) { +TEST_F(StaInitTest, StaArcDelayExists) { auto fn = &Sta::arcDelay; EXPECT_NE(fn, nullptr); } // === Sta: arcDelayAnnotated === -TEST_F(StaInitTest, R6_StaArcDelayAnnotatedExists) { +TEST_F(StaInitTest, StaArcDelayAnnotatedExists) { auto fn = &Sta::arcDelayAnnotated; EXPECT_NE(fn, nullptr); } // === Sta: findClkMinPeriod === -TEST_F(StaInitTest, R6_StaFindClkMinPeriodExists) { +TEST_F(StaInitTest, StaFindClkMinPeriodExists) { auto fn = &Sta::findClkMinPeriod; EXPECT_NE(fn, nullptr); } // === Sta: vertexWorstArrivalPath === -TEST_F(StaInitTest, R6_StaVertexWorstArrivalPathExists) { +TEST_F(StaInitTest, StaVertexWorstArrivalPathExists2) { auto fn = static_cast( &Sta::vertexWorstArrivalPath); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R6_StaVertexWorstArrivalPathRfExists) { +TEST_F(StaInitTest, StaVertexWorstArrivalPathRfExists) { auto fn = static_cast( &Sta::vertexWorstArrivalPath); EXPECT_NE(fn, nullptr); @@ -10232,13 +10232,13 @@ TEST_F(StaInitTest, R6_StaVertexWorstArrivalPathRfExists) { // === Sta: vertexWorstSlackPath === -TEST_F(StaInitTest, R6_StaVertexWorstSlackPathExists) { +TEST_F(StaInitTest, StaVertexWorstSlackPathExists2) { auto fn = static_cast( &Sta::vertexWorstSlackPath); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R6_StaVertexWorstSlackPathRfExists) { +TEST_F(StaInitTest, StaVertexWorstSlackPathRfExists) { auto fn = static_cast( &Sta::vertexWorstSlackPath); EXPECT_NE(fn, nullptr); @@ -10246,13 +10246,13 @@ TEST_F(StaInitTest, R6_StaVertexWorstSlackPathRfExists) { // === Sta: vertexSlew more overloads === -TEST_F(StaInitTest, R6_StaVertexSlewMinMaxExists) { +TEST_F(StaInitTest, StaVertexSlewMinMaxExists2) { auto fn = static_cast( &Sta::vertexSlew); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R6_StaVertexSlewMinMaxOnlyExists) { +TEST_F(StaInitTest, StaVertexSlewMinMaxOnlyExists) { auto fn = static_cast( &Sta::vertexSlew); EXPECT_NE(fn, nullptr); @@ -10260,7 +10260,7 @@ TEST_F(StaInitTest, R6_StaVertexSlewMinMaxOnlyExists) { // === Sta: vertexPathIterator(Vertex*, RiseFall*, MinMax*) === -TEST_F(StaInitTest, R6_StaVertexPathIteratorRfMinMaxExists) { +TEST_F(StaInitTest, StaVertexPathIteratorRfMinMaxExists) { auto fn = static_cast( &Sta::vertexPathIterator); EXPECT_NE(fn, nullptr); @@ -10268,12 +10268,12 @@ TEST_F(StaInitTest, R6_StaVertexPathIteratorRfMinMaxExists) { // === Sta: totalNegativeSlack === -TEST_F(StaInitTest, R6_StaTotalNegativeSlackExists) { +TEST_F(StaInitTest, StaTotalNegativeSlackExists) { auto fn = static_cast(&Sta::totalNegativeSlack); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R6_StaTotalNegativeSlackCornerExists) { +TEST_F(StaInitTest, StaTotalNegativeSlackCornerExists) { auto fn = static_cast( &Sta::totalNegativeSlack); EXPECT_NE(fn, nullptr); @@ -10281,13 +10281,13 @@ TEST_F(StaInitTest, R6_StaTotalNegativeSlackCornerExists) { // === Sta: worstSlack === -TEST_F(StaInitTest, R6_StaWorstSlackExists) { +TEST_F(StaInitTest, StaWorstSlackExists) { auto fn = static_cast( &Sta::worstSlack); EXPECT_NE(fn, nullptr); } -TEST_F(StaInitTest, R6_StaWorstSlackCornerExists) { +TEST_F(StaInitTest, StaWorstSlackCornerExists) { auto fn = static_cast( &Sta::worstSlack); EXPECT_NE(fn, nullptr); @@ -10295,14 +10295,14 @@ TEST_F(StaInitTest, R6_StaWorstSlackCornerExists) { // === Sta: updateTiming === -TEST_F(StaInitTest, R6_StaUpdateTimingExists) { +TEST_F(StaInitTest, StaUpdateTimingExists) { auto fn = &Sta::updateTiming; EXPECT_NE(fn, nullptr); } // === Search: clkPathArrival === -TEST_F(StaInitTest, R6_SearchClkPathArrival1ArgExists) { +TEST_F(StaInitTest, SearchClkPathArrival1ArgExists) { auto fn = static_cast( &Search::clkPathArrival); EXPECT_NE(fn, nullptr); @@ -10312,14 +10312,14 @@ TEST_F(StaInitTest, R6_SearchClkPathArrival1ArgExists) { // === Sta: disconnectPin === -TEST_F(StaInitTest, R6_StaDisconnectPinExists) { +TEST_F(StaInitTest, StaDisconnectPinExists2) { auto fn = &Sta::disconnectPin; EXPECT_NE(fn, nullptr); } // === PathExpandedCtorGenClks === -TEST_F(StaInitTest, R6_PathExpandedCtorGenClksExists) { +TEST_F(StaInitTest, PathExpandedCtorGenClksExists) { // Constructor: PathExpanded(const Path*, bool, const StaState*) Path nullPath; // We can't call this with a null path without crashing, @@ -10333,7 +10333,7 @@ TEST_F(StaInitTest, R6_PathExpandedCtorGenClksExists) { // === Search: deleteFilteredArrivals === -TEST_F(StaInitTest, R6_SearchDeleteFilteredArrivals) { +TEST_F(StaInitTest, SearchDeleteFilteredArrivals) { Search *search = sta_->search(); search->deleteFilteredArrivals(); SUCCEED(); @@ -10341,105 +10341,105 @@ TEST_F(StaInitTest, R6_SearchDeleteFilteredArrivals) { // === Sta: checkSlewLimitPreamble === -TEST_F(StaInitTest, R6_StaCheckSlewLimitPreambleExists) { +TEST_F(StaInitTest, StaCheckSlewLimitPreambleExists) { auto fn = &Sta::checkSlewLimitPreamble; EXPECT_NE(fn, nullptr); } // === Sta: checkFanoutLimitPreamble === -TEST_F(StaInitTest, R6_StaCheckFanoutLimitPreambleExists) { +TEST_F(StaInitTest, StaCheckFanoutLimitPreambleExists) { auto fn = &Sta::checkFanoutLimitPreamble; EXPECT_NE(fn, nullptr); } // === Sta: checkCapacitanceLimitPreamble === -TEST_F(StaInitTest, R6_StaCheckCapacitanceLimitPreambleExists) { +TEST_F(StaInitTest, StaCheckCapacitanceLimitPreambleExists) { auto fn = &Sta::checkCapacitanceLimitPreamble; EXPECT_NE(fn, nullptr); } // === Sta: checkSlewLimits(Net*,...) === -TEST_F(StaInitTest, R6_StaCheckSlewLimitsExists) { +TEST_F(StaInitTest, StaCheckSlewLimitsExists) { auto fn = &Sta::checkSlewLimits; EXPECT_NE(fn, nullptr); } // === Sta: checkFanoutLimits(Net*,...) === -TEST_F(StaInitTest, R6_StaCheckFanoutLimitsExists) { +TEST_F(StaInitTest, StaCheckFanoutLimitsExists) { auto fn = &Sta::checkFanoutLimits; EXPECT_NE(fn, nullptr); } // === Sta: checkCapacitanceLimits(Net*,...) === -TEST_F(StaInitTest, R6_StaCheckCapacitanceLimitsExists) { +TEST_F(StaInitTest, StaCheckCapacitanceLimitsExists) { auto fn = &Sta::checkCapacitanceLimits; EXPECT_NE(fn, nullptr); } // === Search: seedInputSegmentArrival === -TEST_F(StaInitTest, R6_SearchSeedInputSegmentArrivalExists) { +TEST_F(StaInitTest, SearchSeedInputSegmentArrivalExists) { auto fn = &Search::seedInputSegmentArrival; EXPECT_NE(fn, nullptr); } // === Search: enqueueLatchDataOutputs === -TEST_F(StaInitTest, R6_SearchEnqueueLatchDataOutputsExists) { +TEST_F(StaInitTest, SearchEnqueueLatchDataOutputsExists) { auto fn = &Search::enqueueLatchDataOutputs; EXPECT_NE(fn, nullptr); } // === Search: seedRequired === -TEST_F(StaInitTest, R6_SearchSeedRequiredExists) { +TEST_F(StaInitTest, SearchSeedRequiredExists) { auto fn = &Search::seedRequired; EXPECT_NE(fn, nullptr); } // === Search: findClkArrivals === -TEST_F(StaInitTest, R6_SearchFindClkArrivalsExists) { +TEST_F(StaInitTest, SearchFindClkArrivalsExists) { auto fn = &Search::findClkArrivals; EXPECT_NE(fn, nullptr); } // === Search: tnsInvalid === -TEST_F(StaInitTest, R6_SearchTnsInvalidExists) { +TEST_F(StaInitTest, SearchTnsInvalidExists) { auto fn = &Search::tnsInvalid; EXPECT_NE(fn, nullptr); } // === Search: endpointInvalid === -TEST_F(StaInitTest, R6_SearchEndpointInvalidExists) { +TEST_F(StaInitTest, SearchEndpointInvalidExists) { auto fn = &Search::endpointInvalid; EXPECT_NE(fn, nullptr); } // === Search: makePathGroups === -TEST_F(StaInitTest, R6_SearchMakePathGroupsExists) { +TEST_F(StaInitTest, SearchMakePathGroupsExists) { auto fn = &Search::makePathGroups; EXPECT_NE(fn, nullptr); } // === Sta: isIdealClock === -TEST_F(StaInitTest, R6_StaIsIdealClockExists) { +TEST_F(StaInitTest, StaIsIdealClockExists2) { auto fn = &Sta::isIdealClock; EXPECT_NE(fn, nullptr); } // === Sta: isPropagatedClock === -TEST_F(StaInitTest, R6_StaIsPropagatedClockExists) { +TEST_F(StaInitTest, StaIsPropagatedClockExists2) { auto fn = &Sta::isPropagatedClock; EXPECT_NE(fn, nullptr); } @@ -10544,14 +10544,14 @@ protected: // --- vertexArrival overloads --- -TEST_F(StaDesignTest, R8_VertexArrivalMinMax) { +TEST_F(StaDesignTest, VertexArrivalMinMax) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); Arrival arr = sta_->vertexArrival(v, MinMax::max()); (void)arr; } -TEST_F(StaDesignTest, R8_VertexArrivalRfPathAP) { +TEST_F(StaDesignTest, VertexArrivalRfPathAP) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); Corner *corner = sta_->cmdCorner(); @@ -10563,21 +10563,21 @@ TEST_F(StaDesignTest, R8_VertexArrivalRfPathAP) { // --- vertexRequired overloads --- -TEST_F(StaDesignTest, R8_VertexRequiredMinMax) { +TEST_F(StaDesignTest, VertexRequiredMinMax) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Required req = sta_->vertexRequired(v, MinMax::max()); (void)req; } -TEST_F(StaDesignTest, R8_VertexRequiredRfMinMax) { +TEST_F(StaDesignTest, VertexRequiredRfMinMax) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Required req = sta_->vertexRequired(v, RiseFall::rise(), MinMax::max()); (void)req; } -TEST_F(StaDesignTest, R8_VertexRequiredRfPathAP) { +TEST_F(StaDesignTest, VertexRequiredRfPathAP) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Corner *corner = sta_->cmdCorner(); @@ -10589,14 +10589,14 @@ TEST_F(StaDesignTest, R8_VertexRequiredRfPathAP) { // --- vertexSlack overloads --- -TEST_F(StaDesignTest, R8_VertexSlackMinMax) { +TEST_F(StaDesignTest, VertexSlackMinMax) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Slack slk = sta_->vertexSlack(v, MinMax::max()); (void)slk; } -TEST_F(StaDesignTest, R8_VertexSlackRfPathAP) { +TEST_F(StaDesignTest, VertexSlackRfPathAP) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Corner *corner = sta_->cmdCorner(); @@ -10608,7 +10608,7 @@ TEST_F(StaDesignTest, R8_VertexSlackRfPathAP) { // --- vertexSlacks --- -TEST_F(StaDesignTest, R8_VertexSlacks) { +TEST_F(StaDesignTest, VertexSlacks) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Slack slacks[RiseFall::index_count][MinMax::index_count]; @@ -10618,7 +10618,7 @@ TEST_F(StaDesignTest, R8_VertexSlacks) { // --- vertexSlew overloads --- -TEST_F(StaDesignTest, R8_VertexSlewRfCornerMinMax) { +TEST_F(StaDesignTest, VertexSlewRfCornerMinMax) { Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); Corner *corner = sta_->cmdCorner(); @@ -10626,7 +10626,7 @@ TEST_F(StaDesignTest, R8_VertexSlewRfCornerMinMax) { (void)slew; } -TEST_F(StaDesignTest, R8_VertexSlewRfDcalcAP) { +TEST_F(StaDesignTest, VertexSlewRfDcalcAP) { Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); Corner *corner = sta_->cmdCorner(); @@ -10638,7 +10638,7 @@ TEST_F(StaDesignTest, R8_VertexSlewRfDcalcAP) { // --- vertexWorstRequiredPath --- -TEST_F(StaDesignTest, R8_VertexWorstRequiredPath) { +TEST_F(StaDesignTest, VertexWorstRequiredPath) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstRequiredPath(v, MinMax::max()); @@ -10646,7 +10646,7 @@ TEST_F(StaDesignTest, R8_VertexWorstRequiredPath) { (void)path; } -TEST_F(StaDesignTest, R8_VertexWorstRequiredPathRf) { +TEST_F(StaDesignTest, VertexWorstRequiredPathRf) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstRequiredPath(v, RiseFall::rise(), MinMax::max()); @@ -10655,7 +10655,7 @@ TEST_F(StaDesignTest, R8_VertexWorstRequiredPathRf) { // --- vertexPathIterator --- -TEST_F(StaDesignTest, R8_VertexPathIteratorRfPathAP) { +TEST_F(StaDesignTest, VertexPathIteratorRfPathAP) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); Corner *corner = sta_->cmdCorner(); @@ -10668,14 +10668,14 @@ TEST_F(StaDesignTest, R8_VertexPathIteratorRfPathAP) { // --- checkSlewLimits --- -TEST_F(StaDesignTest, R8_CheckSlewLimitPreambleAndLimits) { +TEST_F(StaDesignTest, CheckSlewLimitPreambleAndLimits) { sta_->checkSlewLimitPreamble(); PinSeq pins = sta_->checkSlewLimits(nullptr, false, sta_->cmdCorner(), MinMax::max()); // May be empty; just check no crash } -TEST_F(StaDesignTest, R8_CheckSlewViolators) { +TEST_F(StaDesignTest, CheckSlewViolators) { sta_->checkSlewLimitPreamble(); PinSeq pins = sta_->checkSlewLimits(nullptr, true, sta_->cmdCorner(), MinMax::max()); @@ -10683,7 +10683,7 @@ TEST_F(StaDesignTest, R8_CheckSlewViolators) { // --- checkSlew (single pin) --- -TEST_F(StaDesignTest, R8_CheckSlew) { +TEST_F(StaDesignTest, CheckSlew) { sta_->checkSlewLimitPreamble(); Pin *pin = findPin("u1/Z"); ASSERT_NE(pin, nullptr); @@ -10697,7 +10697,7 @@ TEST_F(StaDesignTest, R8_CheckSlew) { // --- findSlewLimit --- -TEST_F(StaDesignTest, R8_FindSlewLimit) { +TEST_F(StaDesignTest, FindSlewLimit) { sta_->checkSlewLimitPreamble(); LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); @@ -10711,19 +10711,19 @@ TEST_F(StaDesignTest, R8_FindSlewLimit) { // --- checkFanoutLimits --- -TEST_F(StaDesignTest, R8_CheckFanoutLimits) { +TEST_F(StaDesignTest, CheckFanoutLimits) { sta_->checkFanoutLimitPreamble(); PinSeq pins = sta_->checkFanoutLimits(nullptr, false, MinMax::max()); } -TEST_F(StaDesignTest, R8_CheckFanoutViolators) { +TEST_F(StaDesignTest, CheckFanoutViolators) { sta_->checkFanoutLimitPreamble(); PinSeq pins = sta_->checkFanoutLimits(nullptr, true, MinMax::max()); } // --- checkFanout (single pin) --- -TEST_F(StaDesignTest, R8_CheckFanout) { +TEST_F(StaDesignTest, CheckFanout) { sta_->checkFanoutLimitPreamble(); Pin *pin = findPin("u1/Z"); ASSERT_NE(pin, nullptr); @@ -10733,13 +10733,13 @@ TEST_F(StaDesignTest, R8_CheckFanout) { // --- checkCapacitanceLimits --- -TEST_F(StaDesignTest, R8_CheckCapacitanceLimits) { +TEST_F(StaDesignTest, CheckCapacitanceLimits) { sta_->checkCapacitanceLimitPreamble(); PinSeq pins = sta_->checkCapacitanceLimits(nullptr, false, sta_->cmdCorner(), MinMax::max()); } -TEST_F(StaDesignTest, R8_CheckCapacitanceViolators) { +TEST_F(StaDesignTest, CheckCapacitanceViolators) { sta_->checkCapacitanceLimitPreamble(); PinSeq pins = sta_->checkCapacitanceLimits(nullptr, true, sta_->cmdCorner(), MinMax::max()); @@ -10747,7 +10747,7 @@ TEST_F(StaDesignTest, R8_CheckCapacitanceViolators) { // --- checkCapacitance (single pin) --- -TEST_F(StaDesignTest, R8_CheckCapacitance) { +TEST_F(StaDesignTest, CheckCapacitance) { sta_->checkCapacitanceLimitPreamble(); Pin *pin = findPin("u1/Z"); ASSERT_NE(pin, nullptr); @@ -10760,7 +10760,7 @@ TEST_F(StaDesignTest, R8_CheckCapacitance) { // --- minPulseWidthSlack --- -TEST_F(StaDesignTest, R8_MinPulseWidthSlack) { +TEST_F(StaDesignTest, MinPulseWidthSlack) { MinPulseWidthCheck *check = sta_->minPulseWidthSlack(nullptr); // May be nullptr; just don't crash (void)check; @@ -10768,49 +10768,49 @@ TEST_F(StaDesignTest, R8_MinPulseWidthSlack) { // --- minPulseWidthViolations --- -TEST_F(StaDesignTest, R8_MinPulseWidthViolations) { +TEST_F(StaDesignTest, MinPulseWidthViolations) { MinPulseWidthCheckSeq &violations = sta_->minPulseWidthViolations(nullptr); (void)violations; } // --- minPulseWidthChecks (all) --- -TEST_F(StaDesignTest, R8_MinPulseWidthChecksAll) { +TEST_F(StaDesignTest, MinPulseWidthChecksAll) { MinPulseWidthCheckSeq &checks = sta_->minPulseWidthChecks(nullptr); (void)checks; } // --- minPeriodSlack --- -TEST_F(StaDesignTest, R8_MinPeriodSlack) { +TEST_F(StaDesignTest, MinPeriodSlack) { MinPeriodCheck *check = sta_->minPeriodSlack(); (void)check; } // --- minPeriodViolations --- -TEST_F(StaDesignTest, R8_MinPeriodViolations) { +TEST_F(StaDesignTest, MinPeriodViolations) { MinPeriodCheckSeq &violations = sta_->minPeriodViolations(); (void)violations; } // --- maxSkewSlack --- -TEST_F(StaDesignTest, R8_MaxSkewSlack) { +TEST_F(StaDesignTest, MaxSkewSlack) { MaxSkewCheck *check = sta_->maxSkewSlack(); (void)check; } // --- maxSkewViolations --- -TEST_F(StaDesignTest, R8_MaxSkewViolations) { +TEST_F(StaDesignTest, MaxSkewViolations) { MaxSkewCheckSeq &violations = sta_->maxSkewViolations(); (void)violations; } // --- reportCheck (MaxSkewCheck) --- -TEST_F(StaDesignTest, R8_ReportCheckMaxSkew) { +TEST_F(StaDesignTest, ReportCheckMaxSkew) { MaxSkewCheck *check = sta_->maxSkewSlack(); if (check) { sta_->reportCheck(check, false); @@ -10820,7 +10820,7 @@ TEST_F(StaDesignTest, R8_ReportCheckMaxSkew) { // --- reportCheck (MinPeriodCheck) --- -TEST_F(StaDesignTest, R8_ReportCheckMinPeriod) { +TEST_F(StaDesignTest, ReportCheckMinPeriod) { MinPeriodCheck *check = sta_->minPeriodSlack(); if (check) { sta_->reportCheck(check, false); @@ -10830,7 +10830,7 @@ TEST_F(StaDesignTest, R8_ReportCheckMinPeriod) { // --- reportMpwCheck --- -TEST_F(StaDesignTest, R8_ReportMpwCheck) { +TEST_F(StaDesignTest, ReportMpwCheck) { MinPulseWidthCheck *check = sta_->minPulseWidthSlack(nullptr); if (check) { sta_->reportMpwCheck(check, false); @@ -10840,7 +10840,7 @@ TEST_F(StaDesignTest, R8_ReportMpwCheck) { // --- findPathEnds --- -TEST_F(StaDesignTest, R8_FindPathEnds) { +TEST_F(StaDesignTest, FindPathEnds) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, // unconstrained @@ -10865,7 +10865,7 @@ TEST_F(StaDesignTest, R8_FindPathEnds) { // --- reportPathEndHeader / Footer --- -TEST_F(StaDesignTest, R8_ReportPathEndHeaderFooter) { +TEST_F(StaDesignTest, ReportPathEndHeaderFooter) { sta_->setReportPathFormat(ReportPathFormat::full); sta_->reportPathEndHeader(); sta_->reportPathEndFooter(); @@ -10873,7 +10873,7 @@ TEST_F(StaDesignTest, R8_ReportPathEndHeaderFooter) { // --- reportPathEnd --- -TEST_F(StaDesignTest, R8_ReportPathEnd) { +TEST_F(StaDesignTest, ReportPathEnd) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -10886,7 +10886,7 @@ TEST_F(StaDesignTest, R8_ReportPathEnd) { // --- reportPathEnds --- -TEST_F(StaDesignTest, R8_ReportPathEnds) { +TEST_F(StaDesignTest, ReportPathEnds) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -10897,7 +10897,7 @@ TEST_F(StaDesignTest, R8_ReportPathEnds) { // --- reportClkSkew --- -TEST_F(StaDesignTest, R8_ReportClkSkew) { +TEST_F(StaDesignTest, ReportClkSkew) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); ConstClockSeq clks; @@ -10907,7 +10907,7 @@ TEST_F(StaDesignTest, R8_ReportClkSkew) { // --- isClock(Net*) --- -TEST_F(StaDesignTest, R8_IsClockNet) { +TEST_F(StaDesignTest, IsClockNet) { sta_->ensureClkNetwork(); Network *network = sta_->cmdNetwork(); Pin *clk1_pin = findPin("clk1"); @@ -10921,7 +10921,7 @@ TEST_F(StaDesignTest, R8_IsClockNet) { // --- pins(Clock*) --- -TEST_F(StaDesignTest, R8_ClockPins) { +TEST_F(StaDesignTest, ClockPins) { sta_->ensureClkNetwork(); Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); @@ -10934,7 +10934,7 @@ TEST_F(StaDesignTest, R8_ClockPins) { // --- pvt / setPvt --- -TEST_F(StaDesignTest, R8_PvtGetSet) { +TEST_F(StaDesignTest, PvtGetSet) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); const Pvt *p = sta_->pvt(top, MinMax::max()); @@ -10946,29 +10946,29 @@ TEST_F(StaDesignTest, R8_PvtGetSet) { // --- findDelays(int) --- -TEST_F(StaDesignTest, R8_FindDelaysLevel) { +TEST_F(StaDesignTest, FindDelaysLevel) { sta_->findDelays(0); } // --- findDelays (no arg - public) --- -TEST_F(StaDesignTest, R8_FindDelays) { +TEST_F(StaDesignTest, FindDelays) { sta_->findDelays(); } // --- arrivalsInvalid / delaysInvalid --- -TEST_F(StaDesignTest, R8_ArrivalsInvalid) { +TEST_F(StaDesignTest, ArrivalsInvalid) { sta_->arrivalsInvalid(); } -TEST_F(StaDesignTest, R8_DelaysInvalid) { +TEST_F(StaDesignTest, DelaysInvalid) { sta_->delaysInvalid(); } // --- makeEquivCells --- -TEST_F(StaDesignTest, R8_MakeEquivCells) { +TEST_F(StaDesignTest, MakeEquivCells) { LibertyLibrarySeq *equiv_libs = new LibertyLibrarySeq; equiv_libs->push_back(lib_); LibertyLibrarySeq *map_libs = new LibertyLibrarySeq; @@ -10984,7 +10984,7 @@ TEST_F(StaDesignTest, R8_MakeEquivCells) { // --- maxPathCountVertex --- -TEST_F(StaDesignTest, R8_MaxPathCountVertex) { +TEST_F(StaDesignTest, MaxPathCountVertex) { Vertex *v = sta_->maxPathCountVertex(); // May be nullptr; just don't crash (void)v; @@ -10992,21 +10992,21 @@ TEST_F(StaDesignTest, R8_MaxPathCountVertex) { // --- makeParasiticAnalysisPts --- -TEST_F(StaDesignTest, R8_MakeParasiticAnalysisPts) { +TEST_F(StaDesignTest, MakeParasiticAnalysisPts) { sta_->setParasiticAnalysisPts(false); // Ensures parasitic analysis points are set up } // --- findLogicConstants (Sim) --- -TEST_F(StaDesignTest, R8_FindLogicConstants) { +TEST_F(StaDesignTest, FindLogicConstants) { sta_->findLogicConstants(); sta_->clearLogicConstants(); } // --- checkTiming --- -TEST_F(StaDesignTest, R8_CheckTiming) { +TEST_F(StaDesignTest, CheckTiming) { CheckErrorSeq &errors = sta_->checkTiming( true, // no_input_delay true, // no_output_delay @@ -11020,7 +11020,7 @@ TEST_F(StaDesignTest, R8_CheckTiming) { // --- Property methods --- -TEST_F(StaDesignTest, R8_PropertyGetPinArrival) { +TEST_F(StaDesignTest, PropertyGetPinArrival) { Properties &props = sta_->properties(); Pin *pin = findPin("u1/Z"); ASSERT_NE(pin, nullptr); @@ -11028,7 +11028,7 @@ TEST_F(StaDesignTest, R8_PropertyGetPinArrival) { (void)pv; } -TEST_F(StaDesignTest, R8_PropertyGetPinSlack) { +TEST_F(StaDesignTest, PropertyGetPinSlack) { Properties &props = sta_->properties(); Pin *pin = findPin("r3/D"); ASSERT_NE(pin, nullptr); @@ -11036,7 +11036,7 @@ TEST_F(StaDesignTest, R8_PropertyGetPinSlack) { (void)pv; } -TEST_F(StaDesignTest, R8_PropertyGetPinSlew) { +TEST_F(StaDesignTest, PropertyGetPinSlew) { Properties &props = sta_->properties(); Pin *pin = findPin("u1/Z"); ASSERT_NE(pin, nullptr); @@ -11044,7 +11044,7 @@ TEST_F(StaDesignTest, R8_PropertyGetPinSlew) { (void)pv; } -TEST_F(StaDesignTest, R8_PropertyGetPinArrivalFall) { +TEST_F(StaDesignTest, PropertyGetPinArrivalFall) { Properties &props = sta_->properties(); Pin *pin = findPin("u1/Z"); ASSERT_NE(pin, nullptr); @@ -11052,7 +11052,7 @@ TEST_F(StaDesignTest, R8_PropertyGetPinArrivalFall) { (void)pv; } -TEST_F(StaDesignTest, R8_PropertyGetInstanceName) { +TEST_F(StaDesignTest, PropertyGetInstanceName) { Properties &props = sta_->properties(); Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); @@ -11062,7 +11062,7 @@ TEST_F(StaDesignTest, R8_PropertyGetInstanceName) { (void)pv; } -TEST_F(StaDesignTest, R8_PropertyGetNetName) { +TEST_F(StaDesignTest, PropertyGetNetName) { Properties &props = sta_->properties(); Network *network = sta_->cmdNetwork(); Pin *pin = findPin("u1/Z"); @@ -11076,13 +11076,13 @@ TEST_F(StaDesignTest, R8_PropertyGetNetName) { // --- Search methods --- -TEST_F(StaDesignTest, R8_SearchCopyState) { +TEST_F(StaDesignTest, SearchCopyState) { Search *search = sta_->search(); ASSERT_NE(search, nullptr); search->copyState(sta_); } -TEST_F(StaDesignTest, R8_SearchFindPathGroupByName) { +TEST_F(StaDesignTest, SearchFindPathGroupByName) { Search *search = sta_->search(); // First ensure path groups exist sta_->findPathEnds(nullptr, nullptr, nullptr, @@ -11094,7 +11094,7 @@ TEST_F(StaDesignTest, R8_SearchFindPathGroupByName) { (void)pg; } -TEST_F(StaDesignTest, R8_SearchFindPathGroupByClock) { +TEST_F(StaDesignTest, SearchFindPathGroupByClock) { Search *search = sta_->search(); sta_->findPathEnds(nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -11106,12 +11106,12 @@ TEST_F(StaDesignTest, R8_SearchFindPathGroupByClock) { (void)pg; } -TEST_F(StaDesignTest, R8_SearchReportTagGroups) { +TEST_F(StaDesignTest, SearchReportTagGroups) { Search *search = sta_->search(); search->reportTagGroups(); } -TEST_F(StaDesignTest, R8_SearchDeletePathGroups) { +TEST_F(StaDesignTest, SearchDeletePathGroups) { Search *search = sta_->search(); // Ensure path groups exist first sta_->findPathEnds(nullptr, nullptr, nullptr, @@ -11121,7 +11121,7 @@ TEST_F(StaDesignTest, R8_SearchDeletePathGroups) { search->deletePathGroups(); } -TEST_F(StaDesignTest, R8_SearchVisitEndpoints) { +TEST_F(StaDesignTest, SearchVisitEndpoints) { Search *search = sta_->search(); Network *network = sta_->cmdNetwork(); PinSet pins(network); @@ -11131,7 +11131,7 @@ TEST_F(StaDesignTest, R8_SearchVisitEndpoints) { // --- Search: visitStartpoints --- -TEST_F(StaDesignTest, R8_SearchVisitStartpoints) { +TEST_F(StaDesignTest, SearchVisitStartpoints) { Search *search = sta_->search(); Network *network = sta_->cmdNetwork(); PinSet pins(network); @@ -11139,7 +11139,7 @@ TEST_F(StaDesignTest, R8_SearchVisitStartpoints) { search->visitStartpoints(&collector); } -TEST_F(StaDesignTest, R8_SearchTagGroup) { +TEST_F(StaDesignTest, SearchTagGroup) { Search *search = sta_->search(); // Tag group index 0 may or may not exist; just don't crash if (search->tagGroupCount() > 0) { @@ -11148,7 +11148,7 @@ TEST_F(StaDesignTest, R8_SearchTagGroup) { } } -TEST_F(StaDesignTest, R8_SearchClockDomainsVertex) { +TEST_F(StaDesignTest, SearchClockDomainsVertex) { Search *search = sta_->search(); Vertex *v = findVertex("r1/CK"); if (v) { @@ -11157,7 +11157,7 @@ TEST_F(StaDesignTest, R8_SearchClockDomainsVertex) { } } -TEST_F(StaDesignTest, R8_SearchIsGenClkSrc) { +TEST_F(StaDesignTest, SearchIsGenClkSrc) { Search *search = sta_->search(); Vertex *v = findVertex("r1/Q"); if (v) { @@ -11166,7 +11166,7 @@ TEST_F(StaDesignTest, R8_SearchIsGenClkSrc) { } } -TEST_F(StaDesignTest, R8_SearchPathGroups) { +TEST_F(StaDesignTest, SearchPathGroups) { // Get a path end to query its path groups PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -11180,7 +11180,7 @@ TEST_F(StaDesignTest, R8_SearchPathGroups) { } } -TEST_F(StaDesignTest, R8_SearchPathClkPathArrival) { +TEST_F(StaDesignTest, SearchPathClkPathArrival) { Search *search = sta_->search(); // Get a path from a vertex Vertex *v = findVertex("r1/Q"); @@ -11196,7 +11196,7 @@ TEST_F(StaDesignTest, R8_SearchPathClkPathArrival) { // --- ReportPath: reportFull exercised through reportPathEnd (full format) --- -TEST_F(StaDesignTest, R8_ReportPathFullClockFormat) { +TEST_F(StaDesignTest, ReportPathFullClockFormat) { sta_->setReportPathFormat(ReportPathFormat::full_clock); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -11208,7 +11208,7 @@ TEST_F(StaDesignTest, R8_ReportPathFullClockFormat) { } } -TEST_F(StaDesignTest, R8_ReportPathFullClockExpandedFormat) { +TEST_F(StaDesignTest, ReportPathFullClockExpandedFormat) { sta_->setReportPathFormat(ReportPathFormat::full_clock_expanded); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -11220,7 +11220,7 @@ TEST_F(StaDesignTest, R8_ReportPathFullClockExpandedFormat) { } } -TEST_F(StaDesignTest, R8_ReportPathShorterFormat) { +TEST_F(StaDesignTest, ReportPathShorterFormat) { sta_->setReportPathFormat(ReportPathFormat::shorter); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -11232,7 +11232,7 @@ TEST_F(StaDesignTest, R8_ReportPathShorterFormat) { } } -TEST_F(StaDesignTest, R8_ReportPathJsonFormat) { +TEST_F(StaDesignTest, ReportPathJsonFormat) { sta_->setReportPathFormat(ReportPathFormat::json); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -11244,7 +11244,7 @@ TEST_F(StaDesignTest, R8_ReportPathJsonFormat) { } } -TEST_F(StaDesignTest, R8_ReportPathShortMpw) { +TEST_F(StaDesignTest, ReportPathShortMpw) { MinPulseWidthCheck *check = sta_->minPulseWidthSlack(nullptr); if (check) { ReportPath *rpt = sta_->reportPath(); @@ -11252,7 +11252,7 @@ TEST_F(StaDesignTest, R8_ReportPathShortMpw) { } } -TEST_F(StaDesignTest, R8_ReportPathVerboseMpw) { +TEST_F(StaDesignTest, ReportPathVerboseMpw) { MinPulseWidthCheck *check = sta_->minPulseWidthSlack(nullptr); if (check) { ReportPath *rpt = sta_->reportPath(); @@ -11262,14 +11262,14 @@ TEST_F(StaDesignTest, R8_ReportPathVerboseMpw) { // --- ReportPath: reportJson --- -TEST_F(StaDesignTest, R8_ReportJsonHeaderFooter) { +TEST_F(StaDesignTest, ReportJsonHeaderFooter) { ReportPath *rpt = sta_->reportPath(); ASSERT_NE(rpt, nullptr); rpt->reportJsonHeader(); rpt->reportJsonFooter(); } -TEST_F(StaDesignTest, R8_ReportJsonPathEnd) { +TEST_F(StaDesignTest, ReportJsonPathEnd) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -11285,7 +11285,7 @@ TEST_F(StaDesignTest, R8_ReportJsonPathEnd) { // --- disable / removeDisable --- -TEST_F(StaDesignTest, R8_DisableEnableLibertyPort) { +TEST_F(StaDesignTest, DisableEnableLibertyPort) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *port_a = buf->findLibertyPort("A"); @@ -11294,7 +11294,7 @@ TEST_F(StaDesignTest, R8_DisableEnableLibertyPort) { sta_->removeDisable(port_a); } -TEST_F(StaDesignTest, R8_DisableEnableTimingArcSet) { +TEST_F(StaDesignTest, DisableEnableTimingArcSet) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); const TimingArcSetSeq &arc_sets = buf->timingArcSets(); @@ -11303,7 +11303,7 @@ TEST_F(StaDesignTest, R8_DisableEnableTimingArcSet) { sta_->removeDisable(arc_sets[0]); } -TEST_F(StaDesignTest, R8_DisableEnableEdge) { +TEST_F(StaDesignTest, DisableEnableEdge) { Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); // Get an edge from this vertex @@ -11317,7 +11317,7 @@ TEST_F(StaDesignTest, R8_DisableEnableEdge) { // --- disableClockGatingCheck / removeDisableClockGatingCheck --- -TEST_F(StaDesignTest, R8_DisableClockGatingCheckPin) { +TEST_F(StaDesignTest, DisableClockGatingCheckPin) { Pin *pin = findPin("r1/CK"); ASSERT_NE(pin, nullptr); sta_->disableClockGatingCheck(pin); @@ -11326,7 +11326,7 @@ TEST_F(StaDesignTest, R8_DisableClockGatingCheckPin) { // --- setCmdNamespace1 (Sta internal) --- -TEST_F(StaDesignTest, R8_SetCmdNamespace1) { +TEST_F(StaDesignTest, SetCmdNamespace1) { sta_->setCmdNamespace(CmdNamespace::sdc); EXPECT_EQ(sta_->cmdNamespace(), CmdNamespace::sdc); sta_->setCmdNamespace(CmdNamespace::sta); @@ -11335,7 +11335,7 @@ TEST_F(StaDesignTest, R8_SetCmdNamespace1) { // --- delaysInvalidFromFanin --- -TEST_F(StaDesignTest, R8_DelaysInvalidFromFaninPin) { +TEST_F(StaDesignTest, DelaysInvalidFromFaninPin) { Pin *pin = findPin("u1/Z"); ASSERT_NE(pin, nullptr); sta_->delaysInvalidFromFanin(pin); @@ -11343,7 +11343,7 @@ TEST_F(StaDesignTest, R8_DelaysInvalidFromFaninPin) { // --- setArcDelayAnnotated --- -TEST_F(StaDesignTest, R8_SetArcDelayAnnotated) { +TEST_F(StaDesignTest, SetArcDelayAnnotated) { Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); VertexInEdgeIterator edge_iter(v, sta_->graph()); @@ -11364,7 +11364,7 @@ TEST_F(StaDesignTest, R8_SetArcDelayAnnotated) { // --- pathAnalysisPt / pathDcalcAnalysisPt --- -TEST_F(StaDesignTest, R8_PathAnalysisPt) { +TEST_F(StaDesignTest, PathAnalysisPt) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstArrivalPath(v, MinMax::max()); @@ -11378,14 +11378,14 @@ TEST_F(StaDesignTest, R8_PathAnalysisPt) { // --- worstSlack / totalNegativeSlack --- -TEST_F(StaDesignTest, R8_WorstSlack) { +TEST_F(StaDesignTest, WorstSlack) { Slack worst; Vertex *worst_vertex = nullptr; sta_->worstSlack(MinMax::max(), worst, worst_vertex); (void)worst; } -TEST_F(StaDesignTest, R8_WorstSlackCorner) { +TEST_F(StaDesignTest, WorstSlackCorner) { Slack worst; Vertex *worst_vertex = nullptr; Corner *corner = sta_->cmdCorner(); @@ -11393,12 +11393,12 @@ TEST_F(StaDesignTest, R8_WorstSlackCorner) { (void)worst; } -TEST_F(StaDesignTest, R8_TotalNegativeSlack) { +TEST_F(StaDesignTest, TotalNegativeSlack) { Slack tns = sta_->totalNegativeSlack(MinMax::max()); (void)tns; } -TEST_F(StaDesignTest, R8_TotalNegativeSlackCorner) { +TEST_F(StaDesignTest, TotalNegativeSlackCorner) { Corner *corner = sta_->cmdCorner(); Slack tns = sta_->totalNegativeSlack(corner, MinMax::max()); (void)tns; @@ -11406,25 +11406,25 @@ TEST_F(StaDesignTest, R8_TotalNegativeSlackCorner) { // --- endpoints / endpointViolationCount --- -TEST_F(StaDesignTest, R8_Endpoints) { +TEST_F(StaDesignTest, Endpoints) { VertexSet *eps = sta_->endpoints(); EXPECT_NE(eps, nullptr); } -TEST_F(StaDesignTest, R8_EndpointViolationCount) { +TEST_F(StaDesignTest, EndpointViolationCount) { int count = sta_->endpointViolationCount(MinMax::max()); (void)count; } // --- findRequireds --- -TEST_F(StaDesignTest, R8_FindRequireds) { +TEST_F(StaDesignTest, FindRequireds) { sta_->findRequireds(); } // --- Search: tag(0) --- -TEST_F(StaDesignTest, R8_SearchTag) { +TEST_F(StaDesignTest, SearchTag) { Search *search = sta_->search(); if (search->tagCount() > 0) { Tag *t = search->tag(0); @@ -11434,14 +11434,14 @@ TEST_F(StaDesignTest, R8_SearchTag) { // --- Levelize: checkLevels --- -TEST_F(StaDesignTest, R8_GraphLoops) { +TEST_F(StaDesignTest, GraphLoops) { GraphLoopSeq &loops = sta_->graphLoops(); (void)loops; } // --- reportPath (Path*) --- -TEST_F(StaDesignTest, R8_ReportPath) { +TEST_F(StaDesignTest, ReportPath) { Vertex *v = findVertex("u2/ZN"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstArrivalPath(v, MinMax::max()); @@ -11452,7 +11452,7 @@ TEST_F(StaDesignTest, R8_ReportPath) { // --- ClkNetwork: clocks(Pin*) --- -TEST_F(StaDesignTest, R8_ClkNetworkClocksPinDirect) { +TEST_F(StaDesignTest, ClkNetworkClocksPinDirect) { sta_->ensureClkNetwork(); ClkNetwork *clk_net = sta_->clkNetwork(); ASSERT_NE(clk_net, nullptr); @@ -11464,7 +11464,7 @@ TEST_F(StaDesignTest, R8_ClkNetworkClocksPinDirect) { // --- ClkNetwork: pins(Clock*) --- -TEST_F(StaDesignTest, R8_ClkNetworkPins) { +TEST_F(StaDesignTest, ClkNetworkPins) { sta_->ensureClkNetwork(); ClkNetwork *clk_net = sta_->clkNetwork(); ASSERT_NE(clk_net, nullptr); @@ -11476,7 +11476,7 @@ TEST_F(StaDesignTest, R8_ClkNetworkPins) { // --- ClkNetwork: isClock(Net*) --- -TEST_F(StaDesignTest, R8_ClkNetworkIsClockNet) { +TEST_F(StaDesignTest, ClkNetworkIsClockNet) { sta_->ensureClkNetwork(); ClkNetwork *clk_net = sta_->clkNetwork(); ASSERT_NE(clk_net, nullptr); @@ -11492,7 +11492,7 @@ TEST_F(StaDesignTest, R8_ClkNetworkIsClockNet) { // --- ClkInfo accessors --- -TEST_F(StaDesignTest, R8_ClkInfoAccessors) { +TEST_F(StaDesignTest, ClkInfoAccessors) { Search *search = sta_->search(); if (search->tagCount() > 0) { Tag *tag = search->tag(0); @@ -11512,7 +11512,7 @@ TEST_F(StaDesignTest, R8_ClkInfoAccessors) { // --- Tag accessors --- -TEST_F(StaDesignTest, R8_TagAccessors) { +TEST_F(StaDesignTest, TagAccessors) { Search *search = sta_->search(); if (search->tagCount() > 0) { Tag *tag = search->tag(0); @@ -11527,7 +11527,7 @@ TEST_F(StaDesignTest, R8_TagAccessors) { // --- TagGroup::report --- -TEST_F(StaDesignTest, R8_TagGroupReport) { +TEST_F(StaDesignTest, TagGroupReport) { Search *search = sta_->search(); if (search->tagGroupCount() > 0) { TagGroup *tg = search->tagGroup(0); @@ -11539,7 +11539,7 @@ TEST_F(StaDesignTest, R8_TagGroupReport) { // --- BfsIterator --- -TEST_F(StaDesignTest, R8_BfsIteratorInit) { +TEST_F(StaDesignTest, BfsIteratorInit) { BfsFwdIterator *iter = sta_->search()->arrivalIterator(); ASSERT_NE(iter, nullptr); // Just verify the iterator exists - init is called internally @@ -11547,7 +11547,7 @@ TEST_F(StaDesignTest, R8_BfsIteratorInit) { // --- SearchPredNonReg2 --- -TEST_F(StaDesignTest, R8_SearchPredNonReg2SearchThru) { +TEST_F(StaDesignTest, SearchPredNonReg2SearchThru) { SearchPredNonReg2 pred(sta_); Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); @@ -11561,7 +11561,7 @@ TEST_F(StaDesignTest, R8_SearchPredNonReg2SearchThru) { // --- PathExpanded --- -TEST_F(StaDesignTest, R8_PathExpanded) { +TEST_F(StaDesignTest, PathExpanded) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstArrivalPath(v, MinMax::max()); @@ -11577,7 +11577,7 @@ TEST_F(StaDesignTest, R8_PathExpanded) { // --- Search: endpoints --- -TEST_F(StaDesignTest, R8_SearchEndpoints) { +TEST_F(StaDesignTest, SearchEndpoints) { Search *search = sta_->search(); VertexSet *eps = search->endpoints(); EXPECT_NE(eps, nullptr); @@ -11585,7 +11585,7 @@ TEST_F(StaDesignTest, R8_SearchEndpoints) { // --- FindRegister (findRegs) --- -TEST_F(StaDesignTest, R8_FindRegPins) { +TEST_F(StaDesignTest, FindRegPins) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); ClockSet clk_set; @@ -11595,25 +11595,25 @@ TEST_F(StaDesignTest, R8_FindRegPins) { (void)reg_clk_pins; } -TEST_F(StaDesignTest, R8_FindRegDataPins) { +TEST_F(StaDesignTest, FindRegDataPins) { PinSet reg_data_pins = sta_->findRegisterDataPins(nullptr, RiseFallBoth::riseFall(), false, false); (void)reg_data_pins; } -TEST_F(StaDesignTest, R8_FindRegOutputPins) { +TEST_F(StaDesignTest, FindRegOutputPins) { PinSet reg_out_pins = sta_->findRegisterOutputPins(nullptr, RiseFallBoth::riseFall(), false, false); (void)reg_out_pins; } -TEST_F(StaDesignTest, R8_FindRegAsyncPins) { +TEST_F(StaDesignTest, FindRegAsyncPins) { PinSet reg_async_pins = sta_->findRegisterAsyncPins(nullptr, RiseFallBoth::riseFall(), false, false); (void)reg_async_pins; } -TEST_F(StaDesignTest, R8_FindRegInstances) { +TEST_F(StaDesignTest, FindRegInstances) { InstanceSet reg_insts = sta_->findRegisterInstances(nullptr, RiseFallBoth::riseFall(), false, false); (void)reg_insts; @@ -11621,7 +11621,7 @@ TEST_F(StaDesignTest, R8_FindRegInstances) { // --- Sim::findLogicConstants --- -TEST_F(StaDesignTest, R8_SimFindLogicConstants) { +TEST_F(StaDesignTest, SimFindLogicConstants) { Sim *sim = sta_->sim(); ASSERT_NE(sim, nullptr); sim->findLogicConstants(); @@ -11629,25 +11629,25 @@ TEST_F(StaDesignTest, R8_SimFindLogicConstants) { // --- reportSlewLimitShortHeader --- -TEST_F(StaDesignTest, R8_ReportSlewLimitShortHeader) { +TEST_F(StaDesignTest, ReportSlewLimitShortHeader) { sta_->reportSlewLimitShortHeader(); } // --- reportFanoutLimitShortHeader --- -TEST_F(StaDesignTest, R8_ReportFanoutLimitShortHeader) { +TEST_F(StaDesignTest, ReportFanoutLimitShortHeader) { sta_->reportFanoutLimitShortHeader(); } // --- reportCapacitanceLimitShortHeader --- -TEST_F(StaDesignTest, R8_ReportCapacitanceLimitShortHeader) { +TEST_F(StaDesignTest, ReportCapacitanceLimitShortHeader) { sta_->reportCapacitanceLimitShortHeader(); } // --- Path methods --- -TEST_F(StaDesignTest, R8_PathTransition) { +TEST_F(StaDesignTest, PathTransition) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstArrivalPath(v, MinMax::max()); @@ -11659,7 +11659,7 @@ TEST_F(StaDesignTest, R8_PathTransition) { // --- endpointSlack --- -TEST_F(StaDesignTest, R8_EndpointSlack) { +TEST_F(StaDesignTest, EndpointSlack) { Pin *pin = findPin("r3/D"); ASSERT_NE(pin, nullptr); Slack slk = sta_->endpointSlack(pin, "clk", MinMax::max()); @@ -11668,7 +11668,7 @@ TEST_F(StaDesignTest, R8_EndpointSlack) { // --- replaceCell --- -TEST_F(StaDesignTest, R8_ReplaceCell) { +TEST_F(StaDesignTest, ReplaceCell) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); // Find instance u1 (BUF_X1) @@ -11687,7 +11687,7 @@ TEST_F(StaDesignTest, R8_ReplaceCell) { // --- reportPathEnd with prev_end --- -TEST_F(StaDesignTest, R8_ReportPathEndWithPrev) { +TEST_F(StaDesignTest, ReportPathEndWithPrev) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -11700,7 +11700,7 @@ TEST_F(StaDesignTest, R8_ReportPathEndWithPrev) { // --- PathEnd static methods --- -TEST_F(StaDesignTest, R8_PathEndLess) { +TEST_F(StaDesignTest, PathEndLess) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -11716,7 +11716,7 @@ TEST_F(StaDesignTest, R8_PathEndLess) { // --- PathEnd accessors on real path ends --- -TEST_F(StaDesignTest, R8_PathEndAccessors) { +TEST_F(StaDesignTest, PathEndAccessors) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -11757,7 +11757,7 @@ TEST_F(StaDesignTest, R8_PathEndAccessors) { // --- ReportPath: reportShort for MinPeriodCheck --- -TEST_F(StaDesignTest, R8_ReportPathShortMinPeriod) { +TEST_F(StaDesignTest, ReportPathShortMinPeriod) { MinPeriodCheck *check = sta_->minPeriodSlack(); if (check) { ReportPath *rpt = sta_->reportPath(); @@ -11767,7 +11767,7 @@ TEST_F(StaDesignTest, R8_ReportPathShortMinPeriod) { // --- ReportPath: reportShort for MaxSkewCheck --- -TEST_F(StaDesignTest, R8_ReportPathShortMaxSkew) { +TEST_F(StaDesignTest, ReportPathShortMaxSkew) { MaxSkewCheck *check = sta_->maxSkewSlack(); if (check) { ReportPath *rpt = sta_->reportPath(); @@ -11777,7 +11777,7 @@ TEST_F(StaDesignTest, R8_ReportPathShortMaxSkew) { // --- ReportPath: reportCheck for MaxSkewCheck --- -TEST_F(StaDesignTest, R8_ReportPathCheckMaxSkew) { +TEST_F(StaDesignTest, ReportPathCheckMaxSkew) { MaxSkewCheck *check = sta_->maxSkewSlack(); if (check) { ReportPath *rpt = sta_->reportPath(); @@ -11788,7 +11788,7 @@ TEST_F(StaDesignTest, R8_ReportPathCheckMaxSkew) { // --- ReportPath: reportVerbose for MaxSkewCheck --- -TEST_F(StaDesignTest, R8_ReportPathVerboseMaxSkew) { +TEST_F(StaDesignTest, ReportPathVerboseMaxSkew) { MaxSkewCheck *check = sta_->maxSkewSlack(); if (check) { ReportPath *rpt = sta_->reportPath(); @@ -11798,7 +11798,7 @@ TEST_F(StaDesignTest, R8_ReportPathVerboseMaxSkew) { // --- ReportPath: reportMpwChecks (covers mpwCheckHiLow internally) --- -TEST_F(StaDesignTest, R8_ReportMpwChecks) { +TEST_F(StaDesignTest, ReportMpwChecks) { MinPulseWidthCheckSeq &checks = sta_->minPulseWidthChecks(nullptr); if (!checks.empty()) { ReportPath *rpt = sta_->reportPath(); @@ -11809,7 +11809,7 @@ TEST_F(StaDesignTest, R8_ReportMpwChecks) { // --- findClkMinPeriod --- -TEST_F(StaDesignTest, R8_FindClkMinPeriod) { +TEST_F(StaDesignTest, FindClkMinPeriod) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); float min_period = sta_->findClkMinPeriod(clk, false); @@ -11818,14 +11818,14 @@ TEST_F(StaDesignTest, R8_FindClkMinPeriod) { // --- slowDrivers --- -TEST_F(StaDesignTest, R8_SlowDrivers) { +TEST_F(StaDesignTest, SlowDrivers) { InstanceSeq slow = sta_->slowDrivers(5); (void)slow; } // --- vertexLevel --- -TEST_F(StaDesignTest, R8_VertexLevel) { +TEST_F(StaDesignTest, VertexLevel) { Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); Level lvl = sta_->vertexLevel(v); @@ -11834,7 +11834,7 @@ TEST_F(StaDesignTest, R8_VertexLevel) { // --- simLogicValue --- -TEST_F(StaDesignTest, R8_SimLogicValue) { +TEST_F(StaDesignTest, SimLogicValue) { Pin *pin = findPin("u1/Z"); ASSERT_NE(pin, nullptr); LogicValue val = sta_->simLogicValue(pin); @@ -11843,7 +11843,7 @@ TEST_F(StaDesignTest, R8_SimLogicValue) { // --- Search: clear (exercises initVars internally) --- -TEST_F(StaDesignTest, R8_SearchClear) { +TEST_F(StaDesignTest, SearchClear) { Search *search = sta_->search(); // clear() calls initVars() internally search->clear(); @@ -11852,7 +11852,7 @@ TEST_F(StaDesignTest, R8_SearchClear) { // --- readLibertyFile (protected, call through public readLiberty) --- // This tests readLibertyFile indirectly -TEST_F(StaDesignTest, R8_ReadLibertyFile) { +TEST_F(StaDesignTest, ReadLibertyFile) { Corner *corner = sta_->cmdCorner(); LibertyLibrary *lib = sta_->readLiberty( "test/nangate45/Nangate45_slow.lib", corner, MinMaxAll::min(), false); @@ -11862,7 +11862,7 @@ TEST_F(StaDesignTest, R8_ReadLibertyFile) { // --- Property: getProperty on LibertyLibrary --- -TEST_F(StaDesignTest, R8_PropertyGetPropertyLibertyLibrary) { +TEST_F(StaDesignTest, PropertyGetPropertyLibertyLibrary) { Properties &props = sta_->properties(); ASSERT_NE(lib_, nullptr); PropertyValue pv = props.getProperty(lib_, "name"); @@ -11871,7 +11871,7 @@ TEST_F(StaDesignTest, R8_PropertyGetPropertyLibertyLibrary) { // --- Property: getProperty on LibertyCell --- -TEST_F(StaDesignTest, R8_PropertyGetPropertyLibertyCell) { +TEST_F(StaDesignTest, PropertyGetPropertyLibertyCell) { Properties &props = sta_->properties(); LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); @@ -11881,7 +11881,7 @@ TEST_F(StaDesignTest, R8_PropertyGetPropertyLibertyCell) { // --- findPathEnds with unconstrained --- -TEST_F(StaDesignTest, R8_FindPathEndsUnconstrained) { +TEST_F(StaDesignTest, FindPathEndsUnconstrained) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, true, // unconstrained @@ -11894,7 +11894,7 @@ TEST_F(StaDesignTest, R8_FindPathEndsUnconstrained) { // --- findPathEnds with hold --- -TEST_F(StaDesignTest, R8_FindPathEndsHold) { +TEST_F(StaDesignTest, FindPathEndsHold) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::min(), @@ -11905,14 +11905,14 @@ TEST_F(StaDesignTest, R8_FindPathEndsHold) { // --- Search: findAllArrivals --- -TEST_F(StaDesignTest, R8_SearchFindAllArrivals) { +TEST_F(StaDesignTest, SearchFindAllArrivals) { Search *search = sta_->search(); search->findAllArrivals(); } // --- Search: findArrivals / findRequireds --- -TEST_F(StaDesignTest, R8_SearchFindArrivalsRequireds) { +TEST_F(StaDesignTest, SearchFindArrivalsRequireds) { Search *search = sta_->search(); search->findArrivals(); search->findRequireds(); @@ -11920,7 +11920,7 @@ TEST_F(StaDesignTest, R8_SearchFindArrivalsRequireds) { // --- Search: clocks for vertex --- -TEST_F(StaDesignTest, R8_SearchClocksVertex) { +TEST_F(StaDesignTest, SearchClocksVertex) { Search *search = sta_->search(); Vertex *v = findVertex("r1/CK"); if (v) { @@ -11931,7 +11931,7 @@ TEST_F(StaDesignTest, R8_SearchClocksVertex) { // --- Search: wnsSlack --- -TEST_F(StaDesignTest, R8_SearchWnsSlack) { +TEST_F(StaDesignTest, SearchWnsSlack) { Search *search = sta_->search(); Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); @@ -11941,7 +11941,7 @@ TEST_F(StaDesignTest, R8_SearchWnsSlack) { // --- Search: isEndpoint --- -TEST_F(StaDesignTest, R8_SearchIsEndpoint) { +TEST_F(StaDesignTest, SearchIsEndpoint) { Search *search = sta_->search(); Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); @@ -11951,13 +11951,13 @@ TEST_F(StaDesignTest, R8_SearchIsEndpoint) { // --- reportParasiticAnnotation --- -TEST_F(StaDesignTest, R8_ReportParasiticAnnotation) { +TEST_F(StaDesignTest, ReportParasiticAnnotation) { sta_->reportParasiticAnnotation(false, sta_->cmdCorner()); } // --- findClkDelays --- -TEST_F(StaDesignTest, R8_FindClkDelays) { +TEST_F(StaDesignTest, FindClkDelays) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); ClkDelays delays = sta_->findClkDelays(clk, false); @@ -11966,7 +11966,7 @@ TEST_F(StaDesignTest, R8_FindClkDelays) { // --- reportClkLatency --- -TEST_F(StaDesignTest, R8_ReportClkLatency) { +TEST_F(StaDesignTest, ReportClkLatency) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); ConstClockSeq clks; @@ -11976,14 +11976,14 @@ TEST_F(StaDesignTest, R8_ReportClkLatency) { // --- findWorstClkSkew --- -TEST_F(StaDesignTest, R8_FindWorstClkSkew) { +TEST_F(StaDesignTest, FindWorstClkSkew) { float worst = sta_->findWorstClkSkew(SetupHold::max(), false); (void)worst; } // --- ReportPath: reportJson on a Path --- -TEST_F(StaDesignTest, R8_ReportJsonPath) { +TEST_F(StaDesignTest, ReportJsonPath) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstArrivalPath(v, MinMax::max()); @@ -11995,7 +11995,7 @@ TEST_F(StaDesignTest, R8_ReportJsonPath) { // --- reportEndHeader / reportEndLine --- -TEST_F(StaDesignTest, R8_ReportEndHeaderLine) { +TEST_F(StaDesignTest, ReportEndHeaderLine) { sta_->setReportPathFormat(ReportPathFormat::endpoint); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -12011,7 +12011,7 @@ TEST_F(StaDesignTest, R8_ReportEndHeaderLine) { // --- reportSummaryHeader / reportSummaryLine --- -TEST_F(StaDesignTest, R8_ReportSummaryHeaderLine) { +TEST_F(StaDesignTest, ReportSummaryHeaderLine) { sta_->setReportPathFormat(ReportPathFormat::summary); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -12027,7 +12027,7 @@ TEST_F(StaDesignTest, R8_ReportSummaryHeaderLine) { // --- reportSlackOnlyHeader / reportSlackOnly --- -TEST_F(StaDesignTest, R8_ReportSlackOnly) { +TEST_F(StaDesignTest, ReportSlackOnly) { sta_->setReportPathFormat(ReportPathFormat::slack_only); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -12043,7 +12043,7 @@ TEST_F(StaDesignTest, R8_ReportSlackOnly) { // --- Search: reportArrivals --- -TEST_F(StaDesignTest, R8_SearchReportArrivals) { +TEST_F(StaDesignTest, SearchReportArrivals) { Search *search = sta_->search(); Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); @@ -12052,34 +12052,34 @@ TEST_F(StaDesignTest, R8_SearchReportArrivals) { // --- Search: reportPathCountHistogram --- -TEST_F(StaDesignTest, R8_SearchReportPathCountHistogram) { +TEST_F(StaDesignTest, SearchReportPathCountHistogram) { Search *search = sta_->search(); search->reportPathCountHistogram(); } // --- Search: reportTags --- -TEST_F(StaDesignTest, R8_SearchReportTags) { +TEST_F(StaDesignTest, SearchReportTags) { Search *search = sta_->search(); search->reportTags(); } // --- Search: reportClkInfos --- -TEST_F(StaDesignTest, R8_SearchReportClkInfos) { +TEST_F(StaDesignTest, SearchReportClkInfos) { Search *search = sta_->search(); search->reportClkInfos(); } // --- setReportPathFields --- -TEST_F(StaDesignTest, R8_SetReportPathFields) { +TEST_F(StaDesignTest, SetReportPathFields) { sta_->setReportPathFields(true, true, true, true, true, true, true); } // --- setReportPathFieldOrder --- -TEST_F(StaDesignTest, R8_SetReportPathFieldOrder) { +TEST_F(StaDesignTest, SetReportPathFieldOrder) { StringSeq *fields = new StringSeq; fields->push_back("Fanout"); fields->push_back("Cap"); @@ -12089,14 +12089,14 @@ TEST_F(StaDesignTest, R8_SetReportPathFieldOrder) { // --- Search: saveEnumPath --- // (This is complex - need a valid enumerated path. Test existence.) -TEST_F(StaDesignTest, R8_SearchSaveEnumPathExists) { +TEST_F(StaDesignTest, SearchSaveEnumPathExists) { auto fn = &Search::saveEnumPath; EXPECT_NE(fn, nullptr); } // --- vertexPathCount --- -TEST_F(StaDesignTest, R8_VertexPathCount) { +TEST_F(StaDesignTest, VertexPathCount) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); int count = sta_->vertexPathCount(v); @@ -12105,20 +12105,20 @@ TEST_F(StaDesignTest, R8_VertexPathCount) { // --- pathCount --- -TEST_F(StaDesignTest, R8_PathCount) { +TEST_F(StaDesignTest, PathCount) { int count = sta_->pathCount(); EXPECT_GE(count, 0); } // --- writeSdc --- -TEST_F(StaDesignTest, R8_WriteSdc) { +TEST_F(StaDesignTest, WriteSdc) { sta_->writeSdc("/dev/null", false, false, 4, false, true); } // --- ReportPath: reportFull for PathEndCheck --- -TEST_F(StaDesignTest, R8_ReportPathFullPathEnd) { +TEST_F(StaDesignTest, ReportPathFullPathEnd) { sta_->setReportPathFormat(ReportPathFormat::full); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -12133,14 +12133,14 @@ TEST_F(StaDesignTest, R8_ReportPathFullPathEnd) { // --- Search: ensureDownstreamClkPins --- -TEST_F(StaDesignTest, R8_SearchEnsureDownstreamClkPins) { +TEST_F(StaDesignTest, SearchEnsureDownstreamClkPins) { Search *search = sta_->search(); search->ensureDownstreamClkPins(); } // --- Genclks --- -TEST_F(StaDesignTest, R8_GenclksAccessor) { +TEST_F(StaDesignTest, GenclksAccessor) { Search *search = sta_->search(); Genclks *genclks = search->genclks(); EXPECT_NE(genclks, nullptr); @@ -12148,7 +12148,7 @@ TEST_F(StaDesignTest, R8_GenclksAccessor) { // --- CheckCrpr accessor --- -TEST_F(StaDesignTest, R8_CheckCrprAccessor) { +TEST_F(StaDesignTest, CheckCrprAccessor) { Search *search = sta_->search(); CheckCrpr *crpr = search->checkCrpr(); EXPECT_NE(crpr, nullptr); @@ -12156,7 +12156,7 @@ TEST_F(StaDesignTest, R8_CheckCrprAccessor) { // --- GatedClk accessor --- -TEST_F(StaDesignTest, R8_GatedClkAccessor) { +TEST_F(StaDesignTest, GatedClkAccessor) { Search *search = sta_->search(); GatedClk *gated = search->gatedClk(); EXPECT_NE(gated, nullptr); @@ -12164,7 +12164,7 @@ TEST_F(StaDesignTest, R8_GatedClkAccessor) { // --- VisitPathEnds accessor --- -TEST_F(StaDesignTest, R8_VisitPathEndsAccessor) { +TEST_F(StaDesignTest, VisitPathEndsAccessor) { Search *search = sta_->search(); VisitPathEnds *vpe = search->visitPathEnds(); EXPECT_NE(vpe, nullptr); @@ -12176,7 +12176,7 @@ TEST_F(StaDesignTest, R8_VisitPathEndsAccessor) { // --- Search: worstSlack (triggers WorstSlack methods) --- -TEST_F(StaDesignTest, R8_SearchWorstSlackMinMax) { +TEST_F(StaDesignTest, SearchWorstSlackMinMax) { Search *search = sta_->search(); Slack worst; Vertex *worst_vertex = nullptr; @@ -12184,7 +12184,7 @@ TEST_F(StaDesignTest, R8_SearchWorstSlackMinMax) { (void)worst; } -TEST_F(StaDesignTest, R8_SearchWorstSlackCorner) { +TEST_F(StaDesignTest, SearchWorstSlackCorner) { Search *search = sta_->search(); Corner *corner = sta_->cmdCorner(); Slack worst; @@ -12195,13 +12195,13 @@ TEST_F(StaDesignTest, R8_SearchWorstSlackCorner) { // --- Search: totalNegativeSlack --- -TEST_F(StaDesignTest, R8_SearchTotalNegativeSlack) { +TEST_F(StaDesignTest, SearchTotalNegativeSlack) { Search *search = sta_->search(); Slack tns = search->totalNegativeSlack(MinMax::max()); (void)tns; } -TEST_F(StaDesignTest, R8_SearchTotalNegativeSlackCorner) { +TEST_F(StaDesignTest, SearchTotalNegativeSlackCorner) { Search *search = sta_->search(); Corner *corner = sta_->cmdCorner(); Slack tns = search->totalNegativeSlack(corner, MinMax::max()); @@ -12210,7 +12210,7 @@ TEST_F(StaDesignTest, R8_SearchTotalNegativeSlackCorner) { // --- Property: getProperty on Edge --- -TEST_F(StaDesignTest, R8_PropertyGetEdge) { +TEST_F(StaDesignTest, PropertyGetEdge) { Properties &props = sta_->properties(); Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); @@ -12224,7 +12224,7 @@ TEST_F(StaDesignTest, R8_PropertyGetEdge) { // --- Property: getProperty on Clock --- -TEST_F(StaDesignTest, R8_PropertyGetClock) { +TEST_F(StaDesignTest, PropertyGetClock) { Properties &props = sta_->properties(); Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); @@ -12234,7 +12234,7 @@ TEST_F(StaDesignTest, R8_PropertyGetClock) { // --- Property: getProperty on LibertyPort --- -TEST_F(StaDesignTest, R8_PropertyGetLibertyPort) { +TEST_F(StaDesignTest, PropertyGetLibertyPort) { Properties &props = sta_->properties(); LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); @@ -12246,7 +12246,7 @@ TEST_F(StaDesignTest, R8_PropertyGetLibertyPort) { // --- Property: getProperty on Port --- -TEST_F(StaDesignTest, R8_PropertyGetPort) { +TEST_F(StaDesignTest, PropertyGetPort) { Properties &props = sta_->properties(); Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); @@ -12261,7 +12261,7 @@ TEST_F(StaDesignTest, R8_PropertyGetPort) { // --- Sta: makeInstance / deleteInstance --- -TEST_F(StaDesignTest, R8_MakeDeleteInstance) { +TEST_F(StaDesignTest, MakeDeleteInstance) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); Network *network = sta_->cmdNetwork(); @@ -12273,7 +12273,7 @@ TEST_F(StaDesignTest, R8_MakeDeleteInstance) { // --- Sta: makeNet / deleteNet --- -TEST_F(StaDesignTest, R8_MakeDeleteNet) { +TEST_F(StaDesignTest, MakeDeleteNet) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Net *new_net = sta_->makeNet("test_net", top); @@ -12283,7 +12283,7 @@ TEST_F(StaDesignTest, R8_MakeDeleteNet) { // --- Sta: connectPin / disconnectPin --- -TEST_F(StaDesignTest, R8_ConnectDisconnectPin) { +TEST_F(StaDesignTest, ConnectDisconnectPin) { LibertyCell *buf = lib_->findLibertyCell("BUF_X1"); ASSERT_NE(buf, nullptr); LibertyPort *port_a = buf->findLibertyPort("A"); @@ -12305,21 +12305,21 @@ TEST_F(StaDesignTest, R8_ConnectDisconnectPin) { // --- Sta: endpointPins --- -TEST_F(StaDesignTest, R8_EndpointPins) { +TEST_F(StaDesignTest, EndpointPins) { PinSet eps = sta_->endpointPins(); EXPECT_GT(eps.size(), 0u); } // --- Sta: startpointPins --- -TEST_F(StaDesignTest, R8_StartpointPins) { +TEST_F(StaDesignTest, StartpointPins) { PinSet sps = sta_->startpointPins(); EXPECT_GT(sps.size(), 0u); } // --- Search: arrivalsValid --- -TEST_F(StaDesignTest, R8_SearchArrivalsValidDesign) { +TEST_F(StaDesignTest, SearchArrivalsValidDesign) { Search *search = sta_->search(); bool valid = search->arrivalsValid(); EXPECT_TRUE(valid); @@ -12327,7 +12327,7 @@ TEST_F(StaDesignTest, R8_SearchArrivalsValidDesign) { // --- Sta: netSlack --- -TEST_F(StaDesignTest, R8_NetSlack) { +TEST_F(StaDesignTest, NetSlack) { Network *network = sta_->cmdNetwork(); Pin *pin = findPin("u1/Z"); ASSERT_NE(pin, nullptr); @@ -12340,14 +12340,14 @@ TEST_F(StaDesignTest, R8_NetSlack) { // --- Sta: pinSlack --- -TEST_F(StaDesignTest, R8_PinSlackMinMax) { +TEST_F(StaDesignTest, PinSlackMinMax) { Pin *pin = findPin("r3/D"); ASSERT_NE(pin, nullptr); Slack slk = sta_->pinSlack(pin, MinMax::max()); (void)slk; } -TEST_F(StaDesignTest, R8_PinSlackRfMinMax) { +TEST_F(StaDesignTest, PinSlackRfMinMax) { Pin *pin = findPin("r3/D"); ASSERT_NE(pin, nullptr); Slack slk = sta_->pinSlack(pin, RiseFall::rise(), MinMax::max()); @@ -12356,7 +12356,7 @@ TEST_F(StaDesignTest, R8_PinSlackRfMinMax) { // --- Sta: pinArrival --- -TEST_F(StaDesignTest, R8_PinArrival) { +TEST_F(StaDesignTest, PinArrival) { Pin *pin = findPin("u1/Z"); ASSERT_NE(pin, nullptr); Arrival arr = sta_->pinArrival(pin, RiseFall::rise(), MinMax::max()); @@ -12365,14 +12365,14 @@ TEST_F(StaDesignTest, R8_PinArrival) { // --- Sta: clocks / clockDomains --- -TEST_F(StaDesignTest, R8_ClocksOnPin) { +TEST_F(StaDesignTest, ClocksOnPin) { Pin *pin = findPin("clk1"); ASSERT_NE(pin, nullptr); ClockSet clks = sta_->clocks(pin); (void)clks; } -TEST_F(StaDesignTest, R8_ClockDomainsOnPin) { +TEST_F(StaDesignTest, ClockDomainsOnPin) { Pin *pin = findPin("r1/CK"); ASSERT_NE(pin, nullptr); ClockSet domains = sta_->clockDomains(pin); @@ -12381,14 +12381,14 @@ TEST_F(StaDesignTest, R8_ClockDomainsOnPin) { // --- Sta: vertexWorstArrivalPath (both overloads) --- -TEST_F(StaDesignTest, R8_VertexWorstArrivalPathMinMax) { +TEST_F(StaDesignTest, VertexWorstArrivalPathMinMax) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstArrivalPath(v, MinMax::max()); (void)path; } -TEST_F(StaDesignTest, R8_VertexWorstArrivalPathRf) { +TEST_F(StaDesignTest, VertexWorstArrivalPathRf) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstArrivalPath(v, RiseFall::rise(), MinMax::max()); @@ -12397,14 +12397,14 @@ TEST_F(StaDesignTest, R8_VertexWorstArrivalPathRf) { // --- Sta: vertexWorstSlackPath --- -TEST_F(StaDesignTest, R8_VertexWorstSlackPath) { +TEST_F(StaDesignTest, VertexWorstSlackPath) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstSlackPath(v, MinMax::max()); (void)path; } -TEST_F(StaDesignTest, R8_VertexWorstSlackPathRf) { +TEST_F(StaDesignTest, VertexWorstSlackPathRf) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstSlackPath(v, RiseFall::rise(), MinMax::max()); @@ -12413,7 +12413,7 @@ TEST_F(StaDesignTest, R8_VertexWorstSlackPathRf) { // --- Search: isClock on clock vertex --- -TEST_F(StaDesignTest, R8_SearchIsClockVertex) { +TEST_F(StaDesignTest, SearchIsClockVertex) { Search *search = sta_->search(); Vertex *v = findVertex("r1/CK"); ASSERT_NE(v, nullptr); @@ -12423,7 +12423,7 @@ TEST_F(StaDesignTest, R8_SearchIsClockVertex) { // --- Search: clkPathArrival --- -TEST_F(StaDesignTest, R8_SearchClkPathArrival) { +TEST_F(StaDesignTest, SearchClkPathArrival) { Search *search = sta_->search(); // Need a clock path Vertex *v = findVertex("r1/CK"); @@ -12437,45 +12437,45 @@ TEST_F(StaDesignTest, R8_SearchClkPathArrival) { // --- Sta: removeDelaySlewAnnotations --- -TEST_F(StaDesignTest, R8_RemoveDelaySlewAnnotations) { +TEST_F(StaDesignTest, RemoveDelaySlewAnnotations) { sta_->removeDelaySlewAnnotations(); } // --- Sta: deleteParasitics --- -TEST_F(StaDesignTest, R8_DeleteParasitics) { +TEST_F(StaDesignTest, DeleteParasitics) { sta_->deleteParasitics(); } // --- Sta: constraintsChanged --- -TEST_F(StaDesignTest, R8_ConstraintsChanged) { +TEST_F(StaDesignTest, ConstraintsChanged) { sta_->constraintsChanged(); } // --- Sta: networkChanged --- -TEST_F(StaDesignTest, R8_NetworkChanged) { +TEST_F(StaDesignTest, NetworkChanged) { sta_->networkChanged(); } // --- Search: endpointsInvalid --- -TEST_F(StaDesignTest, R8_EndpointsInvalid) { +TEST_F(StaDesignTest, EndpointsInvalid) { Search *search = sta_->search(); search->endpointsInvalid(); } // --- Search: requiredsInvalid --- -TEST_F(StaDesignTest, R8_RequiredsInvalid) { +TEST_F(StaDesignTest, RequiredsInvalid) { Search *search = sta_->search(); search->requiredsInvalid(); } // --- Search: deleteFilter / filteredEndpoints --- -TEST_F(StaDesignTest, R8_SearchDeleteFilter) { +TEST_F(StaDesignTest, SearchDeleteFilter) { Search *search = sta_->search(); // No filter set, but calling is safe search->deleteFilter(); @@ -12483,7 +12483,7 @@ TEST_F(StaDesignTest, R8_SearchDeleteFilter) { // --- Sta: reportDelayCalc --- -TEST_F(StaDesignTest, R8_ReportDelayCalc) { +TEST_F(StaDesignTest, ReportDelayCalc) { Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); VertexInEdgeIterator edge_iter(v, sta_->graph()); @@ -12501,7 +12501,7 @@ TEST_F(StaDesignTest, R8_ReportDelayCalc) { // --- Sta: arcDelay --- -TEST_F(StaDesignTest, R8_ArcDelay) { +TEST_F(StaDesignTest, ArcDelay) { Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); VertexInEdgeIterator edge_iter(v, sta_->graph()); @@ -12519,7 +12519,7 @@ TEST_F(StaDesignTest, R8_ArcDelay) { // --- Sta: arcDelayAnnotated --- -TEST_F(StaDesignTest, R8_ArcDelayAnnotated) { +TEST_F(StaDesignTest, ArcDelayAnnotated) { Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); VertexInEdgeIterator edge_iter(v, sta_->graph()); @@ -12537,14 +12537,14 @@ TEST_F(StaDesignTest, R8_ArcDelayAnnotated) { // --- Sta: findReportPathField --- -TEST_F(StaDesignTest, R8_FindReportPathField) { +TEST_F(StaDesignTest, FindReportPathField) { ReportField *field = sta_->findReportPathField("Fanout"); (void)field; } // --- Search: arrivalInvalid on a vertex --- -TEST_F(StaDesignTest, R8_SearchArrivalInvalid) { +TEST_F(StaDesignTest, SearchArrivalInvalid) { Search *search = sta_->search(); Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); @@ -12553,7 +12553,7 @@ TEST_F(StaDesignTest, R8_SearchArrivalInvalid) { // --- Search: requiredInvalid on a vertex --- -TEST_F(StaDesignTest, R8_SearchRequiredInvalid) { +TEST_F(StaDesignTest, SearchRequiredInvalid) { Search *search = sta_->search(); Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); @@ -12562,7 +12562,7 @@ TEST_F(StaDesignTest, R8_SearchRequiredInvalid) { // --- Search: isSegmentStart --- -TEST_F(StaDesignTest, R8_SearchIsSegmentStart) { +TEST_F(StaDesignTest, SearchIsSegmentStart) { Search *search = sta_->search(); Pin *pin = findPin("in1"); ASSERT_NE(pin, nullptr); @@ -12572,7 +12572,7 @@ TEST_F(StaDesignTest, R8_SearchIsSegmentStart) { // --- Search: isInputArrivalSrchStart --- -TEST_F(StaDesignTest, R8_SearchIsInputArrivalSrchStart) { +TEST_F(StaDesignTest, SearchIsInputArrivalSrchStart) { Search *search = sta_->search(); Vertex *v = findVertex("in1"); ASSERT_NE(v, nullptr); @@ -12582,20 +12582,20 @@ TEST_F(StaDesignTest, R8_SearchIsInputArrivalSrchStart) { // --- Sta: operatingConditions --- -TEST_F(StaDesignTest, R8_OperatingConditions) { +TEST_F(StaDesignTest, OperatingConditions) { OperatingConditions *op = sta_->operatingConditions(MinMax::max()); (void)op; } // --- Search: evalPred / searchAdj --- -TEST_F(StaDesignTest, R8_SearchEvalPred) { +TEST_F(StaDesignTest, SearchEvalPred) { Search *search = sta_->search(); EvalPred *ep = search->evalPred(); EXPECT_NE(ep, nullptr); } -TEST_F(StaDesignTest, R8_SearchSearchAdj) { +TEST_F(StaDesignTest, SearchSearchAdj) { Search *search = sta_->search(); SearchPred *sp = search->searchAdj(); EXPECT_NE(sp, nullptr); @@ -12603,7 +12603,7 @@ TEST_F(StaDesignTest, R8_SearchSearchAdj) { // --- Search: endpointInvalid --- -TEST_F(StaDesignTest, R8_SearchEndpointInvalid) { +TEST_F(StaDesignTest, SearchEndpointInvalid) { Search *search = sta_->search(); Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); @@ -12612,7 +12612,7 @@ TEST_F(StaDesignTest, R8_SearchEndpointInvalid) { // --- Search: tnsInvalid --- -TEST_F(StaDesignTest, R8_SearchTnsInvalid) { +TEST_F(StaDesignTest, SearchTnsInvalid) { Search *search = sta_->search(); Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); @@ -12621,13 +12621,13 @@ TEST_F(StaDesignTest, R8_SearchTnsInvalid) { // --- Sta: unsetTimingDerate --- -TEST_F(StaDesignTest, R8_UnsetTimingDerate) { +TEST_F(StaDesignTest, UnsetTimingDerate) { sta_->unsetTimingDerate(); } // --- Sta: setAnnotatedSlew --- -TEST_F(StaDesignTest, R8_SetAnnotatedSlew) { +TEST_F(StaDesignTest, SetAnnotatedSlew) { Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); Corner *corner = sta_->cmdCorner(); @@ -12637,7 +12637,7 @@ TEST_F(StaDesignTest, R8_SetAnnotatedSlew) { // --- Sta: vertexPathIterator with MinMax --- -TEST_F(StaDesignTest, R8_VertexPathIteratorMinMax) { +TEST_F(StaDesignTest, VertexPathIteratorMinMax) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); VertexPathIterator *iter = sta_->vertexPathIterator(v, RiseFall::rise(), MinMax::max()); @@ -12652,7 +12652,7 @@ TEST_F(StaDesignTest, R8_VertexPathIteratorMinMax) { // --- Tag comparison operations (exercised through timing) --- -TEST_F(StaDesignTest, R8_TagOperations) { +TEST_F(StaDesignTest, TagOperations) { Search *search = sta_->search(); TagIndex count = search->tagCount(); if (count >= 2) { @@ -12676,7 +12676,7 @@ TEST_F(StaDesignTest, R8_TagOperations) { // --- PathEnd::cmp --- -TEST_F(StaDesignTest, R8_PathEndCmp) { +TEST_F(StaDesignTest, PathEndCmp) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -12694,7 +12694,7 @@ TEST_F(StaDesignTest, R8_PathEndCmp) { // --- PathEnd: various accessors on specific PathEnd types --- -TEST_F(StaDesignTest, R8_PathEndSlackNoCrpr) { +TEST_F(StaDesignTest, PathEndSlackNoCrpr) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -12723,7 +12723,7 @@ TEST_F(StaDesignTest, R8_PathEndSlackNoCrpr) { // --- PathEnd: reportShort --- -TEST_F(StaDesignTest, R8_PathEndReportShort) { +TEST_F(StaDesignTest, PathEndReportShort) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -12737,7 +12737,7 @@ TEST_F(StaDesignTest, R8_PathEndReportShort) { // --- PathEnd: copy --- -TEST_F(StaDesignTest, R8_PathEndCopy) { +TEST_F(StaDesignTest, PathEndCopy) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -12752,7 +12752,7 @@ TEST_F(StaDesignTest, R8_PathEndCopy) { // --- Search: tagGroup for a vertex --- -TEST_F(StaDesignTest, R8_SearchTagGroupForVertex) { +TEST_F(StaDesignTest, SearchTagGroupForVertex) { Search *search = sta_->search(); Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); @@ -12762,7 +12762,7 @@ TEST_F(StaDesignTest, R8_SearchTagGroupForVertex) { // --- Sta: findFaninPins / findFanoutPins --- -TEST_F(StaDesignTest, R8_FindFaninPins) { +TEST_F(StaDesignTest, FindFaninPins) { Pin *pin = findPin("r3/D"); ASSERT_NE(pin, nullptr); PinSeq to_pins; @@ -12771,7 +12771,7 @@ TEST_F(StaDesignTest, R8_FindFaninPins) { (void)fanin; } -TEST_F(StaDesignTest, R8_FindFanoutPins) { +TEST_F(StaDesignTest, FindFanoutPins) { Pin *pin = findPin("r1/Q"); ASSERT_NE(pin, nullptr); PinSeq from_pins; @@ -12782,7 +12782,7 @@ TEST_F(StaDesignTest, R8_FindFanoutPins) { // --- Sta: findFaninInstances / findFanoutInstances --- -TEST_F(StaDesignTest, R8_FindFaninInstances) { +TEST_F(StaDesignTest, FindFaninInstances) { Pin *pin = findPin("r3/D"); ASSERT_NE(pin, nullptr); PinSeq to_pins; @@ -12793,13 +12793,13 @@ TEST_F(StaDesignTest, R8_FindFaninInstances) { // --- Sta: setVoltage --- -TEST_F(StaDesignTest, R8_SetVoltage) { +TEST_F(StaDesignTest, SetVoltage) { sta_->setVoltage(MinMax::max(), 1.1f); } // --- Sta: removeConstraints --- -TEST_F(StaDesignTest, R8_RemoveConstraints) { +TEST_F(StaDesignTest, RemoveConstraints) { // This is a destructive operation, so call it but re-create constraints after // Just verifying it doesn't crash sta_->removeConstraints(); @@ -12807,7 +12807,7 @@ TEST_F(StaDesignTest, R8_RemoveConstraints) { // --- Search: filter --- -TEST_F(StaDesignTest, R8_SearchFilter) { +TEST_F(StaDesignTest, SearchFilter) { Search *search = sta_->search(); FilterPath *filter = search->filter(); // filter should be null since we haven't set one @@ -12816,7 +12816,7 @@ TEST_F(StaDesignTest, R8_SearchFilter) { // --- PathExpanded: path(i) and pathsIndex --- -TEST_F(StaDesignTest, R8_PathExpandedPaths) { +TEST_F(StaDesignTest, PathExpandedPaths) { Vertex *v = findVertex("u2/ZN"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstArrivalPath(v, MinMax::max()); @@ -12831,7 +12831,7 @@ TEST_F(StaDesignTest, R8_PathExpandedPaths) { // --- Sta: setOutputDelay --- -TEST_F(StaDesignTest, R8_SetOutputDelay) { +TEST_F(StaDesignTest, SetOutputDelay) { Pin *out = findPin("out"); ASSERT_NE(out, nullptr); Clock *clk = sta_->sdc()->findClock("clk"); @@ -12843,7 +12843,7 @@ TEST_F(StaDesignTest, R8_SetOutputDelay) { // --- Sta: findPathEnds with setup+hold --- -TEST_F(StaDesignTest, R8_FindPathEndsSetupHold) { +TEST_F(StaDesignTest, FindPathEndsSetupHold) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::all(), @@ -12854,7 +12854,7 @@ TEST_F(StaDesignTest, R8_FindPathEndsSetupHold) { // --- Sta: findPathEnds unique_pins --- -TEST_F(StaDesignTest, R8_FindPathEndsUniquePins) { +TEST_F(StaDesignTest, FindPathEndsUniquePins) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -12865,7 +12865,7 @@ TEST_F(StaDesignTest, R8_FindPathEndsUniquePins) { // --- Sta: findPathEnds sort_by_slack --- -TEST_F(StaDesignTest, R8_FindPathEndsSortBySlack) { +TEST_F(StaDesignTest, FindPathEndsSortBySlack) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -12876,7 +12876,7 @@ TEST_F(StaDesignTest, R8_FindPathEndsSortBySlack) { // --- Sta: reportChecks for MinPeriod --- -TEST_F(StaDesignTest, R8_ReportChecksMinPeriod) { +TEST_F(StaDesignTest, ReportChecksMinPeriod) { MinPeriodCheckSeq &checks = sta_->minPeriodViolations(); sta_->reportChecks(&checks, false); sta_->reportChecks(&checks, true); @@ -12884,7 +12884,7 @@ TEST_F(StaDesignTest, R8_ReportChecksMinPeriod) { // --- Sta: reportChecks for MaxSkew --- -TEST_F(StaDesignTest, R8_ReportChecksMaxSkew) { +TEST_F(StaDesignTest, ReportChecksMaxSkew) { MaxSkewCheckSeq &checks = sta_->maxSkewViolations(); sta_->reportChecks(&checks, false); sta_->reportChecks(&checks, true); @@ -12892,21 +12892,21 @@ TEST_F(StaDesignTest, R8_ReportChecksMaxSkew) { // --- ReportPath: reportPeriodHeaderShort --- -TEST_F(StaDesignTest, R8_ReportPeriodHeaderShort) { +TEST_F(StaDesignTest, ReportPeriodHeaderShort) { ReportPath *rpt = sta_->reportPath(); rpt->reportPeriodHeaderShort(); } // --- ReportPath: reportMpwHeaderShort --- -TEST_F(StaDesignTest, R8_ReportMpwHeaderShort) { +TEST_F(StaDesignTest, ReportMpwHeaderShort) { ReportPath *rpt = sta_->reportPath(); rpt->reportMpwHeaderShort(); } // --- Sta: maxSlewCheck --- -TEST_F(StaDesignTest, R8_MaxSlewCheck) { +TEST_F(StaDesignTest, MaxSlewCheck) { sta_->checkSlewLimitPreamble(); const Pin *pin = nullptr; Slew slew; @@ -12917,7 +12917,7 @@ TEST_F(StaDesignTest, R8_MaxSlewCheck) { // --- Sta: maxFanoutCheck --- -TEST_F(StaDesignTest, R8_MaxFanoutCheck) { +TEST_F(StaDesignTest, MaxFanoutCheck) { sta_->checkFanoutLimitPreamble(); const Pin *pin = nullptr; float fanout, slack, limit; @@ -12926,7 +12926,7 @@ TEST_F(StaDesignTest, R8_MaxFanoutCheck) { // --- Sta: maxCapacitanceCheck --- -TEST_F(StaDesignTest, R8_MaxCapacitanceCheck) { +TEST_F(StaDesignTest, MaxCapacitanceCheck) { sta_->checkCapacitanceLimitPreamble(); const Pin *pin = nullptr; float cap, slack, limit; @@ -12935,7 +12935,7 @@ TEST_F(StaDesignTest, R8_MaxCapacitanceCheck) { // --- Sta: vertexSlack with RiseFall + MinMax --- -TEST_F(StaDesignTest, R8_VertexSlackRfMinMax) { +TEST_F(StaDesignTest, VertexSlackRfMinMax) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Slack slk = sta_->vertexSlack(v, RiseFall::rise(), MinMax::max()); @@ -12944,7 +12944,7 @@ TEST_F(StaDesignTest, R8_VertexSlackRfMinMax) { // --- Sta: vertexSlew with MinMax only --- -TEST_F(StaDesignTest, R8_VertexSlewMinMax) { +TEST_F(StaDesignTest, VertexSlewMinMax) { Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); Slew slew = sta_->vertexSlew(v, MinMax::max()); @@ -12953,7 +12953,7 @@ TEST_F(StaDesignTest, R8_VertexSlewMinMax) { // --- Sta: setReportPathFormat to each format and report --- -TEST_F(StaDesignTest, R8_ReportPathEndpointFormat) { +TEST_F(StaDesignTest, ReportPathEndpointFormat) { sta_->setReportPathFormat(ReportPathFormat::endpoint); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -12968,7 +12968,7 @@ TEST_F(StaDesignTest, R8_ReportPathEndpointFormat) { // --- Search: findClkVertexPins --- -TEST_F(StaDesignTest, R8_SearchFindClkVertexPins) { +TEST_F(StaDesignTest, SearchFindClkVertexPins) { Search *search = sta_->search(); PinSet clk_pins(sta_->cmdNetwork()); search->findClkVertexPins(clk_pins); @@ -12977,7 +12977,7 @@ TEST_F(StaDesignTest, R8_SearchFindClkVertexPins) { // --- Property: getProperty on PathEnd --- -TEST_F(StaDesignTest, R8_PropertyGetPathEnd) { +TEST_F(StaDesignTest, PropertyGetPathEnd) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -12992,7 +12992,7 @@ TEST_F(StaDesignTest, R8_PropertyGetPathEnd) { // --- Property: getProperty on Path --- -TEST_F(StaDesignTest, R8_PropertyGetPath) { +TEST_F(StaDesignTest, PropertyGetPath) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstArrivalPath(v, MinMax::max()); @@ -13005,7 +13005,7 @@ TEST_F(StaDesignTest, R8_PropertyGetPath) { // --- Property: getProperty on TimingArcSet --- -TEST_F(StaDesignTest, R8_PropertyGetTimingArcSet) { +TEST_F(StaDesignTest, PropertyGetTimingArcSet) { Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); VertexInEdgeIterator edge_iter(v, sta_->graph()); @@ -13024,7 +13024,7 @@ TEST_F(StaDesignTest, R8_PropertyGetTimingArcSet) { // --- Sta: setParasiticAnalysisPts per_corner --- -TEST_F(StaDesignTest, R8_SetParasiticAnalysisPtsPerCorner) { +TEST_F(StaDesignTest, SetParasiticAnalysisPtsPerCorner) { sta_->setParasiticAnalysisPts(true); } @@ -13034,7 +13034,7 @@ TEST_F(StaDesignTest, R8_SetParasiticAnalysisPtsPerCorner) { // --- FindRegister tests --- -TEST_F(StaDesignTest, R9_FindRegisterInstances) { +TEST_F(StaDesignTest, FindRegisterInstances) { ClockSet *clks = nullptr; InstanceSet reg_insts = sta_->findRegisterInstances(clks, RiseFallBoth::riseFall(), true, false); @@ -13042,21 +13042,21 @@ TEST_F(StaDesignTest, R9_FindRegisterInstances) { EXPECT_GE(reg_insts.size(), 1u); } -TEST_F(StaDesignTest, R9_FindRegisterDataPins) { +TEST_F(StaDesignTest, FindRegisterDataPins) { ClockSet *clks = nullptr; PinSet data_pins = sta_->findRegisterDataPins(clks, RiseFallBoth::riseFall(), true, false); EXPECT_GE(data_pins.size(), 1u); } -TEST_F(StaDesignTest, R9_FindRegisterClkPins) { +TEST_F(StaDesignTest, FindRegisterClkPins) { ClockSet *clks = nullptr; PinSet clk_pins = sta_->findRegisterClkPins(clks, RiseFallBoth::riseFall(), true, false); EXPECT_GE(clk_pins.size(), 1u); } -TEST_F(StaDesignTest, R9_FindRegisterAsyncPins) { +TEST_F(StaDesignTest, FindRegisterAsyncPins) { ClockSet *clks = nullptr; PinSet async_pins = sta_->findRegisterAsyncPins(clks, RiseFallBoth::riseFall(), true, false); @@ -13064,14 +13064,14 @@ TEST_F(StaDesignTest, R9_FindRegisterAsyncPins) { (void)async_pins; } -TEST_F(StaDesignTest, R9_FindRegisterOutputPins) { +TEST_F(StaDesignTest, FindRegisterOutputPins) { ClockSet *clks = nullptr; PinSet out_pins = sta_->findRegisterOutputPins(clks, RiseFallBoth::riseFall(), true, false); EXPECT_GE(out_pins.size(), 1u); } -TEST_F(StaDesignTest, R9_FindRegisterInstancesWithClock) { +TEST_F(StaDesignTest, FindRegisterInstancesWithClock) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); ClockSet *clks = new ClockSet; @@ -13081,7 +13081,7 @@ TEST_F(StaDesignTest, R9_FindRegisterInstancesWithClock) { EXPECT_GE(reg_insts.size(), 1u); } -TEST_F(StaDesignTest, R9_FindRegisterDataPinsWithClock) { +TEST_F(StaDesignTest, FindRegisterDataPinsWithClock) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); ClockSet *clks = new ClockSet; @@ -13091,7 +13091,7 @@ TEST_F(StaDesignTest, R9_FindRegisterDataPinsWithClock) { EXPECT_GE(data_pins.size(), 1u); } -TEST_F(StaDesignTest, R9_FindRegisterClkPinsWithClock) { +TEST_F(StaDesignTest, FindRegisterClkPinsWithClock) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); ClockSet *clks = new ClockSet; @@ -13101,7 +13101,7 @@ TEST_F(StaDesignTest, R9_FindRegisterClkPinsWithClock) { EXPECT_GE(clk_pins.size(), 1u); } -TEST_F(StaDesignTest, R9_FindRegisterOutputPinsWithClock) { +TEST_F(StaDesignTest, FindRegisterOutputPinsWithClock) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); ClockSet *clks = new ClockSet; @@ -13111,21 +13111,21 @@ TEST_F(StaDesignTest, R9_FindRegisterOutputPinsWithClock) { EXPECT_GE(out_pins.size(), 1u); } -TEST_F(StaDesignTest, R9_FindRegisterRiseOnly) { +TEST_F(StaDesignTest, FindRegisterRiseOnly) { ClockSet *clks = nullptr; PinSet clk_pins = sta_->findRegisterClkPins(clks, RiseFallBoth::rise(), true, false); (void)clk_pins; } -TEST_F(StaDesignTest, R9_FindRegisterFallOnly) { +TEST_F(StaDesignTest, FindRegisterFallOnly) { ClockSet *clks = nullptr; PinSet clk_pins = sta_->findRegisterClkPins(clks, RiseFallBoth::fall(), true, false); (void)clk_pins; } -TEST_F(StaDesignTest, R9_FindRegisterLatches) { +TEST_F(StaDesignTest, FindRegisterLatches) { ClockSet *clks = nullptr; InstanceSet insts = sta_->findRegisterInstances(clks, RiseFallBoth::riseFall(), false, true); @@ -13133,14 +13133,14 @@ TEST_F(StaDesignTest, R9_FindRegisterLatches) { (void)insts; } -TEST_F(StaDesignTest, R9_FindRegisterBothEdgeAndLatch) { +TEST_F(StaDesignTest, FindRegisterBothEdgeAndLatch) { ClockSet *clks = nullptr; InstanceSet insts = sta_->findRegisterInstances(clks, RiseFallBoth::riseFall(), true, true); EXPECT_GE(insts.size(), 1u); } -TEST_F(StaDesignTest, R9_FindRegisterAsyncPinsWithClock) { +TEST_F(StaDesignTest, FindRegisterAsyncPinsWithClock) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); ClockSet *clks = new ClockSet; @@ -13152,7 +13152,7 @@ TEST_F(StaDesignTest, R9_FindRegisterAsyncPinsWithClock) { // --- PathEnd: detailed accessors --- -TEST_F(StaDesignTest, R9_PathEndType) { +TEST_F(StaDesignTest, PathEndType) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13166,7 +13166,7 @@ TEST_F(StaDesignTest, R9_PathEndType) { } } -TEST_F(StaDesignTest, R9_PathEndCheckRole) { +TEST_F(StaDesignTest, PathEndCheckRole) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13180,7 +13180,7 @@ TEST_F(StaDesignTest, R9_PathEndCheckRole) { } } -TEST_F(StaDesignTest, R9_PathEndVertex) { +TEST_F(StaDesignTest, PathEndVertex) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13192,7 +13192,7 @@ TEST_F(StaDesignTest, R9_PathEndVertex) { } } -TEST_F(StaDesignTest, R9_PathEndMinMax) { +TEST_F(StaDesignTest, PathEndMinMax) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13206,7 +13206,7 @@ TEST_F(StaDesignTest, R9_PathEndMinMax) { } } -TEST_F(StaDesignTest, R9_PathEndTransition) { +TEST_F(StaDesignTest, PathEndTransition) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13218,7 +13218,7 @@ TEST_F(StaDesignTest, R9_PathEndTransition) { } } -TEST_F(StaDesignTest, R9_PathEndPathAnalysisPt) { +TEST_F(StaDesignTest, PathEndPathAnalysisPt) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13232,7 +13232,7 @@ TEST_F(StaDesignTest, R9_PathEndPathAnalysisPt) { } } -TEST_F(StaDesignTest, R9_PathEndTargetClkAccessors) { +TEST_F(StaDesignTest, PathEndTargetClkAccessors) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13256,7 +13256,7 @@ TEST_F(StaDesignTest, R9_PathEndTargetClkAccessors) { } } -TEST_F(StaDesignTest, R9_PathEndTargetClkUncertainty) { +TEST_F(StaDesignTest, PathEndTargetClkUncertainty) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13274,7 +13274,7 @@ TEST_F(StaDesignTest, R9_PathEndTargetClkUncertainty) { } } -TEST_F(StaDesignTest, R9_PathEndClkEarlyLate) { +TEST_F(StaDesignTest, PathEndClkEarlyLate) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13286,7 +13286,7 @@ TEST_F(StaDesignTest, R9_PathEndClkEarlyLate) { } } -TEST_F(StaDesignTest, R9_PathEndIsTypePredicates) { +TEST_F(StaDesignTest, PathEndIsTypePredicates) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13307,7 +13307,7 @@ TEST_F(StaDesignTest, R9_PathEndIsTypePredicates) { } } -TEST_F(StaDesignTest, R9_PathEndCrpr) { +TEST_F(StaDesignTest, PathEndCrpr) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13321,7 +13321,7 @@ TEST_F(StaDesignTest, R9_PathEndCrpr) { } } -TEST_F(StaDesignTest, R9_PathEndClkSkew) { +TEST_F(StaDesignTest, PathEndClkSkew) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13333,7 +13333,7 @@ TEST_F(StaDesignTest, R9_PathEndClkSkew) { } } -TEST_F(StaDesignTest, R9_PathEndBorrow) { +TEST_F(StaDesignTest, PathEndBorrow) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13345,7 +13345,7 @@ TEST_F(StaDesignTest, R9_PathEndBorrow) { } } -TEST_F(StaDesignTest, R9_PathEndSourceClkInsertionDelay) { +TEST_F(StaDesignTest, PathEndSourceClkInsertionDelay) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13357,7 +13357,7 @@ TEST_F(StaDesignTest, R9_PathEndSourceClkInsertionDelay) { } } -TEST_F(StaDesignTest, R9_PathEndTargetClkPath) { +TEST_F(StaDesignTest, PathEndTargetClkPath) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13371,7 +13371,7 @@ TEST_F(StaDesignTest, R9_PathEndTargetClkPath) { } } -TEST_F(StaDesignTest, R9_PathEndTargetClkEndTrans) { +TEST_F(StaDesignTest, PathEndTargetClkEndTrans) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13383,7 +13383,7 @@ TEST_F(StaDesignTest, R9_PathEndTargetClkEndTrans) { } } -TEST_F(StaDesignTest, R9_PathEndExceptPathCmp) { +TEST_F(StaDesignTest, PathEndExceptPathCmp) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13395,7 +13395,7 @@ TEST_F(StaDesignTest, R9_PathEndExceptPathCmp) { } } -TEST_F(StaDesignTest, R9_PathEndDataArrivalTimeOffset) { +TEST_F(StaDesignTest, PathEndDataArrivalTimeOffset) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13407,7 +13407,7 @@ TEST_F(StaDesignTest, R9_PathEndDataArrivalTimeOffset) { } } -TEST_F(StaDesignTest, R9_PathEndRequiredTimeOffset) { +TEST_F(StaDesignTest, PathEndRequiredTimeOffset) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13419,7 +13419,7 @@ TEST_F(StaDesignTest, R9_PathEndRequiredTimeOffset) { } } -TEST_F(StaDesignTest, R9_PathEndMultiCyclePath) { +TEST_F(StaDesignTest, PathEndMultiCyclePath) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13433,7 +13433,7 @@ TEST_F(StaDesignTest, R9_PathEndMultiCyclePath) { } } -TEST_F(StaDesignTest, R9_PathEndCmpNoCrpr) { +TEST_F(StaDesignTest, PathEndCmpNoCrpr) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13445,7 +13445,7 @@ TEST_F(StaDesignTest, R9_PathEndCmpNoCrpr) { } } -TEST_F(StaDesignTest, R9_PathEndLess) { +TEST_F(StaDesignTest, PathEndLess2) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13457,7 +13457,7 @@ TEST_F(StaDesignTest, R9_PathEndLess) { } } -TEST_F(StaDesignTest, R9_PathEndMacroClkTreeDelay) { +TEST_F(StaDesignTest, PathEndMacroClkTreeDelay) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13471,7 +13471,7 @@ TEST_F(StaDesignTest, R9_PathEndMacroClkTreeDelay) { // --- PathEnd: hold check --- -TEST_F(StaDesignTest, R9_FindPathEndsHold) { +TEST_F(StaDesignTest, FindPathEndsHold2) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::min(), @@ -13480,7 +13480,7 @@ TEST_F(StaDesignTest, R9_FindPathEndsHold) { (void)ends; } -TEST_F(StaDesignTest, R9_FindPathEndsHoldAccessors) { +TEST_F(StaDesignTest, FindPathEndsHoldAccessors) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::min(), @@ -13498,7 +13498,7 @@ TEST_F(StaDesignTest, R9_FindPathEndsHoldAccessors) { // --- PathEnd: unconstrained --- -TEST_F(StaDesignTest, R9_FindPathEndsUnconstrained) { +TEST_F(StaDesignTest, FindPathEndsUnconstrained2) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, true, nullptr, MinMaxAll::max(), @@ -13515,15 +13515,15 @@ TEST_F(StaDesignTest, R9_FindPathEndsUnconstrained) { // --- ReportPath: various report functions --- -TEST_F(StaDesignTest, R9_ReportPathEndHeader) { +TEST_F(StaDesignTest, ReportPathEndHeader) { sta_->reportPathEndHeader(); } -TEST_F(StaDesignTest, R9_ReportPathEndFooter) { +TEST_F(StaDesignTest, ReportPathEndFooter) { sta_->reportPathEndFooter(); } -TEST_F(StaDesignTest, R9_ReportPathEnd) { +TEST_F(StaDesignTest, ReportPathEnd2) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13534,7 +13534,7 @@ TEST_F(StaDesignTest, R9_ReportPathEnd) { } } -TEST_F(StaDesignTest, R9_ReportPathEnds) { +TEST_F(StaDesignTest, ReportPathEnds2) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13543,7 +13543,7 @@ TEST_F(StaDesignTest, R9_ReportPathEnds) { sta_->reportPathEnds(&ends); } -TEST_F(StaDesignTest, R9_ReportPathEndFull) { +TEST_F(StaDesignTest, ReportPathEndFull) { sta_->setReportPathFormat(ReportPathFormat::full); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -13555,7 +13555,7 @@ TEST_F(StaDesignTest, R9_ReportPathEndFull) { } } -TEST_F(StaDesignTest, R9_ReportPathEndFullClkPath) { +TEST_F(StaDesignTest, ReportPathEndFullClkPath) { sta_->setReportPathFormat(ReportPathFormat::full_clock); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -13567,7 +13567,7 @@ TEST_F(StaDesignTest, R9_ReportPathEndFullClkPath) { } } -TEST_F(StaDesignTest, R9_ReportPathEndFullClkExpanded) { +TEST_F(StaDesignTest, ReportPathEndFullClkExpanded) { sta_->setReportPathFormat(ReportPathFormat::full_clock_expanded); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -13579,7 +13579,7 @@ TEST_F(StaDesignTest, R9_ReportPathEndFullClkExpanded) { } } -TEST_F(StaDesignTest, R9_ReportPathEndShortFormat) { +TEST_F(StaDesignTest, ReportPathEndShortFormat) { sta_->setReportPathFormat(ReportPathFormat::shorter); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -13591,7 +13591,7 @@ TEST_F(StaDesignTest, R9_ReportPathEndShortFormat) { } } -TEST_F(StaDesignTest, R9_ReportPathEndSummary) { +TEST_F(StaDesignTest, ReportPathEndSummary) { sta_->setReportPathFormat(ReportPathFormat::summary); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -13603,7 +13603,7 @@ TEST_F(StaDesignTest, R9_ReportPathEndSummary) { } } -TEST_F(StaDesignTest, R9_ReportPathEndSlackOnly) { +TEST_F(StaDesignTest, ReportPathEndSlackOnly) { sta_->setReportPathFormat(ReportPathFormat::slack_only); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -13615,7 +13615,7 @@ TEST_F(StaDesignTest, R9_ReportPathEndSlackOnly) { } } -TEST_F(StaDesignTest, R9_ReportPathEndJson) { +TEST_F(StaDesignTest, ReportPathEndJson) { sta_->setReportPathFormat(ReportPathFormat::json); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -13627,7 +13627,7 @@ TEST_F(StaDesignTest, R9_ReportPathEndJson) { } } -TEST_F(StaDesignTest, R9_ReportPathFromVertex) { +TEST_F(StaDesignTest, ReportPathFromVertex) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstArrivalPath(v, MinMax::max()); @@ -13636,7 +13636,7 @@ TEST_F(StaDesignTest, R9_ReportPathFromVertex) { } } -TEST_F(StaDesignTest, R9_ReportPathFullWithPrevEnd) { +TEST_F(StaDesignTest, ReportPathFullWithPrevEnd) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13649,7 +13649,7 @@ TEST_F(StaDesignTest, R9_ReportPathFullWithPrevEnd) { } } -TEST_F(StaDesignTest, R9_ReportPathFieldOrder) { +TEST_F(StaDesignTest, ReportPathFieldOrder) { StringSeq *field_names = new StringSeq; field_names->push_back("fanout"); field_names->push_back("capacitance"); @@ -13657,23 +13657,23 @@ TEST_F(StaDesignTest, R9_ReportPathFieldOrder) { sta_->setReportPathFieldOrder(field_names); } -TEST_F(StaDesignTest, R9_ReportPathFields) { +TEST_F(StaDesignTest, ReportPathFields) { sta_->setReportPathFields(true, true, true, true, true, true, true); } -TEST_F(StaDesignTest, R9_ReportPathDigits) { +TEST_F(StaDesignTest, ReportPathDigits) { sta_->setReportPathDigits(4); } -TEST_F(StaDesignTest, R9_ReportPathNoSplit) { +TEST_F(StaDesignTest, ReportPathNoSplit) { sta_->setReportPathNoSplit(true); } -TEST_F(StaDesignTest, R9_ReportPathSigmas) { +TEST_F(StaDesignTest, ReportPathSigmas) { sta_->setReportPathSigmas(true); } -TEST_F(StaDesignTest, R9_FindReportPathField) { +TEST_F(StaDesignTest, FindReportPathField2) { ReportField *field = sta_->findReportPathField("fanout"); EXPECT_NE(field, nullptr); field = sta_->findReportPathField("capacitance"); @@ -13682,7 +13682,7 @@ TEST_F(StaDesignTest, R9_FindReportPathField) { EXPECT_NE(field, nullptr); } -TEST_F(StaDesignTest, R9_ReportPathFieldAccessors) { +TEST_F(StaDesignTest, ReportPathFieldAccessors) { ReportPath *rpt = sta_->reportPath(); ReportField *slew = rpt->fieldSlew(); EXPECT_NE(slew, nullptr); @@ -13694,23 +13694,23 @@ TEST_F(StaDesignTest, R9_ReportPathFieldAccessors) { // --- ReportPath: MinPulseWidth check --- -TEST_F(StaDesignTest, R9_MinPulseWidthSlack) { +TEST_F(StaDesignTest, MinPulseWidthSlack2) { MinPulseWidthCheck *check = sta_->minPulseWidthSlack(nullptr); (void)check; } -TEST_F(StaDesignTest, R9_MinPulseWidthViolations) { +TEST_F(StaDesignTest, MinPulseWidthViolations2) { MinPulseWidthCheckSeq &viols = sta_->minPulseWidthViolations(nullptr); (void)viols; } -TEST_F(StaDesignTest, R9_MinPulseWidthChecksAll) { +TEST_F(StaDesignTest, MinPulseWidthChecksAll2) { MinPulseWidthCheckSeq &checks = sta_->minPulseWidthChecks(nullptr); sta_->reportMpwChecks(&checks, false); sta_->reportMpwChecks(&checks, true); } -TEST_F(StaDesignTest, R9_MinPulseWidthCheckForPin) { +TEST_F(StaDesignTest, MinPulseWidthCheckForPin) { Pin *pin = findPin("r1/CK"); if (pin) { PinSeq pins; @@ -13722,17 +13722,17 @@ TEST_F(StaDesignTest, R9_MinPulseWidthCheckForPin) { // --- ReportPath: MinPeriod --- -TEST_F(StaDesignTest, R9_MinPeriodSlack) { +TEST_F(StaDesignTest, MinPeriodSlack2) { MinPeriodCheck *check = sta_->minPeriodSlack(); (void)check; } -TEST_F(StaDesignTest, R9_MinPeriodViolations) { +TEST_F(StaDesignTest, MinPeriodViolations2) { MinPeriodCheckSeq &viols = sta_->minPeriodViolations(); (void)viols; } -TEST_F(StaDesignTest, R9_MinPeriodCheckVerbose) { +TEST_F(StaDesignTest, MinPeriodCheckVerbose) { MinPeriodCheck *check = sta_->minPeriodSlack(); if (check) { sta_->reportCheck(check, false); @@ -13742,17 +13742,17 @@ TEST_F(StaDesignTest, R9_MinPeriodCheckVerbose) { // --- ReportPath: MaxSkew --- -TEST_F(StaDesignTest, R9_MaxSkewSlack) { +TEST_F(StaDesignTest, MaxSkewSlack2) { MaxSkewCheck *check = sta_->maxSkewSlack(); (void)check; } -TEST_F(StaDesignTest, R9_MaxSkewViolations) { +TEST_F(StaDesignTest, MaxSkewViolations2) { MaxSkewCheckSeq &viols = sta_->maxSkewViolations(); (void)viols; } -TEST_F(StaDesignTest, R9_MaxSkewCheckVerbose) { +TEST_F(StaDesignTest, MaxSkewCheckVerbose) { MaxSkewCheck *check = sta_->maxSkewSlack(); if (check) { sta_->reportCheck(check, false); @@ -13760,14 +13760,14 @@ TEST_F(StaDesignTest, R9_MaxSkewCheckVerbose) { } } -TEST_F(StaDesignTest, R9_ReportMaxSkewHeaderShort) { +TEST_F(StaDesignTest, ReportMaxSkewHeaderShort) { ReportPath *rpt = sta_->reportPath(); rpt->reportMaxSkewHeaderShort(); } // --- ClkSkew / ClkLatency --- -TEST_F(StaDesignTest, R9_ReportClkSkewSetup) { +TEST_F(StaDesignTest, ReportClkSkewSetup) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); ConstClockSeq clks; @@ -13775,7 +13775,7 @@ TEST_F(StaDesignTest, R9_ReportClkSkewSetup) { sta_->reportClkSkew(clks, nullptr, SetupHold::max(), false, 3); } -TEST_F(StaDesignTest, R9_ReportClkSkewHold) { +TEST_F(StaDesignTest, ReportClkSkewHold) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); ConstClockSeq clks; @@ -13783,7 +13783,7 @@ TEST_F(StaDesignTest, R9_ReportClkSkewHold) { sta_->reportClkSkew(clks, nullptr, SetupHold::min(), false, 3); } -TEST_F(StaDesignTest, R9_ReportClkSkewWithInternalLatency) { +TEST_F(StaDesignTest, ReportClkSkewWithInternalLatency) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); ConstClockSeq clks; @@ -13791,12 +13791,12 @@ TEST_F(StaDesignTest, R9_ReportClkSkewWithInternalLatency) { sta_->reportClkSkew(clks, nullptr, SetupHold::max(), true, 3); } -TEST_F(StaDesignTest, R9_FindWorstClkSkew) { +TEST_F(StaDesignTest, FindWorstClkSkew2) { float worst = sta_->findWorstClkSkew(SetupHold::max(), false); (void)worst; } -TEST_F(StaDesignTest, R9_ReportClkLatency) { +TEST_F(StaDesignTest, ReportClkLatency2) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); ConstClockSeq clks; @@ -13804,7 +13804,7 @@ TEST_F(StaDesignTest, R9_ReportClkLatency) { sta_->reportClkLatency(clks, nullptr, false, 3); } -TEST_F(StaDesignTest, R9_ReportClkLatencyWithInternal) { +TEST_F(StaDesignTest, ReportClkLatencyWithInternal) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); ConstClockSeq clks; @@ -13812,21 +13812,21 @@ TEST_F(StaDesignTest, R9_ReportClkLatencyWithInternal) { sta_->reportClkLatency(clks, nullptr, true, 3); } -TEST_F(StaDesignTest, R9_FindClkDelays) { +TEST_F(StaDesignTest, FindClkDelays2) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); ClkDelays delays = sta_->findClkDelays(clk, false); (void)delays; } -TEST_F(StaDesignTest, R9_FindClkMinPeriod) { +TEST_F(StaDesignTest, FindClkMinPeriod2) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); float min_period = sta_->findClkMinPeriod(clk, false); (void)min_period; } -TEST_F(StaDesignTest, R9_FindClkMinPeriodWithPorts) { +TEST_F(StaDesignTest, FindClkMinPeriodWithPorts) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); float min_period = sta_->findClkMinPeriod(clk, true); @@ -13835,7 +13835,7 @@ TEST_F(StaDesignTest, R9_FindClkMinPeriodWithPorts) { // --- Property tests --- -TEST_F(StaDesignTest, R9_PropertyGetLibrary) { +TEST_F(StaDesignTest, PropertyGetLibrary) { Network *network = sta_->cmdNetwork(); LibraryIterator *lib_iter = network->libraryIterator(); if (lib_iter->hasNext()) { @@ -13847,7 +13847,7 @@ TEST_F(StaDesignTest, R9_PropertyGetLibrary) { delete lib_iter; } -TEST_F(StaDesignTest, R9_PropertyGetCell) { +TEST_F(StaDesignTest, PropertyGetCell) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Cell *cell = network->cell(top); @@ -13858,13 +13858,13 @@ TEST_F(StaDesignTest, R9_PropertyGetCell) { } } -TEST_F(StaDesignTest, R9_PropertyGetLibertyLibrary) { +TEST_F(StaDesignTest, PropertyGetLibertyLibrary) { Properties &props = sta_->properties(); PropertyValue pv = props.getProperty(lib_, "name"); EXPECT_EQ(pv.type(), PropertyValue::type_string); } -TEST_F(StaDesignTest, R9_PropertyGetLibertyCell) { +TEST_F(StaDesignTest, PropertyGetLibertyCell) { LibertyCell *cell = lib_->findLibertyCell("DFF_X1"); ASSERT_NE(cell, nullptr); Properties &props = sta_->properties(); @@ -13872,7 +13872,7 @@ TEST_F(StaDesignTest, R9_PropertyGetLibertyCell) { EXPECT_EQ(pv.type(), PropertyValue::type_string); } -TEST_F(StaDesignTest, R9_PropertyGetLibertyPort) { +TEST_F(StaDesignTest, PropertyGetLibertyPort2) { LibertyCell *cell = lib_->findLibertyCell("DFF_X1"); ASSERT_NE(cell, nullptr); LibertyPort *port = cell->findLibertyPort("D"); @@ -13882,7 +13882,7 @@ TEST_F(StaDesignTest, R9_PropertyGetLibertyPort) { EXPECT_EQ(pv.type(), PropertyValue::type_string); } -TEST_F(StaDesignTest, R9_PropertyGetInstance) { +TEST_F(StaDesignTest, PropertyGetInstance) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *child_iter = network->childIterator(top); @@ -13895,7 +13895,7 @@ TEST_F(StaDesignTest, R9_PropertyGetInstance) { delete child_iter; } -TEST_F(StaDesignTest, R9_PropertyGetPin) { +TEST_F(StaDesignTest, PropertyGetPin) { Pin *pin = findPin("r1/Q"); ASSERT_NE(pin, nullptr); Properties &props = sta_->properties(); @@ -13903,7 +13903,7 @@ TEST_F(StaDesignTest, R9_PropertyGetPin) { EXPECT_EQ(pv.type(), PropertyValue::type_string); } -TEST_F(StaDesignTest, R9_PropertyGetPinDirection) { +TEST_F(StaDesignTest, PropertyGetPinDirection) { Pin *pin = findPin("r1/Q"); ASSERT_NE(pin, nullptr); Properties &props = sta_->properties(); @@ -13911,7 +13911,7 @@ TEST_F(StaDesignTest, R9_PropertyGetPinDirection) { EXPECT_EQ(pv.type(), PropertyValue::type_string); } -TEST_F(StaDesignTest, R9_PropertyGetNet) { +TEST_F(StaDesignTest, PropertyGetNet) { Network *network = sta_->cmdNetwork(); Pin *pin = findPin("r1/Q"); ASSERT_NE(pin, nullptr); @@ -13923,7 +13923,7 @@ TEST_F(StaDesignTest, R9_PropertyGetNet) { } } -TEST_F(StaDesignTest, R9_PropertyGetClock) { +TEST_F(StaDesignTest, PropertyGetClock2) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); Properties &props = sta_->properties(); @@ -13931,7 +13931,7 @@ TEST_F(StaDesignTest, R9_PropertyGetClock) { EXPECT_EQ(pv.type(), PropertyValue::type_string); } -TEST_F(StaDesignTest, R9_PropertyGetClockPeriod) { +TEST_F(StaDesignTest, PropertyGetClockPeriod) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); Properties &props = sta_->properties(); @@ -13939,7 +13939,7 @@ TEST_F(StaDesignTest, R9_PropertyGetClockPeriod) { EXPECT_EQ(pv.type(), PropertyValue::type_float); } -TEST_F(StaDesignTest, R9_PropertyGetPort) { +TEST_F(StaDesignTest, PropertyGetPort2) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Cell *cell = network->cell(top); @@ -13953,7 +13953,7 @@ TEST_F(StaDesignTest, R9_PropertyGetPort) { delete port_iter; } -TEST_F(StaDesignTest, R9_PropertyGetEdge) { +TEST_F(StaDesignTest, PropertyGetEdge2) { Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); VertexInEdgeIterator edge_iter(v, sta_->graph()); @@ -13965,7 +13965,7 @@ TEST_F(StaDesignTest, R9_PropertyGetEdge) { } } -TEST_F(StaDesignTest, R9_PropertyGetPathEndSlack) { +TEST_F(StaDesignTest, PropertyGetPathEndSlack) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13980,7 +13980,7 @@ TEST_F(StaDesignTest, R9_PropertyGetPathEndSlack) { } } -TEST_F(StaDesignTest, R9_PropertyGetPathEndMore) { +TEST_F(StaDesignTest, PropertyGetPathEndMore) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -13999,14 +13999,14 @@ TEST_F(StaDesignTest, R9_PropertyGetPathEndMore) { // --- Property: pin arrival/slack --- -TEST_F(StaDesignTest, R9_PinArrival) { +TEST_F(StaDesignTest, PinArrival2) { Pin *pin = findPin("r1/Q"); ASSERT_NE(pin, nullptr); Arrival arr = sta_->pinArrival(pin, RiseFall::rise(), MinMax::max()); (void)arr; } -TEST_F(StaDesignTest, R9_PinSlack) { +TEST_F(StaDesignTest, PinSlack) { Pin *pin = findPin("r3/D"); ASSERT_NE(pin, nullptr); Slack slk = sta_->pinSlack(pin, MinMax::max()); @@ -14015,7 +14015,7 @@ TEST_F(StaDesignTest, R9_PinSlack) { (void)slk_rf; } -TEST_F(StaDesignTest, R9_NetSlack) { +TEST_F(StaDesignTest, NetSlack2) { Network *network = sta_->cmdNetwork(); Pin *pin = findPin("r3/D"); ASSERT_NE(pin, nullptr); @@ -14028,7 +14028,7 @@ TEST_F(StaDesignTest, R9_NetSlack) { // --- Search: various methods --- -TEST_F(StaDesignTest, R9_SearchIsClock) { +TEST_F(StaDesignTest, SearchIsClock) { Search *search = sta_->search(); Vertex *v = findVertex("r1/CK"); if (v) { @@ -14037,7 +14037,7 @@ TEST_F(StaDesignTest, R9_SearchIsClock) { } } -TEST_F(StaDesignTest, R9_SearchIsGenClkSrc) { +TEST_F(StaDesignTest, SearchIsGenClkSrc2) { Search *search = sta_->search(); Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); @@ -14045,7 +14045,7 @@ TEST_F(StaDesignTest, R9_SearchIsGenClkSrc) { (void)is_gen; } -TEST_F(StaDesignTest, R9_SearchClocks) { +TEST_F(StaDesignTest, SearchClocks) { Search *search = sta_->search(); Vertex *v = findVertex("r1/CK"); if (v) { @@ -14054,7 +14054,7 @@ TEST_F(StaDesignTest, R9_SearchClocks) { } } -TEST_F(StaDesignTest, R9_SearchClockDomains) { +TEST_F(StaDesignTest, SearchClockDomains) { Search *search = sta_->search(); Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); @@ -14062,7 +14062,7 @@ TEST_F(StaDesignTest, R9_SearchClockDomains) { (void)domains; } -TEST_F(StaDesignTest, R9_SearchClockDomainsPin) { +TEST_F(StaDesignTest, SearchClockDomainsPin) { Search *search = sta_->search(); Pin *pin = findPin("r1/Q"); ASSERT_NE(pin, nullptr); @@ -14070,7 +14070,7 @@ TEST_F(StaDesignTest, R9_SearchClockDomainsPin) { (void)domains; } -TEST_F(StaDesignTest, R9_SearchClocksPin) { +TEST_F(StaDesignTest, SearchClocksPin) { Search *search = sta_->search(); Pin *pin = findPin("r1/CK"); if (pin) { @@ -14079,7 +14079,7 @@ TEST_F(StaDesignTest, R9_SearchClocksPin) { } } -TEST_F(StaDesignTest, R9_SearchIsEndpoint) { +TEST_F(StaDesignTest, SearchIsEndpoint2) { Search *search = sta_->search(); Vertex *v_data = findVertex("r3/D"); if (v_data) { @@ -14093,13 +14093,13 @@ TEST_F(StaDesignTest, R9_SearchIsEndpoint) { } } -TEST_F(StaDesignTest, R9_SearchHavePathGroups) { +TEST_F(StaDesignTest, SearchHavePathGroups) { Search *search = sta_->search(); bool have = search->havePathGroups(); (void)have; } -TEST_F(StaDesignTest, R9_SearchFindPathGroup) { +TEST_F(StaDesignTest, SearchFindPathGroup) { Search *search = sta_->search(); Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); @@ -14107,19 +14107,19 @@ TEST_F(StaDesignTest, R9_SearchFindPathGroup) { (void)pg; } -TEST_F(StaDesignTest, R9_SearchClkInfoCount) { +TEST_F(StaDesignTest, SearchClkInfoCount) { Search *search = sta_->search(); int count = search->clkInfoCount(); EXPECT_GE(count, 0); } -TEST_F(StaDesignTest, R9_SearchTagGroupCount) { +TEST_F(StaDesignTest, SearchTagGroupCount) { Search *search = sta_->search(); TagGroupIndex count = search->tagGroupCount(); EXPECT_GE(count, 0u); } -TEST_F(StaDesignTest, R9_SearchTagGroupByIndex) { +TEST_F(StaDesignTest, SearchTagGroupByIndex) { Search *search = sta_->search(); TagGroupIndex count = search->tagGroupCount(); if (count > 0) { @@ -14128,12 +14128,12 @@ TEST_F(StaDesignTest, R9_SearchTagGroupByIndex) { } } -TEST_F(StaDesignTest, R9_SearchReportTagGroups) { +TEST_F(StaDesignTest, SearchReportTagGroups2) { Search *search = sta_->search(); search->reportTagGroups(); } -TEST_F(StaDesignTest, R9_SearchReportArrivals) { +TEST_F(StaDesignTest, SearchReportArrivals2) { Search *search = sta_->search(); Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); @@ -14141,7 +14141,7 @@ TEST_F(StaDesignTest, R9_SearchReportArrivals) { search->reportArrivals(v, true); } -TEST_F(StaDesignTest, R9_SearchSeedArrival) { +TEST_F(StaDesignTest, SearchSeedArrival) { Search *search = sta_->search(); Vertex *v = findVertex("in1"); if (v) { @@ -14149,7 +14149,7 @@ TEST_F(StaDesignTest, R9_SearchSeedArrival) { } } -TEST_F(StaDesignTest, R9_SearchPathClkPathArrival) { +TEST_F(StaDesignTest, SearchPathClkPathArrival2) { Search *search = sta_->search(); Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); @@ -14160,43 +14160,43 @@ TEST_F(StaDesignTest, R9_SearchPathClkPathArrival) { } } -TEST_F(StaDesignTest, R9_SearchFindClkArrivals) { +TEST_F(StaDesignTest, SearchFindClkArrivals) { Search *search = sta_->search(); search->findClkArrivals(); } -TEST_F(StaDesignTest, R9_SearchFindRequireds) { +TEST_F(StaDesignTest, SearchFindRequireds) { Search *search = sta_->search(); search->findRequireds(); EXPECT_TRUE(search->requiredsExist()); } -TEST_F(StaDesignTest, R9_SearchRequiredsSeeded) { +TEST_F(StaDesignTest, SearchRequiredsSeeded) { sta_->findRequireds(); Search *search = sta_->search(); bool seeded = search->requiredsSeeded(); (void)seeded; } -TEST_F(StaDesignTest, R9_SearchArrivalsAtEndpoints) { +TEST_F(StaDesignTest, SearchArrivalsAtEndpoints) { Search *search = sta_->search(); bool exist = search->arrivalsAtEndpointsExist(); (void)exist; } -TEST_F(StaDesignTest, R9_SearchArrivalIterator) { +TEST_F(StaDesignTest, SearchArrivalIterator) { Search *search = sta_->search(); BfsFwdIterator *fwd = search->arrivalIterator(); EXPECT_NE(fwd, nullptr); } -TEST_F(StaDesignTest, R9_SearchRequiredIterator) { +TEST_F(StaDesignTest, SearchRequiredIterator) { Search *search = sta_->search(); BfsBkwdIterator *bkwd = search->requiredIterator(); EXPECT_NE(bkwd, nullptr); } -TEST_F(StaDesignTest, R9_SearchWnsSlack) { +TEST_F(StaDesignTest, SearchWnsSlack2) { Search *search = sta_->search(); Vertex *v = findVertex("r3/D"); if (v) { @@ -14205,7 +14205,7 @@ TEST_F(StaDesignTest, R9_SearchWnsSlack) { } } -TEST_F(StaDesignTest, R9_SearchDeratedDelay) { +TEST_F(StaDesignTest, SearchDeratedDelay) { Search *search = sta_->search(); Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); @@ -14224,7 +14224,7 @@ TEST_F(StaDesignTest, R9_SearchDeratedDelay) { } } -TEST_F(StaDesignTest, R9_SearchMatchesFilter) { +TEST_F(StaDesignTest, SearchMatchesFilter) { Search *search = sta_->search(); Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); @@ -14235,30 +14235,30 @@ TEST_F(StaDesignTest, R9_SearchMatchesFilter) { } } -TEST_F(StaDesignTest, R9_SearchEnsureDownstreamClkPins) { +TEST_F(StaDesignTest, SearchEnsureDownstreamClkPins2) { Search *search = sta_->search(); search->ensureDownstreamClkPins(); } -TEST_F(StaDesignTest, R9_SearchVisitPathEnds) { +TEST_F(StaDesignTest, SearchVisitPathEnds) { Search *search = sta_->search(); VisitPathEnds *vpe = search->visitPathEnds(); EXPECT_NE(vpe, nullptr); } -TEST_F(StaDesignTest, R9_SearchGatedClk) { +TEST_F(StaDesignTest, SearchGatedClk) { Search *search = sta_->search(); GatedClk *gc = search->gatedClk(); EXPECT_NE(gc, nullptr); } -TEST_F(StaDesignTest, R9_SearchGenclks) { +TEST_F(StaDesignTest, SearchGenclks) { Search *search = sta_->search(); Genclks *gen = search->genclks(); EXPECT_NE(gen, nullptr); } -TEST_F(StaDesignTest, R9_SearchCheckCrpr) { +TEST_F(StaDesignTest, SearchCheckCrpr) { Search *search = sta_->search(); CheckCrpr *crpr = search->checkCrpr(); EXPECT_NE(crpr, nullptr); @@ -14266,7 +14266,7 @@ TEST_F(StaDesignTest, R9_SearchCheckCrpr) { // --- Sta: various methods --- -TEST_F(StaDesignTest, R9_StaIsClock) { +TEST_F(StaDesignTest, StaIsClock) { sta_->ensureClkNetwork(); Pin *clk_pin = findPin("r1/CK"); if (clk_pin) { @@ -14275,7 +14275,7 @@ TEST_F(StaDesignTest, R9_StaIsClock) { } } -TEST_F(StaDesignTest, R9_StaIsClockNet) { +TEST_F(StaDesignTest, StaIsClockNet) { Network *network = sta_->cmdNetwork(); sta_->ensureClkNetwork(); Pin *clk_pin = findPin("r1/CK"); @@ -14288,7 +14288,7 @@ TEST_F(StaDesignTest, R9_StaIsClockNet) { } } -TEST_F(StaDesignTest, R9_StaIsIdealClock) { +TEST_F(StaDesignTest, StaIsIdealClock) { sta_->ensureClkNetwork(); Pin *clk_pin = findPin("r1/CK"); if (clk_pin) { @@ -14297,7 +14297,7 @@ TEST_F(StaDesignTest, R9_StaIsIdealClock) { } } -TEST_F(StaDesignTest, R9_StaIsPropagatedClock) { +TEST_F(StaDesignTest, StaIsPropagatedClock) { sta_->ensureClkNetwork(); Pin *clk_pin = findPin("r1/CK"); if (clk_pin) { @@ -14306,7 +14306,7 @@ TEST_F(StaDesignTest, R9_StaIsPropagatedClock) { } } -TEST_F(StaDesignTest, R9_StaPins) { +TEST_F(StaDesignTest, StaPins) { Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); sta_->ensureClkNetwork(); @@ -14314,44 +14314,44 @@ TEST_F(StaDesignTest, R9_StaPins) { (void)pins; } -TEST_F(StaDesignTest, R9_StaStartpointPins) { +TEST_F(StaDesignTest, StaStartpointPins) { PinSet startpoints = sta_->startpointPins(); EXPECT_GE(startpoints.size(), 1u); } -TEST_F(StaDesignTest, R9_StaEndpointPins) { +TEST_F(StaDesignTest, StaEndpointPins) { PinSet endpoints = sta_->endpointPins(); EXPECT_GE(endpoints.size(), 1u); } -TEST_F(StaDesignTest, R9_StaEndpoints) { +TEST_F(StaDesignTest, StaEndpoints) { VertexSet *endpoints = sta_->endpoints(); EXPECT_NE(endpoints, nullptr); EXPECT_GE(endpoints->size(), 1u); } -TEST_F(StaDesignTest, R9_StaEndpointViolationCount) { +TEST_F(StaDesignTest, StaEndpointViolationCount) { int count = sta_->endpointViolationCount(MinMax::max()); (void)count; } -TEST_F(StaDesignTest, R9_StaTotalNegativeSlack) { +TEST_F(StaDesignTest, StaTotalNegativeSlack) { Slack tns = sta_->totalNegativeSlack(MinMax::max()); (void)tns; } -TEST_F(StaDesignTest, R9_StaTotalNegativeSlackCorner) { +TEST_F(StaDesignTest, StaTotalNegativeSlackCorner) { Corner *corner = sta_->cmdCorner(); Slack tns = sta_->totalNegativeSlack(corner, MinMax::max()); (void)tns; } -TEST_F(StaDesignTest, R9_StaWorstSlack) { +TEST_F(StaDesignTest, StaWorstSlack) { Slack wns = sta_->worstSlack(MinMax::max()); (void)wns; } -TEST_F(StaDesignTest, R9_StaWorstSlackVertex) { +TEST_F(StaDesignTest, StaWorstSlackVertex) { Slack worst_slack; Vertex *worst_vertex; sta_->worstSlack(MinMax::max(), worst_slack, worst_vertex); @@ -14359,7 +14359,7 @@ TEST_F(StaDesignTest, R9_StaWorstSlackVertex) { (void)worst_vertex; } -TEST_F(StaDesignTest, R9_StaWorstSlackCornerVertex) { +TEST_F(StaDesignTest, StaWorstSlackCornerVertex) { Corner *corner = sta_->cmdCorner(); Slack worst_slack; Vertex *worst_vertex; @@ -14368,42 +14368,42 @@ TEST_F(StaDesignTest, R9_StaWorstSlackCornerVertex) { (void)worst_vertex; } -TEST_F(StaDesignTest, R9_StaVertexWorstSlackPath) { +TEST_F(StaDesignTest, StaVertexWorstSlackPath) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstSlackPath(v, MinMax::max()); (void)path; } -TEST_F(StaDesignTest, R9_StaVertexWorstSlackPathRf) { +TEST_F(StaDesignTest, StaVertexWorstSlackPathRf) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstSlackPath(v, RiseFall::rise(), MinMax::max()); (void)path; } -TEST_F(StaDesignTest, R9_StaVertexWorstRequiredPath) { +TEST_F(StaDesignTest, StaVertexWorstRequiredPath) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstRequiredPath(v, MinMax::max()); (void)path; } -TEST_F(StaDesignTest, R9_StaVertexWorstRequiredPathRf) { +TEST_F(StaDesignTest, StaVertexWorstRequiredPathRf) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstRequiredPath(v, RiseFall::rise(), MinMax::max()); (void)path; } -TEST_F(StaDesignTest, R9_StaVertexWorstArrivalPathRf) { +TEST_F(StaDesignTest, StaVertexWorstArrivalPathRf) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstArrivalPath(v, RiseFall::rise(), MinMax::max()); (void)path; } -TEST_F(StaDesignTest, R9_StaVertexSlacks) { +TEST_F(StaDesignTest, StaVertexSlacks) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Slack slacks[RiseFall::index_count][MinMax::index_count]; @@ -14411,7 +14411,7 @@ TEST_F(StaDesignTest, R9_StaVertexSlacks) { // slacks should be populated } -TEST_F(StaDesignTest, R9_StaVertexSlewRfCorner) { +TEST_F(StaDesignTest, StaVertexSlewRfCorner) { Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); Corner *corner = sta_->cmdCorner(); @@ -14419,14 +14419,14 @@ TEST_F(StaDesignTest, R9_StaVertexSlewRfCorner) { (void)slew; } -TEST_F(StaDesignTest, R9_StaVertexSlewRfMinMax) { +TEST_F(StaDesignTest, StaVertexSlewRfMinMax) { Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); Slew slew = sta_->vertexSlew(v, RiseFall::rise(), MinMax::max()); (void)slew; } -TEST_F(StaDesignTest, R9_StaVertexRequiredRfPathAP) { +TEST_F(StaDesignTest, StaVertexRequiredRfPathAP) { Vertex *v = findVertex("r3/D"); ASSERT_NE(v, nullptr); Corner *corner = sta_->cmdCorner(); @@ -14435,7 +14435,7 @@ TEST_F(StaDesignTest, R9_StaVertexRequiredRfPathAP) { (void)req; } -TEST_F(StaDesignTest, R9_StaVertexArrivalClkEdge) { +TEST_F(StaDesignTest, StaVertexArrivalClkEdge) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); Clock *clk = sta_->sdc()->findClock("clk"); @@ -14449,31 +14449,31 @@ TEST_F(StaDesignTest, R9_StaVertexArrivalClkEdge) { // --- Sta: CheckTiming --- -TEST_F(StaDesignTest, R9_CheckTiming) { +TEST_F(StaDesignTest, CheckTiming2) { CheckErrorSeq &errors = sta_->checkTiming( true, true, true, true, true, true, true); (void)errors; } -TEST_F(StaDesignTest, R9_CheckTimingNoInputDelay) { +TEST_F(StaDesignTest, CheckTimingNoInputDelay) { CheckErrorSeq &errors = sta_->checkTiming( true, false, false, false, false, false, false); (void)errors; } -TEST_F(StaDesignTest, R9_CheckTimingNoOutputDelay) { +TEST_F(StaDesignTest, CheckTimingNoOutputDelay) { CheckErrorSeq &errors = sta_->checkTiming( false, true, false, false, false, false, false); (void)errors; } -TEST_F(StaDesignTest, R9_CheckTimingUnconstrained) { +TEST_F(StaDesignTest, CheckTimingUnconstrained) { CheckErrorSeq &errors = sta_->checkTiming( false, false, false, false, true, false, false); (void)errors; } -TEST_F(StaDesignTest, R9_CheckTimingLoops) { +TEST_F(StaDesignTest, CheckTimingLoops) { CheckErrorSeq &errors = sta_->checkTiming( false, false, false, false, false, true, false); (void)errors; @@ -14481,7 +14481,7 @@ TEST_F(StaDesignTest, R9_CheckTimingLoops) { // --- Sta: delay calc --- -TEST_F(StaDesignTest, R9_ReportDelayCalc) { +TEST_F(StaDesignTest, ReportDelayCalc2) { Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); Corner *corner = sta_->cmdCorner(); @@ -14499,7 +14499,7 @@ TEST_F(StaDesignTest, R9_ReportDelayCalc) { // --- Sta: CRPR settings --- -TEST_F(StaDesignTest, R9_CrprEnabled) { +TEST_F(StaDesignTest, CrprEnabled) { bool enabled = sta_->crprEnabled(); (void)enabled; sta_->setCrprEnabled(true); @@ -14507,7 +14507,7 @@ TEST_F(StaDesignTest, R9_CrprEnabled) { sta_->setCrprEnabled(false); } -TEST_F(StaDesignTest, R9_CrprMode) { +TEST_F(StaDesignTest, CrprMode) { CrprMode mode = sta_->crprMode(); (void)mode; sta_->setCrprMode(CrprMode::same_pin); @@ -14516,7 +14516,7 @@ TEST_F(StaDesignTest, R9_CrprMode) { // --- Sta: propagateGatedClockEnable --- -TEST_F(StaDesignTest, R9_PropagateGatedClockEnable) { +TEST_F(StaDesignTest, PropagateGatedClockEnable) { bool prop = sta_->propagateGatedClockEnable(); (void)prop; sta_->setPropagateGatedClockEnable(true); @@ -14526,29 +14526,29 @@ TEST_F(StaDesignTest, R9_PropagateGatedClockEnable) { // --- Sta: analysis mode --- -TEST_F(StaDesignTest, R9_CmdNamespace) { +TEST_F(StaDesignTest, CmdNamespace) { CmdNamespace ns = sta_->cmdNamespace(); (void)ns; } -TEST_F(StaDesignTest, R9_CmdCorner) { +TEST_F(StaDesignTest, CmdCorner) { Corner *corner = sta_->cmdCorner(); EXPECT_NE(corner, nullptr); } -TEST_F(StaDesignTest, R9_FindCorner) { +TEST_F(StaDesignTest, FindCorner) { Corner *corner = sta_->findCorner("default"); (void)corner; } -TEST_F(StaDesignTest, R9_MultiCorner) { +TEST_F(StaDesignTest, MultiCorner) { bool multi = sta_->multiCorner(); (void)multi; } // --- PathExpanded: detailed accessors --- -TEST_F(StaDesignTest, R9_PathExpandedSize) { +TEST_F(StaDesignTest, PathExpandedSize) { Vertex *v = findVertex("u2/ZN"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstArrivalPath(v, MinMax::max()); @@ -14558,7 +14558,7 @@ TEST_F(StaDesignTest, R9_PathExpandedSize) { } } -TEST_F(StaDesignTest, R9_PathExpandedStartPath) { +TEST_F(StaDesignTest, PathExpandedStartPath) { Vertex *v = findVertex("u2/ZN"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstArrivalPath(v, MinMax::max()); @@ -14573,7 +14573,7 @@ TEST_F(StaDesignTest, R9_PathExpandedStartPath) { // --- Sta: Timing derate --- -TEST_F(StaDesignTest, R9_SetTimingDerate) { +TEST_F(StaDesignTest, SetTimingDerate) { sta_->setTimingDerate(TimingDerateType::cell_delay, PathClkOrData::clk, RiseFallBoth::riseFall(), EarlyLate::early(), 0.95f); @@ -14582,7 +14582,7 @@ TEST_F(StaDesignTest, R9_SetTimingDerate) { // --- Sta: setArcDelay --- -TEST_F(StaDesignTest, R9_SetArcDelay) { +TEST_F(StaDesignTest, SetArcDelay) { Vertex *v = findVertex("u1/Z"); ASSERT_NE(v, nullptr); Corner *corner = sta_->cmdCorner(); @@ -14599,13 +14599,13 @@ TEST_F(StaDesignTest, R9_SetArcDelay) { // --- Sta: removeDelaySlewAnnotations --- -TEST_F(StaDesignTest, R9_RemoveDelaySlewAnnotations) { +TEST_F(StaDesignTest, RemoveDelaySlewAnnotations2) { sta_->removeDelaySlewAnnotations(); } // --- Sta: endpoint slack --- -TEST_F(StaDesignTest, R9_EndpointSlack) { +TEST_F(StaDesignTest, EndpointSlack2) { Pin *pin = findPin("r3/D"); if (pin) { Slack slk = sta_->endpointSlack(pin, "clk", MinMax::max()); @@ -14615,24 +14615,24 @@ TEST_F(StaDesignTest, R9_EndpointSlack) { // --- Sta: delaysInvalid/arrivalsInvalid --- -TEST_F(StaDesignTest, R9_DelaysInvalid) { +TEST_F(StaDesignTest, DelaysInvalid2) { sta_->delaysInvalid(); sta_->updateTiming(true); } -TEST_F(StaDesignTest, R9_ArrivalsInvalid) { +TEST_F(StaDesignTest, ArrivalsInvalid2) { sta_->arrivalsInvalid(); sta_->updateTiming(true); } -TEST_F(StaDesignTest, R9_DelaysInvalidFrom) { +TEST_F(StaDesignTest, DelaysInvalidFrom) { Pin *pin = findPin("u1/Z"); if (pin) { sta_->delaysInvalidFrom(pin); } } -TEST_F(StaDesignTest, R9_DelaysInvalidFromFanin) { +TEST_F(StaDesignTest, DelaysInvalidFromFanin) { Pin *pin = findPin("r3/D"); if (pin) { sta_->delaysInvalidFromFanin(pin); @@ -14641,48 +14641,48 @@ TEST_F(StaDesignTest, R9_DelaysInvalidFromFanin) { // --- Sta: searchPreamble --- -TEST_F(StaDesignTest, R9_SearchPreamble) { +TEST_F(StaDesignTest, SearchPreamble) { sta_->searchPreamble(); } // --- Sta: ensureLevelized / ensureGraph / ensureLinked --- -TEST_F(StaDesignTest, R9_EnsureLevelized) { +TEST_F(StaDesignTest, EnsureLevelized) { sta_->ensureLevelized(); } -TEST_F(StaDesignTest, R9_EnsureGraph) { +TEST_F(StaDesignTest, EnsureGraph) { Graph *graph = sta_->ensureGraph(); EXPECT_NE(graph, nullptr); } -TEST_F(StaDesignTest, R9_EnsureLinked) { +TEST_F(StaDesignTest, EnsureLinked) { Network *network = sta_->ensureLinked(); EXPECT_NE(network, nullptr); } -TEST_F(StaDesignTest, R9_EnsureLibLinked) { +TEST_F(StaDesignTest, EnsureLibLinked) { Network *network = sta_->ensureLibLinked(); EXPECT_NE(network, nullptr); } -TEST_F(StaDesignTest, R9_EnsureClkArrivals) { +TEST_F(StaDesignTest, EnsureClkArrivals) { sta_->ensureClkArrivals(); } -TEST_F(StaDesignTest, R9_EnsureClkNetwork) { +TEST_F(StaDesignTest, EnsureClkNetwork) { sta_->ensureClkNetwork(); } // --- Sta: findDelays --- -TEST_F(StaDesignTest, R9_FindDelays) { +TEST_F(StaDesignTest, FindDelays2) { sta_->findDelays(); } // --- Sta: setVoltage for net --- -TEST_F(StaDesignTest, R9_SetVoltageNet) { +TEST_F(StaDesignTest, SetVoltageNet) { Network *network = sta_->cmdNetwork(); Pin *pin = findPin("r1/Q"); if (pin) { @@ -14695,7 +14695,7 @@ TEST_F(StaDesignTest, R9_SetVoltageNet) { // --- Sta: PVT --- -TEST_F(StaDesignTest, R9_GetPvt) { +TEST_F(StaDesignTest, GetPvt) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); const Pvt *pvt = sta_->pvt(top, MinMax::max()); @@ -14704,7 +14704,7 @@ TEST_F(StaDesignTest, R9_GetPvt) { // --- ClkNetwork --- -TEST_F(StaDesignTest, R9_ClkNetworkIsClock) { +TEST_F(StaDesignTest, ClkNetworkIsClock) { ClkNetwork *clk_network = sta_->search()->clkNetwork(); if (clk_network) { Pin *clk_pin = findPin("r1/CK"); @@ -14717,7 +14717,7 @@ TEST_F(StaDesignTest, R9_ClkNetworkIsClock) { // --- Tag operations --- -TEST_F(StaDesignTest, R9_TagPathAPIndex) { +TEST_F(StaDesignTest, TagPathAPIndex) { Search *search = sta_->search(); TagIndex count = search->tagCount(); if (count > 0) { @@ -14729,7 +14729,7 @@ TEST_F(StaDesignTest, R9_TagPathAPIndex) { } } -TEST_F(StaDesignTest, R9_TagCmp) { +TEST_F(StaDesignTest, TagCmp) { Search *search = sta_->search(); TagIndex count = search->tagCount(); if (count >= 2) { @@ -14744,7 +14744,7 @@ TEST_F(StaDesignTest, R9_TagCmp) { } } -TEST_F(StaDesignTest, R9_TagHash) { +TEST_F(StaDesignTest, TagHash) { Search *search = sta_->search(); TagIndex count = search->tagCount(); if (count > 0) { @@ -14758,7 +14758,7 @@ TEST_F(StaDesignTest, R9_TagHash) { } } -TEST_F(StaDesignTest, R9_TagMatchHashEqual) { +TEST_F(StaDesignTest, TagMatchHashEqual) { Search *search = sta_->search(); TagIndex count = search->tagCount(); if (count >= 2) { @@ -14779,7 +14779,7 @@ TEST_F(StaDesignTest, R9_TagMatchHashEqual) { // --- ClkInfo operations --- -TEST_F(StaDesignTest, R9_ClkInfoAccessors) { +TEST_F(StaDesignTest, ClkInfoAccessors2) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); VertexPathIterator *iter = sta_->vertexPathIterator(v, RiseFall::rise(), MinMax::max()); @@ -14805,7 +14805,7 @@ TEST_F(StaDesignTest, R9_ClkInfoAccessors) { // --- Sim --- -TEST_F(StaDesignTest, R9_SimLogicValue) { +TEST_F(StaDesignTest, SimLogicValue2) { Sim *sim = sta_->sim(); ASSERT_NE(sim, nullptr); Pin *pin = findPin("r1/D"); @@ -14815,7 +14815,7 @@ TEST_F(StaDesignTest, R9_SimLogicValue) { } } -TEST_F(StaDesignTest, R9_SimLogicZeroOne) { +TEST_F(StaDesignTest, SimLogicZeroOne) { Sim *sim = sta_->sim(); ASSERT_NE(sim, nullptr); Pin *pin = findPin("r1/D"); @@ -14825,13 +14825,13 @@ TEST_F(StaDesignTest, R9_SimLogicZeroOne) { } } -TEST_F(StaDesignTest, R9_SimEnsureConstantsPropagated) { +TEST_F(StaDesignTest, SimEnsureConstantsPropagated) { Sim *sim = sta_->sim(); ASSERT_NE(sim, nullptr); sim->ensureConstantsPropagated(); } -TEST_F(StaDesignTest, R9_SimFunctionSense) { +TEST_F(StaDesignTest, SimFunctionSense) { Sim *sim = sta_->sim(); ASSERT_NE(sim, nullptr); // Use u1 (BUF_X1) which has known input A and output Z @@ -14850,14 +14850,14 @@ TEST_F(StaDesignTest, R9_SimFunctionSense) { // --- Levelize --- -TEST_F(StaDesignTest, R9_LevelizeMaxLevel) { +TEST_F(StaDesignTest, LevelizeMaxLevel) { Levelize *lev = sta_->levelize(); ASSERT_NE(lev, nullptr); Level max_level = lev->maxLevel(); EXPECT_GT(max_level, 0); } -TEST_F(StaDesignTest, R9_LevelizeLevelized) { +TEST_F(StaDesignTest, LevelizeLevelized) { Levelize *lev = sta_->levelize(); ASSERT_NE(lev, nullptr); bool is_levelized = lev->levelized(); @@ -14866,7 +14866,7 @@ TEST_F(StaDesignTest, R9_LevelizeLevelized) { // --- Sta: makeParasiticNetwork --- -TEST_F(StaDesignTest, R9_MakeParasiticNetwork) { +TEST_F(StaDesignTest, MakeParasiticNetwork) { Network *network = sta_->cmdNetwork(); Pin *pin = findPin("r1/Q"); if (pin) { @@ -14884,12 +14884,12 @@ TEST_F(StaDesignTest, R9_MakeParasiticNetwork) { // --- Path: operations on actual paths --- -TEST_F(StaDesignTest, R9_PathIsNull) { +TEST_F(StaDesignTest, PathIsNull) { Path path; EXPECT_TRUE(path.isNull()); } -TEST_F(StaDesignTest, R9_PathFromVertex) { +TEST_F(StaDesignTest, PathFromVertex) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstArrivalPath(v, MinMax::max()); @@ -14907,7 +14907,7 @@ TEST_F(StaDesignTest, R9_PathFromVertex) { } } -TEST_F(StaDesignTest, R9_PathPrevPath) { +TEST_F(StaDesignTest, PathPrevPath) { Vertex *v = findVertex("u2/ZN"); ASSERT_NE(v, nullptr); Path *path = sta_->vertexWorstArrivalPath(v, MinMax::max()); @@ -14923,7 +14923,7 @@ TEST_F(StaDesignTest, R9_PathPrevPath) { // --- PathExpanded: with clk path --- -TEST_F(StaDesignTest, R9_PathExpandedWithClk) { +TEST_F(StaDesignTest, PathExpandedWithClk) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -14943,7 +14943,7 @@ TEST_F(StaDesignTest, R9_PathExpandedWithClk) { // --- GatedClk --- -TEST_F(StaDesignTest, R9_GatedClkIsEnable) { +TEST_F(StaDesignTest, GatedClkIsEnable) { GatedClk *gc = sta_->search()->gatedClk(); Vertex *v = findVertex("u1/Z"); if (v) { @@ -14952,7 +14952,7 @@ TEST_F(StaDesignTest, R9_GatedClkIsEnable) { } } -TEST_F(StaDesignTest, R9_GatedClkEnables) { +TEST_F(StaDesignTest, GatedClkEnables) { GatedClk *gc = sta_->search()->gatedClk(); Vertex *v = findVertex("r1/CK"); if (v) { @@ -14964,7 +14964,7 @@ TEST_F(StaDesignTest, R9_GatedClkEnables) { // --- Genclks --- -TEST_F(StaDesignTest, R9_GenclksClear) { +TEST_F(StaDesignTest, GenclksClear) { Genclks *gen = sta_->search()->genclks(); // Clear should not crash on design without generated clocks gen->clear(); @@ -14972,7 +14972,7 @@ TEST_F(StaDesignTest, R9_GenclksClear) { // --- Search: visitStartpoints/visitEndpoints --- -TEST_F(StaDesignTest, R9_SearchVisitEndpoints) { +TEST_F(StaDesignTest, SearchVisitEndpoints2) { Search *search = sta_->search(); PinSet pins(sta_->network()); VertexPinCollector collector(pins); @@ -14980,7 +14980,7 @@ TEST_F(StaDesignTest, R9_SearchVisitEndpoints) { EXPECT_GE(pins.size(), 1u); } -TEST_F(StaDesignTest, R9_SearchVisitStartpoints) { +TEST_F(StaDesignTest, SearchVisitStartpoints2) { Search *search = sta_->search(); PinSet pins(sta_->network()); VertexPinCollector collector(pins); @@ -14990,7 +14990,7 @@ TEST_F(StaDesignTest, R9_SearchVisitStartpoints) { // --- PathGroup --- -TEST_F(StaDesignTest, R9_PathGroupFindByName) { +TEST_F(StaDesignTest, PathGroupFindByName) { Search *search = sta_->search(); // After findPathEnds, path groups should exist PathEndSeq ends = sta_->findPathEnds( @@ -15007,7 +15007,7 @@ TEST_F(StaDesignTest, R9_PathGroupFindByName) { } } -TEST_F(StaDesignTest, R9_PathGroups) { +TEST_F(StaDesignTest, PathGroups) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -15022,7 +15022,7 @@ TEST_F(StaDesignTest, R9_PathGroups) { // --- VertexPathIterator with PathAnalysisPt --- -TEST_F(StaDesignTest, R9_VertexPathIteratorPathAP) { +TEST_F(StaDesignTest, VertexPathIteratorPathAP) { Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); Corner *corner = sta_->cmdCorner(); @@ -15038,7 +15038,7 @@ TEST_F(StaDesignTest, R9_VertexPathIteratorPathAP) { // --- Sta: setOutputDelay and find unconstrained --- -TEST_F(StaDesignTest, R9_SetOutputDelayAndCheck) { +TEST_F(StaDesignTest, SetOutputDelayAndCheck) { Pin *out = findPin("out"); ASSERT_NE(out, nullptr); Clock *clk = sta_->sdc()->findClock("clk"); @@ -15059,7 +15059,7 @@ TEST_F(StaDesignTest, R9_SetOutputDelayAndCheck) { // --- Sta: unique_edges findPathEnds --- -TEST_F(StaDesignTest, R9_FindPathEndsUniqueEdges) { +TEST_F(StaDesignTest, FindPathEndsUniqueEdges) { PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, nullptr, MinMaxAll::max(), @@ -15070,7 +15070,7 @@ TEST_F(StaDesignTest, R9_FindPathEndsUniqueEdges) { // --- Sta: corner path analysis pt --- -TEST_F(StaDesignTest, R9_CornerPathAnalysisPt) { +TEST_F(StaDesignTest, CornerPathAnalysisPt) { Corner *corner = sta_->cmdCorner(); ASSERT_NE(corner, nullptr); const PathAnalysisPt *max_ap = corner->findPathAnalysisPt(MinMax::max()); @@ -15081,20 +15081,20 @@ TEST_F(StaDesignTest, R9_CornerPathAnalysisPt) { // --- Sta: incrementalDelayTolerance --- -TEST_F(StaDesignTest, R9_IncrementalDelayTolerance) { +TEST_F(StaDesignTest, IncrementalDelayTolerance) { sta_->setIncrementalDelayTolerance(0.01f); } // --- Sta: pocvEnabled --- -TEST_F(StaDesignTest, R9_PocvEnabled) { +TEST_F(StaDesignTest, PocvEnabled) { bool enabled = sta_->pocvEnabled(); (void)enabled; } // --- Sta: makePiElmore --- -TEST_F(StaDesignTest, R9_MakePiElmore) { +TEST_F(StaDesignTest, MakePiElmore) { Pin *pin = findPin("r1/Q"); ASSERT_NE(pin, nullptr); sta_->makePiElmore(pin, RiseFall::rise(), MinMaxAll::all(), @@ -15110,13 +15110,13 @@ TEST_F(StaDesignTest, R9_MakePiElmore) { // --- Sta: deleteParasitics --- -TEST_F(StaDesignTest, R9_DeleteParasitics) { +TEST_F(StaDesignTest, DeleteParasitics2) { sta_->deleteParasitics(); } // --- Search: arrivalsChanged --- -TEST_F(StaDesignTest, R9_SearchArrivalsVertexData) { +TEST_F(StaDesignTest, SearchArrivalsVertexData) { // Verify arrivals exist through the Sta API Vertex *v = findVertex("r1/Q"); ASSERT_NE(v, nullptr); @@ -15128,7 +15128,7 @@ TEST_F(StaDesignTest, R9_SearchArrivalsVertexData) { // --- Sta: activity --- -TEST_F(StaDesignTest, R9_PinActivity) { +TEST_F(StaDesignTest, PinActivity) { Pin *pin = findPin("r1/Q"); ASSERT_NE(pin, nullptr); PwrActivity act = sta_->activity(pin); @@ -15137,7 +15137,7 @@ TEST_F(StaDesignTest, R9_PinActivity) { // --- Search: isInputArrivalSrchStart --- -TEST_F(StaDesignTest, R9_IsInputArrivalSrchStart) { +TEST_F(StaDesignTest, IsInputArrivalSrchStart) { Search *search = sta_->search(); Vertex *v = findVertex("in1"); if (v) { @@ -15146,7 +15146,7 @@ TEST_F(StaDesignTest, R9_IsInputArrivalSrchStart) { } } -TEST_F(StaDesignTest, R9_IsSegmentStart) { +TEST_F(StaDesignTest, IsSegmentStart) { Search *search = sta_->search(); Pin *pin = findPin("in1"); if (pin) { @@ -15157,7 +15157,7 @@ TEST_F(StaDesignTest, R9_IsSegmentStart) { // --- Search: clockInsertion --- -TEST_F(StaDesignTest, R9_ClockInsertion) { +TEST_F(StaDesignTest, ClockInsertion) { Search *search = sta_->search(); Clock *clk = sta_->sdc()->findClock("clk"); ASSERT_NE(clk, nullptr); @@ -15173,7 +15173,7 @@ TEST_F(StaDesignTest, R9_ClockInsertion) { // --- Levelize: edges --- -TEST_F(StaDesignTest, R9_LevelizeLevelsValid) { +TEST_F(StaDesignTest, LevelizeLevelsValid) { Levelize *lev = sta_->levelize(); ASSERT_NE(lev, nullptr); bool valid = lev->levelized(); @@ -15182,24 +15182,24 @@ TEST_F(StaDesignTest, R9_LevelizeLevelsValid) { // --- Search: reporting --- -TEST_F(StaDesignTest, R9_SearchReportPathCountHistogram) { +TEST_F(StaDesignTest, SearchReportPathCountHistogram2) { Search *search = sta_->search(); search->reportPathCountHistogram(); } -TEST_F(StaDesignTest, R9_SearchReportTags) { +TEST_F(StaDesignTest, SearchReportTags2) { Search *search = sta_->search(); search->reportTags(); } -TEST_F(StaDesignTest, R9_SearchReportClkInfos) { +TEST_F(StaDesignTest, SearchReportClkInfos2) { Search *search = sta_->search(); search->reportClkInfos(); } // --- Search: filteredEndpoints --- -TEST_F(StaDesignTest, R9_SearchFilteredEndpoints) { +TEST_F(StaDesignTest, SearchFilteredEndpoints) { Search *search = sta_->search(); VertexSeq endpoints = search->filteredEndpoints(); (void)endpoints; @@ -15207,7 +15207,7 @@ TEST_F(StaDesignTest, R9_SearchFilteredEndpoints) { // --- Sta: findFanoutInstances --- -TEST_F(StaDesignTest, R9_FindFanoutInstances) { +TEST_F(StaDesignTest, FindFanoutInstances) { Pin *pin = findPin("r1/Q"); ASSERT_NE(pin, nullptr); PinSeq from_pins; @@ -15218,32 +15218,32 @@ TEST_F(StaDesignTest, R9_FindFanoutInstances) { // --- Sta: search endpointsInvalid --- -TEST_F(StaDesignTest, R9_EndpointsInvalid) { +TEST_F(StaDesignTest, EndpointsInvalid2) { Search *search = sta_->search(); search->endpointsInvalid(); } // --- Sta: constraintsChanged --- -TEST_F(StaDesignTest, R9_ConstraintsChanged) { +TEST_F(StaDesignTest, ConstraintsChanged2) { sta_->constraintsChanged(); } // --- Sta: networkChanged --- -TEST_F(StaDesignTest, R9_NetworkChanged) { +TEST_F(StaDesignTest, NetworkChanged2) { sta_->networkChanged(); } // --- Sta: clkPinsInvalid --- -TEST_F(StaDesignTest, R9_ClkPinsInvalid) { +TEST_F(StaDesignTest, ClkPinsInvalid) { sta_->clkPinsInvalid(); } // --- PropertyValue constructors and types --- -TEST_F(StaDesignTest, R9_PropertyValueConstructors) { +TEST_F(StaDesignTest, PropertyValueConstructors) { PropertyValue pv1; EXPECT_EQ(pv1.type(), PropertyValue::type_none); @@ -15266,7 +15266,7 @@ TEST_F(StaDesignTest, R9_PropertyValueConstructors) { // --- Sta: setPvt --- -TEST_F(StaDesignTest, R9_SetPvt) { +TEST_F(StaDesignTest, SetPvt) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); sta_->setPvt(top, MinMaxAll::all(), 1.0f, 1.1f, 25.0f); @@ -15276,7 +15276,7 @@ TEST_F(StaDesignTest, R9_SetPvt) { // --- Search: propagateClkSense --- -TEST_F(StaDesignTest, R9_SearchClkPathArrival) { +TEST_F(StaDesignTest, SearchClkPathArrival2) { Search *search = sta_->search(); Vertex *v = findVertex("r1/CK"); if (v) { @@ -15296,7 +15296,7 @@ TEST_F(StaDesignTest, R9_SearchClkPathArrival) { // --- Properties: pinArrival, pinSlack via Properties --- -TEST_F(StaDesignTest, R10_PropertyPinArrivalRf) { +TEST_F(StaDesignTest, PropertyPinArrivalRf) { // Cover Properties::pinArrival(pin, rf, min_max) Properties &props = sta_->properties(); Pin *pin = findPin("r1/D"); @@ -15308,7 +15308,7 @@ TEST_F(StaDesignTest, R10_PropertyPinArrivalRf) { } } -TEST_F(StaDesignTest, R10_PropertyPinSlackMinMax) { +TEST_F(StaDesignTest, PropertyPinSlackMinMax) { // Cover Properties::pinSlack(pin, min_max) Properties &props = sta_->properties(); Pin *pin = findPin("r1/D"); @@ -15320,7 +15320,7 @@ TEST_F(StaDesignTest, R10_PropertyPinSlackMinMax) { } } -TEST_F(StaDesignTest, R10_PropertyPinSlackRf) { +TEST_F(StaDesignTest, PropertyPinSlackRf) { // Cover Properties::pinSlack(pin, rf, min_max) Properties &props = sta_->properties(); Pin *pin = findPin("r1/D"); @@ -15332,7 +15332,7 @@ TEST_F(StaDesignTest, R10_PropertyPinSlackRf) { } } -TEST_F(StaDesignTest, R10_PropertyDelayPropertyValue) { +TEST_F(StaDesignTest, PropertyDelayPropertyValue) { // Cover Properties::delayPropertyValue, resistancePropertyValue, capacitancePropertyValue Properties &props = sta_->properties(); Graph *graph = sta_->graph(); @@ -15347,7 +15347,7 @@ TEST_F(StaDesignTest, R10_PropertyDelayPropertyValue) { } } -TEST_F(StaDesignTest, R10_PropertyGetCellAndLibrary) { +TEST_F(StaDesignTest, PropertyGetCellAndLibrary) { // Cover PropertyRegistry::getProperty, PropertyRegistry::getProperty Properties &props = sta_->properties(); Network *network = sta_->cmdNetwork(); @@ -15364,7 +15364,7 @@ TEST_F(StaDesignTest, R10_PropertyGetCellAndLibrary) { } } -TEST_F(StaDesignTest, R10_PropertyUnknownException) { +TEST_F(StaDesignTest, PropertyUnknownException) { // Cover PropertyUnknown constructor and what() Properties &props = sta_->properties(); Pin *pin = findPin("r1/D"); @@ -15379,7 +15379,7 @@ TEST_F(StaDesignTest, R10_PropertyUnknownException) { } } -TEST_F(StaDesignTest, R10_PropertyTypeWrongException) { +TEST_F(StaDesignTest, PropertyTypeWrongException) { // Cover PropertyTypeWrong constructor and what() PropertyValue pv("test_string"); EXPECT_EQ(pv.type(), PropertyValue::type_string); @@ -15394,7 +15394,7 @@ TEST_F(StaDesignTest, R10_PropertyTypeWrongException) { // --- CheckTiming: hasClkedCheck, clear --- -TEST_F(StaDesignTest, R10_CheckTimingClear) { +TEST_F(StaDesignTest, CheckTimingClear) { CheckErrorSeq &errors = sta_->checkTiming(true, true, true, true, true, true, true); (void)errors; CheckErrorSeq &errors2 = sta_->checkTiming(true, true, true, true, true, true, true); @@ -15403,7 +15403,7 @@ TEST_F(StaDesignTest, R10_CheckTimingClear) { // --- BfsIterator: init, destructor, enqueueAdjacentVertices --- -TEST_F(StaDesignTest, R10_BfsIterator) { +TEST_F(StaDesignTest, BfsIterator) { Graph *graph = sta_->graph(); if (graph) { SearchPred1 pred(sta_); @@ -15422,7 +15422,7 @@ TEST_F(StaDesignTest, R10_BfsIterator) { // --- ClkInfo accessors --- -TEST_F(StaDesignTest, R10_ClkInfoAccessors) { +TEST_F(StaDesignTest, ClkInfoAccessors3) { Pin *clk_pin = findPin("r1/CK"); if (clk_pin) { Vertex *v = findVertex("r1/CK"); @@ -15450,7 +15450,7 @@ TEST_F(StaDesignTest, R10_ClkInfoAccessors) { // --- Tag: pathAPIndex --- -TEST_F(StaDesignTest, R10_TagPathAPIndex) { +TEST_F(StaDesignTest, TagPathAPIndex2) { Vertex *v = findVertex("r1/D"); if (v) { VertexPathIterator *iter = sta_->vertexPathIterator(v, RiseFall::rise(), MinMax::max()); @@ -15468,7 +15468,7 @@ TEST_F(StaDesignTest, R10_TagPathAPIndex) { // --- Path: tagIndex, prevVertex --- -TEST_F(StaDesignTest, R10_PathAccessors) { +TEST_F(StaDesignTest, PathAccessors) { Vertex *v = findVertex("r1/D"); if (v) { VertexPathIterator *iter = sta_->vertexPathIterator(v, RiseFall::rise(), MinMax::max()); @@ -15485,7 +15485,7 @@ TEST_F(StaDesignTest, R10_PathAccessors) { // --- PathGroup constructor --- -TEST_F(StaDesignTest, R10_PathGroupConstructor) { +TEST_F(StaDesignTest, PathGroupConstructor) { Search *search = sta_->search(); if (search) { PathGroup *pg = search->findPathGroup("clk", MinMax::max()); @@ -15497,7 +15497,7 @@ TEST_F(StaDesignTest, R10_PathGroupConstructor) { // --- PathLess --- -TEST_F(StaDesignTest, R10_PathLessComparator) { +TEST_F(StaDesignTest, PathLessComparator) { Vertex *v = findVertex("r1/D"); if (v) { VertexPathIterator *iter = sta_->vertexPathIterator(v, RiseFall::rise(), MinMax::max()); @@ -15513,7 +15513,7 @@ TEST_F(StaDesignTest, R10_PathLessComparator) { // --- PathEnd methods on real path ends --- -TEST_F(StaDesignTest, R10_PathEndTargetClkMethods) { +TEST_F(StaDesignTest, PathEndTargetClkMethods) { CornerSeq &corners = sta_->corners()->corners(); Corner *corner = corners[0]; PathEndSeq ends = sta_->findPathEnds( @@ -15540,7 +15540,7 @@ TEST_F(StaDesignTest, R10_PathEndTargetClkMethods) { } } -TEST_F(StaDesignTest, R10_PathEndUnconstrainedMethods) { +TEST_F(StaDesignTest, PathEndUnconstrainedMethods) { CornerSeq &corners = sta_->corners()->corners(); Corner *corner = corners[0]; PathEndSeq ends = sta_->findPathEnds( @@ -15558,7 +15558,7 @@ TEST_F(StaDesignTest, R10_PathEndUnconstrainedMethods) { // --- PathEndPathDelay methods --- -TEST_F(StaDesignTest, R10_PathEndPathDelay) { +TEST_F(StaDesignTest, PathEndPathDelay) { sta_->makePathDelay(nullptr, nullptr, nullptr, MinMax::max(), false, false, 5.0, nullptr); sta_->updateTiming(true); @@ -15584,14 +15584,14 @@ TEST_F(StaDesignTest, R10_PathEndPathDelay) { // --- ReportPath methods via sta_ calls --- -TEST_F(StaDesignTest, R10_ReportPathShortMinPeriod) { +TEST_F(StaDesignTest, ReportPathShortMinPeriod2) { MinPeriodCheckSeq &checks = sta_->minPeriodViolations(); if (!checks.empty()) { sta_->reportCheck(checks[0], false); } } -TEST_F(StaDesignTest, R10_ReportPathCheckMaxSkew) { +TEST_F(StaDesignTest, ReportPathCheckMaxSkew2) { MaxSkewCheckSeq &violations = sta_->maxSkewViolations(); if (!violations.empty()) { sta_->reportCheck(violations[0], true); @@ -15601,7 +15601,7 @@ TEST_F(StaDesignTest, R10_ReportPathCheckMaxSkew) { // --- ReportPath full report --- -TEST_F(StaDesignTest, R10_ReportPathFullReport) { +TEST_F(StaDesignTest, ReportPathFullReport) { CornerSeq &corners = sta_->corners()->corners(); Corner *corner = corners[0]; sta_->setReportPathFormat(ReportPathFormat::full); @@ -15615,7 +15615,7 @@ TEST_F(StaDesignTest, R10_ReportPathFullReport) { } } -TEST_F(StaDesignTest, R10_ReportPathFullClkExpanded) { +TEST_F(StaDesignTest, ReportPathFullClkExpanded) { CornerSeq &corners = sta_->corners()->corners(); Corner *corner = corners[0]; sta_->setReportPathFormat(ReportPathFormat::full_clock_expanded); @@ -15630,7 +15630,7 @@ TEST_F(StaDesignTest, R10_ReportPathFullClkExpanded) { // --- WorstSlack: worstSlack, sortQueue, checkQueue --- -TEST_F(StaDesignTest, R10_WorstSlackMethods) { +TEST_F(StaDesignTest, WorstSlackMethods) { Slack worst_slack; Vertex *worst_vertex; sta_->worstSlack(MinMax::max(), worst_slack, worst_vertex); @@ -15643,7 +15643,7 @@ TEST_F(StaDesignTest, R10_WorstSlackMethods) { // --- WnsSlackLess --- -TEST_F(StaDesignTest, R10_WnsSlackLess) { +TEST_F(StaDesignTest, WnsSlackLess) { CornerSeq &corners = sta_->corners()->corners(); Corner *corner = corners[0]; PathAnalysisPt *path_ap = corner->findPathAnalysisPt(MinMax::max()); @@ -15660,18 +15660,18 @@ TEST_F(StaDesignTest, R10_WnsSlackLess) { // --- Search: various methods --- -TEST_F(StaDesignTest, R10_SearchInitVars) { +TEST_F(StaDesignTest, SearchInitVars) { Search *search = sta_->search(); search->clear(); sta_->updateTiming(true); } -TEST_F(StaDesignTest, R10_SearchCheckPrevPaths) { +TEST_F(StaDesignTest, SearchCheckPrevPaths) { Search *search = sta_->search(); search->checkPrevPaths(); } -TEST_F(StaDesignTest, R10_SearchPathClkPathArrival1) { +TEST_F(StaDesignTest, SearchPathClkPathArrival1) { Search *search = sta_->search(); Vertex *v = findVertex("r1/D"); if (v) { @@ -15687,7 +15687,7 @@ TEST_F(StaDesignTest, R10_SearchPathClkPathArrival1) { // --- Sim --- -TEST_F(StaDesignTest, R10_SimMethods) { +TEST_F(StaDesignTest, SimMethods) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *pin = network->findPin(top, "r1/D"); @@ -15700,13 +15700,13 @@ TEST_F(StaDesignTest, R10_SimMethods) { // --- Levelize --- -TEST_F(StaDesignTest, R10_LevelizeCheckLevels) { +TEST_F(StaDesignTest, LevelizeCheckLevels) { sta_->ensureLevelized(); } // --- Sta: clkSkewPreamble (called by reportClkSkew) --- -TEST_F(StaDesignTest, R10_ClkSkewPreamble) { +TEST_F(StaDesignTest, ClkSkewPreamble) { ConstClockSeq clks; Clock *clk = sta_->sdc()->findClock("clk"); if (clk) { @@ -15719,20 +15719,20 @@ TEST_F(StaDesignTest, R10_ClkSkewPreamble) { // --- Sta: delayCalcPreamble --- -TEST_F(StaDesignTest, R10_DelayCalcPreamble) { +TEST_F(StaDesignTest, DelayCalcPreamble) { sta_->findDelays(); } // --- Sta: setCmdNamespace --- -TEST_F(StaDesignTest, R10_SetCmdNamespace1) { +TEST_F(StaDesignTest, SetCmdNamespace12) { sta_->setCmdNamespace(CmdNamespace::sta); sta_->setCmdNamespace(CmdNamespace::sdc); } // --- Sta: replaceCell --- -TEST_F(StaDesignTest, R10_ReplaceCell) { +TEST_F(StaDesignTest, ReplaceCell2) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *inst_iter = network->childIterator(top); @@ -15748,7 +15748,7 @@ TEST_F(StaDesignTest, R10_ReplaceCell) { // --- ClkSkew: srcInternalClkLatency, tgtInternalClkLatency --- -TEST_F(StaDesignTest, R10_ClkSkewInternalLatency) { +TEST_F(StaDesignTest, ClkSkewInternalLatency) { ConstClockSeq clks; Clock *clk = sta_->sdc()->findClock("clk"); if (clk) { @@ -15761,7 +15761,7 @@ TEST_F(StaDesignTest, R10_ClkSkewInternalLatency) { // --- MaxSkewCheck accessors --- -TEST_F(StaDesignTest, R10_MaxSkewCheckAccessors) { +TEST_F(StaDesignTest, MaxSkewCheckAccessors) { MaxSkewCheckSeq &checks = sta_->maxSkewViolations(); if (!checks.empty()) { MaxSkewCheck *c1 = checks[0]; @@ -15783,7 +15783,7 @@ TEST_F(StaDesignTest, R10_MaxSkewCheckAccessors) { // --- MinPeriodSlackLess --- -TEST_F(StaDesignTest, R10_MinPeriodCheckAccessors) { +TEST_F(StaDesignTest, MinPeriodCheckAccessors) { MinPeriodCheckSeq &checks = sta_->minPeriodViolations(); if (checks.size() >= 2) { MinPeriodSlackLess less(sta_); @@ -15796,7 +15796,7 @@ TEST_F(StaDesignTest, R10_MinPeriodCheckAccessors) { // --- MinPulseWidthCheck: corner --- -TEST_F(StaDesignTest, R10_MinPulseWidthCheckCorner) { +TEST_F(StaDesignTest, MinPulseWidthCheckCorner) { CornerSeq &corners = sta_->corners()->corners(); Corner *corner = corners[0]; MinPulseWidthCheckSeq &checks = sta_->minPulseWidthChecks(corner); @@ -15807,7 +15807,7 @@ TEST_F(StaDesignTest, R10_MinPulseWidthCheckCorner) { } } -TEST_F(StaDesignTest, R10_MinPulseWidthSlack) { +TEST_F(StaDesignTest, MinPulseWidthSlack3) { CornerSeq &corners = sta_->corners()->corners(); Corner *corner = corners[0]; MinPulseWidthCheck *min_check = sta_->minPulseWidthSlack(corner); @@ -15816,7 +15816,7 @@ TEST_F(StaDesignTest, R10_MinPulseWidthSlack) { // --- GraphLoop: report --- -TEST_F(StaDesignTest, R10_GraphLoopReport) { +TEST_F(StaDesignTest, GraphLoopReport) { sta_->ensureLevelized(); GraphLoopSeq &loops = sta_->graphLoops(); for (GraphLoop *loop : loops) { @@ -15826,7 +15826,7 @@ TEST_F(StaDesignTest, R10_GraphLoopReport) { // --- Sta: makePortPinAfter --- -TEST_F(StaDesignTest, R10_MakePortPinAfter) { +TEST_F(StaDesignTest, MakePortPinAfter) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *pin = network->findPin(top, "clk1"); @@ -15837,7 +15837,7 @@ TEST_F(StaDesignTest, R10_MakePortPinAfter) { // --- Sta: removeDataCheck --- -TEST_F(StaDesignTest, R10_RemoveDataCheck) { +TEST_F(StaDesignTest, RemoveDataCheck) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *from_pin = network->findPin(top, "r1/D"); @@ -15854,7 +15854,7 @@ TEST_F(StaDesignTest, R10_RemoveDataCheck) { // --- PathEnum via multiple path ends --- -TEST_F(StaDesignTest, R10_PathEnum) { +TEST_F(StaDesignTest, PathEnum) { CornerSeq &corners = sta_->corners()->corners(); Corner *corner = corners[0]; PathEndSeq ends = sta_->findPathEnds( @@ -15866,21 +15866,21 @@ TEST_F(StaDesignTest, R10_PathEnum) { // --- EndpointPathEndVisitor --- -TEST_F(StaDesignTest, R10_EndpointPins) { +TEST_F(StaDesignTest, EndpointPins2) { PinSet pins = sta_->endpointPins(); EXPECT_GE(pins.size(), 0u); } // --- FindEndRequiredVisitor, RequiredCmp --- -TEST_F(StaDesignTest, R10_FindRequiredsAgain) { +TEST_F(StaDesignTest, FindRequiredsAgain) { sta_->findRequireds(); sta_->findRequireds(); } // --- FindEndSlackVisitor --- -TEST_F(StaDesignTest, R10_TotalNegativeSlackBothMinMax) { +TEST_F(StaDesignTest, TotalNegativeSlackBothMinMax) { Slack tns_max = sta_->totalNegativeSlack(MinMax::max()); (void)tns_max; Slack tns_min = sta_->totalNegativeSlack(MinMax::min()); @@ -15889,7 +15889,7 @@ TEST_F(StaDesignTest, R10_TotalNegativeSlackBothMinMax) { // --- ReportPath: reportEndpoint for output delay --- -TEST_F(StaDesignTest, R10_ReportPathOutputDelay) { +TEST_F(StaDesignTest, ReportPathOutputDelay) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -15916,7 +15916,7 @@ TEST_F(StaDesignTest, R10_ReportPathOutputDelay) { // --- Sta: writeSdc --- -TEST_F(StaDesignTest, R10_WriteSdc) { +TEST_F(StaDesignTest, WriteSdc2) { const char *filename = "/tmp/test_write_sdc_r10.sdc"; sta_->writeSdc(filename, false, false, 4, false, true); FILE *f = fopen(filename, "r"); @@ -15924,7 +15924,7 @@ TEST_F(StaDesignTest, R10_WriteSdc) { if (f) fclose(f); } -TEST_F(StaDesignTest, R10_WriteSdcWithConstraints) { +TEST_F(StaDesignTest, WriteSdcWithConstraints) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -15951,7 +15951,7 @@ TEST_F(StaDesignTest, R10_WriteSdcWithConstraints) { if (f) fclose(f); } -TEST_F(StaDesignTest, R10_WriteSdcNative) { +TEST_F(StaDesignTest, WriteSdcNative) { const char *filename = "/tmp/test_write_sdc_r10_native.sdc"; sta_->writeSdc(filename, false, true, 4, false, true); FILE *f = fopen(filename, "r"); @@ -15959,7 +15959,7 @@ TEST_F(StaDesignTest, R10_WriteSdcNative) { if (f) fclose(f); } -TEST_F(StaDesignTest, R10_WriteSdcLeaf) { +TEST_F(StaDesignTest, WriteSdcLeaf) { const char *filename = "/tmp/test_write_sdc_r10_leaf.sdc"; sta_->writeSdc(filename, true, false, 4, false, true); FILE *f = fopen(filename, "r"); @@ -15969,7 +15969,7 @@ TEST_F(StaDesignTest, R10_WriteSdcLeaf) { // --- Path ends with sorting --- -TEST_F(StaDesignTest, R10_SaveEnumPath) { +TEST_F(StaDesignTest, SaveEnumPath) { CornerSeq &corners = sta_->corners()->corners(); Corner *corner = corners[0]; PathEndSeq ends = sta_->findPathEnds( @@ -15979,7 +15979,7 @@ TEST_F(StaDesignTest, R10_SaveEnumPath) { (void)ends; } -TEST_F(StaDesignTest, R10_ReportPathLess) { +TEST_F(StaDesignTest, ReportPathLess) { CornerSeq &corners = sta_->corners()->corners(); Corner *corner = corners[0]; PathEndSeq ends = sta_->findPathEnds( @@ -15991,7 +15991,7 @@ TEST_F(StaDesignTest, R10_ReportPathLess) { // --- ClkDelays --- -TEST_F(StaDesignTest, R10_ClkDelaysDelay) { +TEST_F(StaDesignTest, ClkDelaysDelay) { Clock *clk = sta_->sdc()->findClock("clk"); if (clk) { CornerSeq &corners = sta_->corners()->corners(); @@ -16003,7 +16003,7 @@ TEST_F(StaDesignTest, R10_ClkDelaysDelay) { // --- Sta WriteSdc with Derating --- -TEST_F(StaDesignTest, R10_WriteSdcDerating) { +TEST_F(StaDesignTest, WriteSdcDerating) { sta_->setTimingDerate(TimingDerateType::cell_delay, PathClkOrData::data, RiseFallBoth::riseFall(), @@ -16021,7 +16021,7 @@ TEST_F(StaDesignTest, R10_WriteSdcDerating) { // --- Sta WriteSdc with disable edges --- -TEST_F(StaDesignTest, R10_WriteSdcDisableEdge) { +TEST_F(StaDesignTest, WriteSdcDisableEdge) { Graph *graph = sta_->graph(); Vertex *v = findVertex("r1/D"); if (v && graph) { @@ -16040,7 +16040,7 @@ TEST_F(StaDesignTest, R10_WriteSdcDisableEdge) { // --- ClkInfoHash, ClkInfoEqual --- -TEST_F(StaDesignTest, R10_ClkInfoHashEqual) { +TEST_F(StaDesignTest, ClkInfoHashEqual) { Vertex *v = findVertex("r1/CK"); if (v) { VertexPathIterator *iter = sta_->vertexPathIterator(v, RiseFall::rise(), MinMax::max()); @@ -16065,7 +16065,7 @@ TEST_F(StaDesignTest, R10_ClkInfoHashEqual) { // --- Report MPW checks --- -TEST_F(StaDesignTest, R10_ReportMpwChecksAll) { +TEST_F(StaDesignTest, ReportMpwChecksAll) { CornerSeq &corners = sta_->corners()->corners(); Corner *corner = corners[0]; MinPulseWidthCheckSeq &checks = sta_->minPulseWidthChecks(corner); @@ -16075,7 +16075,7 @@ TEST_F(StaDesignTest, R10_ReportMpwChecksAll) { // --- Report min period checks --- -TEST_F(StaDesignTest, R10_ReportMinPeriodChecks) { +TEST_F(StaDesignTest, ReportMinPeriodChecks) { MinPeriodCheckSeq &checks = sta_->minPeriodViolations(); for (auto *check : checks) { sta_->reportCheck(check, false); @@ -16085,7 +16085,7 @@ TEST_F(StaDesignTest, R10_ReportMinPeriodChecks) { // --- Endpoints hold --- -TEST_F(StaDesignTest, R10_FindPathEndsHold) { +TEST_F(StaDesignTest, FindPathEndsHold3) { CornerSeq &corners = sta_->corners()->corners(); Corner *corner = corners[0]; PathEndSeq ends = sta_->findPathEnds( @@ -16102,7 +16102,7 @@ TEST_F(StaDesignTest, R10_FindPathEndsHold) { // --- Report path end as JSON --- -TEST_F(StaDesignTest, R10_ReportPathEndJson) { +TEST_F(StaDesignTest, ReportPathEndJson2) { CornerSeq &corners = sta_->corners()->corners(); Corner *corner = corners[0]; sta_->setReportPathFormat(ReportPathFormat::json); @@ -16119,7 +16119,7 @@ TEST_F(StaDesignTest, R10_ReportPathEndJson) { // --- Report path end shorter --- -TEST_F(StaDesignTest, R10_ReportPathEndShorter) { +TEST_F(StaDesignTest, ReportPathEndShorter) { CornerSeq &corners = sta_->corners()->corners(); Corner *corner = corners[0]; sta_->setReportPathFormat(ReportPathFormat::shorter); @@ -16134,7 +16134,7 @@ TEST_F(StaDesignTest, R10_ReportPathEndShorter) { // --- WriteSdc with clock groups --- -TEST_F(StaDesignTest, R10_WriteSdcWithClockGroups) { +TEST_F(StaDesignTest, WriteSdcWithClockGroups) { Clock *clk = sta_->sdc()->findClock("clk"); if (clk) { ClockGroups *cg = sta_->makeClockGroups("test_group", true, false, false, false, nullptr); @@ -16150,7 +16150,7 @@ TEST_F(StaDesignTest, R10_WriteSdcWithClockGroups) { // --- WriteSdc with inter-clock uncertainty --- -TEST_F(StaDesignTest, R10_WriteSdcInterClkUncertainty) { +TEST_F(StaDesignTest, WriteSdcInterClkUncertainty) { Clock *clk = sta_->sdc()->findClock("clk"); if (clk) { sta_->setClockUncertainty(clk, RiseFallBoth::riseFall(), @@ -16166,7 +16166,7 @@ TEST_F(StaDesignTest, R10_WriteSdcInterClkUncertainty) { // --- WriteSdc with clock latency --- -TEST_F(StaDesignTest, R10_WriteSdcClockLatency) { +TEST_F(StaDesignTest, WriteSdcClockLatency) { Clock *clk = sta_->sdc()->findClock("clk"); if (clk) { sta_->setClockLatency(clk, nullptr, RiseFallBoth::riseFall(), @@ -16184,7 +16184,7 @@ TEST_F(StaDesignTest, R10_WriteSdcClockLatency) { // ============================================================ // --- FindRegister: find register instances --- -TEST_F(StaDesignTest, R10_FindRegisterInstances) { +TEST_F(StaDesignTest, FindRegisterInstances2) { ClockSet *clks = nullptr; // all clocks InstanceSet regs = sta_->findRegisterInstances(clks, RiseFallBoth::riseFall(), true, true); @@ -16193,7 +16193,7 @@ TEST_F(StaDesignTest, R10_FindRegisterInstances) { } // --- FindRegister: data pins --- -TEST_F(StaDesignTest, R10_FindRegisterDataPins) { +TEST_F(StaDesignTest, FindRegisterDataPins2) { ClockSet *clks = nullptr; PinSet data_pins = sta_->findRegisterDataPins(clks, RiseFallBoth::riseFall(), true, true); @@ -16201,7 +16201,7 @@ TEST_F(StaDesignTest, R10_FindRegisterDataPins) { } // --- FindRegister: clock pins --- -TEST_F(StaDesignTest, R10_FindRegisterClkPins) { +TEST_F(StaDesignTest, FindRegisterClkPins2) { ClockSet *clks = nullptr; PinSet clk_pins = sta_->findRegisterClkPins(clks, RiseFallBoth::riseFall(), true, true); @@ -16209,7 +16209,7 @@ TEST_F(StaDesignTest, R10_FindRegisterClkPins) { } // --- FindRegister: async pins --- -TEST_F(StaDesignTest, R10_FindRegisterAsyncPins) { +TEST_F(StaDesignTest, FindRegisterAsyncPins2) { ClockSet *clks = nullptr; PinSet async_pins = sta_->findRegisterAsyncPins(clks, RiseFallBoth::riseFall(), true, true); @@ -16218,7 +16218,7 @@ TEST_F(StaDesignTest, R10_FindRegisterAsyncPins) { } // --- FindRegister: output pins --- -TEST_F(StaDesignTest, R10_FindRegisterOutputPins) { +TEST_F(StaDesignTest, FindRegisterOutputPins2) { ClockSet *clks = nullptr; PinSet out_pins = sta_->findRegisterOutputPins(clks, RiseFallBoth::riseFall(), true, true); @@ -16226,7 +16226,7 @@ TEST_F(StaDesignTest, R10_FindRegisterOutputPins) { } // --- FindRegister: with specific clock --- -TEST_F(StaDesignTest, R10_FindRegisterWithClock) { +TEST_F(StaDesignTest, FindRegisterWithClock) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); ASSERT_NE(clk, nullptr); @@ -16240,7 +16240,7 @@ TEST_F(StaDesignTest, R10_FindRegisterWithClock) { } // --- FindRegister: registers only (no latches) --- -TEST_F(StaDesignTest, R10_FindRegisterRegistersOnly) { +TEST_F(StaDesignTest, FindRegisterRegistersOnly) { ClockSet *clks = nullptr; InstanceSet regs = sta_->findRegisterInstances(clks, RiseFallBoth::riseFall(), true, false); @@ -16248,7 +16248,7 @@ TEST_F(StaDesignTest, R10_FindRegisterRegistersOnly) { } // --- FindRegister: latches only --- -TEST_F(StaDesignTest, R10_FindRegisterLatchesOnly) { +TEST_F(StaDesignTest, FindRegisterLatchesOnly) { ClockSet *clks = nullptr; InstanceSet latches = sta_->findRegisterInstances(clks, RiseFallBoth::riseFall(), false, true); @@ -16256,7 +16256,7 @@ TEST_F(StaDesignTest, R10_FindRegisterLatchesOnly) { } // --- FindFanin/Fanout: fanin pins --- -TEST_F(StaDesignTest, R10_FindFaninPins) { +TEST_F(StaDesignTest, FindFaninPins2) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -16270,7 +16270,7 @@ TEST_F(StaDesignTest, R10_FindFaninPins) { } // --- FindFanin: fanin instances --- -TEST_F(StaDesignTest, R10_FindFaninInstances) { +TEST_F(StaDesignTest, FindFaninInstances2) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -16284,7 +16284,7 @@ TEST_F(StaDesignTest, R10_FindFaninInstances) { } // --- FindFanout: fanout pins --- -TEST_F(StaDesignTest, R10_FindFanoutPins) { +TEST_F(StaDesignTest, FindFanoutPins2) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -16298,7 +16298,7 @@ TEST_F(StaDesignTest, R10_FindFanoutPins) { } // --- FindFanout: fanout instances --- -TEST_F(StaDesignTest, R10_FindFanoutInstances) { +TEST_F(StaDesignTest, FindFanoutInstances2) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -16312,7 +16312,7 @@ TEST_F(StaDesignTest, R10_FindFanoutInstances) { } // --- CmdNamespace: get and set --- -TEST_F(StaDesignTest, R10_CmdNamespace) { +TEST_F(StaDesignTest, CmdNamespace2) { CmdNamespace ns = sta_->cmdNamespace(); // Set to STA namespace sta_->setCmdNamespace(CmdNamespace::sta); @@ -16325,7 +16325,7 @@ TEST_F(StaDesignTest, R10_CmdNamespace) { } // --- Sta: setSlewLimit on clock --- -TEST_F(StaDesignTest, R10_SetSlewLimitClock) { +TEST_F(StaDesignTest, SetSlewLimitClock) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); if (clk) { @@ -16335,7 +16335,7 @@ TEST_F(StaDesignTest, R10_SetSlewLimitClock) { } // --- Sta: setSlewLimit on port --- -TEST_F(StaDesignTest, R10_SetSlewLimitPort) { +TEST_F(StaDesignTest, SetSlewLimitPort) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -16348,7 +16348,7 @@ TEST_F(StaDesignTest, R10_SetSlewLimitPort) { } // --- Sta: setSlewLimit on cell --- -TEST_F(StaDesignTest, R10_SetSlewLimitCell) { +TEST_F(StaDesignTest, SetSlewLimitCell) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -16363,7 +16363,7 @@ TEST_F(StaDesignTest, R10_SetSlewLimitCell) { } // --- Sta: setCapacitanceLimit on cell --- -TEST_F(StaDesignTest, R10_SetCapacitanceLimitCell) { +TEST_F(StaDesignTest, SetCapacitanceLimitCell) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -16378,7 +16378,7 @@ TEST_F(StaDesignTest, R10_SetCapacitanceLimitCell) { } // --- Sta: setCapacitanceLimit on port --- -TEST_F(StaDesignTest, R10_SetCapacitanceLimitPort) { +TEST_F(StaDesignTest, SetCapacitanceLimitPort) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -16391,7 +16391,7 @@ TEST_F(StaDesignTest, R10_SetCapacitanceLimitPort) { } // --- Sta: setCapacitanceLimit on pin --- -TEST_F(StaDesignTest, R10_SetCapacitanceLimitPin) { +TEST_F(StaDesignTest, SetCapacitanceLimitPin) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -16401,7 +16401,7 @@ TEST_F(StaDesignTest, R10_SetCapacitanceLimitPin) { } // --- Sta: setFanoutLimit on cell --- -TEST_F(StaDesignTest, R10_SetFanoutLimitCell) { +TEST_F(StaDesignTest, SetFanoutLimitCell) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -16416,7 +16416,7 @@ TEST_F(StaDesignTest, R10_SetFanoutLimitCell) { } // --- Sta: setFanoutLimit on port --- -TEST_F(StaDesignTest, R10_SetFanoutLimitPort) { +TEST_F(StaDesignTest, SetFanoutLimitPort) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -16429,12 +16429,12 @@ TEST_F(StaDesignTest, R10_SetFanoutLimitPort) { } // --- Sta: setMaxArea --- -TEST_F(StaDesignTest, R10_SetMaxArea) { +TEST_F(StaDesignTest, SetMaxArea) { sta_->setMaxArea(500.0f); } // --- Sta: setMinPulseWidth on clock --- -TEST_F(StaDesignTest, R10_SetMinPulseWidthClock) { +TEST_F(StaDesignTest, SetMinPulseWidthClock) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); if (clk) { @@ -16443,7 +16443,7 @@ TEST_F(StaDesignTest, R10_SetMinPulseWidthClock) { } // --- Sta: MinPeriod checks --- -TEST_F(StaDesignTest, R10_MinPeriodSlack) { +TEST_F(StaDesignTest, MinPeriodSlack3) { MinPeriodCheck *check = sta_->minPeriodSlack(); if (check) { sta_->reportCheck(check, false); @@ -16451,7 +16451,7 @@ TEST_F(StaDesignTest, R10_MinPeriodSlack) { } } -TEST_F(StaDesignTest, R10_MinPeriodViolations) { +TEST_F(StaDesignTest, MinPeriodViolations3) { MinPeriodCheckSeq &viols = sta_->minPeriodViolations(); if (!viols.empty()) { sta_->reportChecks(&viols, false); @@ -16460,7 +16460,7 @@ TEST_F(StaDesignTest, R10_MinPeriodViolations) { } // --- Sta: MaxSkew checks --- -TEST_F(StaDesignTest, R10_MaxSkewSlack) { +TEST_F(StaDesignTest, MaxSkewSlack3) { MaxSkewCheck *check = sta_->maxSkewSlack(); if (check) { sta_->reportCheck(check, false); @@ -16468,7 +16468,7 @@ TEST_F(StaDesignTest, R10_MaxSkewSlack) { } } -TEST_F(StaDesignTest, R10_MaxSkewViolations) { +TEST_F(StaDesignTest, MaxSkewViolations3) { MaxSkewCheckSeq &viols = sta_->maxSkewViolations(); if (!viols.empty()) { sta_->reportChecks(&viols, false); @@ -16477,7 +16477,7 @@ TEST_F(StaDesignTest, R10_MaxSkewViolations) { } // --- Sta: clocks arriving at pin --- -TEST_F(StaDesignTest, R10_ClocksAtPin) { +TEST_F(StaDesignTest, ClocksAtPin) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *clk1 = network->findPin(top, "clk1"); @@ -16488,7 +16488,7 @@ TEST_F(StaDesignTest, R10_ClocksAtPin) { } // --- Sta: isClockSrc --- -TEST_F(StaDesignTest, R10_IsClockSrc) { +TEST_F(StaDesignTest, IsClockSrc) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *clk1 = network->findPin(top, "clk1"); @@ -16504,7 +16504,7 @@ TEST_F(StaDesignTest, R10_IsClockSrc) { } // --- Sta: setPvt and pvt --- -TEST_F(StaDesignTest, R10_SetPvt) { +TEST_F(StaDesignTest, SetPvt2) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -16517,7 +16517,7 @@ TEST_F(StaDesignTest, R10_SetPvt) { } // --- Property: Library and Cell properties --- -TEST_F(StaDesignTest, R10_PropertyLibrary) { +TEST_F(StaDesignTest, PropertyLibrary) { Network *network = sta_->cmdNetwork(); Library *library = network->findLibrary("Nangate45"); if (library) { @@ -16526,7 +16526,7 @@ TEST_F(StaDesignTest, R10_PropertyLibrary) { } } -TEST_F(StaDesignTest, R10_PropertyCell) { +TEST_F(StaDesignTest, PropertyCell) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -16542,7 +16542,7 @@ TEST_F(StaDesignTest, R10_PropertyCell) { } // --- Property: getProperty on Clock --- -TEST_F(StaDesignTest, R10_PropertyClock) { +TEST_F(StaDesignTest, PropertyClock) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); if (clk) { @@ -16556,7 +16556,7 @@ TEST_F(StaDesignTest, R10_PropertyClock) { } // --- MaxSkewCheck: detailed accessors --- -TEST_F(StaDesignTest, R10_MaxSkewCheckDetailedAccessors) { +TEST_F(StaDesignTest, MaxSkewCheckDetailedAccessors) { MaxSkewCheck *check = sta_->maxSkewSlack(); if (check) { const Pin *clk_pin = check->clkPin(sta_); @@ -16571,7 +16571,7 @@ TEST_F(StaDesignTest, R10_MaxSkewCheckDetailedAccessors) { } // --- MinPeriodCheck: detailed accessors --- -TEST_F(StaDesignTest, R10_MinPeriodCheckDetailedAccessors) { +TEST_F(StaDesignTest, MinPeriodCheckDetailedAccessors) { MinPeriodCheck *check = sta_->minPeriodSlack(); if (check) { float min_period = check->minPeriod(sta_); @@ -16586,7 +16586,7 @@ TEST_F(StaDesignTest, R10_MinPeriodCheckDetailedAccessors) { } // --- Sta: WriteSdc with various limits --- -TEST_F(StaDesignTest, R10_WriteSdcWithSlewLimit) { +TEST_F(StaDesignTest, WriteSdcWithSlewLimit) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); if (clk) { @@ -16600,7 +16600,7 @@ TEST_F(StaDesignTest, R10_WriteSdcWithSlewLimit) { if (f) fclose(f); } -TEST_F(StaDesignTest, R10_WriteSdcWithCapLimit) { +TEST_F(StaDesignTest, WriteSdcWithCapLimit) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -16617,7 +16617,7 @@ TEST_F(StaDesignTest, R10_WriteSdcWithCapLimit) { if (f) fclose(f); } -TEST_F(StaDesignTest, R10_WriteSdcWithFanoutLimit) { +TEST_F(StaDesignTest, WriteSdcWithFanoutLimit) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -16635,7 +16635,7 @@ TEST_F(StaDesignTest, R10_WriteSdcWithFanoutLimit) { } // --- Sta: makeGeneratedClock and removeAllClocks --- -TEST_F(StaDesignTest, R10_MakeGeneratedClock) { +TEST_F(StaDesignTest, MakeGeneratedClock) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *clk2 = network->findPin(top, "clk2"); @@ -16655,7 +16655,7 @@ TEST_F(StaDesignTest, R10_MakeGeneratedClock) { } // --- Sta: removeAllClocks --- -TEST_F(StaDesignTest, R10_RemoveAllClocks) { +TEST_F(StaDesignTest, RemoveAllClocks) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); ASSERT_NE(clk, nullptr); @@ -16665,7 +16665,7 @@ TEST_F(StaDesignTest, R10_RemoveAllClocks) { } // --- FindFanin: startpoints only --- -TEST_F(StaDesignTest, R10_FindFaninStartpoints) { +TEST_F(StaDesignTest, FindFaninStartpoints) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -16679,7 +16679,7 @@ TEST_F(StaDesignTest, R10_FindFaninStartpoints) { } // --- FindFanout: endpoints only --- -TEST_F(StaDesignTest, R10_FindFanoutEndpoints) { +TEST_F(StaDesignTest, FindFanoutEndpoints) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -16693,7 +16693,7 @@ TEST_F(StaDesignTest, R10_FindFanoutEndpoints) { } // --- Sta: report unconstrained path ends --- -TEST_F(StaDesignTest, R10_ReportUnconstrained) { +TEST_F(StaDesignTest, ReportUnconstrained) { Corner *corner = sta_->cmdCorner(); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -16714,7 +16714,7 @@ TEST_F(StaDesignTest, R10_ReportUnconstrained) { } // --- Sta: hold path ends --- -TEST_F(StaDesignTest, R10_FindPathEndsHoldVerbose) { +TEST_F(StaDesignTest, FindPathEndsHoldVerbose) { Corner *corner = sta_->cmdCorner(); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -16739,7 +16739,7 @@ TEST_F(StaDesignTest, R10_FindPathEndsHoldVerbose) { // ============================================================ // --- Sta: checkSlewLimits --- -TEST_F(StaDesignTest, R10_CheckSlewLimits) { +TEST_F(StaDesignTest, CheckSlewLimits) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -16763,7 +16763,7 @@ TEST_F(StaDesignTest, R10_CheckSlewLimits) { } // --- Sta: checkSlew on specific pin --- -TEST_F(StaDesignTest, R10_CheckSlewOnPin) { +TEST_F(StaDesignTest, CheckSlewOnPin) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -16783,7 +16783,7 @@ TEST_F(StaDesignTest, R10_CheckSlewOnPin) { } // --- Sta: checkCapacitanceLimits --- -TEST_F(StaDesignTest, R10_CheckCapacitanceLimits) { +TEST_F(StaDesignTest, CheckCapacitanceLimits2) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -16806,7 +16806,7 @@ TEST_F(StaDesignTest, R10_CheckCapacitanceLimits) { } // --- Sta: checkCapacitance on specific pin --- -TEST_F(StaDesignTest, R10_CheckCapacitanceOnPin) { +TEST_F(StaDesignTest, CheckCapacitanceOnPin) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -16823,7 +16823,7 @@ TEST_F(StaDesignTest, R10_CheckCapacitanceOnPin) { } // --- Sta: checkFanoutLimits --- -TEST_F(StaDesignTest, R10_CheckFanoutLimits) { +TEST_F(StaDesignTest, CheckFanoutLimits2) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -16845,7 +16845,7 @@ TEST_F(StaDesignTest, R10_CheckFanoutLimits) { } // --- Sta: checkFanout on specific pin --- -TEST_F(StaDesignTest, R10_CheckFanoutOnPin) { +TEST_F(StaDesignTest, CheckFanoutOnPin) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -16860,7 +16860,7 @@ TEST_F(StaDesignTest, R10_CheckFanoutOnPin) { } // --- Sta: reportClkSkew --- -TEST_F(StaDesignTest, R10_ReportClkSkew) { +TEST_F(StaDesignTest, ReportClkSkew2) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); if (clk) { @@ -16873,13 +16873,13 @@ TEST_F(StaDesignTest, R10_ReportClkSkew) { } // --- Sta: findWorstClkSkew --- -TEST_F(StaDesignTest, R10_FindWorstClkSkew) { +TEST_F(StaDesignTest, FindWorstClkSkew3) { float worst = sta_->findWorstClkSkew(MinMax::max(), false); (void)worst; } // --- Sta: reportClkLatency --- -TEST_F(StaDesignTest, R10_ReportClkLatency) { +TEST_F(StaDesignTest, ReportClkLatency3) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); if (clk) { @@ -16891,7 +16891,7 @@ TEST_F(StaDesignTest, R10_ReportClkLatency) { } // --- Sta: findSlewLimit --- -TEST_F(StaDesignTest, R10_FindSlewLimit) { +TEST_F(StaDesignTest, FindSlewLimit2) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -16913,7 +16913,7 @@ TEST_F(StaDesignTest, R10_FindSlewLimit) { } // --- Sta: MinPulseWidth violations --- -TEST_F(StaDesignTest, R10_MpwViolations) { +TEST_F(StaDesignTest, MpwViolations) { Corner *corner = sta_->cmdCorner(); MinPulseWidthCheckSeq &viols = sta_->minPulseWidthViolations(corner); if (!viols.empty()) { @@ -16923,7 +16923,7 @@ TEST_F(StaDesignTest, R10_MpwViolations) { } // --- Sta: minPulseWidthSlack (all corners) --- -TEST_F(StaDesignTest, R10_MpwSlackAllCorners) { +TEST_F(StaDesignTest, MpwSlackAllCorners) { Corner *corner = sta_->cmdCorner(); MinPulseWidthCheck *check = sta_->minPulseWidthSlack(corner); if (check) { @@ -16933,7 +16933,7 @@ TEST_F(StaDesignTest, R10_MpwSlackAllCorners) { } // --- Sta: minPulseWidthChecks (all) --- -TEST_F(StaDesignTest, R10_MpwChecksAll) { +TEST_F(StaDesignTest, MpwChecksAll) { Corner *corner = sta_->cmdCorner(); MinPulseWidthCheckSeq &checks = sta_->minPulseWidthChecks(corner); if (!checks.empty()) { @@ -16942,7 +16942,7 @@ TEST_F(StaDesignTest, R10_MpwChecksAll) { } // --- Sta: WriteSdc with min pulse width + clock latency + all constraints --- -TEST_F(StaDesignTest, R10_WriteSdcFullConstraints) { +TEST_F(StaDesignTest, WriteSdcFullConstraints) { Sdc *sdc = sta_->sdc(); Clock *clk = sdc->findClock("clk"); Network *network = sta_->cmdNetwork(); @@ -17000,7 +17000,7 @@ TEST_F(StaDesignTest, R10_WriteSdcFullConstraints) { } // --- Sta: Property getProperty on edge --- -TEST_F(StaDesignTest, R10_PropertyEdge) { +TEST_F(StaDesignTest, PropertyEdge) { Network *network = sta_->cmdNetwork(); Graph *graph = sta_->graph(); Instance *top = network->topInstance(); @@ -17021,7 +17021,7 @@ TEST_F(StaDesignTest, R10_PropertyEdge) { } // --- Sta: Property getProperty on net --- -TEST_F(StaDesignTest, R10_PropertyNet) { +TEST_F(StaDesignTest, PropertyNet) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); NetIterator *net_iter = network->netIterator(top); @@ -17034,7 +17034,7 @@ TEST_F(StaDesignTest, R10_PropertyNet) { } // --- Sta: Property getProperty on port --- -TEST_F(StaDesignTest, R10_PropertyPort) { +TEST_F(StaDesignTest, PropertyPort) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -17050,7 +17050,7 @@ TEST_F(StaDesignTest, R10_PropertyPort) { } // --- Sta: Property getProperty on LibertyCell --- -TEST_F(StaDesignTest, R10_PropertyLibertyCell) { +TEST_F(StaDesignTest, PropertyLibertyCell) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -17068,7 +17068,7 @@ TEST_F(StaDesignTest, R10_PropertyLibertyCell) { } // --- Sta: Property getProperty on LibertyPort --- -TEST_F(StaDesignTest, R10_PropertyLibertyPort) { +TEST_F(StaDesignTest, PropertyLibertyPort) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -17090,7 +17090,7 @@ TEST_F(StaDesignTest, R10_PropertyLibertyPort) { } // --- Sta: Property getProperty on LibertyLibrary --- -TEST_F(StaDesignTest, R10_PropertyLibertyLibrary) { +TEST_F(StaDesignTest, PropertyLibertyLibrary) { Network *network = sta_->cmdNetwork(); LibertyLibraryIterator *lib_iter = network->libertyLibraryIterator(); if (lib_iter->hasNext()) { @@ -17102,7 +17102,7 @@ TEST_F(StaDesignTest, R10_PropertyLibertyLibrary) { } // --- Sta: Property getProperty on instance --- -TEST_F(StaDesignTest, R10_PropertyInstance) { +TEST_F(StaDesignTest, PropertyInstance) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -17115,7 +17115,7 @@ TEST_F(StaDesignTest, R10_PropertyInstance) { } // --- Sta: Property getProperty on TimingArcSet --- -TEST_F(StaDesignTest, R10_PropertyTimingArcSet) { +TEST_F(StaDesignTest, PropertyTimingArcSet) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -17134,7 +17134,7 @@ TEST_F(StaDesignTest, R10_PropertyTimingArcSet) { } // --- Sta: Property getProperty on PathEnd --- -TEST_F(StaDesignTest, R10_PropertyPathEnd) { +TEST_F(StaDesignTest, PropertyPathEnd) { Corner *corner = sta_->cmdCorner(); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -17155,7 +17155,7 @@ TEST_F(StaDesignTest, R10_PropertyPathEnd) { } // --- Sta: Property getProperty on Path --- -TEST_F(StaDesignTest, R10_PropertyPath) { +TEST_F(StaDesignTest, PropertyPath) { Corner *corner = sta_->cmdCorner(); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, @@ -17181,7 +17181,7 @@ TEST_F(StaDesignTest, R10_PropertyPath) { // ============================================================ // --- Properties::getProperty on Pin: arrival, slack, slew --- -TEST_F(StaDesignTest, R11_PropertiesGetPropertyPin) { +TEST_F(StaDesignTest, PropertiesGetPropertyPin) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -17215,7 +17215,7 @@ TEST_F(StaDesignTest, R11_PropertiesGetPropertyPin) { } // --- Properties::getProperty on Cell --- -TEST_F(StaDesignTest, R11_PropertiesGetPropertyCell) { +TEST_F(StaDesignTest, PropertiesGetPropertyCell) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); InstanceChildIterator *iter = network->childIterator(top); @@ -17231,7 +17231,7 @@ TEST_F(StaDesignTest, R11_PropertiesGetPropertyCell) { } // --- Properties::getProperty on Library --- -TEST_F(StaDesignTest, R11_PropertiesGetPropertyLibrary) { +TEST_F(StaDesignTest, PropertiesGetPropertyLibrary) { Network *network = sta_->cmdNetwork(); Library *lib = network->findLibrary("Nangate45_typ"); if (lib) { @@ -17241,7 +17241,7 @@ TEST_F(StaDesignTest, R11_PropertiesGetPropertyLibrary) { } // --- PropertyUnknown exception --- -TEST_F(StaDesignTest, R11_PropertyUnknown) { +TEST_F(StaDesignTest, PropertyUnknown) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -17257,7 +17257,7 @@ TEST_F(StaDesignTest, R11_PropertyUnknown) { } // --- Sta::reportClkSkew (triggers clkSkewPreamble) --- -TEST_F(StaDesignTest, R11_ReportClkSkew) { +TEST_F(StaDesignTest, ReportClkSkew3) { Clock *clk = sta_->sdc()->findClock("clk"); if (clk) { ConstClockSeq clks; @@ -17269,7 +17269,7 @@ TEST_F(StaDesignTest, R11_ReportClkSkew) { } // --- Sta::findWorstClkSkew --- -TEST_F(StaDesignTest, R11_FindWorstClkSkew) { +TEST_F(StaDesignTest, FindWorstClkSkew4) { float skew = sta_->findWorstClkSkew(MinMax::max(), false); (void)skew; float skew2 = sta_->findWorstClkSkew(MinMax::min(), false); @@ -17277,7 +17277,7 @@ TEST_F(StaDesignTest, R11_FindWorstClkSkew) { } // --- Sta::reportClkLatency --- -TEST_F(StaDesignTest, R11_ReportClkLatency) { +TEST_F(StaDesignTest, ReportClkLatency4) { Clock *clk = sta_->sdc()->findClock("clk"); if (clk) { ConstClockSeq clks; @@ -17289,7 +17289,7 @@ TEST_F(StaDesignTest, R11_ReportClkLatency) { } // --- Sta: propagated clock detection --- -TEST_F(StaDesignTest, R11_PropagatedClockDetection) { +TEST_F(StaDesignTest, PropagatedClockDetection) { Clock *clk = sta_->sdc()->findClock("clk"); if (clk) { bool prop = clk->isPropagated(); @@ -17298,7 +17298,7 @@ TEST_F(StaDesignTest, R11_PropagatedClockDetection) { } // --- Sta::removeDataCheck --- -TEST_F(StaDesignTest, R11_StaRemoveDataCheck) { +TEST_F(StaDesignTest, StaRemoveDataCheck) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *from_pin = network->findPin(top, "r1/D"); @@ -17315,7 +17315,7 @@ TEST_F(StaDesignTest, R11_StaRemoveDataCheck) { // --- PathEnd methods: targetClk, targetClkArrival, targetClkDelay, // targetClkInsertionDelay, targetClkUncertainty, targetClkMcpAdjustment --- -TEST_F(StaDesignTest, R11_PathEndTargetClkMethods) { +TEST_F(StaDesignTest, PathEndTargetClkMethods2) { Corner *corner = sta_->cmdCorner(); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, corner, MinMaxAll::max(), @@ -17344,7 +17344,7 @@ TEST_F(StaDesignTest, R11_PathEndTargetClkMethods) { } // --- PathExpanded::pathsIndex --- -TEST_F(StaDesignTest, R11_PathExpandedPathsIndex) { +TEST_F(StaDesignTest, PathExpandedPathsIndex) { Corner *corner = sta_->cmdCorner(); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, corner, MinMaxAll::max(), @@ -17372,7 +17372,7 @@ TEST_F(StaDesignTest, R11_PathExpandedPathsIndex) { } // --- Report path end with format full_clock --- -TEST_F(StaDesignTest, R11_ReportPathEndFullClock) { +TEST_F(StaDesignTest, ReportPathEndFullClock) { Corner *corner = sta_->cmdCorner(); sta_->setReportPathFormat(ReportPathFormat::full_clock); PathEndSeq ends = sta_->findPathEnds( @@ -17387,7 +17387,7 @@ TEST_F(StaDesignTest, R11_ReportPathEndFullClock) { } // --- Report path end with format full_clock_expanded --- -TEST_F(StaDesignTest, R11_ReportPathEndFullClockExpanded) { +TEST_F(StaDesignTest, ReportPathEndFullClockExpanded) { Corner *corner = sta_->cmdCorner(); sta_->setReportPathFormat(ReportPathFormat::full_clock_expanded); PathEndSeq ends = sta_->findPathEnds( @@ -17402,7 +17402,7 @@ TEST_F(StaDesignTest, R11_ReportPathEndFullClockExpanded) { } // --- Report path end with format end --- -TEST_F(StaDesignTest, R11_ReportPathEndEnd) { +TEST_F(StaDesignTest, ReportPathEndEnd) { Corner *corner = sta_->cmdCorner(); sta_->setReportPathFormat(ReportPathFormat::endpoint); PathEndSeq ends = sta_->findPathEnds( @@ -17417,7 +17417,7 @@ TEST_F(StaDesignTest, R11_ReportPathEndEnd) { } // --- Report path end with format summary --- -TEST_F(StaDesignTest, R11_ReportPathEndSummary) { +TEST_F(StaDesignTest, ReportPathEndSummary2) { Corner *corner = sta_->cmdCorner(); sta_->setReportPathFormat(ReportPathFormat::summary); PathEndSeq ends = sta_->findPathEnds( @@ -17432,7 +17432,7 @@ TEST_F(StaDesignTest, R11_ReportPathEndSummary) { } // --- Report path end with format slack_only --- -TEST_F(StaDesignTest, R11_ReportPathEndSlackOnly) { +TEST_F(StaDesignTest, ReportPathEndSlackOnly2) { Corner *corner = sta_->cmdCorner(); sta_->setReportPathFormat(ReportPathFormat::slack_only); PathEndSeq ends = sta_->findPathEnds( @@ -17447,7 +17447,7 @@ TEST_F(StaDesignTest, R11_ReportPathEndSlackOnly) { } // --- Report multiple path ends --- -TEST_F(StaDesignTest, R11_ReportPathEnds) { +TEST_F(StaDesignTest, ReportPathEnds3) { Corner *corner = sta_->cmdCorner(); sta_->setReportPathFormat(ReportPathFormat::full); PathEndSeq ends = sta_->findPathEnds( @@ -17460,7 +17460,7 @@ TEST_F(StaDesignTest, R11_ReportPathEnds) { } // --- Sta: worstSlack --- -TEST_F(StaDesignTest, R11_WorstSlack) { +TEST_F(StaDesignTest, WorstSlack2) { Slack ws_max = sta_->worstSlack(MinMax::max()); (void)ws_max; Slack ws_min = sta_->worstSlack(MinMax::min()); @@ -17468,7 +17468,7 @@ TEST_F(StaDesignTest, R11_WorstSlack) { } // --- Sta: worstSlack with corner --- -TEST_F(StaDesignTest, R11_WorstSlackCorner) { +TEST_F(StaDesignTest, WorstSlackCorner2) { Corner *corner = sta_->cmdCorner(); Slack ws; Vertex *v; @@ -17478,7 +17478,7 @@ TEST_F(StaDesignTest, R11_WorstSlackCorner) { } // --- Sta: totalNegativeSlack --- -TEST_F(StaDesignTest, R11_TotalNegativeSlack) { +TEST_F(StaDesignTest, TotalNegativeSlack2) { Slack tns = sta_->totalNegativeSlack(MinMax::max()); (void)tns; Slack tns2 = sta_->totalNegativeSlack(MinMax::min()); @@ -17486,14 +17486,14 @@ TEST_F(StaDesignTest, R11_TotalNegativeSlack) { } // --- Sta: totalNegativeSlack with corner --- -TEST_F(StaDesignTest, R11_TotalNegativeSlackCorner) { +TEST_F(StaDesignTest, TotalNegativeSlackCorner2) { Corner *corner = sta_->cmdCorner(); Slack tns = sta_->totalNegativeSlack(corner, MinMax::max()); (void)tns; } // --- WriteSdc with many constraints from search side --- -TEST_F(StaDesignTest, R11_WriteSdcComprehensive) { +TEST_F(StaDesignTest, WriteSdcComprehensive) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Corner *corner = sta_->cmdCorner(); @@ -17600,7 +17600,7 @@ TEST_F(StaDesignTest, R11_WriteSdcComprehensive) { } // --- Sta: report path with verbose format --- -TEST_F(StaDesignTest, R11_ReportPathVerbose) { +TEST_F(StaDesignTest, ReportPathVerbose) { Corner *corner = sta_->cmdCorner(); sta_->setReportPathFormat(ReportPathFormat::full); PathEndSeq ends = sta_->findPathEnds( @@ -17615,7 +17615,7 @@ TEST_F(StaDesignTest, R11_ReportPathVerbose) { } // --- Sta: report path for hold (min) --- -TEST_F(StaDesignTest, R11_ReportPathHold) { +TEST_F(StaDesignTest, ReportPathHold) { Corner *corner = sta_->cmdCorner(); sta_->setReportPathFormat(ReportPathFormat::full); PathEndSeq ends = sta_->findPathEnds( @@ -17630,7 +17630,7 @@ TEST_F(StaDesignTest, R11_ReportPathHold) { } // --- Sta: max skew checks with report --- -TEST_F(StaDesignTest, R11_MaxSkewChecksReport) { +TEST_F(StaDesignTest, MaxSkewChecksReport) { MaxSkewCheckSeq &viols = sta_->maxSkewViolations(); for (auto *check : viols) { sta_->reportCheck(check, true); @@ -17644,7 +17644,7 @@ TEST_F(StaDesignTest, R11_MaxSkewChecksReport) { } // --- Sta: min period checks with report --- -TEST_F(StaDesignTest, R11_MinPeriodChecksReport) { +TEST_F(StaDesignTest, MinPeriodChecksReport) { MinPeriodCheckSeq &viols = sta_->minPeriodViolations(); for (auto *check : viols) { sta_->reportCheck(check, true); @@ -17658,7 +17658,7 @@ TEST_F(StaDesignTest, R11_MinPeriodChecksReport) { } // --- Sta: MPW slack check --- -TEST_F(StaDesignTest, R11_MpwSlackCheck) { +TEST_F(StaDesignTest, MpwSlackCheck) { Corner *corner = sta_->cmdCorner(); MinPulseWidthCheck *check = sta_->minPulseWidthSlack(corner); if (check) { @@ -17668,7 +17668,7 @@ TEST_F(StaDesignTest, R11_MpwSlackCheck) { } // --- Sta: MPW checks on all --- -TEST_F(StaDesignTest, R11_MpwChecksAll) { +TEST_F(StaDesignTest, MpwChecksAll2) { Corner *corner = sta_->cmdCorner(); MinPulseWidthCheckSeq &checks = sta_->minPulseWidthChecks(corner); sta_->reportMpwChecks(&checks, false); @@ -17676,7 +17676,7 @@ TEST_F(StaDesignTest, R11_MpwChecksAll) { } // --- Sta: MPW violations --- -TEST_F(StaDesignTest, R11_MpwViolations) { +TEST_F(StaDesignTest, MpwViolations2) { Corner *corner = sta_->cmdCorner(); MinPulseWidthCheckSeq &viols = sta_->minPulseWidthViolations(corner); if (!viols.empty()) { @@ -17685,13 +17685,13 @@ TEST_F(StaDesignTest, R11_MpwViolations) { } // --- Sta: check timing --- -TEST_F(StaDesignTest, R11_CheckTiming) { +TEST_F(StaDesignTest, CheckTiming3) { CheckErrorSeq &errors = sta_->checkTiming(true, true, true, true, true, true, true); (void)errors; } // --- Sta: find path ends with output delay --- -TEST_F(StaDesignTest, R11_FindPathEndsWithOutputDelay) { +TEST_F(StaDesignTest, FindPathEndsWithOutputDelay) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *out = network->findPin(top, "out"); @@ -17718,7 +17718,7 @@ TEST_F(StaDesignTest, R11_FindPathEndsWithOutputDelay) { } // --- PathEnd: type and typeName --- -TEST_F(StaDesignTest, R11_PathEndTypeInfo) { +TEST_F(StaDesignTest, PathEndTypeInfo) { Corner *corner = sta_->cmdCorner(); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, corner, MinMaxAll::max(), @@ -17735,7 +17735,7 @@ TEST_F(StaDesignTest, R11_PathEndTypeInfo) { } // --- Sta: find path ends unconstrained --- -TEST_F(StaDesignTest, R11_FindPathEndsUnconstrained) { +TEST_F(StaDesignTest, FindPathEndsUnconstrained3) { Corner *corner = sta_->cmdCorner(); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, corner, MinMaxAll::max(), @@ -17754,7 +17754,7 @@ TEST_F(StaDesignTest, R11_FindPathEndsUnconstrained) { } // --- Sta: find path ends with group filter --- -TEST_F(StaDesignTest, R11_FindPathEndsGroupFilter) { +TEST_F(StaDesignTest, FindPathEndsGroupFilter) { // Create a group path first sta_->makeGroupPath("r11_grp", false, nullptr, nullptr, nullptr, nullptr); Corner *corner = sta_->cmdCorner(); @@ -17766,7 +17766,7 @@ TEST_F(StaDesignTest, R11_FindPathEndsGroupFilter) { } // --- Sta: pathGroupNames --- -TEST_F(StaDesignTest, R11_PathGroupNames) { +TEST_F(StaDesignTest, PathGroupNames) { sta_->makeGroupPath("test_group_r11", false, nullptr, nullptr, nullptr, nullptr); StdStringSeq names = sta_->pathGroupNames(); bool found = false; @@ -17778,7 +17778,7 @@ TEST_F(StaDesignTest, R11_PathGroupNames) { } // --- Sta: isPathGroupName --- -TEST_F(StaDesignTest, R11_IsPathGroupName) { +TEST_F(StaDesignTest, IsPathGroupName) { sta_->makeGroupPath("test_pg_r11", false, nullptr, nullptr, nullptr, nullptr); bool is_group = sta_->isPathGroupName("test_pg_r11"); EXPECT_TRUE(is_group); @@ -17787,7 +17787,7 @@ TEST_F(StaDesignTest, R11_IsPathGroupName) { } // --- Sta: report path with max_delay constraint --- -TEST_F(StaDesignTest, R11_ReportPathWithMaxDelay) { +TEST_F(StaDesignTest, ReportPathWithMaxDelay) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -17821,7 +17821,7 @@ TEST_F(StaDesignTest, R11_ReportPathWithMaxDelay) { } // --- ClkInfo accessors via tag on vertex path --- -TEST_F(StaDesignTest, R11_ClkInfoAccessors) { +TEST_F(StaDesignTest, ClkInfoAccessors4) { Vertex *v = findVertex("r1/CK"); if (v) { VertexPathIterator *iter = sta_->vertexPathIterator(v, RiseFall::rise(), @@ -17848,7 +17848,7 @@ TEST_F(StaDesignTest, R11_ClkInfoAccessors) { } // --- Sta: WriteSdc with clock sense from search --- -TEST_F(StaDesignTest, R11_WriteSdcClockSense) { +TEST_F(StaDesignTest, WriteSdcClockSense) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *clk1 = network->findPin(top, "clk1"); @@ -17868,7 +17868,7 @@ TEST_F(StaDesignTest, R11_WriteSdcClockSense) { } // --- Sta: WriteSdc with driving cell --- -TEST_F(StaDesignTest, R11_WriteSdcDrivingCell) { +TEST_F(StaDesignTest, WriteSdcDrivingCell) { Network *network = sta_->cmdNetwork(); Instance *top = network->topInstance(); Pin *in1 = network->findPin(top, "in1"); @@ -17900,7 +17900,7 @@ TEST_F(StaDesignTest, R11_WriteSdcDrivingCell) { } // --- Sta: report path end with reportPath --- -TEST_F(StaDesignTest, R11_ReportPath) { +TEST_F(StaDesignTest, ReportPath2) { Corner *corner = sta_->cmdCorner(); PathEndSeq ends = sta_->findPathEnds( nullptr, nullptr, nullptr, false, corner, MinMaxAll::max(), @@ -17915,7 +17915,7 @@ TEST_F(StaDesignTest, R11_ReportPath) { } // --- Sta: propagated clock and report --- -TEST_F(StaDesignTest, R11_PropagatedClockReport) { +TEST_F(StaDesignTest, PropagatedClockReport) { Clock *clk = sta_->sdc()->findClock("clk"); if (clk) { sta_->setPropagatedClock(clk); @@ -17938,7 +17938,7 @@ TEST_F(StaDesignTest, R11_PropagatedClockReport) { } // --- Sta: setCmdNamespace to STA (covers setCmdNamespace1) --- -TEST_F(StaDesignTest, R11_SetCmdNamespace) { +TEST_F(StaDesignTest, SetCmdNamespace) { CmdNamespace orig = sta_->cmdNamespace(); sta_->setCmdNamespace(CmdNamespace::sta); EXPECT_EQ(sta_->cmdNamespace(), CmdNamespace::sta); @@ -17948,7 +17948,7 @@ TEST_F(StaDesignTest, R11_SetCmdNamespace) { } // --- Sta: endpoints --- -TEST_F(StaDesignTest, R11_Endpoints) { +TEST_F(StaDesignTest, Endpoints2) { VertexSet *eps = sta_->endpoints(); EXPECT_NE(eps, nullptr); if (eps) @@ -17956,7 +17956,7 @@ TEST_F(StaDesignTest, R11_Endpoints) { } // --- Sta: worst slack vertex --- -TEST_F(StaDesignTest, R11_WorstSlackVertex) { +TEST_F(StaDesignTest, WorstSlackVertex) { Slack ws; Vertex *v; sta_->worstSlack(MinMax::max(), ws, v); diff --git a/spice/test/cpp/TestSpice.cc b/spice/test/cpp/TestSpice.cc index 811a99b8..8fa8b011 100644 --- a/spice/test/cpp/TestSpice.cc +++ b/spice/test/cpp/TestSpice.cc @@ -1,6 +1,7 @@ #include #include #include +#include #include "MinMax.hh" #include "Transition.hh" @@ -33,7 +34,11 @@ TEST_F(SpiceSmokeTest, TransitionNames) { class StreamPrintTest : public ::testing::Test { protected: void SetUp() override { - tmpfile_ = std::tmpnam(nullptr); + char tmpl[] = "/tmp/sta_spice_test_XXXXXX"; + int fd = mkstemp(tmpl); + ASSERT_NE(fd, -1); + close(fd); + tmpfile_ = tmpl; } void TearDown() override { std::remove(tmpfile_.c_str()); @@ -97,7 +102,11 @@ TEST_F(StreamPrintTest, MultipleWrites) { class XyceCsvTest : public ::testing::Test { protected: void SetUp() override { - tmpfile_ = std::tmpnam(nullptr); + char tmpl[] = "/tmp/sta_xyce_test_XXXXXX"; + int fd = mkstemp(tmpl); + ASSERT_NE(fd, -1); + close(fd); + tmpfile_ = tmpl; } void TearDown() override { std::remove(tmpfile_.c_str()); @@ -465,7 +474,7 @@ TEST_F(SpiceSmokeTest, MinMaxCompare) { } // Test RiseFall find -TEST_F(SpiceSmokeTest, R5_RiseFallFind) { +TEST_F(SpiceSmokeTest, RiseFallFind) { EXPECT_EQ(RiseFall::find("rise"), RiseFall::rise()); EXPECT_EQ(RiseFall::find("fall"), RiseFall::fall()); EXPECT_EQ(RiseFall::find("^"), RiseFall::rise()); @@ -474,13 +483,13 @@ TEST_F(SpiceSmokeTest, R5_RiseFallFind) { } // Test Transition find used in spice -TEST_F(SpiceSmokeTest, R5_TransitionFind) { +TEST_F(SpiceSmokeTest, TransitionFind) { EXPECT_EQ(Transition::find("^"), Transition::rise()); EXPECT_EQ(Transition::find("v"), Transition::fall()); } // Test streamPrint with empty format -TEST_F(StreamPrintTest, R5_EmptyFormat) { +TEST_F(StreamPrintTest, EmptyFormat) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, "%s", ""); @@ -493,7 +502,7 @@ TEST_F(StreamPrintTest, R5_EmptyFormat) { } // Test streamPrint with integer formatting -TEST_F(StreamPrintTest, R5_IntegerFormatting) { +TEST_F(StreamPrintTest, IntegerFormatting) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, "R%d %d %d %.2f\n", 1, 10, 20, 100.5); @@ -506,7 +515,7 @@ TEST_F(StreamPrintTest, R5_IntegerFormatting) { } // Test streamPrint with multiple lines -TEST_F(StreamPrintTest, R5_MultipleLines) { +TEST_F(StreamPrintTest, MultipleLines) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, "line1\n"); @@ -525,7 +534,7 @@ TEST_F(StreamPrintTest, R5_MultipleLines) { } // Test streamPrint with special characters -TEST_F(StreamPrintTest, R5_SpecialChars) { +TEST_F(StreamPrintTest, SpecialChars) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, "* SPICE deck for %s\n", "test_design"); @@ -538,7 +547,7 @@ TEST_F(StreamPrintTest, R5_SpecialChars) { } // Test RiseFall index constants used by spice -TEST_F(SpiceSmokeTest, R5_RiseFallIndexConstants) { +TEST_F(SpiceSmokeTest, RiseFallIndexConstants) { EXPECT_EQ(RiseFall::riseIndex(), 0); EXPECT_EQ(RiseFall::fallIndex(), 1); // index_count is a static constexpr, verify via range size @@ -546,7 +555,7 @@ TEST_F(SpiceSmokeTest, R5_RiseFallIndexConstants) { } // Test RiseFall range iteration used in spice -TEST_F(SpiceSmokeTest, R5_RiseFallRange) { +TEST_F(SpiceSmokeTest, RiseFallRange2) { int count = 0; for (auto rf : RiseFall::range()) { EXPECT_NE(rf, nullptr); @@ -556,20 +565,20 @@ TEST_F(SpiceSmokeTest, R5_RiseFallRange) { } // Test RiseFallBoth range -TEST_F(SpiceSmokeTest, R5_RiseFallBothRange) { +TEST_F(SpiceSmokeTest, RiseFallBothRange) { EXPECT_NE(RiseFallBoth::rise(), nullptr); EXPECT_NE(RiseFallBoth::fall(), nullptr); EXPECT_NE(RiseFallBoth::riseFall(), nullptr); } // Test Transition init strings used in WriteSpice -TEST_F(SpiceSmokeTest, R5_TransitionInitFinalStrings) { +TEST_F(SpiceSmokeTest, TransitionInitFinalStrings) { EXPECT_NE(Transition::rise()->asInitFinalString(), nullptr); EXPECT_NE(Transition::fall()->asInitFinalString(), nullptr); } // Test MinMax initValue used in spice -TEST_F(SpiceSmokeTest, R5_MinMaxInitValue) { +TEST_F(SpiceSmokeTest, MinMaxInitValue) { float min_init = MinMax::min()->initValue(); float max_init = MinMax::max()->initValue(); EXPECT_GT(min_init, 0.0f); @@ -577,7 +586,7 @@ TEST_F(SpiceSmokeTest, R5_MinMaxInitValue) { } // Test MinMax opposite used in spice -TEST_F(SpiceSmokeTest, R5_MinMaxOpposite) { +TEST_F(SpiceSmokeTest, MinMaxOpposite) { EXPECT_EQ(MinMax::min()->opposite(), MinMax::max()); EXPECT_EQ(MinMax::max()->opposite(), MinMax::min()); } @@ -588,7 +597,7 @@ TEST_F(SpiceSmokeTest, R5_MinMaxOpposite) { // Test streamPrint with wide variety of format specifiers // Covers: streamPrint with many format types -TEST_F(StreamPrintTest, R6_FormatSpecifiers) { +TEST_F(StreamPrintTest, FormatSpecifiers) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, "%c %s %d %f %e %g\n", 'A', "test", 42, 3.14, 1.5e-12, 1.8); @@ -604,7 +613,7 @@ TEST_F(StreamPrintTest, R6_FormatSpecifiers) { // Test streamPrint with SPICE node naming // Covers: streamPrint for SPICE net naming patterns -TEST_F(StreamPrintTest, R6_SpiceNodeNaming) { +TEST_F(StreamPrintTest, SpiceNodeNaming) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, "C%d %s %s %.4e\n", 1, "n_top/sub/net:1", "0", 1.5e-15); @@ -619,7 +628,7 @@ TEST_F(StreamPrintTest, R6_SpiceNodeNaming) { // Test streamPrint with SPICE .include directive // Covers: streamPrint for SPICE directives -TEST_F(StreamPrintTest, R6_SpiceIncludeDirective) { +TEST_F(StreamPrintTest, SpiceIncludeDirective) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, ".include \"%s\"\n", "/path/to/models.spice"); @@ -634,7 +643,7 @@ TEST_F(StreamPrintTest, R6_SpiceIncludeDirective) { // Test streamPrint SPICE voltage source // Covers: streamPrint for voltage sources -TEST_F(StreamPrintTest, R6_SpiceVoltageSource) { +TEST_F(StreamPrintTest, SpiceVoltageSource) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, "v%s %s 0 %.3f\n", "dd", "vdd", 1.800); @@ -648,7 +657,7 @@ TEST_F(StreamPrintTest, R6_SpiceVoltageSource) { // Test streamPrint SPICE .tran with detailed parameters // Covers: streamPrint for transient analysis -TEST_F(StreamPrintTest, R6_SpiceTransAnalysis) { +TEST_F(StreamPrintTest, SpiceTransAnalysis) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, ".tran %g %g %g %g\n", 1e-13, 5e-9, 0.0, 1e-12); @@ -662,7 +671,7 @@ TEST_F(StreamPrintTest, R6_SpiceTransAnalysis) { // Test streamPrint SPICE PWL source // Covers: streamPrint with PWL voltage source -TEST_F(StreamPrintTest, R6_SpicePWLSource) { +TEST_F(StreamPrintTest, SpicePWLSource) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, "v_in in 0 PWL(\n"); @@ -680,7 +689,7 @@ TEST_F(StreamPrintTest, R6_SpicePWLSource) { // Test readXyceCsv with precision values // Covers: readXyceCsv parsing -TEST_F(XyceCsvTest, R6_ReadPrecisionValues) { +TEST_F(XyceCsvTest, ReadPrecisionValues) { { std::ofstream out(tmpfile_); out << "TIME,V(out)\n"; @@ -701,7 +710,7 @@ TEST_F(XyceCsvTest, R6_ReadPrecisionValues) { // Test readXyceCsv with many signals // Covers: readXyceCsv with wide data -TEST_F(XyceCsvTest, R6_ReadManySignals) { +TEST_F(XyceCsvTest, ReadManySignals) { { std::ofstream out(tmpfile_); out << "TIME"; @@ -727,7 +736,7 @@ TEST_F(XyceCsvTest, R6_ReadManySignals) { // Test Transition asRiseFall returns correct mapping for all types // Covers: Transition::asRiseFall for spice -TEST_F(SpiceSmokeTest, R6_TransitionAsRiseFallMapping) { +TEST_F(SpiceSmokeTest, TransitionAsRiseFallMapping) { // Rise-type transitions EXPECT_EQ(Transition::rise()->asRiseFall(), RiseFall::rise()); EXPECT_EQ(Transition::tr0Z()->asRiseFall(), RiseFall::rise()); @@ -749,7 +758,7 @@ TEST_F(SpiceSmokeTest, R6_TransitionAsRiseFallMapping) { // Test MinMax compare function exhaustively // Covers: MinMax::compare -TEST_F(SpiceSmokeTest, R6_MinMaxCompareExhaustive) { +TEST_F(SpiceSmokeTest, MinMaxCompareExhaustive) { // min: true when v1 < v2 EXPECT_TRUE(MinMax::min()->compare(-1.0f, 0.0f)); EXPECT_TRUE(MinMax::min()->compare(0.0f, 1.0f)); @@ -765,7 +774,7 @@ TEST_F(SpiceSmokeTest, R6_MinMaxCompareExhaustive) { // Test MinMax find by string name // Covers: MinMax::find -TEST_F(SpiceSmokeTest, R6_MinMaxFindByName) { +TEST_F(SpiceSmokeTest, MinMaxFindByName) { EXPECT_EQ(MinMax::find("min"), MinMax::min()); EXPECT_EQ(MinMax::find("max"), MinMax::max()); EXPECT_EQ(MinMax::find("unknown"), nullptr); @@ -773,14 +782,14 @@ TEST_F(SpiceSmokeTest, R6_MinMaxFindByName) { // Test MinMax to_string // Covers: MinMax::to_string -TEST_F(SpiceSmokeTest, R6_MinMaxToString) { +TEST_F(SpiceSmokeTest, MinMaxToString) { EXPECT_EQ(MinMax::min()->to_string(), "min"); EXPECT_EQ(MinMax::max()->to_string(), "max"); } // Test RiseFall shortName // Covers: RiseFall::shortName -TEST_F(SpiceSmokeTest, R6_RiseFallShortName) { +TEST_F(SpiceSmokeTest, RiseFallShortName) { EXPECT_STREQ(RiseFall::rise()->shortName(), "^"); EXPECT_STREQ(RiseFall::fall()->shortName(), "v"); } @@ -791,7 +800,7 @@ TEST_F(SpiceSmokeTest, R6_RiseFallShortName) { // Test streamPrint with SPICE transistor format (used in writeParasiticNetwork) // Covers: streamPrint paths used by WriteSpice -TEST_F(StreamPrintTest, R8_SpiceTransistorFormat) { +TEST_F(StreamPrintTest, SpiceTransistorFormat) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, "M%d %s %s %s %s %s W=%.3e L=%.3e\n", @@ -809,7 +818,7 @@ TEST_F(StreamPrintTest, R8_SpiceTransistorFormat) { // Test streamPrint with SPICE capacitor format (used in writeParasiticNetwork) // Covers: streamPrint paths used by WriteSpice::writeParasiticNetwork -TEST_F(StreamPrintTest, R8_SpiceCapacitorFormat) { +TEST_F(StreamPrintTest, SpiceCapacitorFormat) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, "C%d %s %s %.4e\n", 1, "net1:1", "0", 1.5e-15); @@ -826,7 +835,7 @@ TEST_F(StreamPrintTest, R8_SpiceCapacitorFormat) { // Test streamPrint with SPICE voltage source (used in writeClkedStepSource) // Covers: streamPrint paths used by WriteSpice::writeClkedStepSource -TEST_F(StreamPrintTest, R8_SpiceVoltageSource) { +TEST_F(StreamPrintTest, SpiceVoltageSource2) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, "v%s %s 0 pwl(0 %.3f %.3e %.3f)\n", @@ -842,7 +851,7 @@ TEST_F(StreamPrintTest, R8_SpiceVoltageSource) { // Test streamPrint with SPICE waveform format (used in writeWaveformVoltSource) // Covers: streamPrint paths used by WriteSpice::writeWaveformVoltSource -TEST_F(StreamPrintTest, R8_SpiceWaveformFormat) { +TEST_F(StreamPrintTest, SpiceWaveformFormat) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, "v%s %s 0 pwl(\n", "in", "in_node"); @@ -861,7 +870,7 @@ TEST_F(StreamPrintTest, R8_SpiceWaveformFormat) { // Test streamPrint with SPICE .measure format (used in spiceTrans context) // Covers: streamPrint with RISE/FALL strings (used by WriteSpice::spiceTrans) -TEST_F(StreamPrintTest, R8_SpiceMeasureRiseFall) { +TEST_F(StreamPrintTest, SpiceMeasureRiseFall) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); // This mimics how spiceTrans returns RISE/FALL strings @@ -880,7 +889,7 @@ TEST_F(StreamPrintTest, R8_SpiceMeasureRiseFall) { // Test Xyce CSV with special values // Covers: readXyceCsv edge cases -TEST_F(XyceCsvTest, R8_ReadCsvWithZeroValues) { +TEST_F(XyceCsvTest, ReadCsvWithZeroValues) { { std::ofstream out(tmpfile_); out << "TIME,V(sig)\n"; @@ -901,7 +910,7 @@ TEST_F(XyceCsvTest, R8_ReadCsvWithZeroValues) { // Test Xyce CSV with large number of signals // Covers: readXyceCsv with many columns -TEST_F(XyceCsvTest, R8_ReadCsvManySignals) { +TEST_F(XyceCsvTest, ReadCsvManySignals) { { std::ofstream out(tmpfile_); out << "TIME"; @@ -928,7 +937,7 @@ TEST_F(XyceCsvTest, R8_ReadCsvManySignals) { //////////////////////////////////////////////////////////////// // streamPrint: SPICE subcircuit definition (used by WriteSpice) -TEST_F(StreamPrintTest, R9_SpiceSubcktDefinition) { +TEST_F(StreamPrintTest, SpiceSubcktDefinition) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, ".subckt %s %s %s %s %s\n", @@ -948,7 +957,7 @@ TEST_F(StreamPrintTest, R9_SpiceSubcktDefinition) { } // streamPrint: SPICE resistor network (used in writeParasiticNetwork) -TEST_F(StreamPrintTest, R9_SpiceResistorNetwork) { +TEST_F(StreamPrintTest, SpiceResistorNetwork) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); for (int i = 0; i < 10; i++) { @@ -964,7 +973,7 @@ TEST_F(StreamPrintTest, R9_SpiceResistorNetwork) { } // streamPrint: SPICE capacitor network (used in writeParasiticNetwork) -TEST_F(StreamPrintTest, R9_SpiceCapacitorNetwork) { +TEST_F(StreamPrintTest, SpiceCapacitorNetwork) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); for (int i = 0; i < 10; i++) { @@ -980,7 +989,7 @@ TEST_F(StreamPrintTest, R9_SpiceCapacitorNetwork) { } // streamPrint: SPICE .lib directive -TEST_F(StreamPrintTest, R9_SpiceLibDirective) { +TEST_F(StreamPrintTest, SpiceLibDirective) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, ".lib '%s' %s\n", "/path/to/models.lib", "tt"); @@ -994,7 +1003,7 @@ TEST_F(StreamPrintTest, R9_SpiceLibDirective) { } // streamPrint: SPICE .option directive -TEST_F(StreamPrintTest, R9_SpiceOptionDirective) { +TEST_F(StreamPrintTest, SpiceOptionDirective) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, ".option %s=%g %s=%g\n", "reltol", 1e-6, "abstol", 1e-12); @@ -1008,7 +1017,7 @@ TEST_F(StreamPrintTest, R9_SpiceOptionDirective) { } // streamPrint: SPICE .print directive -TEST_F(StreamPrintTest, R9_SpicePrintDirective) { +TEST_F(StreamPrintTest, SpicePrintDirective) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, ".print tran v(%s) v(%s) v(%s)\n", @@ -1024,7 +1033,7 @@ TEST_F(StreamPrintTest, R9_SpicePrintDirective) { } // streamPrint: SPICE pulse source -TEST_F(StreamPrintTest, R9_SpicePulseSource) { +TEST_F(StreamPrintTest, SpicePulseSource) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, "v%s %s 0 PULSE(%.3f %.3f %.3e %.3e %.3e %.3e %.3e)\n", @@ -1039,7 +1048,7 @@ TEST_F(StreamPrintTest, R9_SpicePulseSource) { } // streamPrint: SPICE mutual inductance -TEST_F(StreamPrintTest, R9_SpiceMutualInductance) { +TEST_F(StreamPrintTest, SpiceMutualInductance) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, "L%d %s %s %.4e\n", 1, "n1", "n2", 1e-9); @@ -1055,7 +1064,7 @@ TEST_F(StreamPrintTest, R9_SpiceMutualInductance) { } // streamPrint: SPICE probe statement -TEST_F(StreamPrintTest, R9_SpiceProbeStatement) { +TEST_F(StreamPrintTest, SpiceProbeStatement) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, ".probe v(%s) v(%s) i(%s)\n", @@ -1069,7 +1078,7 @@ TEST_F(StreamPrintTest, R9_SpiceProbeStatement) { } // streamPrint: SPICE with escaped characters -TEST_F(StreamPrintTest, R9_SpiceEscapedChars) { +TEST_F(StreamPrintTest, SpiceEscapedChars) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, "* Node: %s\n", "top/sub/inst:pin"); @@ -1084,7 +1093,7 @@ TEST_F(StreamPrintTest, R9_SpiceEscapedChars) { } // streamPrint: SPICE full deck structure -TEST_F(StreamPrintTest, R9_SpiceFullDeck) { +TEST_F(StreamPrintTest, SpiceFullDeck) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, "* Full SPICE deck\n"); @@ -1116,7 +1125,7 @@ TEST_F(StreamPrintTest, R9_SpiceFullDeck) { } // XyceCsv: with very small values -TEST_F(XyceCsvTest, R9_ReadCsvSmallValues) { +TEST_F(XyceCsvTest, ReadCsvSmallValues) { { std::ofstream out(tmpfile_); out << "TIME,V(sig1),V(sig2)\n"; @@ -1134,7 +1143,7 @@ TEST_F(XyceCsvTest, R9_ReadCsvSmallValues) { } // XyceCsv: with very large values -TEST_F(XyceCsvTest, R9_ReadCsvLargeValues) { +TEST_F(XyceCsvTest, ReadCsvLargeValues) { { std::ofstream out(tmpfile_); out << "TIME,V(sig)\n"; @@ -1152,7 +1161,7 @@ TEST_F(XyceCsvTest, R9_ReadCsvLargeValues) { } // XyceCsv: with 100 time steps -TEST_F(XyceCsvTest, R9_ReadCsv100TimeSteps) { +TEST_F(XyceCsvTest, ReadCsv100TimeSteps) { { std::ofstream out(tmpfile_); out << "TIME,V(out),V(in)\n"; @@ -1174,7 +1183,7 @@ TEST_F(XyceCsvTest, R9_ReadCsv100TimeSteps) { } // XyceCsv: with signal names containing special characters -TEST_F(XyceCsvTest, R9_ReadCsvSpecialSignalNames) { +TEST_F(XyceCsvTest, ReadCsvSpecialSignalNames) { { std::ofstream out(tmpfile_); out << "TIME,V(top/sub/net:1),V(top/sub/net:2)\n"; @@ -1193,7 +1202,7 @@ TEST_F(XyceCsvTest, R9_ReadCsvSpecialSignalNames) { } // XyceCsv: with current probes -TEST_F(XyceCsvTest, R9_ReadCsvCurrentProbes) { +TEST_F(XyceCsvTest, ReadCsvCurrentProbes) { { std::ofstream out(tmpfile_); out << "TIME,I(v_supply),V(out)\n"; @@ -1211,7 +1220,7 @@ TEST_F(XyceCsvTest, R9_ReadCsvCurrentProbes) { } // Transition properties relevant to SPICE -TEST_F(SpiceSmokeTest, R9_TransitionAsRiseFallBoth) { +TEST_F(SpiceSmokeTest, TransitionAsRiseFallBoth) { // Rise-like transitions have valid asRiseFallBoth EXPECT_NE(Transition::rise()->asRiseFallBoth(), nullptr); EXPECT_NE(Transition::fall()->asRiseFallBoth(), nullptr); @@ -1219,25 +1228,25 @@ TEST_F(SpiceSmokeTest, R9_TransitionAsRiseFallBoth) { EXPECT_NE(Transition::trZ1()->asRiseFallBoth(), nullptr); } -TEST_F(SpiceSmokeTest, R9_TransitionIndex) { +TEST_F(SpiceSmokeTest, TransitionIndex) { EXPECT_GE(Transition::rise()->index(), 0); EXPECT_GE(Transition::fall()->index(), 0); EXPECT_NE(Transition::rise()->index(), Transition::fall()->index()); } -TEST_F(SpiceSmokeTest, R9_RiseFallBothIndex) { +TEST_F(SpiceSmokeTest, RiseFallBothIndex) { EXPECT_GE(RiseFallBoth::rise()->index(), 0); EXPECT_GE(RiseFallBoth::fall()->index(), 0); EXPECT_GE(RiseFallBoth::riseFall()->index(), 0); } -TEST_F(SpiceSmokeTest, R9_RiseFallBothToString) { +TEST_F(SpiceSmokeTest, RiseFallBothToString) { EXPECT_EQ(RiseFallBoth::rise()->to_string(), "^"); EXPECT_EQ(RiseFallBoth::fall()->to_string(), "v"); EXPECT_FALSE(RiseFallBoth::riseFall()->to_string().empty()); } -TEST_F(SpiceSmokeTest, R9_MinMaxAllForSpice) { +TEST_F(SpiceSmokeTest, MinMaxAllForSpice) { // MinMaxAll range used in SPICE for iteration int count = 0; for (auto mm : MinMaxAll::all()->range()) { @@ -1247,12 +1256,12 @@ TEST_F(SpiceSmokeTest, R9_MinMaxAllForSpice) { EXPECT_EQ(count, 2); } -TEST_F(SpiceSmokeTest, R9_MinMaxAllAsMinMax) { +TEST_F(SpiceSmokeTest, MinMaxAllAsMinMax) { EXPECT_EQ(MinMaxAll::min()->asMinMax(), MinMax::min()); EXPECT_EQ(MinMaxAll::max()->asMinMax(), MinMax::max()); } -TEST_F(SpiceSmokeTest, R9_TransitionRiseFallAsString) { +TEST_F(SpiceSmokeTest, TransitionRiseFallAsString) { // Transition::to_string used in SPICE reporting EXPECT_EQ(Transition::rise()->to_string(), "^"); EXPECT_EQ(Transition::fall()->to_string(), "v"); @@ -1260,12 +1269,12 @@ TEST_F(SpiceSmokeTest, R9_TransitionRiseFallAsString) { EXPECT_FALSE(Transition::riseFall()->to_string().empty()); } -TEST_F(SpiceSmokeTest, R9_RiseFallAsRiseFallBoth) { +TEST_F(SpiceSmokeTest, RiseFallAsRiseFallBoth) { EXPECT_EQ(RiseFall::rise()->asRiseFallBoth(), RiseFallBoth::rise()); EXPECT_EQ(RiseFall::fall()->asRiseFallBoth(), RiseFallBoth::fall()); } -TEST_F(SpiceSmokeTest, R9_MinMaxCompareInfinity) { +TEST_F(SpiceSmokeTest, MinMaxCompareInfinity) { float large = 1e30f; float small = -1e30f; EXPECT_TRUE(MinMax::min()->compare(small, large)); @@ -1274,7 +1283,7 @@ TEST_F(SpiceSmokeTest, R9_MinMaxCompareInfinity) { EXPECT_FALSE(MinMax::max()->compare(small, large)); } -TEST_F(SpiceSmokeTest, R9_RiseFallRangeValues) { +TEST_F(SpiceSmokeTest, RiseFallRangeValues) { // Verify range produces rise then fall auto range = RiseFall::range(); int idx = 0; @@ -1287,7 +1296,7 @@ TEST_F(SpiceSmokeTest, R9_RiseFallRangeValues) { } // XyceCsv: single row of data -TEST_F(XyceCsvTest, R9_ReadCsvSingleRow) { +TEST_F(XyceCsvTest, ReadCsvSingleRow) { { std::ofstream out(tmpfile_); out << "TIME,V(out)\n"; @@ -1304,7 +1313,7 @@ TEST_F(XyceCsvTest, R9_ReadCsvSingleRow) { } // XyceCsv: with alternating sign values -TEST_F(XyceCsvTest, R9_ReadCsvAlternatingSign) { +TEST_F(XyceCsvTest, ReadCsvAlternatingSign) { { std::ofstream out(tmpfile_); out << "TIME,V(out)\n"; @@ -1323,7 +1332,7 @@ TEST_F(XyceCsvTest, R9_ReadCsvAlternatingSign) { } // streamPrint: SPICE .end directive -TEST_F(StreamPrintTest, R9_SpiceEndDirective) { +TEST_F(StreamPrintTest, SpiceEndDirective) { std::ofstream out(tmpfile_); ASSERT_TRUE(out.is_open()); streamPrint(out, ".end\n"); @@ -1336,7 +1345,7 @@ TEST_F(StreamPrintTest, R9_SpiceEndDirective) { } // XyceCsv: many columns (50 signals) -TEST_F(XyceCsvTest, R9_ReadCsv50Signals) { +TEST_F(XyceCsvTest, ReadCsv50Signals) { { std::ofstream out(tmpfile_); out << "TIME"; diff --git a/spice/test/spice_write.tcl b/spice/test/spice_write.tcl index a9539020..43d67439 100644 --- a/spice/test/spice_write.tcl +++ b/spice/test/spice_write.tcl @@ -56,9 +56,7 @@ if { $rc == 0 } { puts "PASS: write_path_spice completed successfully" diff_files $test_name.spok [file join $spice_dir path_1.sp] } else { - # Even partial execution gives us coverage of the C++ code - puts "INFO: write_path_spice returned error (expected with mock files): $msg" - puts "PASS: write_path_spice code path exercised" + puts "FAIL: write_path_spice returned error: $msg" } puts "ALL PASSED" diff --git a/util/test/cpp/TestUtil.cc b/util/test/cpp/TestUtil.cc index 35de6fd2..16d11820 100644 --- a/util/test/cpp/TestUtil.cc +++ b/util/test/cpp/TestUtil.cc @@ -2499,7 +2499,7 @@ TEST(StringUtilCovTest, StringDeleteCheckRegular) // Test Report redirectStringPrint with empty string // Covers: Report::redirectStringPrint -TEST(ReportCovTest, R5_RedirectStringPrintEmpty) +TEST(ReportCovTest, RedirectStringPrintEmpty) { Report report; report.redirectStringBegin(); @@ -2509,7 +2509,7 @@ TEST(ReportCovTest, R5_RedirectStringPrintEmpty) } // Test Report redirectStringPrint with large string -TEST(ReportCovTest, R5_RedirectStringPrintLarge) +TEST(ReportCovTest, RedirectStringPrintLarge) { Report report; report.redirectStringBegin(); @@ -2520,7 +2520,7 @@ TEST(ReportCovTest, R5_RedirectStringPrintLarge) } // Test Report redirectStringPrint multiple times -TEST(ReportCovTest, R5_RedirectStringPrintMultiple) +TEST(ReportCovTest, RedirectStringPrintMultiple) { Report report; report.redirectStringBegin(); @@ -2533,7 +2533,7 @@ TEST(ReportCovTest, R5_RedirectStringPrintMultiple) // Test Report printToBuffer with va_list // Covers: Report::printToBuffer(const char*, va_list) -TEST(ReportCovTest, R5_PrintToBufferViaReportLine) +TEST(ReportCovTest, PrintToBufferViaReportLine) { Report report; report.redirectStringBegin(); @@ -2545,7 +2545,7 @@ TEST(ReportCovTest, R5_PrintToBufferViaReportLine) } // Test Report::reportLineString -TEST(ReportCovTest, R5_ReportLineString) +TEST(ReportCovTest, ReportLineString) { Report report; report.redirectStringBegin(); @@ -2556,7 +2556,7 @@ TEST(ReportCovTest, R5_ReportLineString) } // Test Report::reportLineString with std::string -TEST(ReportCovTest, R5_ReportLineStringStd) +TEST(ReportCovTest, ReportLineStringStd) { Report report; report.redirectStringBegin(); @@ -2568,7 +2568,7 @@ TEST(ReportCovTest, R5_ReportLineStringStd) } // Test Report::reportBlankLine -TEST(ReportCovTest, R5_ReportBlankLine) +TEST(ReportCovTest, ReportBlankLine) { Report report; report.redirectStringBegin(); @@ -2580,7 +2580,7 @@ TEST(ReportCovTest, R5_ReportBlankLine) // Test ReportStd constructor // Covers: ReportStd::ReportStd() -TEST(ReportStdCovTest, R5_ReportStdConstructor) +TEST(ReportStdCovTest, ReportStdConstructor) { Report *report = makeReportStd(); EXPECT_NE(report, nullptr); @@ -2591,7 +2591,7 @@ TEST(ReportStdCovTest, R5_ReportStdConstructor) // Test ReportStd printErrorConsole via fileError // Covers: ReportStd::printErrorConsole -TEST(ReportStdCovTest, R5_PrintErrorConsoleViaWarn) +TEST(ReportStdCovTest, PrintErrorConsoleViaWarn) { Report *report = makeReportStd(); // warn uses printErrorConsole path @@ -2600,7 +2600,7 @@ TEST(ReportStdCovTest, R5_PrintErrorConsoleViaWarn) } // Test Report suppress/unsuppress messages -TEST(ReportCovTest, R5_SuppressUnsuppress) +TEST(ReportCovTest, SuppressUnsuppress) { Report report; EXPECT_FALSE(report.isSuppressed(100)); @@ -2611,7 +2611,7 @@ TEST(ReportCovTest, R5_SuppressUnsuppress) } // Test Report suppressed warn is silent -TEST(ReportCovTest, R5_SuppressedWarn) +TEST(ReportCovTest, SuppressedWarn) { Report report; report.suppressMsgId(200); @@ -2623,7 +2623,7 @@ TEST(ReportCovTest, R5_SuppressedWarn) } // Test Report logBegin/logEnd -TEST(ReportCovTest, R5_LogBeginEnd) +TEST(ReportCovTest, LogBeginEnd) { Report report; const char *logfile = "/tmp/sta_test_log_r5.log"; @@ -2641,7 +2641,7 @@ TEST(ReportCovTest, R5_LogBeginEnd) } // Test Report redirectFileBegin/redirectFileEnd -TEST(ReportCovTest, R5_RedirectFileBeginEnd) +TEST(ReportCovTest, RedirectFileBeginEnd) { Report report; const char *tmpfile = "/tmp/sta_test_redirect_r5.txt"; @@ -2659,7 +2659,7 @@ TEST(ReportCovTest, R5_RedirectFileBeginEnd) } // Test Report redirectFileAppendBegin -TEST(ReportCovTest, R5_RedirectFileAppendBegin) +TEST(ReportCovTest, RedirectFileAppendBegin) { Report report; const char *tmpfile = "/tmp/sta_test_append_r5.txt"; @@ -2687,7 +2687,7 @@ TEST(ReportCovTest, R5_RedirectFileAppendBegin) // Test gzstreambuf basic operations // Covers: gzstreambuf::~gzstreambufD0Ev (virtual destructor) -TEST(GzStreamTest, R5_GzStreamBufConstruction) +TEST(GzStreamTest, GzStreamBufConstruction) { // Test igzstream with a non-existent file gzstream::igzstream stream; @@ -2695,7 +2695,7 @@ TEST(GzStreamTest, R5_GzStreamBufConstruction) } // Test gzstreambuf with actual gz file -TEST(GzStreamTest, R5_GzStreamWriteRead) +TEST(GzStreamTest, GzStreamWriteRead) { const char *tmpfile = "/tmp/sta_test_gz_r5.gz"; @@ -2719,21 +2719,21 @@ TEST(GzStreamTest, R5_GzStreamWriteRead) } // Test Report error throws ExceptionMsg -TEST(ReportCovTest, R5_ErrorThrowsException) +TEST(ReportCovTest, ErrorThrowsException) { Report report; EXPECT_THROW(report.error(1, "test error %s", "msg"), ExceptionMsg); } // Test Report fileError throws ExceptionMsg -TEST(ReportCovTest, R5_FileErrorThrowsException) +TEST(ReportCovTest, FileErrorThrowsException) { Report report; EXPECT_THROW(report.fileError(1, "test.v", 10, "file error"), ExceptionMsg); } // Test Report verror throws ExceptionMsg -TEST(ReportCovTest, R5_VerrorThrowsException) +TEST(ReportCovTest, VerrorThrowsException) { Report report; EXPECT_THROW(report.error(1, "verror test"), ExceptionMsg); @@ -2746,7 +2746,7 @@ TEST(ReportCovTest, R5_VerrorThrowsException) // Test Report::critical calls exit (we can't test exit directly, // but we can test that the function exists and the format works) // Covers: Report::critical - we test via Report::error which shares formatting -TEST(ReportCovTest, R6_ReportErrorFormatting) +TEST(ReportCovTest, ReportErrorFormatting) { Report report; try { @@ -2760,7 +2760,7 @@ TEST(ReportCovTest, R6_ReportErrorFormatting) // Test Report::fileCritical via fileError (shares code path) // Covers: Report::fileCritical formatting path -TEST(ReportCovTest, R6_ReportFileErrorFormatting) +TEST(ReportCovTest, ReportFileErrorFormatting) { Report report; try { @@ -2776,7 +2776,7 @@ TEST(ReportCovTest, R6_ReportFileErrorFormatting) // Test Report D0 destructor through base pointer // Covers: Report::~Report() D0 -TEST(ReportCovTest, R6_ReportD0Destructor) +TEST(ReportCovTest, ReportD0Destructor) { Report *report = new Report(); EXPECT_NE(report, nullptr); @@ -2786,7 +2786,7 @@ TEST(ReportCovTest, R6_ReportD0Destructor) // Test ReportStd creation via makeReportStd // Covers: ReportStd::ReportStd constructor, makeReportStd -TEST(ReportCovTest, R6_ReportStdCreation) +TEST(ReportCovTest, ReportStdCreation) { Report *report = makeReportStd(); ASSERT_NE(report, nullptr); @@ -2802,7 +2802,7 @@ TEST(ReportCovTest, R6_ReportStdCreation) // Test ReportStd warn output // Covers: ReportStd::printErrorConsole (indirectly via warn) -TEST(ReportCovTest, R6_ReportStdWarn) +TEST(ReportCovTest, ReportStdWarn) { Report *report = makeReportStd(); ASSERT_NE(report, nullptr); @@ -2817,7 +2817,7 @@ TEST(ReportCovTest, R6_ReportStdWarn) // Test ReportStd error // Covers: ReportStd error path -TEST(ReportCovTest, R6_ReportStdError) +TEST(ReportCovTest, ReportStdError) { Report *report = makeReportStd(); ASSERT_NE(report, nullptr); @@ -2827,7 +2827,7 @@ TEST(ReportCovTest, R6_ReportStdError) // Test Report printToBuffer with long format (indirectly via reportLine) // Covers: Report::printToBuffer buffer growth -TEST(ReportCovTest, R6_ReportPrintToBufferLong) +TEST(ReportCovTest, ReportPrintToBufferLong) { Report report; report.redirectStringBegin(); @@ -2841,7 +2841,7 @@ TEST(ReportCovTest, R6_ReportPrintToBufferLong) // Test Report redirectStringPrint indirectly via redirectStringBegin/End // Covers: Report::redirectStringPrint -TEST(ReportCovTest, R6_RedirectStringPrint) +TEST(ReportCovTest, RedirectStringPrint) { Report report; report.redirectStringBegin(); @@ -2853,7 +2853,7 @@ TEST(ReportCovTest, R6_RedirectStringPrint) // Test Report multiple printString calls during redirect // Covers: Report::redirectStringPrint concatenation -TEST(ReportCovTest, R6_RedirectStringPrintMultiple) +TEST(ReportCovTest, RedirectStringPrintMultiple2) { Report report; report.redirectStringBegin(); @@ -2866,7 +2866,7 @@ TEST(ReportCovTest, R6_RedirectStringPrintMultiple) // Test gzstreambuf D0 destructor through gzstream objects // Covers: gzstreambuf::~gzstreambuf() D0 -TEST(GzStreamCovTest, R6_GzStreamBufD0Destructor) +TEST(GzStreamCovTest, GzStreamBufD0Destructor) { const char *tmpfile = "/tmp/test_gz_d0.gz"; { @@ -2888,7 +2888,7 @@ TEST(GzStreamCovTest, R6_GzStreamBufD0Destructor) // Test Report suppress and unsuppress multiple IDs // Covers: Report::suppressMsgId, unsuppressMsgId -TEST(ReportCovTest, R6_SuppressMultipleIds) +TEST(ReportCovTest, SuppressMultipleIds) { Report report; report.suppressMsgId(1); @@ -2907,7 +2907,7 @@ TEST(ReportCovTest, R6_SuppressMultipleIds) // Test Report warn with long message that exceeds buffer // Covers: Report::printToBuffer buffer reallocation -TEST(ReportCovTest, R6_WarnLongMessage) +TEST(ReportCovTest, WarnLongMessage) { Report report; report.redirectStringBegin(); @@ -2921,7 +2921,7 @@ TEST(ReportCovTest, R6_WarnLongMessage) // Test Report fileWarn with long message // Covers: Report::printToBuffer via fileWarn -TEST(ReportCovTest, R6_FileWarnLongMessage) +TEST(ReportCovTest, FileWarnLongMessage2) { Report report; report.redirectStringBegin(); @@ -2936,7 +2936,7 @@ TEST(ReportCovTest, R6_FileWarnLongMessage) // Test Report error with suppressed flag // Covers: ExceptionMsg suppression -TEST(ReportCovTest, R6_ErrorSuppressed) +TEST(ReportCovTest, ErrorSuppressed) { Report report; report.suppressMsgId(900); @@ -2950,7 +2950,7 @@ TEST(ReportCovTest, R6_ErrorSuppressed) // Test Report error without suppression // Covers: ExceptionMsg non-suppression -TEST(ReportCovTest, R6_ErrorNotSuppressed) +TEST(ReportCovTest, ErrorNotSuppressed) { Report report; try { @@ -2975,7 +2975,7 @@ TEST(ReportCovTest, R6_ErrorNotSuppressed) // Test Report::printToBuffer via reportLine // Covers: Report::printToBuffer(const char*, va_list) -TEST(ReportCovTest, R8_PrintToBufferViaReportLine) +TEST(ReportCovTest, PrintToBufferViaReportLine2) { Report report; report.redirectStringBegin(); @@ -2989,7 +2989,7 @@ TEST(ReportCovTest, R8_PrintToBufferViaReportLine) // Test Report::redirectStringPrint via redirectStringBegin/End // Covers: Report::redirectStringPrint(const char*, size_t) -TEST(ReportCovTest, R8_RedirectStringPrint) +TEST(ReportCovTest, RedirectStringPrint2) { Report report; report.redirectStringBegin(); @@ -3005,7 +3005,7 @@ TEST(ReportCovTest, R8_RedirectStringPrint) // Test Report::redirectStringPrint with long string // Covers: Report::redirectStringPrint(const char*, size_t) -TEST(ReportCovTest, R8_RedirectStringPrintLong) +TEST(ReportCovTest, RedirectStringPrintLong) { Report report; report.redirectStringBegin(); @@ -3018,7 +3018,7 @@ TEST(ReportCovTest, R8_RedirectStringPrintLong) // Test Report::printToBuffer with various format strings // Covers: Report::printToBuffer(const char*, va_list) -TEST(ReportCovTest, R8_PrintToBufferFormats) +TEST(ReportCovTest, PrintToBufferFormats) { Report report; report.redirectStringBegin(); @@ -3035,7 +3035,7 @@ TEST(ReportCovTest, R8_PrintToBufferFormats) // Test ReportStd constructor and printErrorConsole // Covers: ReportStd::ReportStd(), ReportStd::printErrorConsole -TEST(ReportStdCovTest, R8_ReportStdConstructorAndPrint) +TEST(ReportStdCovTest, ReportStdConstructorAndPrint) { Report *report = makeReportStd(); ASSERT_NE(report, nullptr); @@ -3048,7 +3048,7 @@ TEST(ReportStdCovTest, R8_ReportStdConstructorAndPrint) // Test ReportStd printErrorConsole through fileWarn // Covers: ReportStd::printErrorConsole(const char*, size_t) -TEST(ReportStdCovTest, R8_PrintErrorConsoleViaFileWarn) +TEST(ReportStdCovTest, PrintErrorConsoleViaFileWarn) { Report *report = makeReportStd(); ASSERT_NE(report, nullptr); @@ -3058,7 +3058,7 @@ TEST(ReportStdCovTest, R8_PrintErrorConsoleViaFileWarn) // Test Report::printToBuffer with empty format // Covers: Report::printToBuffer -TEST(ReportCovTest, R8_PrintToBufferEmpty) +TEST(ReportCovTest, PrintToBufferEmpty) { Report report; report.redirectStringBegin(); @@ -3070,7 +3070,7 @@ TEST(ReportCovTest, R8_PrintToBufferEmpty) // Test Report warn with redirect // Covers: Report::printToBuffer, Report::redirectStringPrint -TEST(ReportCovTest, R8_WarnWithRedirect) +TEST(ReportCovTest, WarnWithRedirect) { Report report; report.redirectStringBegin(); @@ -3083,7 +3083,7 @@ TEST(ReportCovTest, R8_WarnWithRedirect) // Test Report fileWarn with redirect // Covers: Report::printToBuffer, Report::redirectStringPrint -TEST(ReportCovTest, R8_FileWarnWithRedirect) +TEST(ReportCovTest, FileWarnWithRedirect) { Report report; report.redirectStringBegin(); @@ -3096,7 +3096,7 @@ TEST(ReportCovTest, R8_FileWarnWithRedirect) // Test gzstream write and read // Covers: gzstreambuf (exercises gzstream I/O paths) -TEST(GzStreamTest, R8_WriteAndReadGz) +TEST(GzStreamTest, WriteAndReadGz) { const char *tmpfile = "/tmp/test_r8_gzstream.gz"; { diff --git a/verilog/test/cpp/TestVerilog.cc b/verilog/test/cpp/TestVerilog.cc index 7fc169a0..5a01610a 100644 --- a/verilog/test/cpp/TestVerilog.cc +++ b/verilog/test/cpp/TestVerilog.cc @@ -399,127 +399,127 @@ TEST_F(VerilogTest, NetEscapedBus) { //////////////////////////////////////////////////////////////// // staToVerilog: names with dollar sign -TEST_F(VerilogTest, R5_CellWithDollar) { +TEST_F(VerilogTest, CellWithDollar) { std::string result = cellVerilogName("cell$gen"); EXPECT_EQ(result.front(), '\\'); EXPECT_EQ(result.back(), ' '); } // staToVerilog: name with tab character -TEST_F(VerilogTest, R5_CellWithTab) { +TEST_F(VerilogTest, CellWithTab) { std::string result = cellVerilogName("cell\tname"); EXPECT_EQ(result.front(), '\\'); } // staToVerilog: instance with brackets -TEST_F(VerilogTest, R5_InstanceWithBrackets) { +TEST_F(VerilogTest, InstanceWithBrackets) { std::string result = instanceVerilogName("inst[0]"); EXPECT_EQ(result.front(), '\\'); EXPECT_EQ(result.back(), ' '); } // verilogToSta: empty escaped name -TEST_F(VerilogTest, R5_EmptyEscapedName) { +TEST_F(VerilogTest, EmptyEscapedName) { std::string name = "\\"; std::string result = instanceVerilogToSta(&name); EXPECT_TRUE(result.empty()); } // verilogToSta: escaped name with only space -TEST_F(VerilogTest, R5_EscapedOnlySpace) { +TEST_F(VerilogTest, EscapedOnlySpace) { std::string name = "\\ "; std::string result = instanceVerilogToSta(&name); EXPECT_TRUE(result.empty()); } // netVerilogName: escaped characters with bus notation -TEST_F(VerilogTest, R5_NetEscapedWithBus) { +TEST_F(VerilogTest, NetEscapedWithBus) { std::string result = netVerilogName("net.a[3]"); EXPECT_FALSE(result.empty()); } // portVerilogName: special character with underscore -TEST_F(VerilogTest, R5_PortSpecialWithUnderscore) { +TEST_F(VerilogTest, PortSpecialWithUnderscore) { std::string result = portVerilogName("_port.a_"); EXPECT_EQ(result.front(), '\\'); } // cellVerilogName: name with only special chars -TEST_F(VerilogTest, R5_CellOnlySpecialChars) { +TEST_F(VerilogTest, CellOnlySpecialChars) { std::string result = cellVerilogName("./#@"); EXPECT_EQ(result.front(), '\\'); EXPECT_EQ(result.back(), ' '); } // instanceVerilogToSta: plain unescaped name -TEST_F(VerilogTest, R5_UnescapedInstance) { +TEST_F(VerilogTest, UnescapedInstance) { std::string name = "plain_inst"; std::string result = instanceVerilogToSta(&name); EXPECT_EQ(result, "plain_inst"); } // netVerilogToSta: escaped name with bus notation -TEST_F(VerilogTest, R5_EscapedNetBus) { +TEST_F(VerilogTest, EscapedNetBus) { std::string name = "\\data[7:0] "; std::string result = netVerilogToSta(&name); EXPECT_FALSE(result.empty()); } // moduleVerilogToSta: escaped module name -TEST_F(VerilogTest, R5_EscapedModule) { +TEST_F(VerilogTest, EscapedModule) { std::string name = "\\mod/special "; std::string result = moduleVerilogToSta(&name); EXPECT_FALSE(result.empty()); } // portVerilogToSta: escaped port name -TEST_F(VerilogTest, R5_EscapedPort) { +TEST_F(VerilogTest, EscapedPort) { std::string name = "\\port$gen "; std::string result = portVerilogToSta(&name); EXPECT_FALSE(result.empty()); } // netVerilogName: name with backslash-escaped bracket -TEST_F(VerilogTest, R5_NetEscapedBracketSlash) { +TEST_F(VerilogTest, NetEscapedBracketSlash) { std::string result = netVerilogName("a\\[b"); EXPECT_FALSE(result.empty()); } // portVerilogName: name that is just digits -TEST_F(VerilogTest, R5_PortJustDigits) { +TEST_F(VerilogTest, PortJustDigits) { std::string result = portVerilogName("12345"); // All digits - alphanumeric, no escaping needed EXPECT_EQ(result, "12345"); } // cellVerilogName: name with hyphen -TEST_F(VerilogTest, R5_CellWithHyphen) { +TEST_F(VerilogTest, CellWithHyphen) { std::string result = cellVerilogName("cell-name"); EXPECT_EQ(result.front(), '\\'); EXPECT_EQ(result.back(), ' '); } // instanceVerilogName: name with equal sign -TEST_F(VerilogTest, R5_InstanceWithEquals) { +TEST_F(VerilogTest, InstanceWithEquals) { std::string result = instanceVerilogName("inst=val"); EXPECT_EQ(result.front(), '\\'); } // netVerilogName: name with percent -TEST_F(VerilogTest, R5_NetWithPercent) { +TEST_F(VerilogTest, NetWithPercent) { std::string result = netVerilogName("net%1"); EXPECT_EQ(result.front(), '\\'); EXPECT_EQ(result.back(), ' '); } // portVerilogName: name with plus -TEST_F(VerilogTest, R5_PortWithPlus) { +TEST_F(VerilogTest, PortWithPlus) { std::string result = portVerilogName("port+a"); EXPECT_EQ(result.front(), '\\'); } // instanceVerilogToSta: escaped name with various special chars -TEST_F(VerilogTest, R5_EscapedInstanceComplex) { +TEST_F(VerilogTest, EscapedInstanceComplex) { std::string name = "\\inst.a/b[c] "; std::string result = instanceVerilogToSta(&name); EXPECT_FALSE(result.empty()); @@ -528,66 +528,66 @@ TEST_F(VerilogTest, R5_EscapedInstanceComplex) { } // netVerilogToSta: plain net with underscore -TEST_F(VerilogTest, R5_PlainNetUnderscore) { +TEST_F(VerilogTest, PlainNetUnderscore) { std::string name = "_net_wire_"; std::string result = netVerilogToSta(&name); EXPECT_EQ(result, "_net_wire_"); } // portVerilogToSta: plain port with numbers -TEST_F(VerilogTest, R5_PlainPortNumeric) { +TEST_F(VerilogTest, PlainPortNumeric) { std::string name = "port_123"; std::string result = portVerilogToSta(&name); EXPECT_EQ(result, "port_123"); } // moduleVerilogToSta: plain module with mixed case -TEST_F(VerilogTest, R5_PlainModuleMixedCase) { +TEST_F(VerilogTest, PlainModuleMixedCase) { std::string name = "MyModule_V2"; std::string result = moduleVerilogToSta(&name); EXPECT_EQ(result, "MyModule_V2"); } // cellVerilogName: name with tilde -TEST_F(VerilogTest, R5_CellWithTilde) { +TEST_F(VerilogTest, CellWithTilde) { std::string result = cellVerilogName("cell~inv"); EXPECT_EQ(result.front(), '\\'); } // instanceVerilogName: name with ampersand -TEST_F(VerilogTest, R5_InstanceWithAmpersand) { +TEST_F(VerilogTest, InstanceWithAmpersand) { std::string result = instanceVerilogName("inst&and"); EXPECT_EQ(result.front(), '\\'); } // netVerilogName: name with exclamation -TEST_F(VerilogTest, R5_NetWithExclamation) { +TEST_F(VerilogTest, NetWithExclamation) { std::string result = netVerilogName("net!rst"); EXPECT_EQ(result.front(), '\\'); } // portVerilogName: name with pipe -TEST_F(VerilogTest, R5_PortWithPipe) { +TEST_F(VerilogTest, PortWithPipe) { std::string result = portVerilogName("port|or"); EXPECT_EQ(result.front(), '\\'); } // instanceVerilogToSta: escaped name without trailing space (edge case) -TEST_F(VerilogTest, R5_EscapedNoTrailingSpaceComplex) { +TEST_F(VerilogTest, EscapedNoTrailingSpaceComplex) { std::string name = "\\inst/a[0]"; std::string result = instanceVerilogToSta(&name); EXPECT_FALSE(result.empty()); } // cellVerilogName: very long name -TEST_F(VerilogTest, R5_CellLongName) { +TEST_F(VerilogTest, CellLongName) { std::string long_name(200, 'a'); std::string result = cellVerilogName(long_name.c_str()); EXPECT_EQ(result, long_name); } // cellVerilogName: very long name with special char -TEST_F(VerilogTest, R5_CellLongEscapedName) { +TEST_F(VerilogTest, CellLongEscapedName) { std::string long_name(200, 'a'); long_name[100] = '/'; std::string result = cellVerilogName(long_name.c_str()); @@ -600,7 +600,7 @@ TEST_F(VerilogTest, R5_CellLongEscapedName) { //////////////////////////////////////////////////////////////// // VerilogNetScalar: constructor and properties -TEST_F(VerilogTest, R6_NetScalarConstruct) { +TEST_F(VerilogTest, NetScalarConstruct) { VerilogNetScalar net("wire1"); EXPECT_TRUE(net.isNamed()); EXPECT_TRUE(net.isScalar()); @@ -609,14 +609,14 @@ TEST_F(VerilogTest, R6_NetScalarConstruct) { } // VerilogNetScalar: with bus-like name -TEST_F(VerilogTest, R6_NetScalarBusLikeName) { +TEST_F(VerilogTest, NetScalarBusLikeName) { VerilogNetScalar net("data"); EXPECT_TRUE(net.isScalar()); EXPECT_EQ(net.name(), "data"); } // VerilogNetBitSelect: constructor and properties -TEST_F(VerilogTest, R6_NetBitSelectConstruct) { +TEST_F(VerilogTest, NetBitSelectConstruct) { VerilogNetBitSelect net("data", 3); EXPECT_TRUE(net.isNamed()); EXPECT_FALSE(net.isScalar()); @@ -626,14 +626,14 @@ TEST_F(VerilogTest, R6_NetBitSelectConstruct) { } // VerilogNetBitSelect: index 0 -TEST_F(VerilogTest, R6_NetBitSelectZero) { +TEST_F(VerilogTest, NetBitSelectZero) { VerilogNetBitSelect net("wire", 0); EXPECT_EQ(net.index(), 0); EXPECT_EQ(net.name(), "wire[0]"); } // VerilogNetPartSelect: constructor and properties -TEST_F(VerilogTest, R6_NetPartSelectConstruct) { +TEST_F(VerilogTest, NetPartSelectConstruct) { VerilogNetPartSelect net("bus", 7, 0); EXPECT_TRUE(net.isNamed()); EXPECT_FALSE(net.isScalar()); @@ -643,14 +643,14 @@ TEST_F(VerilogTest, R6_NetPartSelectConstruct) { } // VerilogNetPartSelect: ascending -TEST_F(VerilogTest, R6_NetPartSelectAscending) { +TEST_F(VerilogTest, NetPartSelectAscending) { VerilogNetPartSelect net("addr", 0, 15); EXPECT_EQ(net.fromIndex(), 0); EXPECT_EQ(net.toIndex(), 15); } // VerilogNetUnnamed: constructor and properties via VerilogNetConcat -TEST_F(VerilogTest, R6_NetUnnamedConstruct) { +TEST_F(VerilogTest, NetUnnamedConstruct) { VerilogNetSeq *nets = new VerilogNetSeq; VerilogNetConcat net(nets); // VerilogNetConcat extends VerilogNetUnnamed @@ -659,21 +659,21 @@ TEST_F(VerilogTest, R6_NetUnnamedConstruct) { } // VerilogNetNamed: constructor, destructor, name -TEST_F(VerilogTest, R6_NetNamedConstruct) { +TEST_F(VerilogTest, NetNamedConstruct) { VerilogNetScalar net("test_named"); EXPECT_TRUE(net.isNamed()); EXPECT_EQ(net.name(), "test_named"); } // VerilogNetNamed: destructor (via delete) -TEST_F(VerilogTest, R6_NetNamedDelete) { +TEST_F(VerilogTest, NetNamedDelete) { VerilogNetNamed *net = new VerilogNetScalar("to_delete"); EXPECT_EQ(net->name(), "to_delete"); delete net; } // VerilogNetPortRef: constructor -TEST_F(VerilogTest, R6_NetPortRefConstruct) { +TEST_F(VerilogTest, NetPortRefConstruct) { VerilogNetPortRefScalarNet ref("port_a"); EXPECT_TRUE(ref.isNamedPortRef()); EXPECT_EQ(ref.name(), "port_a"); @@ -681,7 +681,7 @@ TEST_F(VerilogTest, R6_NetPortRefConstruct) { } // VerilogNetPortRefScalarNet: with net name -TEST_F(VerilogTest, R6_NetPortRefScalarNetWithName) { +TEST_F(VerilogTest, NetPortRefScalarNetWithName) { VerilogNetPortRefScalarNet ref("port_a", "wire_a"); EXPECT_TRUE(ref.isNamedPortRef()); EXPECT_TRUE(ref.isNamedPortRefScalarNet()); @@ -691,7 +691,7 @@ TEST_F(VerilogTest, R6_NetPortRefScalarNetWithName) { } // VerilogNetPortRefScalarNet: set net name -TEST_F(VerilogTest, R6_NetPortRefScalarNetSetName) { +TEST_F(VerilogTest, NetPortRefScalarNetSetName) { VerilogNetPortRefScalarNet ref("port_a"); EXPECT_FALSE(ref.hasNet()); ref.setNetName("wire_b"); @@ -700,7 +700,7 @@ TEST_F(VerilogTest, R6_NetPortRefScalarNetSetName) { } // VerilogNetPortRefScalar: constructor with net -TEST_F(VerilogTest, R6_NetPortRefScalarConstruct) { +TEST_F(VerilogTest, NetPortRefScalarConstruct) { VerilogNetScalar *inner_net = new VerilogNetScalar("inner_wire"); VerilogNetPortRefScalar ref("port_b", inner_net); EXPECT_TRUE(ref.isNamedPortRef()); @@ -710,14 +710,14 @@ TEST_F(VerilogTest, R6_NetPortRefScalarConstruct) { } // VerilogNetPortRefScalar: constructor with null net -TEST_F(VerilogTest, R6_NetPortRefScalarNullNet) { +TEST_F(VerilogTest, NetPortRefScalarNullNet) { VerilogNetPortRefScalar ref("port_c", nullptr); EXPECT_TRUE(ref.isNamedPortRef()); EXPECT_FALSE(ref.hasNet()); } // VerilogNetPortRefBit: constructor -TEST_F(VerilogTest, R6_NetPortRefBitConstruct) { +TEST_F(VerilogTest, NetPortRefBitConstruct) { VerilogNetScalar *inner_net = new VerilogNetScalar("inner2"); VerilogNetPortRefBit ref("port_d", 3, inner_net); EXPECT_TRUE(ref.isNamedPortRef()); @@ -727,7 +727,7 @@ TEST_F(VerilogTest, R6_NetPortRefBitConstruct) { } // VerilogNetPortRefPart: constructor and name -TEST_F(VerilogTest, R6_NetPortRefPartConstruct) { +TEST_F(VerilogTest, NetPortRefPartConstruct) { VerilogNetScalar *inner_net = new VerilogNetScalar("inner3"); VerilogNetPortRefPart ref("port_e", 7, 0, inner_net); EXPECT_TRUE(ref.isNamedPortRef()); @@ -737,7 +737,7 @@ TEST_F(VerilogTest, R6_NetPortRefPartConstruct) { } // VerilogNetConcat: constructor with nets -TEST_F(VerilogTest, R6_NetConcatConstruct) { +TEST_F(VerilogTest, NetConcatConstruct) { VerilogNetSeq *nets = new VerilogNetSeq; nets->push_back(new VerilogNetScalar("a")); nets->push_back(new VerilogNetScalar("b")); @@ -746,7 +746,7 @@ TEST_F(VerilogTest, R6_NetConcatConstruct) { } // VerilogDclArg: constructor with name -TEST_F(VerilogTest, R6_DclArgName) { +TEST_F(VerilogTest, DclArgName) { VerilogDclArg arg("wire_name"); EXPECT_EQ(arg.netName(), "wire_name"); EXPECT_TRUE(arg.isNamed()); @@ -754,7 +754,7 @@ TEST_F(VerilogTest, R6_DclArgName) { } // VerilogDclArg: constructor with assign -TEST_F(VerilogTest, R6_DclArgAssign) { +TEST_F(VerilogTest, DclArgAssign) { VerilogNetScalar *lhs = new VerilogNetScalar("out"); VerilogNetScalar *rhs = new VerilogNetScalar("in"); VerilogAssign *assign = new VerilogAssign(lhs, rhs, 1); @@ -764,7 +764,7 @@ TEST_F(VerilogTest, R6_DclArgAssign) { } // VerilogAssign: constructor and accessors -TEST_F(VerilogTest, R6_AssignConstruct) { +TEST_F(VerilogTest, AssignConstruct) { VerilogNetScalar *lhs = new VerilogNetScalar("out"); VerilogNetScalar *rhs = new VerilogNetScalar("in"); VerilogAssign assign(lhs, rhs, 10); @@ -775,7 +775,7 @@ TEST_F(VerilogTest, R6_AssignConstruct) { } // VerilogStmt: constructor and properties -TEST_F(VerilogTest, R6_StmtConstruct) { +TEST_F(VerilogTest, StmtConstruct) { // VerilogStmt is abstract, test through VerilogAssign VerilogNetScalar *lhs = new VerilogNetScalar("a"); VerilogNetScalar *rhs = new VerilogNetScalar("b"); @@ -789,7 +789,7 @@ TEST_F(VerilogTest, R6_StmtConstruct) { } // VerilogStmt: destructor (via delete of derived) -TEST_F(VerilogTest, R6_StmtDelete) { +TEST_F(VerilogTest, StmtDelete) { VerilogNetScalar *lhs = new VerilogNetScalar("x"); VerilogNetScalar *rhs = new VerilogNetScalar("y"); VerilogStmt *stmt = new VerilogAssign(lhs, rhs, 1); @@ -798,7 +798,7 @@ TEST_F(VerilogTest, R6_StmtDelete) { } // VerilogInst: constructor and accessors -TEST_F(VerilogTest, R6_InstConstruct) { +TEST_F(VerilogTest, InstConstruct) { VerilogInst *inst = new VerilogModuleInst("INV", "u1", nullptr, new VerilogAttrStmtSeq, 1); EXPECT_TRUE(inst->isInstance()); @@ -809,7 +809,7 @@ TEST_F(VerilogTest, R6_InstConstruct) { } // VerilogInst: setInstanceName -TEST_F(VerilogTest, R6_InstSetName) { +TEST_F(VerilogTest, InstSetName) { VerilogModuleInst inst("BUF", "old_name", nullptr, new VerilogAttrStmtSeq, 1); EXPECT_EQ(inst.instanceName(), "old_name"); @@ -818,14 +818,14 @@ TEST_F(VerilogTest, R6_InstSetName) { } // VerilogModuleInst: hasPins with nullptr -TEST_F(VerilogTest, R6_ModuleInstHasPinsNull) { +TEST_F(VerilogTest, ModuleInstHasPinsNull) { VerilogModuleInst inst("INV", "u1", nullptr, new VerilogAttrStmtSeq, 1); EXPECT_FALSE(inst.hasPins()); } // VerilogModuleInst: hasPins with empty pins -TEST_F(VerilogTest, R6_ModuleInstHasPinsEmpty) { +TEST_F(VerilogTest, ModuleInstHasPinsEmpty) { VerilogNetSeq *pins = new VerilogNetSeq; VerilogModuleInst inst("INV", "u1", pins, new VerilogAttrStmtSeq, 1); @@ -833,7 +833,7 @@ TEST_F(VerilogTest, R6_ModuleInstHasPinsEmpty) { } // VerilogModuleInst: hasPins with pins -TEST_F(VerilogTest, R6_ModuleInstHasPinsTrue) { +TEST_F(VerilogTest, ModuleInstHasPinsTrue) { VerilogNetSeq *pins = new VerilogNetSeq; pins->push_back(new VerilogNetScalar("wire1")); VerilogModuleInst inst("INV", "u1", pins, @@ -842,14 +842,14 @@ TEST_F(VerilogTest, R6_ModuleInstHasPinsTrue) { } // VerilogModuleInst: moduleName -TEST_F(VerilogTest, R6_ModuleInstModuleName) { +TEST_F(VerilogTest, ModuleInstModuleName) { VerilogModuleInst inst("BUF_X2", "buffer1", nullptr, new VerilogAttrStmtSeq, 5); EXPECT_EQ(inst.moduleName(), "BUF_X2"); } // VerilogDcl: constructor with args seq -TEST_F(VerilogTest, R6_DclConstructSeq) { +TEST_F(VerilogTest, DclConstructSeq) { PortDirection::init(); VerilogDclArgSeq *args = new VerilogDclArgSeq; args->push_back(new VerilogDclArg("wire1")); @@ -862,7 +862,7 @@ TEST_F(VerilogTest, R6_DclConstructSeq) { } // VerilogDcl: portName -TEST_F(VerilogTest, R6_DclPortName) { +TEST_F(VerilogTest, DclPortName) { PortDirection::init(); VerilogDclArgSeq *args = new VerilogDclArgSeq; args->push_back(new VerilogDclArg("my_wire")); @@ -872,7 +872,7 @@ TEST_F(VerilogTest, R6_DclPortName) { } // VerilogDcl: appendArg -TEST_F(VerilogTest, R6_DclAppendArg) { +TEST_F(VerilogTest, DclAppendArg) { PortDirection::init(); VerilogDclArgSeq *args = new VerilogDclArgSeq; args->push_back(new VerilogDclArg("w1")); @@ -882,7 +882,7 @@ TEST_F(VerilogTest, R6_DclAppendArg) { } // VerilogDclBus: constructor with args seq -TEST_F(VerilogTest, R6_DclBusConstructSeq) { +TEST_F(VerilogTest, DclBusConstructSeq) { PortDirection::init(); VerilogDclArgSeq *args = new VerilogDclArgSeq; args->push_back(new VerilogDclArg("bus_wire")); @@ -896,7 +896,7 @@ TEST_F(VerilogTest, R6_DclBusConstructSeq) { } // VerilogDclBus: constructor with single arg -TEST_F(VerilogTest, R6_DclBusConstructSingle) { +TEST_F(VerilogTest, DclBusConstructSingle) { PortDirection::init(); VerilogDclArg *arg = new VerilogDclArg("single_bus"); VerilogDclBus dcl(PortDirection::output(), 3, 0, arg, @@ -906,7 +906,7 @@ TEST_F(VerilogTest, R6_DclBusConstructSingle) { } // VerilogDclBus: ascending range -TEST_F(VerilogTest, R6_DclBusAscending) { +TEST_F(VerilogTest, DclBusAscending) { PortDirection::init(); VerilogDclArgSeq *args = new VerilogDclArgSeq; args->push_back(new VerilogDclArg("asc_bus")); @@ -918,7 +918,7 @@ TEST_F(VerilogTest, R6_DclBusAscending) { } // VerilogAttrStmt: constructor -TEST_F(VerilogTest, R6_AttrStmtConstruct) { +TEST_F(VerilogTest, AttrStmtConstruct) { VerilogAttrEntrySeq *entries = new VerilogAttrEntrySeq; entries->push_back(new VerilogAttrEntry("key1", "val1")); VerilogAttrStmt stmt(entries); @@ -928,14 +928,14 @@ TEST_F(VerilogTest, R6_AttrStmtConstruct) { } // VerilogAttrEntry: constructor and accessors -TEST_F(VerilogTest, R6_AttrEntryConstruct) { +TEST_F(VerilogTest, AttrEntryConstruct) { VerilogAttrEntry entry("my_attr", "my_value"); EXPECT_EQ(entry.key(), "my_attr"); EXPECT_EQ(entry.value(), "my_value"); } // VerilogNetScalar: multiple instances -TEST_F(VerilogTest, R6_MultipleNetScalars) { +TEST_F(VerilogTest, MultipleNetScalars) { VerilogNetScalar net1("a"); VerilogNetScalar net2("b"); VerilogNetScalar net3("c"); @@ -948,14 +948,14 @@ TEST_F(VerilogTest, R6_MultipleNetScalars) { } // VerilogNetPortRefScalarNet: empty net name -TEST_F(VerilogTest, R6_PortRefScalarNetEmpty) { +TEST_F(VerilogTest, PortRefScalarNetEmpty) { VerilogNetPortRefScalarNet ref("port_a"); EXPECT_FALSE(ref.hasNet()); EXPECT_EQ(ref.netName(), ""); } // VerilogNetPortRefBit: index 0 -TEST_F(VerilogTest, R6_PortRefBitIndex0) { +TEST_F(VerilogTest, PortRefBitIndex0) { VerilogNetScalar *inner = new VerilogNetScalar("w"); VerilogNetPortRefBit ref("port", 0, inner); std::string rname = ref.name(); @@ -963,7 +963,7 @@ TEST_F(VerilogTest, R6_PortRefBitIndex0) { } // VerilogNetPortRefPart: ascending range -TEST_F(VerilogTest, R6_PortRefPartAsc) { +TEST_F(VerilogTest, PortRefPartAsc) { VerilogNetScalar *inner = new VerilogNetScalar("w"); VerilogNetPortRefPart ref("port", 0, 3, inner); std::string rname = ref.name(); @@ -972,7 +972,7 @@ TEST_F(VerilogTest, R6_PortRefPartAsc) { } // VerilogDcl: single arg constructor -TEST_F(VerilogTest, R6_DclSingleArg) { +TEST_F(VerilogTest, DclSingleArg) { PortDirection::init(); VerilogDclArg *arg = new VerilogDclArg("single_wire"); VerilogDcl dcl(PortDirection::input(), arg, new VerilogAttrStmtSeq, 1); @@ -981,59 +981,59 @@ TEST_F(VerilogTest, R6_DclSingleArg) { } // Additional name conversion tests -TEST_F(VerilogTest, R6_CellWithQuestionMark) { +TEST_F(VerilogTest, CellWithQuestionMark) { std::string result = cellVerilogName("cell?name"); EXPECT_EQ(result.front(), '\\'); } -TEST_F(VerilogTest, R6_InstanceWithSemicolon) { +TEST_F(VerilogTest, InstanceWithSemicolon) { std::string result = instanceVerilogName("inst;name"); EXPECT_EQ(result.front(), '\\'); } -TEST_F(VerilogTest, R6_NetWithComma) { +TEST_F(VerilogTest, NetWithComma) { std::string result = netVerilogName("net,name"); EXPECT_EQ(result.front(), '\\'); } -TEST_F(VerilogTest, R6_PortWithParens) { +TEST_F(VerilogTest, PortWithParens) { std::string result = portVerilogName("port(a)"); EXPECT_EQ(result.front(), '\\'); } -TEST_F(VerilogTest, R6_CellWithCurlyBraces) { +TEST_F(VerilogTest, CellWithCurlyBraces) { std::string result = cellVerilogName("cell{name}"); EXPECT_EQ(result.front(), '\\'); } -TEST_F(VerilogTest, R6_InstanceWithLessThan) { +TEST_F(VerilogTest, InstanceWithLessThan) { std::string result = instanceVerilogName("inst<0>"); EXPECT_EQ(result.front(), '\\'); } // VerilogToSta: net with bus range -TEST_F(VerilogTest, R6_EscapedNetRange) { +TEST_F(VerilogTest, EscapedNetRange) { std::string name = "\\data[7:0] "; std::string result = netVerilogToSta(&name); EXPECT_FALSE(result.empty()); } // VerilogToSta: module with digit prefix -TEST_F(VerilogTest, R6_ModuleDigitPrefix) { +TEST_F(VerilogTest, ModuleDigitPrefix) { std::string name = "123module"; std::string result = moduleVerilogToSta(&name); EXPECT_EQ(result, "123module"); } // portVerilogToSta: escaped -TEST_F(VerilogTest, R6_EscapedPortComplex) { +TEST_F(VerilogTest, EscapedPortComplex) { std::string name = "\\port.a[0]/b "; std::string result = portVerilogToSta(&name); EXPECT_FALSE(result.empty()); } // cellVerilogName round-trip with special chars -TEST_F(VerilogTest, R6_RoundTripSpecialCell) { +TEST_F(VerilogTest, RoundTripSpecialCell) { // STA name with escaped bracket std::string sta_name = "cell\\[0\\]"; std::string verilog = cellVerilogName(sta_name.c_str()); @@ -1041,13 +1041,13 @@ TEST_F(VerilogTest, R6_RoundTripSpecialCell) { } // instanceVerilogName: name with backslash in middle -TEST_F(VerilogTest, R6_InstanceBackslashMiddle) { +TEST_F(VerilogTest, InstanceBackslashMiddle) { std::string result = instanceVerilogName("inst\\mid"); EXPECT_FALSE(result.empty()); } // netVerilogName: escaped bracket bus -TEST_F(VerilogTest, R6_NetEscapedBracketBus2) { +TEST_F(VerilogTest, NetEscapedBracketBus2) { std::string result = netVerilogName("data\\[3\\]"); EXPECT_FALSE(result.empty()); } @@ -1057,7 +1057,7 @@ TEST_F(VerilogTest, R6_NetEscapedBracketBus2) { //////////////////////////////////////////////////////////////// // VerilogNetScalar::isScalar - uncovered -TEST_F(VerilogTest, R8_NetScalarIsScalar) { +TEST_F(VerilogTest, NetScalarIsScalar) { VerilogNetScalar net("scalar_w"); EXPECT_TRUE(net.isScalar()); EXPECT_TRUE(net.isNamed()); @@ -1065,7 +1065,7 @@ TEST_F(VerilogTest, R8_NetScalarIsScalar) { } // VerilogNetBitSelect::isScalar - uncovered (returns false) -TEST_F(VerilogTest, R8_NetBitSelectNotScalar) { +TEST_F(VerilogTest, NetBitSelectNotScalar) { VerilogNetBitSelect net("bus_w", 5); EXPECT_FALSE(net.isScalar()); EXPECT_TRUE(net.isNamed()); @@ -1074,7 +1074,7 @@ TEST_F(VerilogTest, R8_NetBitSelectNotScalar) { } // VerilogNetPartSelect::isScalar - uncovered (returns false) -TEST_F(VerilogTest, R8_NetPartSelectNotScalar) { +TEST_F(VerilogTest, NetPartSelectNotScalar) { VerilogNetPartSelect net("range_w", 15, 0); EXPECT_FALSE(net.isScalar()); EXPECT_EQ(net.fromIndex(), 15); @@ -1082,7 +1082,7 @@ TEST_F(VerilogTest, R8_NetPartSelectNotScalar) { } // VerilogNetPortRefScalarNet::isScalar - uncovered (returns true) -TEST_F(VerilogTest, R8_NetPortRefScalarNetIsScalar) { +TEST_F(VerilogTest, NetPortRefScalarNetIsScalar) { VerilogNetPortRefScalarNet ref("port_ref", "net_ref"); EXPECT_TRUE(ref.isScalar()); EXPECT_TRUE(ref.isNamedPortRef()); @@ -1091,7 +1091,7 @@ TEST_F(VerilogTest, R8_NetPortRefScalarNetIsScalar) { } // VerilogNetPortRefScalar::isScalar - uncovered (returns true) -TEST_F(VerilogTest, R8_NetPortRefScalarIsScalar) { +TEST_F(VerilogTest, NetPortRefScalarIsScalar) { VerilogNetScalar *inner = new VerilogNetScalar("inner_w"); VerilogNetPortRefScalar ref("pref_s", inner); EXPECT_TRUE(ref.isScalar()); @@ -1100,7 +1100,7 @@ TEST_F(VerilogTest, R8_NetPortRefScalarIsScalar) { } // VerilogNetUnnamed::isNamed - uncovered -TEST_F(VerilogTest, R8_NetUnnamedIsNamed) { +TEST_F(VerilogTest, NetUnnamedIsNamed) { VerilogNetSeq *nets = new VerilogNetSeq; VerilogNetConcat concat(nets); EXPECT_FALSE(concat.isNamed()); @@ -1108,7 +1108,7 @@ TEST_F(VerilogTest, R8_NetUnnamedIsNamed) { } // VerilogNetUnnamed::name - returns empty string -TEST_F(VerilogTest, R8_NetUnnamedName) { +TEST_F(VerilogTest, NetUnnamedName) { VerilogNetSeq *nets = new VerilogNetSeq; nets->push_back(new VerilogNetScalar("x")); VerilogNetConcat concat(nets); @@ -1117,7 +1117,7 @@ TEST_F(VerilogTest, R8_NetUnnamedName) { } // VerilogNetPortRefBit::name - uncovered -TEST_F(VerilogTest, R8_NetPortRefBitName) { +TEST_F(VerilogTest, NetPortRefBitName) { VerilogNetScalar *inner = new VerilogNetScalar("w1"); VerilogNetPortRefBit ref("port_bit", 7, inner); std::string n = ref.name(); @@ -1127,7 +1127,7 @@ TEST_F(VerilogTest, R8_NetPortRefBitName) { } // VerilogNetPortRefBit: index 0 -TEST_F(VerilogTest, R8_NetPortRefBitIndex0) { +TEST_F(VerilogTest, NetPortRefBitIndex0) { VerilogNetScalar *inner = new VerilogNetScalar("w2"); VerilogNetPortRefBit ref("p0", 0, inner); std::string n = ref.name(); @@ -1135,7 +1135,7 @@ TEST_F(VerilogTest, R8_NetPortRefBitIndex0) { } // VerilogNetPortRefBit: null inner net -TEST_F(VerilogTest, R8_NetPortRefBitNullNet) { +TEST_F(VerilogTest, NetPortRefBitNullNet) { VerilogNetPortRefBit ref("p_null", 3, nullptr); EXPECT_FALSE(ref.hasNet()); std::string n = ref.name(); @@ -1143,7 +1143,7 @@ TEST_F(VerilogTest, R8_NetPortRefBitNullNet) { } // VerilogStmt::isAssign - uncovered on base -TEST_F(VerilogTest, R8_StmtIsAssign) { +TEST_F(VerilogTest, StmtIsAssign) { VerilogNetScalar *lhs = new VerilogNetScalar("a"); VerilogNetScalar *rhs = new VerilogNetScalar("b"); VerilogAssign assign(lhs, rhs, 1); @@ -1155,7 +1155,7 @@ TEST_F(VerilogTest, R8_StmtIsAssign) { } // VerilogStmt destructor via delete -TEST_F(VerilogTest, R8_StmtDestructor) { +TEST_F(VerilogTest, StmtDestructor) { VerilogNetScalar *lhs = new VerilogNetScalar("x"); VerilogNetScalar *rhs = new VerilogNetScalar("y"); VerilogStmt *stmt = new VerilogAssign(lhs, rhs, 42); @@ -1165,7 +1165,7 @@ TEST_F(VerilogTest, R8_StmtDestructor) { } // VerilogInst: constructor and destructor -TEST_F(VerilogTest, R8_InstConstructDestruct) { +TEST_F(VerilogTest, InstConstructDestruct) { VerilogModuleInst *inst = new VerilogModuleInst( "AND2", "and_inst", nullptr, new VerilogAttrStmtSeq, 10); EXPECT_TRUE(inst->isInstance()); @@ -1178,7 +1178,7 @@ TEST_F(VerilogTest, R8_InstConstructDestruct) { } // VerilogModuleInst: pins with content -TEST_F(VerilogTest, R8_ModuleInstPinsContent) { +TEST_F(VerilogTest, ModuleInstPinsContent) { VerilogNetSeq *pins = new VerilogNetSeq; pins->push_back(new VerilogNetScalar("a_wire")); pins->push_back(new VerilogNetScalar("b_wire")); @@ -1189,7 +1189,7 @@ TEST_F(VerilogTest, R8_ModuleInstPinsContent) { } // VerilogModuleInst: setInstanceName -TEST_F(VerilogTest, R8_ModuleInstSetName) { +TEST_F(VerilogTest, ModuleInstSetName) { VerilogModuleInst inst("BUF", "old", nullptr, new VerilogAttrStmtSeq, 1); EXPECT_EQ(inst.instanceName(), "old"); @@ -1198,7 +1198,7 @@ TEST_F(VerilogTest, R8_ModuleInstSetName) { } // VerilogDcl: constructor with single arg -TEST_F(VerilogTest, R8_DclSingleArg) { +TEST_F(VerilogTest, DclSingleArg2) { PortDirection::init(); VerilogDclArg *arg = new VerilogDclArg("single_wire"); VerilogDcl dcl(PortDirection::input(), arg, new VerilogAttrStmtSeq, 5); @@ -1209,7 +1209,7 @@ TEST_F(VerilogTest, R8_DclSingleArg) { } // VerilogDcl: output direction -TEST_F(VerilogTest, R8_DclOutputDirection) { +TEST_F(VerilogTest, DclOutputDirection) { PortDirection::init(); VerilogDclArgSeq *args = new VerilogDclArgSeq; args->push_back(new VerilogDclArg("out_wire")); @@ -1218,7 +1218,7 @@ TEST_F(VerilogTest, R8_DclOutputDirection) { } // VerilogDcl: size -TEST_F(VerilogTest, R8_DclSize) { +TEST_F(VerilogTest, DclSize) { PortDirection::init(); VerilogDclArgSeq *args = new VerilogDclArgSeq; args->push_back(new VerilogDclArg("w1")); @@ -1227,7 +1227,7 @@ TEST_F(VerilogTest, R8_DclSize) { } // VerilogDclBus: size calculation -TEST_F(VerilogTest, R8_DclBusSize) { +TEST_F(VerilogTest, DclBusSize) { PortDirection::init(); VerilogDclArgSeq *args = new VerilogDclArgSeq; args->push_back(new VerilogDclArg("bus_w")); @@ -1238,7 +1238,7 @@ TEST_F(VerilogTest, R8_DclBusSize) { } // VerilogDclBus: ascending index -TEST_F(VerilogTest, R8_DclBusAscending) { +TEST_F(VerilogTest, DclBusAscending2) { PortDirection::init(); VerilogDclArgSeq *args = new VerilogDclArgSeq; args->push_back(new VerilogDclArg("bus_asc")); @@ -1250,7 +1250,7 @@ TEST_F(VerilogTest, R8_DclBusAscending) { } // VerilogDclBus: single-arg constructor -TEST_F(VerilogTest, R8_DclBusSingleArg) { +TEST_F(VerilogTest, DclBusSingleArg) { PortDirection::init(); VerilogDclArg *arg = new VerilogDclArg("single_bus"); VerilogDclBus dcl(PortDirection::output(), 3, 0, arg, @@ -1260,14 +1260,14 @@ TEST_F(VerilogTest, R8_DclBusSingleArg) { } // VerilogDclArg: named vs assign -TEST_F(VerilogTest, R8_DclArgNamed) { +TEST_F(VerilogTest, DclArgNamed) { VerilogDclArg arg("my_net"); EXPECT_TRUE(arg.isNamed()); EXPECT_EQ(arg.netName(), "my_net"); EXPECT_EQ(arg.assign(), nullptr); } -TEST_F(VerilogTest, R8_DclArgAssign) { +TEST_F(VerilogTest, DclArgAssign2) { VerilogNetScalar *lhs = new VerilogNetScalar("out"); VerilogNetScalar *rhs = new VerilogNetScalar("in"); VerilogAssign *assign = new VerilogAssign(lhs, rhs, 1); @@ -1277,7 +1277,7 @@ TEST_F(VerilogTest, R8_DclArgAssign) { } // VerilogAssign: accessors -TEST_F(VerilogTest, R8_AssignAccessors) { +TEST_F(VerilogTest, AssignAccessors) { VerilogNetScalar *lhs = new VerilogNetScalar("out"); VerilogNetScalar *rhs = new VerilogNetScalar("in"); VerilogAssign assign(lhs, rhs, 15); @@ -1288,7 +1288,7 @@ TEST_F(VerilogTest, R8_AssignAccessors) { } // VerilogNetNamed: constructor and destructor -TEST_F(VerilogTest, R8_NetNamedConstructDelete) { +TEST_F(VerilogTest, NetNamedConstructDelete) { VerilogNetNamed *net = new VerilogNetScalar("named_w"); EXPECT_TRUE(net->isNamed()); EXPECT_EQ(net->name(), "named_w"); @@ -1296,7 +1296,7 @@ TEST_F(VerilogTest, R8_NetNamedConstructDelete) { } // VerilogNetConcat: with multiple nets -TEST_F(VerilogTest, R8_NetConcatMultiple) { +TEST_F(VerilogTest, NetConcatMultiple) { VerilogNetSeq *nets = new VerilogNetSeq; nets->push_back(new VerilogNetScalar("a")); nets->push_back(new VerilogNetScalar("b")); @@ -1306,7 +1306,7 @@ TEST_F(VerilogTest, R8_NetConcatMultiple) { } // VerilogNetPortRef: constructor -TEST_F(VerilogTest, R8_NetPortRefConstruct) { +TEST_F(VerilogTest, NetPortRefConstruct2) { VerilogNetPortRefScalarNet ref("port_x"); EXPECT_TRUE(ref.isNamedPortRef()); EXPECT_FALSE(ref.hasNet()); @@ -1314,7 +1314,7 @@ TEST_F(VerilogTest, R8_NetPortRefConstruct) { } // VerilogNetPortRefScalarNet: various operations -TEST_F(VerilogTest, R8_NetPortRefScalarNetOps) { +TEST_F(VerilogTest, NetPortRefScalarNetOps) { VerilogNetPortRefScalarNet ref("port_y", "net_y"); EXPECT_TRUE(ref.hasNet()); EXPECT_EQ(ref.netName(), "net_y"); @@ -1323,14 +1323,14 @@ TEST_F(VerilogTest, R8_NetPortRefScalarNetOps) { } // VerilogNetPortRefScalar: null net -TEST_F(VerilogTest, R8_NetPortRefScalarNull) { +TEST_F(VerilogTest, NetPortRefScalarNull) { VerilogNetPortRefScalar ref("port_z", nullptr); EXPECT_FALSE(ref.hasNet()); EXPECT_TRUE(ref.isScalar()); } // VerilogNetPortRefPart: constructor -TEST_F(VerilogTest, R8_NetPortRefPartConstruct) { +TEST_F(VerilogTest, NetPortRefPartConstruct2) { VerilogNetScalar *inner = new VerilogNetScalar("w_part"); VerilogNetPortRefPart ref("port_part", 15, 0, inner); EXPECT_TRUE(ref.isNamedPortRef()); @@ -1340,14 +1340,14 @@ TEST_F(VerilogTest, R8_NetPortRefPartConstruct) { } // VerilogNetPortRefPart: ascending range -TEST_F(VerilogTest, R8_NetPortRefPartAscending) { +TEST_F(VerilogTest, NetPortRefPartAscending) { VerilogNetScalar *inner = new VerilogNetScalar("w_part_asc"); VerilogNetPortRefPart ref("port_asc", 0, 7, inner); EXPECT_EQ(ref.toIndex(), 7); } // VerilogAttrStmt: construction -TEST_F(VerilogTest, R8_AttrStmtConstruct) { +TEST_F(VerilogTest, AttrStmtConstruct2) { VerilogAttrEntrySeq *entries = new VerilogAttrEntrySeq; entries->push_back(new VerilogAttrEntry("key1", "val1")); VerilogAttrStmt stmt(entries); @@ -1357,14 +1357,14 @@ TEST_F(VerilogTest, R8_AttrStmtConstruct) { } // VerilogAttrEntry: key and value -TEST_F(VerilogTest, R8_AttrEntryKeyValue) { +TEST_F(VerilogTest, AttrEntryKeyValue) { VerilogAttrEntry entry("attr_key", "attr_value"); EXPECT_EQ(entry.key(), "attr_key"); EXPECT_EQ(entry.value(), "attr_value"); } // VerilogNetBitSelect: various indices -TEST_F(VerilogTest, R8_NetBitSelectLargeIndex) { +TEST_F(VerilogTest, NetBitSelectLargeIndex) { VerilogNetBitSelect net("data", 31); EXPECT_EQ(net.index(), 31); EXPECT_EQ(net.name(), "data[31]"); @@ -1372,7 +1372,7 @@ TEST_F(VerilogTest, R8_NetBitSelectLargeIndex) { } // VerilogNetPartSelect: equal indices -TEST_F(VerilogTest, R8_NetPartSelectEqual) { +TEST_F(VerilogTest, NetPartSelectEqual) { VerilogNetPartSelect net("single", 5, 5); EXPECT_EQ(net.fromIndex(), 5); EXPECT_EQ(net.toIndex(), 5); @@ -1380,78 +1380,78 @@ TEST_F(VerilogTest, R8_NetPartSelectEqual) { } // VerilogNetScalar: empty name -TEST_F(VerilogTest, R8_NetScalarEmptyName) { +TEST_F(VerilogTest, NetScalarEmptyName) { VerilogNetScalar net(""); EXPECT_TRUE(net.isScalar()); EXPECT_TRUE(net.name().empty()); } // Additional name conversion edge cases -TEST_F(VerilogTest, R8_CellNameWithBackslashEscape) { +TEST_F(VerilogTest, CellNameWithBackslashEscape) { std::string result = cellVerilogName("cell\\name"); EXPECT_FALSE(result.empty()); } -TEST_F(VerilogTest, R8_InstanceNameAllDigits) { +TEST_F(VerilogTest, InstanceNameAllDigits) { std::string result = instanceVerilogName("0123456789"); EXPECT_EQ(result, "0123456789"); } -TEST_F(VerilogTest, R8_NetNameSingleUnderscore) { +TEST_F(VerilogTest, NetNameSingleUnderscore) { EXPECT_EQ(netVerilogName("_"), "_"); } -TEST_F(VerilogTest, R8_PortNameSingleChar) { +TEST_F(VerilogTest, PortNameSingleChar) { EXPECT_EQ(portVerilogName("a"), "a"); } -TEST_F(VerilogTest, R8_CellNameWithBraces) { +TEST_F(VerilogTest, CellNameWithBraces) { std::string result = cellVerilogName("{a,b}"); EXPECT_EQ(result.front(), '\\'); } -TEST_F(VerilogTest, R8_InstanceNameWithStar) { +TEST_F(VerilogTest, InstanceNameWithStar) { std::string result = instanceVerilogName("inst*2"); EXPECT_EQ(result.front(), '\\'); } -TEST_F(VerilogTest, R8_NetNameWithQuote) { +TEST_F(VerilogTest, NetNameWithQuote) { std::string result = netVerilogName("net\"q"); EXPECT_EQ(result.front(), '\\'); } -TEST_F(VerilogTest, R8_PortNameWithBacktick) { +TEST_F(VerilogTest, PortNameWithBacktick) { std::string result = portVerilogName("port`tick"); EXPECT_EQ(result.front(), '\\'); } // Verilog to STA conversions: edge cases -TEST_F(VerilogTest, R8_EscapedInstanceOnlyBrackets) { +TEST_F(VerilogTest, EscapedInstanceOnlyBrackets) { std::string name = "\\[0] "; std::string result = instanceVerilogToSta(&name); EXPECT_FALSE(result.empty()); } -TEST_F(VerilogTest, R8_EscapedNetOnlySlash) { +TEST_F(VerilogTest, EscapedNetOnlySlash) { std::string name = "\\/ "; std::string result = netVerilogToSta(&name); EXPECT_FALSE(result.empty()); } -TEST_F(VerilogTest, R8_ModuleToStaEscapedComplex) { +TEST_F(VerilogTest, ModuleToStaEscapedComplex) { std::string name = "\\mod.a/b[1] "; std::string result = moduleVerilogToSta(&name); EXPECT_FALSE(result.empty()); } -TEST_F(VerilogTest, R8_PortToStaEscapedBracket) { +TEST_F(VerilogTest, PortToStaEscapedBracket) { std::string name = "\\port[3] "; std::string result = portVerilogToSta(&name); EXPECT_FALSE(result.empty()); } // VerilogDcl: appendArg -TEST_F(VerilogTest, R8_DclAppendMultiple) { +TEST_F(VerilogTest, DclAppendMultiple) { PortDirection::init(); VerilogDclArgSeq *args = new VerilogDclArgSeq; args->push_back(new VerilogDclArg("w1")); @@ -1462,7 +1462,7 @@ TEST_F(VerilogTest, R8_DclAppendMultiple) { } // Multiple VerilogNetScalar instances -TEST_F(VerilogTest, R8_MultipleNetScalars) { +TEST_F(VerilogTest, MultipleNetScalars2) { std::vector nets; for (int i = 0; i < 10; i++) { std::string name = "net_" + std::to_string(i); @@ -1478,7 +1478,7 @@ TEST_F(VerilogTest, R8_MultipleNetScalars) { } // VerilogModuleInst: namedPins with named port refs -TEST_F(VerilogTest, R8_ModuleInstNamedPins) { +TEST_F(VerilogTest, ModuleInstNamedPins) { VerilogNetSeq *pins = new VerilogNetSeq; pins->push_back(new VerilogNetPortRefScalarNet("A", "w1")); pins->push_back(new VerilogNetPortRefScalarNet("Y", "w2")); @@ -1489,7 +1489,7 @@ TEST_F(VerilogTest, R8_ModuleInstNamedPins) { } // VerilogModuleInst: ordered pins (not named) -TEST_F(VerilogTest, R8_ModuleInstOrderedPins) { +TEST_F(VerilogTest, ModuleInstOrderedPins) { VerilogNetSeq *pins = new VerilogNetSeq; pins->push_back(new VerilogNetScalar("w1")); pins->push_back(new VerilogNetScalar("w2")); @@ -1500,7 +1500,7 @@ TEST_F(VerilogTest, R8_ModuleInstOrderedPins) { } // VerilogNetPortRefScalarNet: empty net name -TEST_F(VerilogTest, R8_PortRefScalarNetEmptyName) { +TEST_F(VerilogTest, PortRefScalarNetEmptyName) { VerilogNetPortRefScalarNet ref("port_empty"); EXPECT_FALSE(ref.hasNet()); EXPECT_TRUE(ref.netName().empty()); @@ -1511,7 +1511,7 @@ TEST_F(VerilogTest, R8_PortRefScalarNetEmptyName) { //////////////////////////////////////////////////////////////// // VerilogNetScalar: exercises various named operations -TEST_F(VerilogTest, R9_NetScalarOperations) { +TEST_F(VerilogTest, NetScalarOperations) { VerilogNetScalar net("test_wire"); EXPECT_TRUE(net.isNamed()); EXPECT_TRUE(net.isScalar()); @@ -1521,14 +1521,14 @@ TEST_F(VerilogTest, R9_NetScalarOperations) { } // VerilogNetBitSelect: negative index edge case -TEST_F(VerilogTest, R9_NetBitSelectNegativeIndex) { +TEST_F(VerilogTest, NetBitSelectNegativeIndex) { VerilogNetBitSelect net("data", -1); EXPECT_FALSE(net.isScalar()); EXPECT_EQ(net.index(), -1); } // VerilogNetPartSelect: single bit range -TEST_F(VerilogTest, R9_NetPartSelectSingleBit) { +TEST_F(VerilogTest, NetPartSelectSingleBit) { VerilogNetPartSelect net("bus", 0, 0); EXPECT_FALSE(net.isScalar()); EXPECT_EQ(net.fromIndex(), 0); @@ -1536,7 +1536,7 @@ TEST_F(VerilogTest, R9_NetPartSelectSingleBit) { } // VerilogNetConcat: with multiple nested types -TEST_F(VerilogTest, R9_NetConcatMixedTypes) { +TEST_F(VerilogTest, NetConcatMixedTypes) { VerilogNetSeq *nets = new VerilogNetSeq; nets->push_back(new VerilogNetScalar("a")); nets->push_back(new VerilogNetBitSelect("b", 0)); @@ -1547,7 +1547,7 @@ TEST_F(VerilogTest, R9_NetConcatMixedTypes) { } // VerilogNetPortRefScalarNet: setNetName then clear -TEST_F(VerilogTest, R9_PortRefScalarNetSetClear) { +TEST_F(VerilogTest, PortRefScalarNetSetClear) { VerilogNetPortRefScalarNet ref("port_a"); EXPECT_FALSE(ref.hasNet()); ref.setNetName("wire_a"); @@ -1558,7 +1558,7 @@ TEST_F(VerilogTest, R9_PortRefScalarNetSetClear) { } // VerilogNetPortRefScalar: with bit select net -TEST_F(VerilogTest, R9_PortRefScalarWithBitSelect) { +TEST_F(VerilogTest, PortRefScalarWithBitSelect) { VerilogNetBitSelect *inner = new VerilogNetBitSelect("data", 5); VerilogNetPortRefScalar ref("port_data", inner); EXPECT_TRUE(ref.isScalar()); @@ -1566,7 +1566,7 @@ TEST_F(VerilogTest, R9_PortRefScalarWithBitSelect) { } // VerilogNetPortRefBit: with part select net -TEST_F(VerilogTest, R9_PortRefBitWithPartSelect) { +TEST_F(VerilogTest, PortRefBitWithPartSelect) { VerilogNetPartSelect *inner = new VerilogNetPartSelect("bus", 7, 0); VerilogNetPortRefBit ref("port_bus", 0, inner); EXPECT_TRUE(ref.isNamedPortRef()); @@ -1574,7 +1574,7 @@ TEST_F(VerilogTest, R9_PortRefBitWithPartSelect) { } // VerilogNetPortRefPart: with concat net -TEST_F(VerilogTest, R9_PortRefPartWithConcat) { +TEST_F(VerilogTest, PortRefPartWithConcat) { VerilogNetSeq *nets = new VerilogNetSeq; nets->push_back(new VerilogNetScalar("x")); nets->push_back(new VerilogNetScalar("y")); @@ -1585,7 +1585,7 @@ TEST_F(VerilogTest, R9_PortRefPartWithConcat) { } // VerilogModuleInst: with large pin count -TEST_F(VerilogTest, R9_ModuleInstManyPins) { +TEST_F(VerilogTest, ModuleInstManyPins) { VerilogNetSeq *pins = new VerilogNetSeq; for (int i = 0; i < 20; i++) { std::string pname = "pin_" + std::to_string(i); @@ -1600,7 +1600,7 @@ TEST_F(VerilogTest, R9_ModuleInstManyPins) { } // VerilogModuleInst: with mixed pin types -TEST_F(VerilogTest, R9_ModuleInstMixedPins) { +TEST_F(VerilogTest, ModuleInstMixedPins) { VerilogNetSeq *pins = new VerilogNetSeq; pins->push_back(new VerilogNetPortRefScalarNet("A", "w1")); pins->push_back(new VerilogNetPortRefScalarNet("Y")); @@ -1611,7 +1611,7 @@ TEST_F(VerilogTest, R9_ModuleInstMixedPins) { } // VerilogDcl: various directions -TEST_F(VerilogTest, R9_DclBidirectional) { +TEST_F(VerilogTest, DclBidirectional) { PortDirection::init(); VerilogDclArg *arg = new VerilogDclArg("bidir_port"); VerilogDcl dcl(PortDirection::bidirect(), arg, new VerilogAttrStmtSeq, 1); @@ -1620,7 +1620,7 @@ TEST_F(VerilogTest, R9_DclBidirectional) { } // VerilogDcl: appendArg to seq -TEST_F(VerilogTest, R9_DclAppendArgMultiple) { +TEST_F(VerilogTest, DclAppendArgMultiple) { PortDirection::init(); VerilogDclArgSeq *args = new VerilogDclArgSeq; args->push_back(new VerilogDclArg("w1")); @@ -1632,7 +1632,7 @@ TEST_F(VerilogTest, R9_DclAppendArgMultiple) { } // VerilogDclBus: large bus -TEST_F(VerilogTest, R9_DclBusLarge) { +TEST_F(VerilogTest, DclBusLarge) { PortDirection::init(); VerilogDclArgSeq *args = new VerilogDclArgSeq; args->push_back(new VerilogDclArg("wide_bus")); @@ -1643,7 +1643,7 @@ TEST_F(VerilogTest, R9_DclBusLarge) { } // VerilogDclBus: descending range -TEST_F(VerilogTest, R9_DclBusDescending) { +TEST_F(VerilogTest, DclBusDescending) { PortDirection::init(); VerilogDclArgSeq *args = new VerilogDclArgSeq; args->push_back(new VerilogDclArg("desc_bus")); @@ -1655,7 +1655,7 @@ TEST_F(VerilogTest, R9_DclBusDescending) { } // VerilogAttrStmt: multiple entries -TEST_F(VerilogTest, R9_AttrStmtMultipleEntries) { +TEST_F(VerilogTest, AttrStmtMultipleEntries) { VerilogAttrEntrySeq *entries = new VerilogAttrEntrySeq; entries->push_back(new VerilogAttrEntry("attr1", "val1")); entries->push_back(new VerilogAttrEntry("attr2", "val2")); @@ -1665,14 +1665,14 @@ TEST_F(VerilogTest, R9_AttrStmtMultipleEntries) { } // VerilogAttrEntry: empty key and value -TEST_F(VerilogTest, R9_AttrEntryEmpty) { +TEST_F(VerilogTest, AttrEntryEmpty) { VerilogAttrEntry entry("", ""); EXPECT_TRUE(entry.key().empty()); EXPECT_TRUE(entry.value().empty()); } // VerilogAssign: with concat lhs -TEST_F(VerilogTest, R9_AssignConcatLhs) { +TEST_F(VerilogTest, AssignConcatLhs) { VerilogNetSeq *nets = new VerilogNetSeq; nets->push_back(new VerilogNetScalar("a")); nets->push_back(new VerilogNetScalar("b")); @@ -1684,7 +1684,7 @@ TEST_F(VerilogTest, R9_AssignConcatLhs) { } // VerilogInst: destructor coverage -TEST_F(VerilogTest, R9_InstDestructor) { +TEST_F(VerilogTest, InstDestructor) { VerilogNetSeq *pins = new VerilogNetSeq; pins->push_back(new VerilogNetScalar("w1")); VerilogModuleInst *inst = new VerilogModuleInst( @@ -1695,7 +1695,7 @@ TEST_F(VerilogTest, R9_InstDestructor) { } // VerilogStmt: line accessor -TEST_F(VerilogTest, R9_StmtLineAccessor) { +TEST_F(VerilogTest, StmtLineAccessor) { VerilogNetScalar *lhs = new VerilogNetScalar("a"); VerilogNetScalar *rhs = new VerilogNetScalar("b"); VerilogAssign assign(lhs, rhs, 100); @@ -1703,58 +1703,58 @@ TEST_F(VerilogTest, R9_StmtLineAccessor) { } // Additional namespace conversion edge cases -TEST_F(VerilogTest, R9_CellNameWithNewline) { +TEST_F(VerilogTest, CellNameWithNewline) { std::string result = cellVerilogName("cell\nname"); EXPECT_EQ(result.front(), '\\'); EXPECT_EQ(result.back(), ' '); } -TEST_F(VerilogTest, R9_InstanceNameWithCarriageReturn) { +TEST_F(VerilogTest, InstanceNameWithCarriageReturn) { std::string result = instanceVerilogName("inst\rname"); EXPECT_EQ(result.front(), '\\'); } -TEST_F(VerilogTest, R9_NetNameWithNull) { +TEST_F(VerilogTest, NetNameWithNull) { // Test with single character that is not alphanumeric or underscore std::string result = netVerilogName("net!name"); EXPECT_EQ(result.front(), '\\'); } -TEST_F(VerilogTest, R9_PortNameMixedSpecial) { +TEST_F(VerilogTest, PortNameMixedSpecial) { std::string result = portVerilogName("port/name[0]"); EXPECT_EQ(result.front(), '\\'); EXPECT_EQ(result.back(), ' '); } // Round-trip tests: staToVerilog -> verilogToSta should preserve identity for simple names -TEST_F(VerilogTest, R9_RoundTripSimpleName) { +TEST_F(VerilogTest, RoundTripSimpleName) { std::string sta_name = "simple_wire"; std::string verilog = netVerilogName(sta_name.c_str()); std::string back = netVerilogToSta(&verilog); EXPECT_EQ(back, sta_name); } -TEST_F(VerilogTest, R9_RoundTripSimpleCell) { +TEST_F(VerilogTest, RoundTripSimpleCell) { std::string sta_name = "my_cell_123"; std::string verilog = cellVerilogName(sta_name.c_str()); EXPECT_EQ(verilog, sta_name); // no escaping needed } -TEST_F(VerilogTest, R9_RoundTripSimpleInstance) { +TEST_F(VerilogTest, RoundTripSimpleInstance) { std::string sta_name = "u1_abc"; std::string verilog = instanceVerilogName(sta_name.c_str()); std::string back = instanceVerilogToSta(&verilog); EXPECT_EQ(back, sta_name); } -TEST_F(VerilogTest, R9_RoundTripSimplePort) { +TEST_F(VerilogTest, RoundTripSimplePort) { std::string sta_name = "clk_in"; std::string verilog = portVerilogName(sta_name.c_str()); std::string back = portVerilogToSta(&verilog); EXPECT_EQ(back, sta_name); } -TEST_F(VerilogTest, R9_RoundTripSimpleModule) { +TEST_F(VerilogTest, RoundTripSimpleModule) { std::string sta_name = "top_module"; std::string verilog = cellVerilogName(sta_name.c_str()); std::string back = moduleVerilogToSta(&verilog); @@ -1762,14 +1762,14 @@ TEST_F(VerilogTest, R9_RoundTripSimpleModule) { } // VerilogNetPortRefScalarNet: constructor with empty strings -TEST_F(VerilogTest, R9_PortRefScalarNetEmptyBoth) { +TEST_F(VerilogTest, PortRefScalarNetEmptyBoth) { VerilogNetPortRefScalarNet ref(""); EXPECT_TRUE(ref.name().empty()); EXPECT_FALSE(ref.hasNet()); } // VerilogModuleInst: with null pins and null attrs -TEST_F(VerilogTest, R9_ModuleInstNullPinsAndAttrs) { +TEST_F(VerilogTest, ModuleInstNullPinsAndAttrs) { VerilogModuleInst inst("CELL", "u1", nullptr, new VerilogAttrStmtSeq, 1); EXPECT_FALSE(inst.hasPins()); @@ -1777,7 +1777,7 @@ TEST_F(VerilogTest, R9_ModuleInstNullPinsAndAttrs) { } // VerilogDclArg: with long name -TEST_F(VerilogTest, R9_DclArgLongName) { +TEST_F(VerilogTest, DclArgLongName) { std::string long_name(200, 'w'); VerilogDclArg arg(long_name); EXPECT_TRUE(arg.isNamed()); @@ -1785,7 +1785,7 @@ TEST_F(VerilogTest, R9_DclArgLongName) { } // VerilogDcl: portName with bus arg -TEST_F(VerilogTest, R9_DclBusPortName) { +TEST_F(VerilogTest, DclBusPortName) { PortDirection::init(); VerilogDclArgSeq *args = new VerilogDclArgSeq; args->push_back(new VerilogDclArg("bus_port")); @@ -1801,7 +1801,7 @@ TEST_F(VerilogTest, R9_DclBusPortName) { // Test net bus range conversion from verilog to STA format // Covers: netVerilogToSta bus name conversion -TEST_F(VerilogTest, R10_NetBusRangeConversion) { +TEST_F(VerilogTest, NetBusRangeConversion) { // Verilog bus notation should convert properly std::string verilog_name = "data[3]"; std::string net_name = netVerilogToSta(&verilog_name); @@ -1810,7 +1810,7 @@ TEST_F(VerilogTest, R10_NetBusRangeConversion) { // Test instance name starting with digit (needs escaping) // Covers: instanceVerilogName escape handling -TEST_F(VerilogTest, R10_InstanceDigitStart) { +TEST_F(VerilogTest, InstanceDigitStart) { std::string name = instanceVerilogName("123abc"); // Instance names starting with digit get escaped in Verilog EXPECT_FALSE(name.empty()); @@ -1818,14 +1818,14 @@ TEST_F(VerilogTest, R10_InstanceDigitStart) { // Test cell name with special characters // Covers: cellVerilogName special char handling -TEST_F(VerilogTest, R10_CellWithHyphen) { +TEST_F(VerilogTest, CellWithHyphen2) { std::string name = cellVerilogName("cell-name"); EXPECT_FALSE(name.empty()); } // Test empty name handling // Covers: various name conversion with empty strings -TEST_F(VerilogTest, R10_EmptyNames) { +TEST_F(VerilogTest, EmptyNames) { std::string cell = cellVerilogName(""); std::string inst = instanceVerilogName(""); std::string net = netVerilogName(""); @@ -1836,7 +1836,7 @@ TEST_F(VerilogTest, R10_EmptyNames) { // Test bus name from verilog to sta conversion // Covers: netVerilogToSta with bus notation -TEST_F(VerilogTest, R10_BusVerilogToSta) { +TEST_F(VerilogTest, BusVerilogToSta) { std::string verilog_name = "bus[7:0]"; std::string bus = netVerilogToSta(&verilog_name); EXPECT_FALSE(bus.empty()); @@ -1844,7 +1844,7 @@ TEST_F(VerilogTest, R10_BusVerilogToSta) { // Test escaped instance name to STA conversion // Covers: instanceVerilogToSta with escaped name -TEST_F(VerilogTest, R10_EscapedInstanceToSta) { +TEST_F(VerilogTest, EscapedInstanceToSta) { std::string verilog_name = "\\inst[0] "; std::string name = instanceVerilogToSta(&verilog_name); EXPECT_FALSE(name.empty()); @@ -1852,7 +1852,7 @@ TEST_F(VerilogTest, R10_EscapedInstanceToSta) { // Test verilog to STA net conversion with brackets // Covers: netVerilogToSta bracket handling -TEST_F(VerilogTest, R10_NetVerilogToStaBrackets) { +TEST_F(VerilogTest, NetVerilogToStaBrackets) { std::string name1 = "wire1"; std::string net1 = netVerilogToSta(&name1); EXPECT_EQ(net1, "wire1"); @@ -1863,35 +1863,35 @@ TEST_F(VerilogTest, R10_NetVerilogToStaBrackets) { // Test port verilog name with brackets // Covers: portVerilogName bracket/escape handling -TEST_F(VerilogTest, R10_PortWithBrackets) { +TEST_F(VerilogTest, PortWithBrackets2) { std::string name = portVerilogName("data[0]"); EXPECT_FALSE(name.empty()); } // Test cell name that needs escaping // Covers: cellVerilogName with slash -TEST_F(VerilogTest, R10_CellWithSlash) { +TEST_F(VerilogTest, CellWithSlash) { std::string name = cellVerilogName("lib/cell"); EXPECT_FALSE(name.empty()); } // Test net name with multiple special chars // Covers: netVerilogName with special chars -TEST_F(VerilogTest, R10_NetSpecialChars) { +TEST_F(VerilogTest, NetSpecialChars) { std::string name = netVerilogName("net.a/b"); EXPECT_FALSE(name.empty()); } // Test STA to Verilog port name conversion // Covers: portVerilogName with hierarchy separator -TEST_F(VerilogTest, R10_PortHierSep) { +TEST_F(VerilogTest, PortHierSep) { std::string name = portVerilogName("block/port"); EXPECT_FALSE(name.empty()); } // Test instance Verilog to STA with regular name // Covers: instanceVerilogToSta simple case -TEST_F(VerilogTest, R10_InstanceToStaSimple) { +TEST_F(VerilogTest, InstanceToStaSimple) { std::string verilog_name = "u1"; std::string name = instanceVerilogToSta(&verilog_name); EXPECT_EQ(name, "u1"); @@ -1899,7 +1899,7 @@ TEST_F(VerilogTest, R10_InstanceToStaSimple) { // Test VerilogDclArg with string name // Covers: VerilogDclArg constructor, isNamed, netName -TEST_F(VerilogTest, R10_DclArgBasic) { +TEST_F(VerilogTest, DclArgBasic) { VerilogDclArg arg("test_net"); EXPECT_TRUE(arg.isNamed()); EXPECT_EQ(arg.netName(), "test_net"); @@ -1907,7 +1907,7 @@ TEST_F(VerilogTest, R10_DclArgBasic) { // Test VerilogDcl portName // Covers: VerilogDcl::portName -TEST_F(VerilogTest, R10_DclPortName) { +TEST_F(VerilogTest, DclPortName2) { PortDirection::init(); VerilogDclArgSeq *args = new VerilogDclArgSeq; args->push_back(new VerilogDclArg("my_port")); @@ -1917,7 +1917,7 @@ TEST_F(VerilogTest, R10_DclPortName) { // Test VerilogDclBus with different ranges // Covers: VerilogDclBus constructor, portName with different bit ranges -TEST_F(VerilogTest, R10_DclBusDifferentRange) { +TEST_F(VerilogTest, DclBusDifferentRange) { PortDirection::init(); VerilogDclArgSeq *args = new VerilogDclArgSeq; args->push_back(new VerilogDclArg("wide_bus")); @@ -2005,7 +2005,7 @@ protected: // Test readVerilog exercises the VerilogReader, VerilogScanner, VerilogModule paths // Covers: makeVerilogReader, readVerilogFile, deleteVerilogReader, // VerilogScanner, VerilogReader::module -TEST_F(VerilogDesignTest, R9_ReadVerilogExercisesReader) { +TEST_F(VerilogDesignTest, ReadVerilogExercisesReader) { ASSERT_TRUE(design_loaded_); // The design was already loaded via readVerilog in SetUp // Verify we have a valid network @@ -2017,7 +2017,7 @@ TEST_F(VerilogDesignTest, R9_ReadVerilogExercisesReader) { // Test writeVerilog exercises VerilogWriter // Covers: writeVerilog, VerilogWriter::findHierChildren -TEST_F(VerilogDesignTest, R9_WriteVerilog) { +TEST_F(VerilogDesignTest, WriteVerilog) { ASSERT_TRUE(design_loaded_); const char *tmpfile = "/tmp/test_r9_verilog_out.v"; @@ -2035,7 +2035,7 @@ TEST_F(VerilogDesignTest, R9_WriteVerilog) { // Test writeVerilog with include_pwr_gnd flag // Covers: VerilogWriter power/ground pin handling -TEST_F(VerilogDesignTest, R9_WriteVerilogWithPwrGnd) { +TEST_F(VerilogDesignTest, WriteVerilogWithPwrGnd) { ASSERT_TRUE(design_loaded_); const char *tmpfile = "/tmp/test_r9_verilog_pwrgnd.v"; @@ -2053,7 +2053,7 @@ TEST_F(VerilogDesignTest, R9_WriteVerilogWithPwrGnd) { // Test writeVerilog then re-read round-trip // Covers: readVerilog + writeVerilog round-trip, VerilogReader error paths -TEST_F(VerilogDesignTest, R9_WriteReadVerilogRoundTrip) { +TEST_F(VerilogDesignTest, WriteReadVerilogRoundTrip) { ASSERT_TRUE(design_loaded_); const char *tmpfile = "/tmp/test_r9_verilog_rt.v"; @@ -2071,7 +2071,7 @@ TEST_F(VerilogDesignTest, R9_WriteReadVerilogRoundTrip) { // Test readVerilog with nonexistent file throws FileNotReadable // Covers: VerilogReader/VerilogScanner error handling -TEST_F(VerilogDesignTest, R9_ReadVerilogNonexistent) { +TEST_F(VerilogDesignTest, ReadVerilogNonexistent) { ASSERT_TRUE(design_loaded_); EXPECT_THROW( @@ -2082,7 +2082,7 @@ TEST_F(VerilogDesignTest, R9_ReadVerilogNonexistent) { // Test network topology after readVerilog // Covers: VerilogReader::makeNamedPortRefCellPorts, VerilogBindingTbl::bind -TEST_F(VerilogDesignTest, R9_VerifyNetworkTopology) { +TEST_F(VerilogDesignTest, VerifyNetworkTopology) { ASSERT_TRUE(design_loaded_); Network *network = sta_->network(); @@ -2105,7 +2105,7 @@ TEST_F(VerilogDesignTest, R9_VerifyNetworkTopology) { // Test network instances after readVerilog // Covers: VerilogInst, VerilogModuleInst linking -TEST_F(VerilogDesignTest, R9_VerifyNetworkInstances) { +TEST_F(VerilogDesignTest, VerifyNetworkInstances) { ASSERT_TRUE(design_loaded_); Network *network = sta_->network(); @@ -2125,7 +2125,7 @@ TEST_F(VerilogDesignTest, R9_VerifyNetworkInstances) { // Test network nets after readVerilog // Covers: VerilogNetNamed, VerilogNetScalar linking -TEST_F(VerilogDesignTest, R9_VerifyNetworkNets) { +TEST_F(VerilogDesignTest, VerifyNetworkNets) { ASSERT_TRUE(design_loaded_); Network *network = sta_->network(); @@ -2145,7 +2145,7 @@ TEST_F(VerilogDesignTest, R9_VerifyNetworkNets) { // Test writeVerilog with remove_cells // Covers: VerilogWriter cell filtering path -TEST_F(VerilogDesignTest, R9_WriteVerilogRemoveCells) { +TEST_F(VerilogDesignTest, WriteVerilogRemoveCells) { ASSERT_TRUE(design_loaded_); const char *tmpfile = "/tmp/test_r9_verilog_rmcells.v"; @@ -2164,7 +2164,7 @@ TEST_F(VerilogDesignTest, R9_WriteVerilogRemoveCells) { // Test graph construction triggers VerilogReader paths // Covers: VerilogReader cell/instance lookup -TEST_F(VerilogDesignTest, R9_EnsureGraphVerify) { +TEST_F(VerilogDesignTest, EnsureGraphVerify) { ASSERT_TRUE(design_loaded_); sta_->ensureGraph(); @@ -2187,7 +2187,7 @@ TEST_F(VerilogDesignTest, R9_EnsureGraphVerify) { // Test multiple readVerilog calls (re-read) // Covers: VerilogReader::readNetlistBefore, cleanup paths -TEST_F(VerilogDesignTest, R9_ReadVerilogTwice) { +TEST_F(VerilogDesignTest, ReadVerilogTwice) { ASSERT_TRUE(design_loaded_); // Re-read the same verilog @@ -2208,7 +2208,7 @@ TEST_F(VerilogDesignTest, R9_ReadVerilogTwice) { // Test reading verilog with positional (ordered) pin connections // Covers: VerilogReader::makeOrderedInstPins -TEST_F(VerilogDesignTest, R10_ReadPositionalConnections) { +TEST_F(VerilogDesignTest, ReadPositionalConnections) { ASSERT_TRUE(design_loaded_); // Read verilog with positional connections @@ -2233,7 +2233,7 @@ TEST_F(VerilogDesignTest, R10_ReadPositionalConnections) { // Test reading verilog with constant net connections (1'b1, 1'b0) // Covers: VerilogNetConstant, constant pin handling -TEST_F(VerilogDesignTest, R10_ReadConstantConnections) { +TEST_F(VerilogDesignTest, ReadConstantConnections) { ASSERT_TRUE(design_loaded_); bool result = sta_->readVerilog("verilog/test/constant_net.v"); @@ -2254,7 +2254,7 @@ TEST_F(VerilogDesignTest, R10_ReadConstantConnections) { // Test reading verilog with assign statements // Covers: VerilogStmt::isAssign, VerilogAssign -TEST_F(VerilogDesignTest, R10_ReadAssignStatements) { +TEST_F(VerilogDesignTest, ReadAssignStatements) { ASSERT_TRUE(design_loaded_); bool result = sta_->readVerilog("verilog/test/assign_net.v"); @@ -2273,7 +2273,7 @@ TEST_F(VerilogDesignTest, R10_ReadAssignStatements) { // Test reading verilog with bus bit select connections // Covers: makeNetNamedPortRefBit, makeNetNamedPortRefPart -TEST_F(VerilogDesignTest, R10_ReadBusConnections) { +TEST_F(VerilogDesignTest, ReadBusConnections) { ASSERT_TRUE(design_loaded_); bool result = sta_->readVerilog("verilog/test/bus_connect.v"); @@ -2295,7 +2295,7 @@ TEST_F(VerilogDesignTest, R10_ReadBusConnections) { // Test reading same design again (basic reload) // Covers: readVerilog overwrite, VerilogReader cleanup paths -TEST_F(VerilogDesignTest, R10_ReadConcatenation) { +TEST_F(VerilogDesignTest, ReadConcatenation) { ASSERT_TRUE(design_loaded_); // Just re-read the base design @@ -2311,7 +2311,7 @@ TEST_F(VerilogDesignTest, R10_ReadConcatenation) { // Test reading a wrapper module that instantiates a black box // Covers: VerilogReader::makeBlackBox, unknown cell handling -TEST_F(VerilogDesignTest, R10_ReadBlackBoxModule) { +TEST_F(VerilogDesignTest, ReadBlackBoxModule) { ASSERT_TRUE(design_loaded_); // Create a temporary verilog file with a black box @@ -2339,7 +2339,7 @@ TEST_F(VerilogDesignTest, R10_ReadBlackBoxModule) { // Test writeVerilog with sorted output // Covers: writeVerilog, VerilogWriter::writeModule sorted -TEST_F(VerilogDesignTest, R10_WriteVerilogSorted) { +TEST_F(VerilogDesignTest, WriteVerilogSorted) { ASSERT_TRUE(design_loaded_); Network *network = sta_->network(); @@ -2360,7 +2360,7 @@ TEST_F(VerilogDesignTest, R10_WriteVerilogSorted) { // Test reading verilog with escaped names // Covers: VerilogReader escaped name handling -TEST_F(VerilogDesignTest, R10_ReadEscapedNames) { +TEST_F(VerilogDesignTest, ReadEscapedNames) { ASSERT_TRUE(design_loaded_); const char *esc_file = "verilog/test/escaped_r10.v"; @@ -2388,7 +2388,7 @@ TEST_F(VerilogDesignTest, R10_ReadEscapedNames) { // Test reading verilog with unconnected ports (empty parens) // Covers: VerilogReader empty port ref handling -TEST_F(VerilogDesignTest, R10_ReadUnconnectedPorts) { +TEST_F(VerilogDesignTest, ReadUnconnectedPorts) { ASSERT_TRUE(design_loaded_); const char *unc_file = "verilog/test/unconn_r10.v"; @@ -2415,7 +2415,7 @@ TEST_F(VerilogDesignTest, R10_ReadUnconnectedPorts) { // Test reading hierarchical modules // Covers: VerilogReader multi-module handling, linkModule -TEST_F(VerilogDesignTest, R10_ReadMultipleModules) { +TEST_F(VerilogDesignTest, ReadMultipleModules) { ASSERT_TRUE(design_loaded_); const char *hier_file = "verilog/test/hier_r10.v"; @@ -2451,7 +2451,7 @@ TEST_F(VerilogDesignTest, R10_ReadMultipleModules) { // Test reading a non-existent file (error path) // Covers: VerilogReader file open error path -TEST_F(VerilogDesignTest, R10_ReadNonexistentFile) { +TEST_F(VerilogDesignTest, ReadNonexistentFile) { ASSERT_TRUE(design_loaded_); // readVerilog throws an exception for non-existent files @@ -2460,7 +2460,7 @@ TEST_F(VerilogDesignTest, R10_ReadNonexistentFile) { // Test reading with warning-level constructs // Covers: VerilogReader warning paths (duplicate module, etc.) -TEST_F(VerilogDesignTest, R10_ReadWithWarningConstructs) { +TEST_F(VerilogDesignTest, ReadWithWarningConstructs) { ASSERT_TRUE(design_loaded_); const char *warn_file = "verilog/test/warn_r10.v"; @@ -2487,7 +2487,7 @@ TEST_F(VerilogDesignTest, R10_ReadWithWarningConstructs) { // Test writeVerilog with remove cells filter // Covers: VerilogWriter cell removal filtering -TEST_F(VerilogDesignTest, R10_WriteVerilogRemoveCellsActual) { +TEST_F(VerilogDesignTest, WriteVerilogRemoveCellsActual) { ASSERT_TRUE(design_loaded_); Network *network = sta_->network(); @@ -2508,7 +2508,7 @@ TEST_F(VerilogDesignTest, R10_WriteVerilogRemoveCellsActual) { // Test writeVerilog with power/ground net inclusion // Covers: VerilogWriter include_pwr_gnd flag -TEST_F(VerilogDesignTest, R10_WriteVerilogPwrGndTrue) { +TEST_F(VerilogDesignTest, WriteVerilogPwrGndTrue) { ASSERT_TRUE(design_loaded_); Network *network = sta_->network(); @@ -2528,7 +2528,7 @@ TEST_F(VerilogDesignTest, R10_WriteVerilogPwrGndTrue) { // Test read-write-read round trip // Covers: VerilogReader + VerilogWriter pipeline -TEST_F(VerilogDesignTest, R10_ReadWriteRoundTrip) { +TEST_F(VerilogDesignTest, ReadWriteRoundTrip) { ASSERT_TRUE(design_loaded_); Network *network = sta_->network(); @@ -2576,7 +2576,7 @@ TEST_F(VerilogDesignTest, R10_ReadWriteRoundTrip) { // R11_1: Read verilog with constant values to cover VerilogNetConstant, // VerilogConstantNetNameIterator, VerilogNullNetNameIterator -TEST_F(VerilogDesignTest, R11_ReadVerilogConstants) { +TEST_F(VerilogDesignTest, ReadVerilogConstants) { ASSERT_TRUE(design_loaded_); // Write a verilog file with constant connections @@ -2601,7 +2601,7 @@ TEST_F(VerilogDesignTest, R11_ReadVerilogConstants) { // R11_2: Read verilog with bit select and part select connections // Covers VerilogNetBitSelect::isScalar, VerilogNetPartSelect::isScalar, // VerilogNetPortRefBit::name, VerilogBusNetNameIterator -TEST_F(VerilogDesignTest, R11_ReadVerilogBitPartSelect) { +TEST_F(VerilogDesignTest, ReadVerilogBitPartSelect) { ASSERT_TRUE(design_loaded_); const char *vpath = "/tmp/test_r11_bitpart.v"; @@ -2628,7 +2628,7 @@ TEST_F(VerilogDesignTest, R11_ReadVerilogBitPartSelect) { // R11_3: Read verilog with unnamed port connections (positional) // Covers VerilogNetUnnamed::isNamed, VerilogNetUnnamed::name, // VerilogOneNetNameIterator -TEST_F(VerilogDesignTest, R11_ReadVerilogPositional) { +TEST_F(VerilogDesignTest, ReadVerilogPositional) { ASSERT_TRUE(design_loaded_); const char *vpath = "/tmp/test_r11_pos.v"; @@ -2648,7 +2648,7 @@ TEST_F(VerilogDesignTest, R11_ReadVerilogPositional) { // R11_4: Read verilog with named port ref to a concat and complex nets // Covers VerilogNetPortRefScalar, VerilogNetPortRefScalarNet::isScalar -TEST_F(VerilogDesignTest, R11_ReadVerilogConcat) { +TEST_F(VerilogDesignTest, ReadVerilogConcat) { ASSERT_TRUE(design_loaded_); const char *vpath = "/tmp/test_r11_concat.v"; @@ -2670,7 +2670,7 @@ TEST_F(VerilogDesignTest, R11_ReadVerilogConcat) { // R11_5: Read verilog with multiple modules to exercise VerilogReader::module(Cell*) // and VerilogBindingTbl -TEST_F(VerilogDesignTest, R11_ReadVerilogMultiModule) { +TEST_F(VerilogDesignTest, ReadVerilogMultiModule) { ASSERT_TRUE(design_loaded_); const char *vpath = "/tmp/test_r11_multi.v"; @@ -2699,7 +2699,7 @@ TEST_F(VerilogDesignTest, R11_ReadVerilogMultiModule) { // R11_6: Read verilog with black box instance (unknown module) // Covers VerilogReader::isBlackBox, makeBlackBox -TEST_F(VerilogDesignTest, R11_ReadVerilogBlackBox) { +TEST_F(VerilogDesignTest, ReadVerilogBlackBox) { ASSERT_TRUE(design_loaded_); const char *vpath = "/tmp/test_r11_bbox.v"; @@ -2721,7 +2721,7 @@ TEST_F(VerilogDesignTest, R11_ReadVerilogBlackBox) { // R11_7: Read verilog with named port ref and bit index on port // Covers VerilogNetPortRefBit, makeNetNamedPortRefBit, // makeNetNamedPortRefPart -TEST_F(VerilogDesignTest, R11_ReadVerilogNamedPortRefBit) { +TEST_F(VerilogDesignTest, ReadVerilogNamedPortRefBit) { ASSERT_TRUE(design_loaded_); const char *vpath = "/tmp/test_r11_portref_bit.v"; @@ -2745,7 +2745,7 @@ TEST_F(VerilogDesignTest, R11_ReadVerilogNamedPortRefBit) { // R11_8: Read verilog with assign statements and port concatenation // Covers VerilogAssign::isAssign, VerilogStmt hierarchy paths -TEST_F(VerilogDesignTest, R11_ReadVerilogAssignConcat) { +TEST_F(VerilogDesignTest, ReadVerilogAssignConcat) { ASSERT_TRUE(design_loaded_); const char *vpath = "/tmp/test_r11_assign_concat.v"; @@ -2767,7 +2767,7 @@ TEST_F(VerilogDesignTest, R11_ReadVerilogAssignConcat) { } // R11_9: Read verilog with supply0/supply1 nets (covers special net types) -TEST_F(VerilogDesignTest, R11_ReadVerilogSupplyNets) { +TEST_F(VerilogDesignTest, ReadVerilogSupplyNets) { ASSERT_TRUE(design_loaded_); const char *vpath = "/tmp/test_r11_supply.v"; @@ -2788,7 +2788,7 @@ TEST_F(VerilogDesignTest, R11_ReadVerilogSupplyNets) { } // R11_10: Read verilog with escaped names to exercise more parser paths -TEST_F(VerilogDesignTest, R11_ReadVerilogEscapedNames) { +TEST_F(VerilogDesignTest, ReadVerilogEscapedNames) { ASSERT_TRUE(design_loaded_); const char *vpath = "/tmp/test_r11_escaped.v";