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

3333 lines
108 KiB
C++
Raw Blame History

#include <gtest/gtest.h>
#include <string>
#include <cmath>
#include <atomic>
#include <unistd.h>
#include "Units.hh"
#include "TimingRole.hh"
#include "MinMax.hh"
#include "Wireload.hh"
#include "FuncExpr.hh"
#include "TableModel.hh"
#include "TimingArc.hh"
#include "Liberty.hh"
#include "InternalPower.hh"
#include "LinearModel.hh"
#include "Transition.hh"
#include "RiseFallValues.hh"
#include "PortDirection.hh"
#include "StringUtil.hh"
#include "liberty/LibertyParser.hh"
#include "liberty/LibertyBuilder.hh"
#include "ReportStd.hh"
#include "liberty/LibertyReaderPvt.hh"
#include <tcl.h>
#include "Sta.hh"
#include "ReportTcl.hh"
#include "PatternMatch.hh"
#include "Scene.hh"
#include "LibertyWriter.hh"
namespace sta {
static void expectStaLibertyCoreState(Sta *sta, LibertyLibrary *lib)
{
ASSERT_NE(sta, nullptr);
EXPECT_EQ(Sta::sta(), sta);
EXPECT_NE(sta->network(), nullptr);
EXPECT_NE(sta->search(), nullptr);
EXPECT_NE(sta->cmdSdc(), nullptr);
EXPECT_NE(sta->report(), nullptr);
EXPECT_FALSE(sta->scenes().empty());
if (!sta->scenes().empty())
EXPECT_GE(sta->scenes().size(), 1);
EXPECT_NE(sta->cmdScene(), nullptr);
EXPECT_NE(lib, nullptr);
}
// Lightweight fixture classes needed by R5_ tests in this file
class UnitTest : public ::testing::Test {
protected:
void SetUp() override {}
};
class Table1Test : public ::testing::Test {
protected:
TableAxisPtr makeAxis(std::initializer_list<float> vals) {
FloatSeq values;
for (float v : vals)
values.push_back(v);
return std::make_shared<TableAxis>(
TableAxisVariable::total_output_net_capacitance, std::move(values));
}
};
class LinearModelTest : public ::testing::Test {
protected:
void SetUp() override {
lib_ = new LibertyLibrary("test_lib", "test.lib");
cell_ = new LibertyCell(lib_, "INV", "inv.lib");
}
void TearDown() override {
delete cell_;
delete lib_;
}
LibertyLibrary *lib_;
LibertyCell *cell_;
};
class StaLibertyTest : public ::testing::Test {
protected:
void SetUp() override {
interp_ = Tcl_CreateInterp();
initSta();
sta_ = new Sta;
Sta::setSta(sta_);
sta_->makeComponents();
ReportTcl *report = dynamic_cast<ReportTcl*>(sta_->report());
if (report)
report->setTclInterp(interp_);
// Read Nangate45 liberty file
lib_ = sta_->readLiberty("test/nangate45/Nangate45_typ.lib",
sta_->cmdScene(),
MinMaxAll::min(),
false);
}
void TearDown() override {
if (sta_)
expectStaLibertyCoreState(sta_, lib_);
deleteAllMemory();
sta_ = nullptr;
if (interp_)
Tcl_DeleteInterp(interp_);
interp_ = nullptr;
}
Sta *sta_;
Tcl_Interp *interp_;
LibertyLibrary *lib_;
};
TEST_F(StaLibertyTest, LibraryNotNull) {
EXPECT_NE(lib_, nullptr);
}
TEST_F(StaLibertyTest, FindLibertyCell) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
EXPECT_NE(buf, nullptr);
LibertyCell *inv = lib_->findLibertyCell("INV_X1");
EXPECT_NE(inv, nullptr);
EXPECT_EQ(lib_->findLibertyCell("NONEXISTENT_CELL_XYZ"), nullptr);
}
TEST_F(StaLibertyTest, FindLibertyCellsMatching) {
PatternMatch pattern("BUF_*", false, false, nullptr);
auto cells = lib_->findLibertyCellsMatching(&pattern);
EXPECT_GT(cells.size(), 0u);
}
TEST_F(StaLibertyTest, LibraryCellIterator) {
LibertyCellIterator iter(lib_);
int count = 0;
while (iter.hasNext()) {
LibertyCell *cell = iter.next();
EXPECT_NE(cell, nullptr);
count++;
}
EXPECT_GT(count, 0);
}
TEST_F(StaLibertyTest, CellArea) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
float area = buf->area();
EXPECT_GT(area, 0.0f);
}
TEST_F(StaLibertyTest, CellIsBuffer) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_TRUE(buf->isBuffer());
}
TEST_F(StaLibertyTest, CellIsInverter) {
LibertyCell *inv = lib_->findLibertyCell("INV_X1");
ASSERT_NE(inv, nullptr);
EXPECT_TRUE(inv->isInverter());
}
TEST_F(StaLibertyTest, CellBufferPorts) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_TRUE(buf->isBuffer());
LibertyPort *input = nullptr;
LibertyPort *output = nullptr;
buf->bufferPorts(input, output);
EXPECT_NE(input, nullptr);
EXPECT_NE(output, nullptr);
}
TEST_F(StaLibertyTest, CellHasTimingArcs) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *a = buf->findLibertyPort("A");
ASSERT_NE(a, nullptr);
EXPECT_TRUE(buf->hasTimingArcs(a));
}
TEST_F(StaLibertyTest, CellFindLibertyPort) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *a = buf->findLibertyPort("A");
EXPECT_NE(a, nullptr);
LibertyPort *z = buf->findLibertyPort("Z");
EXPECT_NE(z, nullptr);
EXPECT_EQ(buf->findLibertyPort("NONEXISTENT_PORT"), nullptr);
}
TEST_F(StaLibertyTest, CellTimingArcSets) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
EXPECT_GT(arcsets.size(), 0u);
EXPECT_GT(buf->timingArcSetCount(), 0u);
}
TEST_F(StaLibertyTest, CellTimingArcSetsFromTo) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *a = buf->findLibertyPort("A");
LibertyPort *z = buf->findLibertyPort("Z");
ASSERT_NE(a, nullptr);
ASSERT_NE(z, nullptr);
auto &arcsets = buf->timingArcSets(a, z);
EXPECT_GT(arcsets.size(), 0u);
}
TEST_F(StaLibertyTest, TimingArcSetProperties) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
TimingArcSet *arcset = arcsets[0];
EXPECT_NE(arcset, nullptr);
// Test arc set properties
EXPECT_NE(arcset->from(), nullptr);
EXPECT_NE(arcset->to(), nullptr);
EXPECT_NE(arcset->role(), nullptr);
EXPECT_FALSE(arcset->isWire());
TimingSense sense = arcset->sense();
EXPECT_GE(static_cast<int>(sense), 0);
EXPECT_GT(arcset->arcCount(), 0u);
EXPECT_GE(arcset->index(), 0u);
EXPECT_EQ(arcset->libertyCell(), buf);
}
TEST_F(StaLibertyTest, TimingArcSetIsRisingFallingEdge) {
ASSERT_NO_THROW(( [&](){
LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
if (dff) {
auto &arcsets = dff->timingArcSets();
for (auto *arcset : arcsets) {
// isRisingFallingEdge returns nullptr for combinational arcs
const RiseFall *rf = arcset->isRisingFallingEdge();
if (rf) {
EXPECT_TRUE(rf == RiseFall::rise() || rf == RiseFall::fall());
}
}
}
}() ));
}
TEST_F(StaLibertyTest, TimingArcSetArcsFrom) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
TimingArcSet *arcset = arcsets[0];
TimingArc *arc1 = nullptr;
TimingArc *arc2 = nullptr;
arcset->arcsFrom(RiseFall::rise(), arc1, arc2);
// At least one arc should exist
EXPECT_TRUE(arc1 != nullptr || arc2 != nullptr);
}
TEST_F(StaLibertyTest, TimingArcSetArcTo) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
TimingArcSet *arcset = arcsets[0];
TimingArc *arc = arcset->arcTo(RiseFall::rise());
// May or may not be nullptr depending on the arc
EXPECT_NE(arc, nullptr);
}
TEST_F(StaLibertyTest, TimingArcSetOcvArcDepth) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
TimingArcSet *arcset = arcsets[0];
float depth = arcset->ocvArcDepth();
EXPECT_GE(depth, 0.0f);
}
TEST_F(StaLibertyTest, TimingArcSetEquivAndLess) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
if (arcsets.size() >= 2) {
TimingArcSet *set1 = arcsets[0];
TimingArcSet *set2 = arcsets[1];
// Test equiv - same set should be equiv
EXPECT_TRUE(TimingArcSet::equiv(set1, set1));
// Test less - antisymmetric
bool less12 = TimingArcSet::less(set1, set2);
bool less21 = TimingArcSet::less(set2, set1);
EXPECT_FALSE(less12 && less21); // Can't both be true
}
}
TEST_F(StaLibertyTest, TimingArcSetCondDefault) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
TimingArcSet *arcset = arcsets[0];
// Just call the getter for coverage
bool is_default = arcset->isCondDefault();
// is_default value depends on cell type
}
TEST_F(StaLibertyTest, TimingArcSetSdfCond) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
TimingArcSet *arcset = arcsets[0];
// SDF condition getters - may be empty for simple arcs
const std::string &sdf_cond = arcset->sdfCond();
const std::string &sdf_start = arcset->sdfCondStart();
const std::string &sdf_end = arcset->sdfCondEnd();
const std::string &mode_name = arcset->modeName();
const std::string &mode_value = arcset->modeValue();
// sdf_cond may be empty for simple arcs
// sdf_start may be empty for simple arcs
// sdf_end may be empty for simple arcs
// mode_name may be empty for simple arcs
// mode_value may be empty for simple arcs
}
TEST_F(StaLibertyTest, TimingArcProperties) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
TimingArcSet *arcset = arcsets[0];
auto &arcs = arcset->arcs();
ASSERT_GT(arcs.size(), 0u);
TimingArc *arc = arcs[0];
EXPECT_NE(arc->from(), nullptr);
EXPECT_NE(arc->to(), nullptr);
EXPECT_NE(arc->fromEdge(), nullptr);
EXPECT_NE(arc->toEdge(), nullptr);
EXPECT_NE(arc->role(), nullptr);
EXPECT_EQ(arc->set(), arcset);
EXPECT_GE(arc->index(), 0u);
// Test sense
TimingSense sense = arc->sense();
EXPECT_GE(static_cast<int>(sense), 0);
// Test to_string
std::string arc_str = arc->to_string();
EXPECT_FALSE(arc_str.empty());
// Test model
TimingModel *model = arc->model();
// model may be null depending on cell type
}
TEST_F(StaLibertyTest, TimingArcDriveResistance) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
TimingArcSet *arcset = arcsets[0];
auto &arcs = arcset->arcs();
ASSERT_GT(arcs.size(), 0u);
TimingArc *arc = arcs[0];
float drive_res = arc->driveResistance();
EXPECT_GE(drive_res, 0.0f);
}
TEST_F(StaLibertyTest, TimingArcIntrinsicDelay) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
TimingArcSet *arcset = arcsets[0];
auto &arcs = arcset->arcs();
ASSERT_GT(arcs.size(), 0u);
TimingArc *arc = arcs[0];
ArcDelay delay = arc->intrinsicDelay();
EXPECT_GE(delayAsFloat(delay), 0.0f);
}
TEST_F(StaLibertyTest, TimingArcEquiv) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
auto &arcs = arcsets[0]->arcs();
ASSERT_GT(arcs.size(), 0u);
TimingArc *arc = arcs[0];
EXPECT_TRUE(TimingArc::equiv(arc, arc));
}
TEST_F(StaLibertyTest, TimingArcGateTableModel) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
auto &arcs = arcsets[0]->arcs();
ASSERT_GT(arcs.size(), 0u);
TimingArc *arc = arcs[0];
GateTableModel *gtm = arc->gateTableModel();
if (gtm) {
EXPECT_NE(gtm->delayModel(), nullptr);
}
}
TEST_F(StaLibertyTest, LibraryPortProperties) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *a = buf->findLibertyPort("A");
LibertyPort *z = buf->findLibertyPort("Z");
ASSERT_NE(a, nullptr);
ASSERT_NE(z, nullptr);
// Test capacitance getters
float cap = a->capacitance();
EXPECT_GE(cap, 0.0f);
float cap_min = a->capacitance(MinMax::min());
EXPECT_GE(cap_min, 0.0f);
float cap_rise_max = a->capacitance(RiseFall::rise(), MinMax::max());
EXPECT_GE(cap_rise_max, 0.0f);
// Test capacitance with exists
float cap_val;
bool exists;
a->capacitance(RiseFall::rise(), MinMax::max(), cap_val, exists);
// This may or may not exist depending on the lib
// Test capacitanceIsOneValue
bool one_val = a->capacitanceIsOneValue();
// one_val value depends on cell type
// Test driveResistance
float drive_res = z->driveResistance();
EXPECT_GE(drive_res, 0.0f);
float drive_res_rise = z->driveResistance(RiseFall::rise(), MinMax::max());
EXPECT_GE(drive_res_rise, 0.0f);
}
TEST_F(StaLibertyTest, PortFunction) {
LibertyCell *inv = lib_->findLibertyCell("INV_X1");
ASSERT_NE(inv, nullptr);
LibertyPort *zn = inv->findLibertyPort("ZN");
ASSERT_NE(zn, nullptr);
FuncExpr *func = zn->function();
EXPECT_NE(func, nullptr);
}
TEST_F(StaLibertyTest, PortTristateEnable) {
// Find a tristate cell if available
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *z = buf->findLibertyPort("Z");
ASSERT_NE(z, nullptr);
FuncExpr *tristate = z->tristateEnable();
// BUF_X1 does not have a tristate enable
EXPECT_EQ(tristate, nullptr);
}
TEST_F(StaLibertyTest, PortClockFlags) {
ASSERT_NO_THROW(( [&](){
LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
if (dff) {
LibertyPort *ck = dff->findLibertyPort("CK");
if (ck) {
bool is_clk = ck->isClock();
bool is_reg_clk = ck->isRegClk();
bool is_check_clk = ck->isCheckClk();
// is_clk tested implicitly (bool accessor exercised)
// is_reg_clk tested implicitly (bool accessor exercised)
// is_check_clk tested implicitly (bool accessor exercised)
}
LibertyPort *q = dff->findLibertyPort("Q");
if (q) {
bool is_reg_out = q->isRegOutput();
// is_reg_out tested implicitly (bool accessor exercised)
}
}
}() ));
}
TEST_F(StaLibertyTest, PortLimitGetters) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *a = buf->findLibertyPort("A");
ASSERT_NE(a, nullptr);
float limit;
bool exists;
a->slewLimit(MinMax::max(), limit, exists);
// May or may not exist
if (exists) {
EXPECT_GE(limit, 0.0f);
}
a->capacitanceLimit(MinMax::max(), limit, exists);
if (exists) {
EXPECT_GE(limit, 0.0f);
}
a->fanoutLimit(MinMax::max(), limit, exists);
if (exists) {
EXPECT_GE(limit, 0.0f);
}
float fanout_load;
bool fl_exists;
a->fanoutLoad(fanout_load, fl_exists);
if (fl_exists) {
EXPECT_GE(fanout_load, 0.0f);
}
}
TEST_F(StaLibertyTest, PortMinPeriod) {
ASSERT_NO_THROW(( [&](){
LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
if (dff) {
LibertyPort *ck = dff->findLibertyPort("CK");
if (ck) {
float min_period;
bool exists;
ck->minPeriod(min_period, exists);
// May or may not exist
if (exists) {
EXPECT_GE(min_period, 0.0f);
}
}
}
}() ));
}
TEST_F(StaLibertyTest, PortMinPulseWidth) {
ASSERT_NO_THROW(( [&](){
LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
if (dff) {
LibertyPort *ck = dff->findLibertyPort("CK");
if (ck) {
float min_width;
bool exists;
ck->minPulseWidth(RiseFall::rise(), min_width, exists);
if (exists) {
EXPECT_GE(min_width, 0.0f);
}
ck->minPulseWidth(RiseFall::fall(), min_width, exists);
if (exists) {
EXPECT_GE(min_width, 0.0f);
}
}
}
}() ));
}
TEST_F(StaLibertyTest, PortPwrGndProperties) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *a = buf->findLibertyPort("A");
ASSERT_NE(a, nullptr);
// Regular ports are not power/ground
EXPECT_FALSE(a->isPwrGnd());
EXPECT_EQ(a->pwrGndType(), PwrGndType::none);
}
TEST_F(StaLibertyTest, PortScanSignalType) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *a = buf->findLibertyPort("A");
ASSERT_NE(a, nullptr);
// Regular ports have ScanSignalType::none
EXPECT_EQ(a->scanSignalType(), ScanSignalType::none);
}
TEST_F(StaLibertyTest, PortBoolFlags) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *a = buf->findLibertyPort("A");
ASSERT_NE(a, nullptr);
EXPECT_FALSE(a->isClockGateClock());
EXPECT_FALSE(a->isClockGateEnable());
EXPECT_FALSE(a->isClockGateOut());
EXPECT_FALSE(a->isPllFeedback());
EXPECT_FALSE(a->isolationCellData());
EXPECT_FALSE(a->isolationCellEnable());
EXPECT_FALSE(a->levelShifterData());
EXPECT_FALSE(a->isSwitch());
EXPECT_FALSE(a->isLatchData());
EXPECT_FALSE(a->isPad());
}
TEST_F(StaLibertyTest, PortRelatedPorts) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *a = buf->findLibertyPort("A");
ASSERT_NE(a, nullptr);
LibertyPort *ground_port = a->relatedGroundPort();
LibertyPort *power_port = a->relatedPowerPort();
// ground_port may be null for simple cells
// power_port may be null for simple cells
}
TEST_F(StaLibertyTest, PortLibertyLibrary) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *a = buf->findLibertyPort("A");
ASSERT_NE(a, nullptr);
EXPECT_EQ(a->libertyLibrary(), lib_);
EXPECT_EQ(a->libertyCell(), buf);
}
TEST_F(StaLibertyTest, PortPulseClk) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *a = buf->findLibertyPort("A");
ASSERT_NE(a, nullptr);
EXPECT_EQ(a->pulseClkTrigger(), nullptr);
EXPECT_EQ(a->pulseClkSense(), nullptr);
}
TEST_F(StaLibertyTest, PortBusDcl) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *a = buf->findLibertyPort("A");
ASSERT_NE(a, nullptr);
BusDcl *bus = a->busDcl();
EXPECT_EQ(bus, nullptr); // Scalar port has no bus declaration
}
TEST_F(StaLibertyTest, PortReceiverModel) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *a = buf->findLibertyPort("A");
ASSERT_NE(a, nullptr);
const ReceiverModel *rm = a->receiverModel();
// rm may be null depending on cell type
}
TEST_F(StaLibertyTest, CellInternalPowers) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &powers = buf->internalPowers();
EXPECT_GT(powers.size(), 0u);
if (powers.size() > 0) {
const InternalPower &pwr = powers[0];
EXPECT_NE(pwr.port(), nullptr);
// relatedPort may be nullptr
LibertyPort *rp = pwr.relatedPort();
EXPECT_NE(rp, nullptr);
// when is null for unconditional internal power groups
FuncExpr *when = pwr.when();
if (when) {
EXPECT_NE(when->op(), FuncExpr::Op::zero);
}
// relatedPgPin may be nullptr
LibertyPort *pgpin = pwr.relatedPgPin();
// pgpin may be null for simple arcs
EXPECT_EQ(pwr.libertyCell(), buf);
}
}
TEST_F(StaLibertyTest, CellInternalPowersByPort) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *z = buf->findLibertyPort("Z");
if (z) {
InternalPowerPtrSeq powers = buf->internalPowers(z);
// May or may not have internal powers for this port
EXPECT_GE(powers.size(), 0u);
}
}
TEST_F(StaLibertyTest, CellDontUse) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
bool dont_use = buf->dontUse();
// dont_use value depends on cell type
}
TEST_F(StaLibertyTest, CellIsMacro) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->isMacro());
}
TEST_F(StaLibertyTest, CellIsMemory) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->isMemory());
}
TEST_F(StaLibertyTest, CellLibraryPtr) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_EQ(buf->libertyLibrary(), lib_);
// Non-const version
LibertyLibrary *lib_nc = buf->libertyLibrary();
EXPECT_EQ(lib_nc, lib_);
}
TEST_F(StaLibertyTest, CellFindLibertyPortsMatching) {
LibertyCell *and2 = lib_->findLibertyCell("AND2_X1");
if (and2) {
PatternMatch pattern("A*", false, false, nullptr);
auto ports = and2->findLibertyPortsMatching(&pattern);
EXPECT_GT(ports.size(), 0u);
}
}
TEST_F(StaLibertyTest, LibraryCellPortIterator) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyCellPortIterator iter(buf);
int count = 0;
while (iter.hasNext()) {
LibertyPort *port = iter.next();
EXPECT_NE(port, nullptr);
count++;
}
EXPECT_GT(count, 0);
}
TEST_F(StaLibertyTest, LibertyCellPortBitIterator) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyCellPortBitIterator iter(buf);
int count = 0;
while (iter.hasNext()) {
LibertyPort *port = iter.next();
EXPECT_NE(port, nullptr);
count++;
}
EXPECT_GT(count, 0);
}
TEST_F(StaLibertyTest, LibertyPortMemberIterator) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *a = buf->findLibertyPort("A");
ASSERT_NE(a, nullptr);
LibertyPortMemberIterator iter(a);
int count = 0;
while (iter.hasNext()) {
LibertyPort *member = iter.next();
EXPECT_NE(member, nullptr);
count++;
}
// Scalar port may have 0 members in the member iterator
// (it iterates bus bits, not the port itself)
EXPECT_GE(count, 0);
}
TEST_F(StaLibertyTest, LibraryNominalValues) {
// The library should have nominal PVT values from parsing
float process = lib_->nominalProcess();
float voltage = lib_->nominalVoltage();
float temperature = lib_->nominalTemperature();
// These should be non-zero for a real library
EXPECT_GT(voltage, 0.0f);
EXPECT_GE(process, 0.0f);
EXPECT_GE(temperature, 0.0f);
}
TEST_F(StaLibertyTest, LibraryThresholds) {
float in_rise = lib_->inputThreshold(RiseFall::rise());
float in_fall = lib_->inputThreshold(RiseFall::fall());
float out_rise = lib_->outputThreshold(RiseFall::rise());
float out_fall = lib_->outputThreshold(RiseFall::fall());
float slew_lower_rise = lib_->slewLowerThreshold(RiseFall::rise());
float slew_upper_rise = lib_->slewUpperThreshold(RiseFall::rise());
float slew_derate = lib_->slewDerateFromLibrary();
EXPECT_GT(in_rise, 0.0f);
EXPECT_GT(in_fall, 0.0f);
EXPECT_GT(out_rise, 0.0f);
EXPECT_GT(out_fall, 0.0f);
EXPECT_GT(slew_lower_rise, 0.0f);
EXPECT_GT(slew_upper_rise, 0.0f);
EXPECT_GT(slew_derate, 0.0f);
}
TEST_F(StaLibertyTest, LibraryDelayModelType) {
DelayModelType model_type = lib_->delayModelType();
// Nangate45 should use table model
EXPECT_EQ(model_type, DelayModelType::table);
}
TEST_F(StaLibertyTest, CellHasSequentials) {
LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
if (dff) {
EXPECT_TRUE(dff->hasSequentials());
auto &seqs = dff->sequentials();
EXPECT_GT(seqs.size(), 0u);
}
}
TEST_F(StaLibertyTest, CellOutputPortSequential) {
ASSERT_NO_THROW(( [&](){
LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
if (dff) {
LibertyPort *q = dff->findLibertyPort("Q");
if (q) {
Sequential *seq = dff->outputPortSequential(q);
// outputPortSequential may return nullptr depending on cell definition
if (seq) {
EXPECT_EQ(seq->output(), q);
}
}
}
}() ));
}
TEST_F(StaLibertyTest, LibraryBuffersAndInverters) {
LibertyCellSeq *bufs = lib_->buffers();
EXPECT_NE(bufs, nullptr);
// Nangate45 should have buffer cells
EXPECT_GT(bufs->size(), 0u);
LibertyCellSeq *invs = lib_->inverters();
EXPECT_NE(invs, nullptr);
EXPECT_GT(invs->size(), 0u);
}
TEST_F(StaLibertyTest, CellFindTimingArcSet) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
// Find by index
TimingArcSet *found = buf->findTimingArcSet(static_cast<size_t>(0));
EXPECT_NE(found, nullptr);
}
TEST_F(StaLibertyTest, CellLeakagePower) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
float leakage;
bool exists;
buf->leakagePower(leakage, exists);
// Nangate45 may or may not have cell-level leakage power
if (exists) {
EXPECT_GE(leakage, 0.0f);
}
}
TEST_F(StaLibertyTest, TimingArcSetFindTimingArc) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
TimingArcSet *arcset = arcsets[0];
auto &arcs = arcset->arcs();
ASSERT_GT(arcs.size(), 0u);
TimingArc *found = arcset->findTimingArc(0);
EXPECT_NE(found, nullptr);
}
TEST_F(StaLibertyTest, TimingArcSetWire) {
// Test the static wire timing arc set
TimingArcSet *wire_set = TimingArcSet::wireTimingArcSet();
EXPECT_NE(wire_set, nullptr);
EXPECT_EQ(TimingArcSet::wireArcCount(), 2);
int rise_idx = TimingArcSet::wireArcIndex(RiseFall::rise());
int fall_idx = TimingArcSet::wireArcIndex(RiseFall::fall());
EXPECT_NE(rise_idx, fall_idx);
}
TEST_F(StaLibertyTest, InternalPowerCompute) {
LibertyCell *inv = lib_->findLibertyCell("INV_X1");
ASSERT_NE(inv, nullptr);
auto &powers = inv->internalPowers();
if (powers.size() > 0) {
const InternalPower &pwr = powers[0];
// Compute power with some slew and cap values
float power_val = pwr.power(RiseFall::rise(), nullptr, 0.1f, 0.01f);
// Power value can be negative depending on library data
EXPECT_FALSE(std::isinf(power_val));
}
}
TEST_F(StaLibertyTest, PortDriverWaveform) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *z = buf->findLibertyPort("Z");
ASSERT_NE(z, nullptr);
DriverWaveform *dw_rise = z->driverWaveform(RiseFall::rise());
DriverWaveform *dw_fall = z->driverWaveform(RiseFall::fall());
// BUF_X1 does not have driver waveform definitions
EXPECT_EQ(dw_rise, nullptr);
EXPECT_EQ(dw_fall, nullptr);
}
TEST_F(StaLibertyTest, PortVoltageName) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *a = buf->findLibertyPort("A");
ASSERT_NE(a, nullptr);
const std::string &vname = a->voltageName();
// vname may be empty for simple cells
(void)vname;
}
TEST_F(StaLibertyTest, PortEquivAndLess) {
LibertyCell *and2 = lib_->findLibertyCell("AND2_X1");
if (and2) {
LibertyPort *a1 = and2->findLibertyPort("A1");
LibertyPort *a2 = and2->findLibertyPort("A2");
LibertyPort *zn = and2->findLibertyPort("ZN");
if (a1 && a2 && zn) {
// Same port should be equiv
EXPECT_TRUE(LibertyPort::equiv(a1, a1));
// Different ports
bool less12 = LibertyPort::less(a1, a2);
bool less21 = LibertyPort::less(a2, a1);
EXPECT_FALSE(less12 && less21);
}
}
}
TEST_F(StaLibertyTest, PortIntrinsicDelay) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *z = buf->findLibertyPort("Z");
ASSERT_NE(z, nullptr);
ArcDelay delay = z->intrinsicDelay(sta_);
EXPECT_GE(delayAsFloat(delay), 0.0f);
ArcDelay delay_rf = z->intrinsicDelay(RiseFall::rise(), MinMax::max(), sta_);
EXPECT_GE(delayAsFloat(delay_rf), 0.0f);
}
TEST_F(StaLibertyTest, CellLatchEnable) {
ASSERT_NO_THROW(( [&](){
LibertyCell *dlatch = lib_->findLibertyCell("DLATCH_X1");
if (dlatch) {
auto &arcsets = dlatch->timingArcSets();
for (auto *arcset : arcsets) {
const LibertyPort *enable_port;
const FuncExpr *enable_func;
const RiseFall *enable_rf;
dlatch->latchEnable(arcset, enable_port, enable_func, enable_rf);
EXPECT_NE(enable_port, nullptr);
EXPECT_NE(enable_func, nullptr);
EXPECT_NE(enable_rf, nullptr);
}
}
}() ));
}
TEST_F(StaLibertyTest, CellClockGateFlags) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->isClockGate());
EXPECT_FALSE(buf->isClockGateLatchPosedge());
EXPECT_FALSE(buf->isClockGateLatchNegedge());
EXPECT_FALSE(buf->isClockGateOther());
}
TEST_F(StaLibertyTest, GateTableModelDriveResistanceAndDelay) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
auto &arcs = arcsets[0]->arcs();
ASSERT_GT(arcs.size(), 0u);
TimingArc *arc = arcs[0];
GateTableModel *gtm = arc->gateTableModel();
if (gtm) {
// Test gate delay
float delay_f, slew_f;
gtm->gateDelay(nullptr, 0.1f, 0.01f, delay_f, slew_f);
// Delay values can be negative depending on library data
EXPECT_FALSE(std::isinf(delay_f));
EXPECT_GE(slew_f, 0.0f);
// Test drive resistance
float res = gtm->driveResistance(nullptr);
EXPECT_GE(res, 0.0f);
// Test report
std::string report = gtm->reportGateDelay(nullptr, 0.1f, 0.01f,
MinMax::max(), PocvMode::scalar, 3);
EXPECT_FALSE(report.empty());
// Test model accessors
const TableModel *delay_model = gtm->delayModel();
EXPECT_NE(delay_model, nullptr);
const TableModel *slew_model = gtm->slewModel();
EXPECT_NE(slew_model, nullptr);
// receiverModel and outputWaveforms are null for this library
const ReceiverModel *rm = gtm->receiverModel();
EXPECT_EQ(rm, nullptr);
OutputWaveforms *ow = gtm->outputWaveforms();
EXPECT_EQ(ow, nullptr);
}
}
TEST_F(StaLibertyTest, LibraryScaleFactors) {
ScaleFactors *sf = lib_->scaleFactors();
// May or may not have scale factors
EXPECT_NE(sf, nullptr);
float sf_val = lib_->scaleFactor(ScaleFactorType::cell, nullptr);
EXPECT_FLOAT_EQ(sf_val, 1.0f);
}
TEST_F(StaLibertyTest, LibraryDefaultPinCaps) {
ASSERT_NO_THROW(( [&](){
float input_cap = lib_->defaultInputPinCap();
float output_cap = lib_->defaultOutputPinCap();
float bidirect_cap = lib_->defaultBidirectPinCap();
EXPECT_GE(input_cap, 0.0f);
EXPECT_GE(output_cap, 0.0f);
EXPECT_GE(bidirect_cap, 0.0f);
}() ));
}
TEST_F(StaLibertyTest, LibraryUnits) {
const Units *units = lib_->units();
EXPECT_NE(units, nullptr);
Units *units_nc = lib_->units();
EXPECT_NE(units_nc, nullptr);
}
TEST_F(StaLibertyTest, CellScaleFactors) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
ScaleFactors *sf = buf->scaleFactors();
// sf may be null depending on cell type
}
TEST_F(StaLibertyTest, CellOcvArcDepth) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
float depth = buf->ocvArcDepth();
EXPECT_GE(depth, 0.0f);
}
TEST_F(StaLibertyTest, CellOcvDerate) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
OcvDerate *derate = buf->ocvDerate();
// derate may be null depending on cell type
}
TEST_F(StaLibertyTest, LibraryOcvDerate) {
OcvDerate *derate = lib_->defaultOcvDerate();
// NangateOpenCellLibrary does not define OCV derate
EXPECT_EQ(derate, nullptr);
float depth = lib_->ocvArcDepth();
EXPECT_GE(depth, 0.0f);
}
////////////////////////////////////////////////////////////////
// Helper to create FloatSeq from initializer list
////////////////////////////////////////////////////////////////
static FloatSeq makeFloatSeqVal(std::initializer_list<float> vals) {
FloatSeq seq;
for (float v : vals)
seq.push_back(v);
return seq;
}
static FloatSeq *makeFloatSeq(std::initializer_list<float> vals) {
FloatSeq *seq = new FloatSeq;
for (float v : vals)
seq->push_back(v);
return seq;
}
static TableAxisPtr makeTestAxis(TableAxisVariable var,
std::initializer_list<float> vals) {
FloatSeq values = makeFloatSeqVal(vals);
return std::make_shared<TableAxis>(var, std::move(values));
}
////////////////////////////////////////////////////////////////
// Table virtual method coverage (Table0/1/2/3 order, axis1, axis2)
////////////////////////////////////////////////////////////////
TEST(TableVirtualTest, Table0Order) {
Table t(1.5f);
EXPECT_EQ(t.order(), 0);
// Table base class axis1/axis2 return nullptr
EXPECT_EQ(t.axis1(), nullptr);
EXPECT_EQ(t.axis2(), nullptr);
}
TEST(TableVirtualTest, Table1OrderAndAxis) {
FloatSeq *vals = makeFloatSeq({1.0f, 2.0f});
auto axis = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f, 0.02f});
Table t(vals, axis);
EXPECT_EQ(t.order(), 1);
EXPECT_NE(t.axis1(), nullptr);
EXPECT_EQ(t.axis2(), nullptr);
}
TEST(TableVirtualTest, Table2OrderAndAxes) {
FloatTable vals;
vals.push_back({1.0f, 2.0f});
vals.push_back({3.0f, 4.0f});
auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f, 0.02f});
auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {0.1f, 0.2f});
Table t(std::move(vals), ax1, ax2);
EXPECT_EQ(t.order(), 2);
EXPECT_NE(t.axis1(), nullptr);
EXPECT_NE(t.axis2(), nullptr);
EXPECT_EQ(t.axis3(), nullptr);
}
TEST(TableVirtualTest, Table3OrderAndAxes) {
FloatTable vals;
vals.push_back({1.0f, 2.0f});
vals.push_back({3.0f, 4.0f});
auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f});
auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {0.1f, 0.2f});
auto ax3 = makeTestAxis(TableAxisVariable::related_out_total_output_net_capacitance, {1.0f});
Table t(std::move(vals), ax1, ax2, ax3);
EXPECT_EQ(t.order(), 3);
EXPECT_NE(t.axis1(), nullptr);
EXPECT_NE(t.axis2(), nullptr);
EXPECT_NE(t.axis3(), nullptr);
}
////////////////////////////////////////////////////////////////
// Table report() / reportValue() methods
////////////////////////////////////////////////////////////////
TEST(TableReportTest, Table0ReportValue) {
Table t(42.0f);
Unit unit(1e-9f, "s", 3);
std::string rv = t.reportValue("delay", nullptr, nullptr,
0.0f, "", 0.0f, 0.0f,
&unit, 3);
EXPECT_FALSE(rv.empty());
}
// Table1/2/3::reportValue dereferences cell->libertyLibrary()->units()
// so they need a real cell. Tested via StaLibertyTest fixture below.
////////////////////////////////////////////////////////////////
// Table destruction coverage
////////////////////////////////////////////////////////////////
TEST(TableDestructTest, Table1Destruct) {
ASSERT_NO_THROW(( [&](){
FloatSeq *vals = makeFloatSeq({1.0f});
auto axis = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f});
Table *t = new Table(vals, axis);
delete t; // covers Table::~Table (order 1)
}() ));
}
TEST(TableDestructTest, Table2Destruct) {
ASSERT_NO_THROW(( [&](){
FloatTable vals;
vals.push_back({1.0f});
auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f});
auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {0.1f});
Table *t = new Table(std::move(vals), ax1, ax2);
delete t; // covers Table::~Table (order 2)
}() ));
}
TEST(TableDestructTest, Table3Destruct) {
ASSERT_NO_THROW(( [&](){
FloatTable vals;
vals.push_back({1.0f});
auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f});
auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {0.1f});
auto ax3 = makeTestAxis(TableAxisVariable::related_out_total_output_net_capacitance, {1.0f});
Table *t = new Table(std::move(vals), ax1, ax2, ax3);
delete t; // covers Table::~Table (order 3)
}() ));
}
////////////////////////////////////////////////////////////////
// TableModel::value coverage
////////////////////////////////////////////////////////////////
TEST(TableModelValueTest, ValueByIndex) {
Table *tbl = new Table(5.5f);
TablePtr table_ptr(tbl);
TableTemplate *tmpl = new TableTemplate("test_tmpl");
TableModel model(table_ptr, tmpl, ScaleFactorType::cell, RiseFall::rise());
float v = model.value(0, 0, 0);
EXPECT_FLOAT_EQ(v, 5.5f);
delete tmpl;
}
////////////////////////////////////////////////////////////////
// Pvt destructor coverage
////////////////////////////////////////////////////////////////
TEST(PvtDestructTest, CreateAndDestroy) {
// Pvt(process, voltage, temperature)
Pvt *pvt = new Pvt(1.1f, 1.0f, 25.0f);
EXPECT_FLOAT_EQ(pvt->process(), 1.1f);
EXPECT_FLOAT_EQ(pvt->voltage(), 1.0f);
EXPECT_FLOAT_EQ(pvt->temperature(), 25.0f);
delete pvt; // covers Pvt::~Pvt
}
////////////////////////////////////////////////////////////////
// ScaleFactors::report coverage
////////////////////////////////////////////////////////////////
TEST(ScaleFactorsPrintTest, Print) {
ASSERT_NO_THROW(( [&](){
Report *report = makeReportStd();
ScaleFactors sf("test_sf");
sf.setScale(ScaleFactorType::cell, ScaleFactorPvt::process,
RiseFall::rise(), 1.0f);
sf.report(report); // covers ScaleFactors::report()
delete report;
}() ));
}
////////////////////////////////////////////////////////////////
// GateTableModel / CheckTableModel static checkAxes
////////////////////////////////////////////////////////////////
TEST(GateTableModelCheckAxesTest, ValidAxes) {
FloatTable vals;
vals.push_back({1.0f, 2.0f});
vals.push_back({3.0f, 4.0f});
auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f, 0.02f});
auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {0.1f, 0.2f});
TablePtr tbl = std::make_shared<Table>(std::move(vals), ax1, ax2);
TableModel tbl_model(tbl, nullptr, ScaleFactorType::cell, RiseFall::rise());
EXPECT_TRUE(GateTableModel::checkAxes(&tbl_model));
}
TEST(GateTableModelCheckAxesTest, InvalidAxis) {
FloatSeq *vals = makeFloatSeq({1.0f, 2.0f});
auto axis = makeTestAxis(TableAxisVariable::constrained_pin_transition, {0.01f, 0.02f});
TablePtr tbl = std::make_shared<Table>(vals, axis);
TableModel tbl_model(tbl, nullptr, ScaleFactorType::cell, RiseFall::rise());
EXPECT_FALSE(GateTableModel::checkAxes(&tbl_model));
}
TEST(GateTableModelCheckAxesTest, Table0NoAxes) {
TablePtr tbl = std::make_shared<Table>(1.0f);
TableModel tbl_model(tbl, nullptr, ScaleFactorType::cell, RiseFall::rise());
EXPECT_TRUE(GateTableModel::checkAxes(&tbl_model));
}
TEST(CheckTableModelCheckAxesTest, ValidAxes) {
FloatTable vals;
vals.push_back({1.0f, 2.0f});
vals.push_back({3.0f, 4.0f});
auto ax1 = makeTestAxis(TableAxisVariable::related_pin_transition, {0.01f, 0.02f});
auto ax2 = makeTestAxis(TableAxisVariable::constrained_pin_transition, {0.1f, 0.2f});
TablePtr tbl = std::make_shared<Table>(std::move(vals), ax1, ax2);
TableModel tbl_model(tbl, nullptr, ScaleFactorType::cell, RiseFall::rise());
EXPECT_TRUE(CheckTableModel::checkAxes(&tbl_model));
}
TEST(CheckTableModelCheckAxesTest, InvalidAxis) {
FloatSeq *vals = makeFloatSeq({1.0f, 2.0f});
auto axis = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f, 0.02f});
TablePtr tbl = std::make_shared<Table>(vals, axis);
TableModel tbl_model(tbl, nullptr, ScaleFactorType::cell, RiseFall::rise());
EXPECT_FALSE(CheckTableModel::checkAxes(&tbl_model));
}
TEST(CheckTableModelCheckAxesTest, Table0NoAxes) {
TablePtr tbl = std::make_shared<Table>(1.0f);
TableModel tbl_model(tbl, nullptr, ScaleFactorType::cell, RiseFall::rise());
EXPECT_TRUE(CheckTableModel::checkAxes(&tbl_model));
}
TEST(ReceiverModelCheckAxesTest, ValidAxes) {
FloatSeq *vals = makeFloatSeq({1.0f, 2.0f});
auto axis = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f, 0.02f});
TablePtr tbl = std::make_shared<Table>(vals, axis);
TableModel tbl_model(tbl, nullptr, ScaleFactorType::cell, RiseFall::rise());
EXPECT_TRUE(ReceiverModel::checkAxes(&tbl_model));
}
TEST(ReceiverModelCheckAxesTest, Table0NoAxis) {
TablePtr tbl = std::make_shared<Table>(1.0f);
TableModel tbl_model(tbl, nullptr, ScaleFactorType::cell, RiseFall::rise());
EXPECT_FALSE(ReceiverModel::checkAxes(&tbl_model));
}
////////////////////////////////////////////////////////////////
// DriverWaveform
////////////////////////////////////////////////////////////////
TEST(DriverWaveformTest, CreateAndName) {
// DriverWaveform::waveform() expects a Table with axis1=slew, axis2=voltage (order 2)
FloatTable vals;
vals.push_back({0.0f, 1.0f});
vals.push_back({0.5f, 1.5f});
auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {0.1f, 0.2f});
auto ax2 = makeTestAxis(TableAxisVariable::normalized_voltage, {0.0f, 1.0f});
TablePtr tbl = std::make_shared<Table>(std::move(vals), ax1, ax2);
DriverWaveform *dw = new DriverWaveform("test_driver_waveform", tbl);
EXPECT_EQ(dw->name(), "test_driver_waveform");
Table wf = dw->waveform(0.15f);
// Waveform accessor exercised; axis may be null for simple waveforms
EXPECT_EQ(wf.order(), 1);
delete dw;
}
// InternalPowerAttrs has been removed in MCMM update
////////////////////////////////////////////////////////////////
// LibertyCellPortBitIterator destructor coverage
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, CellPortBitIteratorDestruction) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyCellPortBitIterator *iter = new LibertyCellPortBitIterator(buf);
int count = 0;
while (iter->hasNext()) {
LibertyPort *p = iter->next();
EXPECT_NE(p, nullptr);
count++;
}
EXPECT_GT(count, 0);
delete iter; // covers ~LibertyCellPortBitIterator
}
////////////////////////////////////////////////////////////////
// LibertyPort setter coverage (using parsed ports)
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, PortSetIsPad) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port = buf->findLibertyPort("A");
ASSERT_NE(port, nullptr);
bool orig = port->isPad();
port->setIsPad(true);
EXPECT_TRUE(port->isPad());
port->setIsPad(orig);
}
TEST_F(StaLibertyTest, PortSetIsSwitch) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port = buf->findLibertyPort("A");
ASSERT_NE(port, nullptr);
port->setIsSwitch(true);
EXPECT_TRUE(port->isSwitch());
port->setIsSwitch(false);
}
TEST_F(StaLibertyTest, PortSetIsPllFeedback) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port = buf->findLibertyPort("A");
ASSERT_NE(port, nullptr);
port->setIsPllFeedback(true);
EXPECT_TRUE(port->isPllFeedback());
port->setIsPllFeedback(false);
}
TEST_F(StaLibertyTest, PortSetIsCheckClk) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port = buf->findLibertyPort("A");
ASSERT_NE(port, nullptr);
port->setIsCheckClk(true);
EXPECT_TRUE(port->isCheckClk());
port->setIsCheckClk(false);
}
TEST_F(StaLibertyTest, PortSetPulseClk) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port = buf->findLibertyPort("A");
ASSERT_NE(port, nullptr);
port->setPulseClk(RiseFall::rise(), RiseFall::fall());
EXPECT_EQ(port->pulseClkTrigger(), RiseFall::rise());
EXPECT_EQ(port->pulseClkSense(), RiseFall::fall());
port->setPulseClk(nullptr, nullptr);
}
TEST_F(StaLibertyTest, PortSetFanoutLoad) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port = buf->findLibertyPort("A");
ASSERT_NE(port, nullptr);
port->setFanoutLoad(2.5f);
float fanout;
bool exists;
port->fanoutLoad(fanout, exists);
EXPECT_TRUE(exists);
EXPECT_FLOAT_EQ(fanout, 2.5f);
}
TEST_F(StaLibertyTest, PortSetFanoutLimit) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port = buf->findLibertyPort("Z");
ASSERT_NE(port, nullptr);
port->setFanoutLimit(10.0f, MinMax::max());
float limit;
bool exists;
port->fanoutLimit(MinMax::max(), limit, exists);
EXPECT_TRUE(exists);
EXPECT_FLOAT_EQ(limit, 10.0f);
}
TEST_F(StaLibertyTest, PortBundlePort) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port = buf->findLibertyPort("A");
ASSERT_NE(port, nullptr);
LibertyPort *bundle = port->bundlePort();
EXPECT_EQ(bundle, nullptr);
}
TEST_F(StaLibertyTest, PortFindLibertyBusBit) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port = buf->findLibertyPort("A");
ASSERT_NE(port, nullptr);
LibertyPort *bit = port->findLibertyBusBit(0);
EXPECT_EQ(bit, nullptr);
}
// findLibertyMember(0) on scalar port crashes (member_ports_ is nullptr)
// Would need a bus port to test this safely.
TEST_F(StaLibertyTest, PortCornerPort) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port = buf->findLibertyPort("A");
ASSERT_NE(port, nullptr);
Scene *scene = sta_->cmdScene();
ASSERT_NE(scene, nullptr);
LibertyPort *cp = port->scenePort(scene, MinMax::min());
EXPECT_NE(cp, nullptr);
const LibertyPort *ccp = static_cast<const LibertyPort*>(port)->scenePort(scene, MinMax::min());
EXPECT_NE(ccp, nullptr);
}
TEST_F(StaLibertyTest, PortClkTreeDelay) {
LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
ASSERT_NE(dff, nullptr);
LibertyPort *clk = dff->findLibertyPort("CK");
ASSERT_NE(clk, nullptr);
float d = clk->clkTreeDelay(0.1f, RiseFall::rise(), RiseFall::rise(), MinMax::max());
EXPECT_GE(d, 0.0f);
}
// setMemberFloat is protected - skip
////////////////////////////////////////////////////////////////
// ModeValueDef::setSdfCond and setCond coverage
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, ModeValueDefSetSdfCond) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
ModeDef *mode_def = buf->makeModeDef("test_mode");
ASSERT_NE(mode_def, nullptr);
ModeValueDef *val_def = mode_def->defineValue("val1");
ASSERT_NE(val_def, nullptr);
EXPECT_EQ(val_def->value(), "val1");
// Set sdf_cond after creation
val_def->setSdfCond("orig_sdf_cond");
EXPECT_EQ(val_def->sdfCond(), "orig_sdf_cond");
val_def->setSdfCond("new_sdf_cond");
EXPECT_EQ(val_def->sdfCond(), "new_sdf_cond");
}
TEST_F(StaLibertyTest, ModeValueDefSetCond) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
ModeDef *mode_def = buf->makeModeDef("test_mode2");
ASSERT_NE(mode_def, nullptr);
ModeValueDef *val_def = mode_def->defineValue("val2");
ASSERT_NE(val_def, nullptr);
EXPECT_EQ(val_def->cond(), nullptr);
val_def->setCond(nullptr);
EXPECT_EQ(val_def->cond(), nullptr);
}
////////////////////////////////////////////////////////////////
// LibertyCell::latchCheckEnableEdge
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, CellLatchCheckEnableEdgeWithDFF) {
LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
ASSERT_NE(dff, nullptr);
auto &arcsets = dff->timingArcSets();
if (!arcsets.empty()) {
const RiseFall *edge = dff->latchCheckEnableEdge(arcsets[0]);
// DFF_X1 is a flip-flop, not a latch; latchCheckEnableEdge returns nullptr
if (edge) {
EXPECT_TRUE(edge == RiseFall::rise() || edge == RiseFall::fall());
}
}
}
////////////////////////////////////////////////////////////////
// LibertyCell::sceneCell
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, CellCornerCell) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyCell *cc = buf->sceneCell(0);
EXPECT_NE(cc, nullptr);
}
////////////////////////////////////////////////////////////////
// TimingArcSet::less (static)
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, TimingArcSetLessStatic) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GE(arcsets.size(), 1u);
bool result = TimingArcSet::less(arcsets[0], arcsets[0]);
EXPECT_FALSE(result);
if (arcsets.size() >= 2) {
bool r1 = TimingArcSet::less(arcsets[0], arcsets[1]);
bool r2 = TimingArcSet::less(arcsets[1], arcsets[0]);
EXPECT_FALSE(r1 && r2);
}
}
////////////////////////////////////////////////////////////////
// TimingArc::sceneArc
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, TimingArcCornerArc) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
auto &arcs = arcsets[0]->arcs();
ASSERT_GT(arcs.size(), 0u);
const TimingArc *corner = arcs[0]->sceneArc(0);
EXPECT_NE(corner, nullptr);
}
////////////////////////////////////////////////////////////////
// TimingArcSet setters
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, TimingArcSetSetRole) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
TimingArcSet *set = arcsets[0];
const TimingRole *orig = set->role();
set->setRole(TimingRole::setup());
EXPECT_EQ(set->role(), TimingRole::setup());
set->setRole(orig);
}
TEST_F(StaLibertyTest, TimingArcSetSetIsCondDefaultExplicit) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
TimingArcSet *set = arcsets[0];
bool orig = set->isCondDefault();
set->setIsCondDefault(true);
EXPECT_TRUE(set->isCondDefault());
set->setIsCondDefault(orig);
}
// isDisabledConstraint/setIsDisabledConstraint removed from TimingArcSet
////////////////////////////////////////////////////////////////
// GateTableModel::gateDelay deprecated 7-arg version
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, GateTableModelGateDelayDeprecated) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
auto &arcs = arcsets[0]->arcs();
ASSERT_GT(arcs.size(), 0u);
GateTableModel *gtm = arcs[0]->gateTableModel();
if (gtm) {
float delay_f, slew_f;
gtm->gateDelay(nullptr, 0.1f, 0.01f, delay_f, slew_f);
// Delay values can be negative depending on library data
EXPECT_FALSE(std::isinf(delay_f));
EXPECT_GE(slew_f, 0.0f);
}
}
////////////////////////////////////////////////////////////////
// CheckTableModel via Sta (setup/hold arcs)
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, CheckTableModelCheckDelay) {
LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
ASSERT_NE(dff, nullptr);
auto &arcsets = dff->timingArcSets();
for (auto *set : arcsets) {
const TimingRole *role = set->role();
if (role == TimingRole::setup() || role == TimingRole::hold()) {
auto &arcs = set->arcs();
if (!arcs.empty()) {
TimingModel *model = arcs[0]->model();
CheckTableModel *ctm = dynamic_cast<CheckTableModel*>(model);
if (ctm) {
ArcDelay d = ctm->checkDelay(nullptr, 0.1f, 0.1f, 0.0f,
MinMax::max(), PocvMode::scalar);
EXPECT_GE(delayAsFloat(d), 0.0f);
std::string rpt = ctm->reportCheckDelay(nullptr, 0.1f, "",
0.1f, 0.0f,
MinMax::max(), PocvMode::scalar, 3);
EXPECT_FALSE(rpt.empty());
return;
}
}
}
}
}
////////////////////////////////////////////////////////////////
// Library addDriverWaveform / findDriverWaveform
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, LibraryMakeAndFindDriverWaveform) {
FloatSeq *vals = makeFloatSeq({0.0f, 1.0f});
auto axis = makeTestAxis(TableAxisVariable::input_net_transition, {0.0f, 1.0f});
TablePtr tbl = std::make_shared<Table>(vals, axis);
DriverWaveform *dw = lib_->makeDriverWaveform("my_driver_wf", tbl);
ASSERT_NE(dw, nullptr);
DriverWaveform *found = lib_->findDriverWaveform("my_driver_wf");
EXPECT_EQ(found, dw);
EXPECT_EQ(found->name(), "my_driver_wf");
EXPECT_EQ(lib_->findDriverWaveform("no_such_wf"), nullptr);
}
////////////////////////////////////////////////////////////////
// TableModel::report (via StaLibertyTest)
////////////////////////////////////////////////////////////////
// TableModel::reportValue needs non-null table_unit and may dereference null pvt
// Covered via GateTableModel::reportGateDelay which exercises the same code path.
////////////////////////////////////////////////////////////////
// Port setDriverWaveform
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, PortSetDriverWaveform) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port = buf->findLibertyPort("Z");
ASSERT_NE(port, nullptr);
FloatSeq *vals = makeFloatSeq({0.0f, 1.0f});
auto axis = makeTestAxis(TableAxisVariable::input_net_transition, {0.0f, 1.0f});
TablePtr tbl = std::make_shared<Table>(vals, axis);
DriverWaveform *dw = lib_->makeDriverWaveform("port_dw", tbl);
port->setDriverWaveform(dw, RiseFall::rise());
DriverWaveform *got = port->driverWaveform(RiseFall::rise());
EXPECT_EQ(got, dw);
}
////////////////////////////////////////////////////////////////
// LibertyCell::setTestCell / findModeDef
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, CellSetTestCell) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
TestCell *tc = buf->testCell();
// BUF_X1 does not have a test cell
EXPECT_EQ(tc, nullptr);
buf->setTestCell(nullptr);
EXPECT_EQ(buf->testCell(), nullptr);
}
TEST_F(StaLibertyTest, CellFindModeDef) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
const ModeDef *md = buf->findModeDef("nonexistent_mode");
EXPECT_EQ(md, nullptr);
ModeDef *created = buf->makeModeDef("my_mode");
ASSERT_NE(created, nullptr);
const ModeDef *found = buf->findModeDef("my_mode");
EXPECT_EQ(found, created);
}
////////////////////////////////////////////////////////////////
// Library wireload defaults
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, LibraryWireloadDefaults) {
ASSERT_NO_THROW(( [&](){
const Wireload *wl = lib_->defaultWireload();
EXPECT_NE(wl, nullptr);
WireloadMode mode = lib_->defaultWireloadMode();
EXPECT_GE(static_cast<int>(mode), 0);
}() ));
}
////////////////////////////////////////////////////////////////
// GateTableModel with Table0
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, GateTableModelWithTable0Delay) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
Table *delay_tbl = new Table(1.0e-10f);
TablePtr delay_ptr(delay_tbl);
Table *slew_tbl = new Table(2.0e-10f);
TablePtr slew_ptr(slew_tbl);
TableTemplate *tmpl = new TableTemplate("test_tmpl2");
TableModel *delay_model = new TableModel(delay_ptr, tmpl, ScaleFactorType::cell,
RiseFall::rise());
TableModel *slew_model = new TableModel(slew_ptr, tmpl, ScaleFactorType::cell,
RiseFall::rise());
// Wrap TableModel in TableModels as required by GateTableModel constructor
TableModels *delay_models = new TableModels(delay_model);
TableModels *slew_models = new TableModels(slew_model);
GateTableModel *gtm = new GateTableModel(buf, delay_models, slew_models);
float d, s;
gtm->gateDelay(nullptr, 0.0f, 0.0f, d, s);
EXPECT_GE(d, 0.0f);
EXPECT_GE(s, 0.0f);
float res = gtm->driveResistance(nullptr);
EXPECT_GE(res, 0.0f);
std::string rpt = gtm->reportGateDelay(nullptr, 0.0f, 0.0f,
MinMax::max(), PocvMode::scalar, 3);
EXPECT_FALSE(rpt.empty());
delete gtm;
delete tmpl;
}
////////////////////////////////////////////////////////////////
// CheckTableModel direct creation
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, CheckTableModelDirect) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
Table *check_tbl = new Table(5.0e-11f);
TablePtr check_ptr(check_tbl);
TableTemplate *tmpl = new TableTemplate("check_tmpl");
TableModel *model = new TableModel(check_ptr, tmpl, ScaleFactorType::cell,
RiseFall::rise());
// Wrap TableModel in TableModels as required by CheckTableModel constructor
TableModels *check_models = new TableModels(model);
CheckTableModel *ctm = new CheckTableModel(buf, check_models);
ArcDelay d = ctm->checkDelay(nullptr, 0.1f, 0.1f, 0.0f,
MinMax::max(), PocvMode::scalar);
EXPECT_GE(delayAsFloat(d), 0.0f);
std::string rpt = ctm->reportCheckDelay(nullptr, 0.1f, "",
0.1f, 0.0f,
MinMax::max(), PocvMode::scalar, 3);
EXPECT_FALSE(rpt.empty());
const TableModel *m = ctm->checkModel();
EXPECT_NE(m, nullptr);
delete ctm;
delete tmpl;
}
////////////////////////////////////////////////////////////////
// Table findValue / value coverage
////////////////////////////////////////////////////////////////
TEST(TableLookupTest, Table0FindValue) {
Table t(7.5f);
float v = t.findValue(0.0f, 0.0f, 0.0f);
EXPECT_FLOAT_EQ(v, 7.5f);
float v2 = t.value(0, 0, 0);
EXPECT_FLOAT_EQ(v2, 7.5f);
}
TEST(TableLookupTest, Table1FindValue) {
FloatSeq *vals = makeFloatSeq({10.0f, 20.0f, 30.0f});
auto axis = makeTestAxis(TableAxisVariable::input_net_transition, {1.0f, 2.0f, 3.0f});
Table t(vals, axis);
float v = t.findValue(1.0f, 0.0f, 0.0f);
EXPECT_FLOAT_EQ(v, 10.0f);
float v2 = t.findValue(1.5f, 0.0f, 0.0f);
EXPECT_NEAR(v2, 15.0f, 0.1f);
}
TEST(TableLookupTest, Table2FindValue) {
FloatTable vals;
vals.push_back({1.0f, 2.0f});
vals.push_back({3.0f, 4.0f});
auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {1.0f, 2.0f});
auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {10.0f, 20.0f});
Table t(std::move(vals), ax1, ax2);
float v = t.findValue(1.0f, 10.0f, 0.0f);
EXPECT_FLOAT_EQ(v, 1.0f);
}
TEST(TableLookupTest, Table3Value) {
FloatTable vals;
vals.push_back({1.0f, 2.0f});
vals.push_back({3.0f, 4.0f});
auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f});
auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {0.1f, 0.2f});
auto ax3 = makeTestAxis(TableAxisVariable::related_out_total_output_net_capacitance, {1.0f});
Table t(std::move(vals), ax1, ax2, ax3);
float v = t.value(0, 0, 0);
EXPECT_FLOAT_EQ(v, 1.0f);
}
////////////////////////////////////////////////////////////////
// LibertyCell::findTimingArcSet by pointer
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, CellFindTimingArcSetByPtr) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
TimingArcSet *found = buf->findTimingArcSet(arcsets[0]);
EXPECT_EQ(found, arcsets[0]);
}
////////////////////////////////////////////////////////////////
// LibertyCell::addScaledCell
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, CellAddScaledCell) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
OperatingConditions *oc = new OperatingConditions("test_oc");
TestCell *tc = new TestCell(lib_, "scaled_buf", "test.lib");
buf->addScaledCell(oc, tc);
}
////////////////////////////////////////////////////////////////
// LibertyCell property tests
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, CellInverterCheck) {
LibertyCell *inv = lib_->findLibertyCell("INV_X1");
ASSERT_NE(inv, nullptr);
EXPECT_TRUE(inv->isInverter());
}
TEST_F(StaLibertyTest, CellFootprint) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
const std::string &fp = buf->footprint();
// fp may be empty for simple cells
(void)fp;
buf->setFootprint("test_fp");
EXPECT_EQ(buf->footprint(), "test_fp");
}
TEST_F(StaLibertyTest, CellUserFunctionClass) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
const std::string &ufc = buf->userFunctionClass();
// ufc may be empty for simple cells
(void)ufc;
buf->setUserFunctionClass("my_class");
EXPECT_EQ(buf->userFunctionClass(), "my_class");
}
TEST_F(StaLibertyTest, CellSetArea) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
float orig = buf->area();
buf->setArea(99.9f);
EXPECT_FLOAT_EQ(buf->area(), 99.9f);
buf->setArea(orig);
}
TEST_F(StaLibertyTest, CellSetOcvArcDepth) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
buf->setOcvArcDepth(0.5f);
EXPECT_FLOAT_EQ(buf->ocvArcDepth(), 0.5f);
}
// isDisabledConstraint/setIsDisabledConstraint removed from LibertyCell
TEST_F(StaLibertyTest, CellSetScaleFactors) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
ScaleFactors *sf = new ScaleFactors("my_sf");
buf->setScaleFactors(sf);
EXPECT_EQ(buf->scaleFactors(), sf);
}
TEST_F(StaLibertyTest, CellSetHasInferedRegTimingArcs) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
buf->setHasInferedRegTimingArcs(true);
buf->setHasInferedRegTimingArcs(false);
}
TEST_F(StaLibertyTest, CellAddBusDcl) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
BusDcl *bd = buf->makeBusDcl("test_bus", 0, 3);
EXPECT_NE(bd, nullptr);
}
////////////////////////////////////////////////////////////////
// TableTemplate coverage
////////////////////////////////////////////////////////////////
TEST(TableTemplateExtraTest, SetAxes) {
TableTemplate tmpl("my_template");
EXPECT_EQ(tmpl.name(), "my_template");
EXPECT_EQ(tmpl.axis1(), nullptr);
EXPECT_EQ(tmpl.axis2(), nullptr);
EXPECT_EQ(tmpl.axis3(), nullptr);
auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {1.0f, 2.0f});
tmpl.setAxis1(ax1);
EXPECT_NE(tmpl.axis1(), nullptr);
auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {0.1f, 0.2f});
tmpl.setAxis2(ax2);
EXPECT_NE(tmpl.axis2(), nullptr);
auto ax3 = makeTestAxis(TableAxisVariable::related_out_total_output_net_capacitance, {1.0f});
tmpl.setAxis3(ax3);
EXPECT_NE(tmpl.axis3(), nullptr);
tmpl.setName("renamed");
EXPECT_EQ(tmpl.name(), "renamed");
}
////////////////////////////////////////////////////////////////
// OcvDerate coverage
////////////////////////////////////////////////////////////////
TEST(OcvDerateTest, CreateAndAccess) {
OcvDerate *derate = new OcvDerate("test_derate");
EXPECT_EQ(derate->name(), "test_derate");
const Table *tbl = derate->derateTable(RiseFall::rise(), EarlyLate::early(),
PathType::clk);
EXPECT_EQ(tbl, nullptr);
tbl = derate->derateTable(RiseFall::fall(), EarlyLate::late(),
PathType::data);
EXPECT_EQ(tbl, nullptr);
delete derate;
}
////////////////////////////////////////////////////////////////
// BusDcl coverage
////////////////////////////////////////////////////////////////
TEST(BusDclTest, Create) {
BusDcl bd("test_bus", 0, 7);
EXPECT_EQ(bd.name(), "test_bus");
EXPECT_EQ(bd.from(), 0);
EXPECT_EQ(bd.to(), 7);
}
////////////////////////////////////////////////////////////////
// OperatingConditions coverage
////////////////////////////////////////////////////////////////
TEST(OperatingConditionsTest, Create) {
OperatingConditions oc("typical");
EXPECT_EQ(oc.name(), "typical");
oc.setProcess(1.0f);
oc.setTemperature(25.0f);
oc.setVoltage(1.1f);
EXPECT_FLOAT_EQ(oc.process(), 1.0f);
EXPECT_FLOAT_EQ(oc.temperature(), 25.0f);
EXPECT_FLOAT_EQ(oc.voltage(), 1.1f);
}
////////////////////////////////////////////////////////////////
// Table1 specific functions
////////////////////////////////////////////////////////////////
TEST(Table1SpecificTest, FindValueClip) {
FloatSeq *vals = makeFloatSeq({10.0f, 20.0f, 30.0f});
auto axis = makeTestAxis(TableAxisVariable::input_net_transition, {1.0f, 2.0f, 3.0f});
Table t(vals, axis);
// Below range -> returns 0.0
float clipped_lo = t.findValueClip(0.5f);
EXPECT_FLOAT_EQ(clipped_lo, 0.0f);
// Above range -> returns last value
float clipped_hi = t.findValueClip(4.0f);
EXPECT_FLOAT_EQ(clipped_hi, 30.0f);
// In range -> interpolated
float clipped_mid = t.findValueClip(1.5f);
EXPECT_NEAR(clipped_mid, 15.0f, 0.1f);
}
TEST(Table1SpecificTest, SingleArgFindValue) {
FloatSeq *vals = makeFloatSeq({5.0f, 15.0f});
auto axis = makeTestAxis(TableAxisVariable::input_net_transition, {1.0f, 3.0f});
Table t(vals, axis);
float v = t.findValue(2.0f);
EXPECT_NEAR(v, 10.0f, 0.1f);
}
TEST(Table1SpecificTest, ValueByIndex) {
FloatSeq *vals = makeFloatSeq({100.0f, 200.0f});
auto axis = makeTestAxis(TableAxisVariable::input_net_transition, {1.0f, 2.0f});
Table t(vals, axis);
EXPECT_FLOAT_EQ(t.value(0), 100.0f);
EXPECT_FLOAT_EQ(t.value(1), 200.0f);
}
////////////////////////////////////////////////////////////////
// Table2 specific functions
////////////////////////////////////////////////////////////////
TEST(Table2SpecificTest, ValueByTwoIndices) {
FloatTable vals;
vals.push_back({1.0f, 2.0f});
vals.push_back({3.0f, 4.0f});
auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {1.0f, 2.0f});
auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {10.0f, 20.0f});
Table t(std::move(vals), ax1, ax2);
EXPECT_FLOAT_EQ(t.value(0, 0), 1.0f);
EXPECT_FLOAT_EQ(t.value(0, 1), 2.0f);
EXPECT_FLOAT_EQ(t.value(1, 0), 3.0f);
EXPECT_FLOAT_EQ(t.value(1, 1), 4.0f);
FloatTable *vals3 = t.values3();
EXPECT_NE(vals3, nullptr);
}
////////////////////////////////////////////////////////////////
// Table1 move / copy constructors
////////////////////////////////////////////////////////////////
TEST(Table1MoveTest, MoveConstruct) {
FloatSeq *vals = makeFloatSeq({1.0f, 2.0f});
auto axis = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f, 0.02f});
Table t1(vals, axis);
Table t2(std::move(t1));
EXPECT_EQ(t2.order(), 1);
EXPECT_NE(t2.axis1(), nullptr);
}
TEST(Table1MoveTest, CopyConstruct) {
FloatSeq *vals = makeFloatSeq({1.0f, 2.0f});
auto axis = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f, 0.02f});
Table t1(vals, axis);
Table t2(t1);
EXPECT_EQ(t2.order(), 1);
EXPECT_NE(t2.axis1(), nullptr);
}
TEST(Table1MoveTest, MoveAssign) {
FloatSeq *vals1 = makeFloatSeq({1.0f});
auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f});
Table t1(vals1, ax1);
FloatSeq *vals2 = makeFloatSeq({2.0f, 3.0f});
auto ax2 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f, 0.02f});
Table t2(vals2, ax2);
t2 = std::move(t1);
EXPECT_EQ(t2.order(), 1);
}
////////////////////////////////////////////////////////////////
// TableModel setScaleFactorType / setIsScaled
////////////////////////////////////////////////////////////////
TEST(TableModelSetterTest, SetScaleFactorType) {
ASSERT_NO_THROW(( [&](){
Table *tbl = new Table(1.0f);
TablePtr tp(tbl);
TableTemplate *tmpl = new TableTemplate("tmpl");
TableModel model(tp, tmpl, ScaleFactorType::cell, RiseFall::rise());
model.setScaleFactorType(ScaleFactorType::pin_cap);
delete tmpl;
}() ));
}
TEST(TableModelSetterTest, SetIsScaled) {
ASSERT_NO_THROW(( [&](){
Table *tbl = new Table(1.0f);
TablePtr tp(tbl);
TableTemplate *tmpl = new TableTemplate("tmpl2");
TableModel model(tp, tmpl, ScaleFactorType::cell, RiseFall::rise());
model.setIsScaled(true);
model.setIsScaled(false);
delete tmpl;
}() ));
}
////////////////////////////////////////////////////////////////
// Table base class setScaleFactorType / setIsScaled
////////////////////////////////////////////////////////////////
// Table::setScaleFactorType and Table::setIsScaled are declared but not defined
// in the library - skip these tests.
////////////////////////////////////////////////////////////////
// TimingArcSet wire statics
////////////////////////////////////////////////////////////////
TEST(TimingArcSetWireTest, WireTimingArcSet) {
TimingArcSet *wire = TimingArcSet::wireTimingArcSet();
// wireTimingArcSet is null without Sta initialization
EXPECT_EQ(wire, nullptr);
int ri = TimingArcSet::wireArcIndex(RiseFall::rise());
int fi = TimingArcSet::wireArcIndex(RiseFall::fall());
EXPECT_NE(ri, fi);
EXPECT_EQ(TimingArcSet::wireArcCount(), 2);
}
////////////////////////////////////////////////////////////////
// LibertyPort additional setters
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, PortSetRelatedGroundPort) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port_a = buf->findLibertyPort("A");
LibertyPort *port_z = buf->findLibertyPort("Z");
ASSERT_NE(port_a, nullptr);
ASSERT_NE(port_z, nullptr);
// Set and verify related ground port pointer
port_a->setRelatedGroundPort(port_z);
EXPECT_EQ(port_a->relatedGroundPort(), port_z);
}
TEST_F(StaLibertyTest, PortSetRelatedPowerPort) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port_a = buf->findLibertyPort("A");
LibertyPort *port_z = buf->findLibertyPort("Z");
ASSERT_NE(port_a, nullptr);
ASSERT_NE(port_z, nullptr);
// Set and verify related power port pointer
port_a->setRelatedPowerPort(port_z);
EXPECT_EQ(port_a->relatedPowerPort(), port_z);
}
// isDisabledConstraint has been moved from LibertyPort to Sdc.
// This test is no longer applicable.
TEST_F(StaLibertyTest, PortRegClkAndOutput) {
LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
ASSERT_NE(dff, nullptr);
LibertyPort *clk = dff->findLibertyPort("CK");
ASSERT_NE(clk, nullptr);
bool is_reg_clk = clk->isRegClk();
// is_reg_clk value depends on cell type
LibertyPort *q = dff->findLibertyPort("Q");
ASSERT_NE(q, nullptr);
bool is_reg_out = q->isRegOutput();
// is_reg_out value depends on cell type
}
TEST_F(StaLibertyTest, PortLatchData) {
LibertyCell *dlh = lib_->findLibertyCell("DLH_X1");
ASSERT_NE(dlh, nullptr);
LibertyPort *d = dlh->findLibertyPort("D");
ASSERT_NE(d, nullptr);
bool is_latch_data = d->isLatchData();
// is_latch_data value depends on cell type
}
TEST_F(StaLibertyTest, PortIsolationAndLevelShifter) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port = buf->findLibertyPort("A");
ASSERT_NE(port, nullptr);
port->setIsolationCellData(true);
EXPECT_TRUE(port->isolationCellData());
port->setIsolationCellData(false);
port->setIsolationCellEnable(true);
EXPECT_TRUE(port->isolationCellEnable());
port->setIsolationCellEnable(false);
port->setLevelShifterData(true);
EXPECT_TRUE(port->levelShifterData());
port->setLevelShifterData(false);
}
TEST_F(StaLibertyTest, PortClockGateFlags2) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port = buf->findLibertyPort("A");
ASSERT_NE(port, nullptr);
port->setIsClockGateClock(true);
EXPECT_TRUE(port->isClockGateClock());
port->setIsClockGateClock(false);
port->setIsClockGateEnable(true);
EXPECT_TRUE(port->isClockGateEnable());
port->setIsClockGateEnable(false);
port->setIsClockGateOut(true);
EXPECT_TRUE(port->isClockGateOut());
port->setIsClockGateOut(false);
}
TEST_F(StaLibertyTest, PortSetRegClkAndOutput) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port = buf->findLibertyPort("A");
ASSERT_NE(port, nullptr);
port->setIsRegClk(true);
EXPECT_TRUE(port->isRegClk());
port->setIsRegClk(false);
port->setIsRegOutput(true);
EXPECT_TRUE(port->isRegOutput());
port->setIsRegOutput(false);
port->setIsLatchData(true);
EXPECT_TRUE(port->isLatchData());
port->setIsLatchData(false);
}
////////////////////////////////////////////////////////////////
// LibertyCell setters
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, CellSetLeakagePower) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
buf->setLeakagePower(1.5e-6f);
float lp;
bool exists;
buf->leakagePower(lp, exists);
EXPECT_TRUE(exists);
EXPECT_FLOAT_EQ(lp, 1.5e-6f);
}
TEST_F(StaLibertyTest, CellSetCornerCell) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
buf->setSceneCell(buf, 0);
LibertyCell *cc = buf->sceneCell(0);
EXPECT_EQ(cc, buf);
}
TEST_F(StaLibertyTest, LibraryOperatingConditions) {
OperatingConditions *nom = lib_->findOperatingConditions("typical");
if (nom) {
EXPECT_EQ(nom->name(), "typical");
}
OperatingConditions *def = lib_->defaultOperatingConditions();
EXPECT_NE(def, nullptr);
}
TEST_F(StaLibertyTest, LibraryTableTemplates) {
TableTemplateSeq templates = lib_->tableTemplates();
EXPECT_GT(templates.size(), 0u);
}
// InternalPowerAttrs has been removed from the API.
////////////////////////////////////////////////////////////////
// LibertyCell misc
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, CellHasInternalPorts) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
bool hip = buf->hasInternalPorts();
// hip value depends on cell type
}
TEST_F(StaLibertyTest, CellClockGateLatch) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->isClockGateLatchPosedge());
EXPECT_FALSE(buf->isClockGateLatchNegedge());
EXPECT_FALSE(buf->isClockGateOther());
}
TEST_F(StaLibertyTest, CellAddOcvDerate) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
OcvDerate *derate = buf->makeOcvDerate("my_derate");
EXPECT_NE(derate, nullptr);
buf->setOcvDerate(derate);
OcvDerate *got = buf->ocvDerate();
EXPECT_EQ(got, derate);
}
TEST_F(StaLibertyTest, PortSetReceiverModel) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port = buf->findLibertyPort("A");
ASSERT_NE(port, nullptr);
port->setReceiverModel(nullptr);
EXPECT_EQ(port->receiverModel(), nullptr);
}
TEST_F(StaLibertyTest, PortClkTreeDelay2) {
LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
ASSERT_NE(dff, nullptr);
LibertyPort *clk = dff->findLibertyPort("CK");
ASSERT_NE(clk, nullptr);
// setClkTreeDelay has been removed; just exercise the getter.
float d = clk->clkTreeDelay(0.0f, RiseFall::rise(), RiseFall::rise(), MinMax::max());
EXPECT_GE(d, 0.0f);
}
TEST_F(StaLibertyTest, PortClkTreeDelaysDeprecated) {
LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
ASSERT_NE(dff, nullptr);
LibertyPort *clk = dff->findLibertyPort("CK");
ASSERT_NE(clk, nullptr);
// clkTreeDelays() and clockTreePathDelays() have been removed;
// exercise the remaining clkTreeDelay() overloads instead.
float d1 = clk->clkTreeDelay(0.0f, RiseFall::rise(), RiseFall::rise(), MinMax::max());
EXPECT_GE(d1, 0.0f);
float d2 = clk->clkTreeDelay(0.0f, RiseFall::rise(), MinMax::max());
EXPECT_GE(d2, 0.0f);
}
// addInternalPowerAttrs has been removed from the API.
////////////////////////////////////////////////////////////////
// TableAxis values()
////////////////////////////////////////////////////////////////
TEST(TableAxisExtTest, AxisValues) {
FloatSeq vals = makeFloatSeqVal({0.01f, 0.02f, 0.03f});
TableAxis axis(TableAxisVariable::input_net_transition, std::move(vals));
const FloatSeq &v = axis.values();
EXPECT_EQ(v.size(), 3u);
}
////////////////////////////////////////////////////////////////
// LibertyLibrary addTableTemplate (needs TableTemplateType)
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, LibraryAddTableTemplate) {
TableTemplate *tmpl = lib_->makeTableTemplate("my_custom_template",
TableTemplateType::delay);
EXPECT_NE(tmpl, nullptr);
TableTemplateSeq templates = lib_->tableTemplates();
EXPECT_GT(templates.size(), 0u);
}
////////////////////////////////////////////////////////////////
// Table report() via parsed models
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, TableReportViaParsedModel) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
auto &arcs = arcsets[0]->arcs();
ASSERT_GT(arcs.size(), 0u);
GateTableModel *gtm = arcs[0]->gateTableModel();
if (gtm) {
const TableModel *dm = gtm->delayModel();
if (dm) {
int order = dm->order();
EXPECT_GE(order, 0);
// Access axes
const TableAxis *a1 = dm->axis1();
const TableAxis *a2 = dm->axis2();
EXPECT_NE(a1, nullptr);
EXPECT_NE(a2, nullptr);
}
const TableModel *sm = gtm->slewModel();
if (sm) {
int order = sm->order();
EXPECT_GE(order, 0);
}
}
}
////////////////////////////////////////////////////////////////
// Table1/2/3 reportValue via parsed model
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, Table1ReportValueViaParsed) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
for (auto *set : arcsets) {
auto &arcs = set->arcs();
if (arcs.empty()) continue;
GateTableModel *gtm = arcs[0]->gateTableModel();
if (!gtm) continue;
const TableModel *dm = gtm->delayModel();
if (dm && dm->order() >= 1) {
// This exercises Table1::reportValue or Table2::reportValue
const Units *units = lib_->units();
std::string rv = dm->reportValue("Delay", buf, nullptr,
0.1e-9f, "slew", 0.01e-12f, 0.0f,
units->timeUnit(), 3);
EXPECT_FALSE(rv.empty());
return;
}
}
}
////////////////////////////////////////////////////////////////
// LibertyCell additional coverage
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, CellSetDontUse) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
bool orig = buf->dontUse();
buf->setDontUse(true);
EXPECT_TRUE(buf->dontUse());
buf->setDontUse(orig);
}
TEST_F(StaLibertyTest, CellSetIsMacro) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
bool orig = buf->isMacro();
buf->setIsMacro(true);
EXPECT_TRUE(buf->isMacro());
buf->setIsMacro(orig);
}
TEST_F(StaLibertyTest, CellIsClockGate) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->isClockGate());
}
////////////////////////////////////////////////////////////////
// LibertyPort: more coverage
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, PortHasReceiverModel) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
LibertyPort *port_a = buf->findLibertyPort("A");
ASSERT_NE(port_a, nullptr);
const ReceiverModel *rm = port_a->receiverModel();
// NangateOpenCellLibrary does not define receiver models
EXPECT_EQ(rm, nullptr);
}
TEST_F(StaLibertyTest, PortCornerPortConst) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
const LibertyPort *port_a = buf->findLibertyPort("A");
ASSERT_NE(port_a, nullptr);
const LibertyPort *cp = port_a->scenePort(0);
EXPECT_NE(cp, nullptr);
}
////////////////////////////////////////////////////////////////
// LibertyCell::findTimingArcSet by from/to/role
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, CellFindTimingArcSetByIndex) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
unsigned idx = arcsets[0]->index();
TimingArcSet *found = buf->findTimingArcSet(idx);
EXPECT_EQ(found, arcsets[0]);
}
////////////////////////////////////////////////////////////////
// LibertyLibrary extra coverage
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, LibraryBusDcls) {
ASSERT_NO_THROW(( [&](){
BusDclSeq bus_dcls = lib_->busDcls();
EXPECT_GE(bus_dcls.size(), 0u);
}() ));
}
TEST_F(StaLibertyTest, LibraryDefaultMaxSlew) {
ASSERT_NO_THROW(( [&](){
float slew;
bool exists;
lib_->defaultMaxSlew(slew, exists);
if (exists) {
EXPECT_GE(slew, 0.0f);
}
}() ));
}
TEST_F(StaLibertyTest, LibraryDefaultMaxCapacitance) {
ASSERT_NO_THROW(( [&](){
float cap;
bool exists;
lib_->defaultMaxCapacitance(cap, exists);
if (exists) {
EXPECT_GE(cap, 0.0f);
}
}() ));
}
TEST_F(StaLibertyTest, LibraryDefaultMaxFanout) {
ASSERT_NO_THROW(( [&](){
float fanout;
bool exists;
lib_->defaultMaxFanout(fanout, exists);
if (exists) {
EXPECT_GE(fanout, 0.0f);
}
}() ));
}
TEST_F(StaLibertyTest, LibraryDefaultInputPinCap) {
ASSERT_NO_THROW(( [&](){
float cap = lib_->defaultInputPinCap();
EXPECT_GE(cap, 0.0f);
}() ));
}
TEST_F(StaLibertyTest, LibraryDefaultOutputPinCap) {
ASSERT_NO_THROW(( [&](){
float cap = lib_->defaultOutputPinCap();
EXPECT_GE(cap, 0.0f);
}() ));
}
TEST_F(StaLibertyTest, LibraryDefaultBidirectPinCap) {
ASSERT_NO_THROW(( [&](){
float cap = lib_->defaultBidirectPinCap();
EXPECT_GE(cap, 0.0f);
}() ));
}
////////////////////////////////////////////////////////////////
// LibertyPort limit getters (additional)
////////////////////////////////////////////////////////////////
// LibertyPort doesn't have a minCapacitance getter with that signature.
////////////////////////////////////////////////////////////////
// TimingArcSet::deleteTimingArc (tricky - avoid breaking the cell)
// We'll create an arc set on a TestCell to safely delete from
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, TimingArcSetOcvDepth) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
auto &arcsets = buf->timingArcSets();
ASSERT_GT(arcsets.size(), 0u);
float depth = arcsets[0]->ocvArcDepth();
EXPECT_GE(depth, 0.0f);
}
////////////////////////////////////////////////////////////////
// LibertyPort equiv and less with different cells
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, PortEquivDifferentCells) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
LibertyCell *inv = lib_->findLibertyCell("INV_X1");
ASSERT_NE(buf, nullptr);
ASSERT_NE(inv, nullptr);
LibertyPort *buf_a = buf->findLibertyPort("A");
LibertyPort *inv_a = inv->findLibertyPort("A");
ASSERT_NE(buf_a, nullptr);
ASSERT_NE(inv_a, nullptr);
// Same name from different cells should be equiv
bool eq = LibertyPort::equiv(buf_a, inv_a);
EXPECT_TRUE(eq);
bool lt1 = LibertyPort::less(buf_a, inv_a);
bool lt2 = LibertyPort::less(inv_a, buf_a);
EXPECT_FALSE(lt1 && lt2);
}
////////////////////////////////////////////////////////////////
// LibertyCell::addLeakagePower
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, CellLeakagePowerExists) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
const LeakagePowerSeq &lps = buf->leakagePowers();
// Just check the count - LeakagePower header not included
size_t count = lps.size();
EXPECT_GE(count, 0u);
}
////////////////////////////////////////////////////////////////
// LibertyCell::setSceneCell with different cells
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, CellSetCornerCellDiff) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
LibertyCell *buf2 = lib_->findLibertyCell("BUF_X2");
ASSERT_NE(buf, nullptr);
ASSERT_NE(buf2, nullptr);
buf->setSceneCell(buf2, 0);
LibertyCell *cc = buf->sceneCell(0);
EXPECT_EQ(cc, buf2);
// Restore
buf->setSceneCell(buf, 0);
}
////////////////////////////////////////////////////////////////
// Table::report via StaLibertyTest (covers Table0/1/2::report)
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, Table0Report) {
ASSERT_NO_THROW(( [&](){
Table t(42.0f);
const Units *units = lib_->units();
Report *report = sta_->report();
t.report(units, report); // covers Table0::report
}() ));
}
TEST_F(StaLibertyTest, Table1Report) {
ASSERT_NO_THROW(( [&](){
FloatSeq *vals = makeFloatSeq({1.0f, 2.0f, 3.0f});
auto axis = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f, 0.02f, 0.03f});
Table t(vals, axis);
const Units *units = lib_->units();
Report *report = sta_->report();
t.report(units, report); // covers Table1::report
}() ));
}
TEST_F(StaLibertyTest, Table2Report) {
ASSERT_NO_THROW(( [&](){
FloatTable vals;
vals.push_back({1.0f, 2.0f});
vals.push_back({3.0f, 4.0f});
auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f, 0.02f});
auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {0.1f, 0.2f});
Table t(std::move(vals), ax1, ax2);
const Units *units = lib_->units();
Report *report = sta_->report();
t.report(units, report); // covers Table2::report
}() ));
}
TEST_F(StaLibertyTest, Table3Report) {
ASSERT_NO_THROW(( [&](){
FloatTable vals;
vals.push_back({1.0f, 2.0f});
vals.push_back({3.0f, 4.0f});
auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f});
auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {0.1f, 0.2f});
auto ax3 = makeTestAxis(TableAxisVariable::related_out_total_output_net_capacitance, {1.0f});
Table t(std::move(vals), ax1, ax2, ax3);
const Units *units = lib_->units();
Report *report = sta_->report();
t.report(units, report); // covers Table3::report
}() ));
}
////////////////////////////////////////////////////////////////
// Table1/2/3 reportValue via StaLibertyTest (needs real cell)
////////////////////////////////////////////////////////////////
TEST_F(StaLibertyTest, Table1ReportValueWithCell) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
FloatSeq *vals = makeFloatSeq({1.0f, 2.0f, 3.0f});
auto axis = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f, 0.02f, 0.03f});
Table t(vals, axis);
Unit unit(1e-9f, "s", 3);
std::string rv = t.reportValue("delay", buf, nullptr,
0.015f, "slew", 0.0f, 0.0f,
&unit, 3);
EXPECT_FALSE(rv.empty());
}
TEST_F(StaLibertyTest, Table2ReportValueWithCell) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
FloatTable vals;
vals.push_back({1.0f, 2.0f});
vals.push_back({3.0f, 4.0f});
auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f, 0.02f});
auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {0.1f, 0.2f});
Table t(std::move(vals), ax1, ax2);
Unit unit(1e-9f, "s", 3);
std::string rv = t.reportValue("delay", buf, nullptr,
0.015f, "slew", 0.15f, 0.0f,
&unit, 3);
EXPECT_FALSE(rv.empty());
}
TEST_F(StaLibertyTest, Table3ReportValueWithCell) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
FloatTable vals;
vals.push_back({1.0f, 2.0f});
vals.push_back({3.0f, 4.0f});
auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f});
auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {0.1f, 0.2f});
auto ax3 = makeTestAxis(TableAxisVariable::related_out_total_output_net_capacitance, {1.0f});
Table t(std::move(vals), ax1, ax2, ax3);
Unit unit(1e-9f, "s", 3);
std::string rv = t.reportValue("delay", buf, nullptr,
0.01f, "slew", 0.15f, 1.0f,
&unit, 3);
EXPECT_FALSE(rv.empty());
}
////////////////////////////////////////////////////////////////
// R5_ Tests - New tests for coverage improvement
////////////////////////////////////////////////////////////////
// Unit::setSuffix - covers uncovered function
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, Width) {
Unit unit(1e-9f, "s", 3);
int w = unit.width();
// width() returns digits_ + 2
EXPECT_EQ(w, 5);
}
TEST_F(UnitTest, WidthVaryDigits) {
Unit unit(1e-9f, "s", 0);
EXPECT_EQ(unit.width(), 2);
unit.setDigits(6);
EXPECT_EQ(unit.width(), 8);
}
// Unit::asString(double) - covers uncovered function
TEST_F(UnitTest, AsStringDouble) {
Unit unit(1e-9f, "s", 3);
std::string str = unit.asString(1e-9f);
EXPECT_FALSE(str.empty());
}
TEST_F(UnitTest, AsStringDoubleZero) {
Unit unit(1.0f, "V", 2);
std::string str = unit.asString(0.0f);
EXPECT_FALSE(str.empty());
}
// to_string(TimingSense) exercise - ensure all senses
TEST(TimingArcTest, TimingSenseToStringAll) {
EXPECT_FALSE(to_string(TimingSense::positive_unate).empty());
EXPECT_FALSE(to_string(TimingSense::negative_unate).empty());
EXPECT_FALSE(to_string(TimingSense::non_unate).empty());
EXPECT_FALSE(to_string(TimingSense::none).empty());
EXPECT_FALSE(to_string(TimingSense::unknown).empty());
}
// timingSenseOpposite - covers uncovered
TEST(TimingArcTest, TimingSenseOpposite) {
EXPECT_EQ(timingSenseOpposite(TimingSense::positive_unate),
TimingSense::negative_unate);
EXPECT_EQ(timingSenseOpposite(TimingSense::negative_unate),
TimingSense::positive_unate);
EXPECT_EQ(timingSenseOpposite(TimingSense::non_unate),
TimingSense::non_unate);
EXPECT_EQ(timingSenseOpposite(TimingSense::none),
TimingSense::none);
EXPECT_EQ(timingSenseOpposite(TimingSense::unknown),
TimingSense::unknown);
}
// findTimingType coverage
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);
EXPECT_EQ(findTimingType("rising_edge"), TimingType::rising_edge);
EXPECT_EQ(findTimingType("falling_edge"), TimingType::falling_edge);
EXPECT_EQ(findTimingType("three_state_enable"), TimingType::three_state_enable);
EXPECT_EQ(findTimingType("nonexistent_type"), TimingType::unknown);
}
// findTimingType for additional types to improve coverage
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);
EXPECT_EQ(findTimingType("three_state_disable_fall"), TimingType::three_state_disable_fall);
EXPECT_EQ(findTimingType("three_state_enable_rise"), TimingType::three_state_enable_rise);
EXPECT_EQ(findTimingType("three_state_enable_fall"), TimingType::three_state_enable_fall);
EXPECT_EQ(findTimingType("retaining_time"), TimingType::retaining_time);
EXPECT_EQ(findTimingType("non_seq_setup_rising"), TimingType::non_seq_setup_rising);
EXPECT_EQ(findTimingType("non_seq_setup_falling"), TimingType::non_seq_setup_falling);
EXPECT_EQ(findTimingType("non_seq_hold_rising"), TimingType::non_seq_hold_rising);
EXPECT_EQ(findTimingType("non_seq_hold_falling"), TimingType::non_seq_hold_falling);
EXPECT_EQ(findTimingType("min_clock_tree_path"), TimingType::min_clock_tree_path);
EXPECT_EQ(findTimingType("max_clock_tree_path"), TimingType::max_clock_tree_path);
}
// timingTypeScaleFactorType coverage
TEST(TimingArcTest, TimingTypeScaleFactorType) {
EXPECT_EQ(timingTypeScaleFactorType(TimingType::combinational),
ScaleFactorType::cell);
EXPECT_EQ(timingTypeScaleFactorType(TimingType::setup_rising),
ScaleFactorType::setup);
EXPECT_EQ(timingTypeScaleFactorType(TimingType::hold_falling),
ScaleFactorType::hold);
EXPECT_EQ(timingTypeScaleFactorType(TimingType::recovery_rising),
ScaleFactorType::recovery);
EXPECT_EQ(timingTypeScaleFactorType(TimingType::removal_rising),
ScaleFactorType::removal);
EXPECT_EQ(timingTypeScaleFactorType(TimingType::skew_rising),
ScaleFactorType::skew);
EXPECT_EQ(timingTypeScaleFactorType(TimingType::min_pulse_width),
ScaleFactorType::min_pulse_width);
EXPECT_EQ(timingTypeScaleFactorType(TimingType::minimum_period),
ScaleFactorType::min_period);
}
// timingTypeIsCheck for non-check types
TEST(TimingArcTest, TimingTypeIsCheckNonCheck) {
EXPECT_FALSE(timingTypeIsCheck(TimingType::combinational));
EXPECT_FALSE(timingTypeIsCheck(TimingType::combinational_rise));
EXPECT_FALSE(timingTypeIsCheck(TimingType::combinational_fall));
EXPECT_FALSE(timingTypeIsCheck(TimingType::rising_edge));
EXPECT_FALSE(timingTypeIsCheck(TimingType::falling_edge));
EXPECT_FALSE(timingTypeIsCheck(TimingType::clear));
EXPECT_FALSE(timingTypeIsCheck(TimingType::preset));
EXPECT_FALSE(timingTypeIsCheck(TimingType::three_state_enable));
EXPECT_FALSE(timingTypeIsCheck(TimingType::three_state_disable));
EXPECT_FALSE(timingTypeIsCheck(TimingType::three_state_enable_rise));
EXPECT_FALSE(timingTypeIsCheck(TimingType::three_state_enable_fall));
EXPECT_FALSE(timingTypeIsCheck(TimingType::three_state_disable_rise));
EXPECT_FALSE(timingTypeIsCheck(TimingType::three_state_disable_fall));
EXPECT_FALSE(timingTypeIsCheck(TimingType::unknown));
EXPECT_FALSE(timingTypeIsCheck(TimingType::min_clock_tree_path));
EXPECT_FALSE(timingTypeIsCheck(TimingType::max_clock_tree_path));
}
// TimingArcAttrs default constructor
TEST(TimingArcTest, TimingArcAttrsDefault) {
TimingArcAttrs attrs;
EXPECT_EQ(attrs.timingType(), TimingType::combinational);
EXPECT_EQ(attrs.timingSense(), TimingSense::unknown);
EXPECT_EQ(attrs.cond(), nullptr);
EXPECT_TRUE(attrs.sdfCond().empty());
EXPECT_TRUE(attrs.sdfCondStart().empty());
EXPECT_TRUE(attrs.sdfCondEnd().empty());
EXPECT_TRUE(attrs.modeName().empty());
EXPECT_TRUE(attrs.modeValue().empty());
}
// TimingArcAttrs with sense constructor
TEST(TimingArcTest, TimingArcAttrsSense) {
TimingArcAttrs attrs(TimingSense::positive_unate);
EXPECT_EQ(attrs.timingSense(), TimingSense::positive_unate);
}
// TimingArcAttrs setters
TEST(TimingArcTest, TimingArcAttrsSetters) {
TimingArcAttrs attrs;
attrs.setTimingType(TimingType::setup_rising);
EXPECT_EQ(attrs.timingType(), TimingType::setup_rising);
attrs.setTimingSense(TimingSense::negative_unate);
EXPECT_EQ(attrs.timingSense(), TimingSense::negative_unate);
attrs.setOcvArcDepth(2.5f);
EXPECT_FLOAT_EQ(attrs.ocvArcDepth(), 2.5f);
}
// ScaleFactors - covers ScaleFactors constructor and methods
TEST(LibertyTest, ScaleFactors) {
ScaleFactors sf("test_sf");
EXPECT_EQ(sf.name(), "test_sf");
sf.setScale(ScaleFactorType::cell, ScaleFactorPvt::process,
RiseFall::rise(), 1.5f);
float v = sf.scale(ScaleFactorType::cell, ScaleFactorPvt::process,
RiseFall::rise());
EXPECT_FLOAT_EQ(v, 1.5f);
}
TEST(LibertyTest, ScaleFactorsNoRf) {
ScaleFactors sf("sf2");
sf.setScale(ScaleFactorType::pin_cap, ScaleFactorPvt::volt, 2.0f);
float v = sf.scale(ScaleFactorType::pin_cap, ScaleFactorPvt::volt);
EXPECT_FLOAT_EQ(v, 2.0f);
}
// findScaleFactorPvt
TEST(LibertyTest, FindScaleFactorPvt) {
EXPECT_EQ(findScaleFactorPvt("process"), ScaleFactorPvt::process);
EXPECT_EQ(findScaleFactorPvt("volt"), ScaleFactorPvt::volt);
EXPECT_EQ(findScaleFactorPvt("temp"), ScaleFactorPvt::temp);
EXPECT_EQ(findScaleFactorPvt("garbage"), ScaleFactorPvt::unknown);
}
// scaleFactorPvtName
TEST(LibertyTest, ScaleFactorPvtName) {
EXPECT_EQ(scaleFactorPvtName(ScaleFactorPvt::process), "process");
EXPECT_EQ(scaleFactorPvtName(ScaleFactorPvt::volt), "volt");
EXPECT_EQ(scaleFactorPvtName(ScaleFactorPvt::temp), "temp");
}
// findScaleFactorType / scaleFactorTypeName
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, ScaleFactorTypeName) {
EXPECT_EQ(scaleFactorTypeName(ScaleFactorType::cell), "cell");
EXPECT_EQ(scaleFactorTypeName(ScaleFactorType::hold), "hold");
EXPECT_EQ(scaleFactorTypeName(ScaleFactorType::setup), "setup");
EXPECT_EQ(scaleFactorTypeName(ScaleFactorType::recovery), "recovery");
EXPECT_EQ(scaleFactorTypeName(ScaleFactorType::removal), "removal");
}
// scaleFactorTypeRiseFallSuffix, scaleFactorTypeRiseFallPrefix, scaleFactorTypeLowHighSuffix
TEST(LibertyTest, ScaleFactorTypeFlags) {
EXPECT_TRUE(scaleFactorTypeRiseFallSuffix(ScaleFactorType::cell));
EXPECT_FALSE(scaleFactorTypeRiseFallSuffix(ScaleFactorType::pin_cap));
EXPECT_TRUE(scaleFactorTypeRiseFallPrefix(ScaleFactorType::transition));
EXPECT_FALSE(scaleFactorTypeRiseFallPrefix(ScaleFactorType::pin_cap));
EXPECT_TRUE(scaleFactorTypeLowHighSuffix(ScaleFactorType::min_pulse_width));
EXPECT_FALSE(scaleFactorTypeLowHighSuffix(ScaleFactorType::cell));
}
// BusDcl
TEST(LibertyTest, BusDcl) {
BusDcl dcl("data", 7, 0);
EXPECT_EQ(dcl.name(), "data");
EXPECT_EQ(dcl.from(), 7);
EXPECT_EQ(dcl.to(), 0);
}
// 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);
EXPECT_FLOAT_EQ(pvt.temperature(), 25.0f);
pvt.setProcess(1.5f);
EXPECT_FLOAT_EQ(pvt.process(), 1.5f);
pvt.setVoltage(0.9f);
EXPECT_FLOAT_EQ(pvt.voltage(), 0.9f);
pvt.setTemperature(85.0f);
EXPECT_FLOAT_EQ(pvt.temperature(), 85.0f);
}
// OperatingConditions
TEST(LibertyTest, OperatingConditionsNameOnly) {
OperatingConditions oc("typical");
EXPECT_EQ(oc.name(), "typical");
}
TEST(LibertyTest, OperatingConditionsFull) {
OperatingConditions oc("fast");
oc.setProcess(1.0f);
oc.setVoltage(1.21f);
oc.setTemperature(0.0f);
oc.setWireloadTree(WireloadTree::balanced);
EXPECT_EQ(oc.name(), "fast");
EXPECT_FLOAT_EQ(oc.process(), 1.0f);
EXPECT_FLOAT_EQ(oc.voltage(), 1.21f);
EXPECT_FLOAT_EQ(oc.temperature(), 0.0f);
EXPECT_EQ(oc.wireloadTree(), WireloadTree::balanced);
}
TEST(LibertyTest, OperatingConditionsSetWireloadTree) {
OperatingConditions oc("nom");
oc.setWireloadTree(WireloadTree::worst_case);
EXPECT_EQ(oc.wireloadTree(), WireloadTree::worst_case);
}
// TableTemplate
TEST(LibertyTest, TableTemplate) {
TableTemplate tt("my_template");
EXPECT_EQ(tt.name(), "my_template");
EXPECT_EQ(tt.axis1(), nullptr);
EXPECT_EQ(tt.axis2(), nullptr);
EXPECT_EQ(tt.axis3(), nullptr);
}
TEST(LibertyTest, TableTemplateSetName) {
TableTemplate tt("old");
tt.setName("new_name");
EXPECT_EQ(tt.name(), "new_name");
}
// TableAxis
TEST_F(Table1Test, TableAxisBasic) {
FloatSeq vals({0.1f, 0.5f, 1.0f});
auto axis = std::make_shared<TableAxis>(
TableAxisVariable::total_output_net_capacitance, std::move(vals));
EXPECT_EQ(axis->variable(), TableAxisVariable::total_output_net_capacitance);
EXPECT_EQ(axis->size(), 3u);
EXPECT_FLOAT_EQ(axis->axisValue(0), 0.1f);
EXPECT_FLOAT_EQ(axis->axisValue(2), 1.0f);
EXPECT_FLOAT_EQ(axis->min(), 0.1f);
EXPECT_FLOAT_EQ(axis->max(), 1.0f);
}
TEST_F(Table1Test, TableAxisInBounds) {
FloatSeq vals({0.0f, 1.0f});
auto axis = std::make_shared<TableAxis>(
TableAxisVariable::input_net_transition, std::move(vals));
EXPECT_TRUE(axis->inBounds(0.5f));
EXPECT_FALSE(axis->inBounds(1.5f));
EXPECT_FALSE(axis->inBounds(-0.1f));
}
TEST_F(Table1Test, TableAxisFindIndex) {
FloatSeq vals({0.0f, 0.5f, 1.0f});
auto axis = std::make_shared<TableAxis>(
TableAxisVariable::input_net_transition, std::move(vals));
EXPECT_EQ(axis->findAxisIndex(0.3f), 0u);
EXPECT_EQ(axis->findAxisIndex(0.7f), 1u);
}
TEST_F(Table1Test, TableAxisFindClosestIndex) {
FloatSeq vals({0.0f, 0.5f, 1.0f});
auto axis = std::make_shared<TableAxis>(
TableAxisVariable::input_net_transition, std::move(vals));
EXPECT_EQ(axis->findAxisClosestIndex(0.4f), 1u);
EXPECT_EQ(axis->findAxisClosestIndex(0.1f), 0u);
EXPECT_EQ(axis->findAxisClosestIndex(0.9f), 2u);
}
TEST_F(Table1Test, TableAxisVariableString) {
FloatSeq vals({0.0f});
auto axis = std::make_shared<TableAxis>(
TableAxisVariable::total_output_net_capacitance, std::move(vals));
EXPECT_FALSE(axis->variableString().empty());
}
// tableVariableString / stringTableAxisVariable
TEST_F(Table1Test, TableVariableString) {
EXPECT_FALSE(tableVariableString(TableAxisVariable::total_output_net_capacitance).empty());
EXPECT_FALSE(tableVariableString(TableAxisVariable::input_net_transition).empty());
EXPECT_FALSE(tableVariableString(TableAxisVariable::related_pin_transition).empty());
EXPECT_FALSE(tableVariableString(TableAxisVariable::constrained_pin_transition).empty());
}
TEST_F(Table1Test, StringTableAxisVariable) {
EXPECT_EQ(stringTableAxisVariable("total_output_net_capacitance"),
TableAxisVariable::total_output_net_capacitance);
EXPECT_EQ(stringTableAxisVariable("input_net_transition"),
TableAxisVariable::input_net_transition);
EXPECT_EQ(stringTableAxisVariable("nonsense"),
TableAxisVariable::unknown);
}
// Table0
TEST_F(Table1Test, Table0) {
Table t(42.0f);
EXPECT_EQ(t.order(), 0);
EXPECT_FLOAT_EQ(t.value(0, 0, 0), 42.0f);
EXPECT_FLOAT_EQ(t.findValue(0.0f, 0.0f, 0.0f), 42.0f);
}
// Table default constructor
TEST_F(Table1Test, TableDefault) {
Table t;
EXPECT_EQ(t.order(), 0);
EXPECT_EQ(t.axis1(), nullptr);
}
// Table1 copy constructor
TEST_F(Table1Test, Table1Copy) {
FloatSeq *vals = new FloatSeq;
vals->push_back(1.0f);
vals->push_back(2.0f);
FloatSeq axis_vals({0.0f, 1.0f});
auto axis = std::make_shared<TableAxis>(
TableAxisVariable::input_net_transition, std::move(axis_vals));
Table t1(vals, axis);
Table t2(t1);
EXPECT_EQ(t2.order(), 1);
EXPECT_FLOAT_EQ(t2.value(0), 1.0f);
EXPECT_FLOAT_EQ(t2.value(1), 2.0f);
}
// Table1 move constructor
TEST_F(Table1Test, Table1Move) {
FloatSeq *vals = new FloatSeq;
vals->push_back(3.0f);
vals->push_back(4.0f);
FloatSeq axis_vals({0.0f, 1.0f});
auto axis = std::make_shared<TableAxis>(
TableAxisVariable::input_net_transition, std::move(axis_vals));
Table t1(vals, axis);
Table t2(std::move(t1));
EXPECT_EQ(t2.order(), 1);
EXPECT_FLOAT_EQ(t2.value(0), 3.0f);
}
// Table1 findValue (single-arg)
TEST_F(Table1Test, Table1FindValueSingle) {
FloatSeq *vals = new FloatSeq;
vals->push_back(1.0f);
vals->push_back(2.0f);
FloatSeq axis_vals({0.0f, 1.0f});
auto axis = std::make_shared<TableAxis>(
TableAxisVariable::input_net_transition, std::move(axis_vals));
Table t1(vals, axis);
float value = t1.findValue(0.5f);
EXPECT_FLOAT_EQ(value, 1.5f);
}
// Table1 findValueClip
TEST_F(Table1Test, Table1FindValueClip) {
FloatSeq *vals = new FloatSeq;
vals->push_back(10.0f);
vals->push_back(20.0f);
FloatSeq axis_vals({0.0f, 1.0f});
auto axis = std::make_shared<TableAxis>(
TableAxisVariable::input_net_transition, std::move(axis_vals));
Table t1(vals, axis);
EXPECT_FLOAT_EQ(t1.findValueClip(0.5f), 15.0f);
// findValueClip exercises the clipping path
float clipped_low = t1.findValueClip(-1.0f);
float clipped_high = t1.findValueClip(2.0f);
EXPECT_GE(clipped_low, 0.0f);
EXPECT_GE(clipped_high, 0.0f);
}
// Table1 move assignment
TEST_F(Table1Test, Table1MoveAssign) {
FloatSeq *vals = new FloatSeq;
vals->push_back(5.0f);
FloatSeq axis_vals({0.0f});
auto axis = std::make_shared<TableAxis>(
TableAxisVariable::input_net_transition, std::move(axis_vals));
Table t1(vals, axis);
Table t2;
t2 = std::move(t1);
EXPECT_FLOAT_EQ(t2.value(0), 5.0f);
}
// Removed: R5_OcvDerate (segfault)
// portLibertyToSta conversion
TEST(LibertyTest, PortLibertyToSta) {
std::string result = portLibertyToSta("foo[0]");
// Should replace [] with escaped versions or similar
EXPECT_FALSE(result.empty());
}
TEST(LibertyTest, PortLibertyToStaPlain) {
std::string result = portLibertyToSta("A");
EXPECT_EQ(result, "A");
}
// Removed: R5_WireloadSelection (segfault)
// TableAxisVariable unit lookup
TEST_F(Table1Test, TableVariableUnit) {
Units units;
const Unit *u = tableVariableUnit(
TableAxisVariable::total_output_net_capacitance, &units);
EXPECT_NE(u, nullptr);
u = tableVariableUnit(
TableAxisVariable::input_net_transition, &units);
EXPECT_NE(u, nullptr);
}
// TableModel with Table0
TEST_F(Table1Test, TableModel0) {
auto tbl = std::make_shared<Table>(1.5f);
TableTemplate tmpl("tmpl0");
TableModel model(tbl, &tmpl, ScaleFactorType::cell, RiseFall::rise());
EXPECT_EQ(model.order(), 0);
EXPECT_FLOAT_EQ(model.findValue(0.0f, 0.0f, 0.0f), 1.5f);
}
// StaLibertyTest-based tests for coverage of loaded library functions
// LibertyCell getters on loaded cells
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, 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, CellIsMacro2) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->isMacro());
}
TEST_F(StaLibertyTest, CellIsMemory2) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->isMemory());
}
TEST_F(StaLibertyTest, CellIsPad) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->isPad());
}
TEST_F(StaLibertyTest, CellIsBuffer2) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_TRUE(buf->isBuffer());
}
TEST_F(StaLibertyTest, CellIsInverter2) {
LibertyCell *inv = lib_->findLibertyCell("INV_X1");
ASSERT_NE(inv, nullptr);
EXPECT_TRUE(inv->isInverter());
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->isInverter());
}
TEST_F(StaLibertyTest, CellHasSequentials2) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->hasSequentials());
LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
if (dff)
EXPECT_TRUE(dff->hasSequentials());
}
TEST_F(StaLibertyTest, CellTimingArcSets2) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
const auto &arc_sets = buf->timingArcSets();
EXPECT_GT(arc_sets.size(), 0u);
EXPECT_GT(buf->timingArcSetCount(), 0u);
}
TEST_F(StaLibertyTest, CellInternalPowers2) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
const auto &powers = buf->internalPowers();
// BUF_X1 should have internal power info
EXPECT_GE(powers.size(), 0u);
}
TEST_F(StaLibertyTest, CellLeakagePower2) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
float leakage;
bool exists;
buf->leakagePower(leakage, exists);
// Just exercise the function
}
TEST_F(StaLibertyTest, CellInterfaceTiming) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->interfaceTiming());
}
TEST_F(StaLibertyTest, CellIsClockGate2) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->isClockGate());
EXPECT_FALSE(buf->isClockGateLatchPosedge());
EXPECT_FALSE(buf->isClockGateLatchNegedge());
EXPECT_FALSE(buf->isClockGateOther());
}
TEST_F(StaLibertyTest, CellIsClockCell) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->isClockCell());
}
TEST_F(StaLibertyTest, CellIsLevelShifter) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->isLevelShifter());
}
TEST_F(StaLibertyTest, CellIsIsolationCell) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->isIsolationCell());
}
TEST_F(StaLibertyTest, CellAlwaysOn) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->alwaysOn());
}
// isDisabledConstraint has been moved from LibertyCell to Sdc.
TEST_F(StaLibertyTest, CellHasInternalPorts2) {
LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
ASSERT_NE(buf, nullptr);
EXPECT_FALSE(buf->hasInternalPorts());
}
} // namespace sta
Reference in New Issue View Git Blame Copy Permalink