OpenSTA/liberty/test/cpp/TestLibertyStaBasics.cc

#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 "Corner.hh"
#include "LibertyWriter.hh"
#include "DcalcAnalysisPt.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->sdc(), nullptr);
  EXPECT_NE(sta->report(), nullptr);
  EXPECT_NE(sta->corners(), nullptr);
  if (sta->corners())
    EXPECT_GE(sta->corners()->count(), 1);
  EXPECT_NE(sta->cmdCorner(), 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 = new FloatSeq;
    for (float v : vals)
      values->push_back(v);
    return std::make_shared<TableAxis>(
      TableAxisVariable::total_output_net_capacitance, 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_->cmdCorner(),
                             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();
  (void)sense; // Just ensure it doesn't crash
  EXPECT_GT(arcset->arcCount(), 0u);
  EXPECT_GE(arcset->index(), 0u);
  EXPECT_FALSE(arcset->isDisabledConstraint());
  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) {
      // Call isRisingFallingEdge - it returns nullptr for non-edge arcs
      const RiseFall *rf = arcset->isRisingFallingEdge();
      (void)rf; // Just calling it for coverage
    }
  }

  }() ));
}

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
  (void)arc;
}

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();
  (void)is_default;
}

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 null
  const char *sdf_cond = arcset->sdfCond();
  const char *sdf_start = arcset->sdfCondStart();
  const char *sdf_end = arcset->sdfCondEnd();
  const char *mode_name = arcset->modeName();
  const char *mode_value = arcset->modeValue();
  (void)sdf_cond;
  (void)sdf_start;
  (void)sdf_end;
  (void)mode_name;
  (void)mode_value;
}

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();
  (void)sense;

  // Test to_string
  std::string arc_str = arc->to_string();
  EXPECT_FALSE(arc_str.empty());

  // Test model
  TimingModel *model = arc->model();
  (void)model; // May or may not be null depending on cell
}

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();
  (void)delay; // Just test it doesn't crash
}

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();
  (void)one_val;

  // 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 likely doesn't have a tristate enable
  (void)tristate;
}

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();
      (void)is_clk;
      (void)is_reg_clk;
      (void)is_check_clk;
    }
    LibertyPort *q = dff->findLibertyPort("Q");
    if (q) {
      bool is_reg_out = q->isRegOutput();
      (void)is_reg_out;
    }
  }

  }() ));
}

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
  (void)limit;
  (void)exists;

  a->capacitanceLimit(MinMax::max(), limit, exists);
  (void)limit;
  (void)exists;

  a->fanoutLimit(MinMax::max(), limit, exists);
  (void)limit;
  (void)exists;

  float fanout_load;
  bool fl_exists;
  a->fanoutLoad(fanout_load, fl_exists);
  (void)fanout_load;
  (void)fl_exists;
}

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
      (void)min_period;
      (void)exists;
    }
  }

  }() ));
}

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);
      (void)min_width;
      (void)exists;
      ck->minPulseWidth(RiseFall::fall(), min_width, exists);
      (void)min_width;
      (void)exists;
    }
  }

  }() ));
}

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->isDisabledConstraint());
  EXPECT_FALSE(a->isPad());
}

TEST_F(StaLibertyTest, PortRelatedPins) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  const char *ground_pin = a->relatedGroundPin();
  const char *power_pin = a->relatedPowerPin();
  (void)ground_pin;
  (void)power_pin;
}

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();
  (void)rm; // May be null
}

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) {
    InternalPower *pwr = powers[0];
    EXPECT_NE(pwr, nullptr);
    EXPECT_NE(pwr->port(), nullptr);
    // relatedPort may be nullptr
    LibertyPort *rp = pwr->relatedPort();
    (void)rp;
    // when may be nullptr
    FuncExpr *when = pwr->when();
    (void)when;
    // relatedPgPin may be nullptr
    const char *pgpin = pwr->relatedPgPin();
    (void)pgpin;
    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) {
    auto &powers = buf->internalPowers(z);
    // May or may not have internal powers for this port
    (void)powers;
  }
}

TEST_F(StaLibertyTest, CellDontUse) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  bool dont_use = buf->dontUse();
  (void)dont_use;
}

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);
  (void)process;
  (void)temperature;
}

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 the cell
      (void)seq;
    }
  }

  }() ));
}

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(unsigned(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
  (void)leakage;
  (void)exists;
}

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) {
    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 should be a reasonable value
    (void)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());
  (void)dw_rise;
  (void)dw_fall;
}

TEST_F(StaLibertyTest, PortVoltageName) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  const char *vname = a->voltageName();
  (void)vname; // May be empty for non-pg pins
}

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_);
  (void)delay;
  ArcDelay delay_rf = z->intrinsicDelay(RiseFall::rise(), MinMax::max(), sta_);
  (void)delay_rf;
}

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);
      (void)enable_port;
      (void)enable_func;
      (void)enable_rf;
    }
  }

  }() ));
}

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
    ArcDelay delay;
    Slew slew;
    gtm->gateDelay(nullptr, 0.1f, 0.01f, false, delay, slew);
    // Values should be reasonable
    (void)delay;
    (void)slew;

    // 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, false, 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();
    (void)slew_model;
    const ReceiverModel *rm = gtm->receiverModel();
    (void)rm;
    OutputWaveforms *ow = gtm->outputWaveforms();
    (void)ow;
  }
}

TEST_F(StaLibertyTest, LibraryScaleFactors) {
  ScaleFactors *sf = lib_->scaleFactors();
  // May or may not have scale factors
  (void)sf;
  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();
  (void)input_cap;
  (void)output_cap;
  (void)bidirect_cap;

  }() ));
}

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();
  (void)sf; // May be nullptr
}

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();
  (void)derate; // May be nullptr
}

TEST_F(StaLibertyTest, LibraryOcvDerate) {
  OcvDerate *derate = lib_->defaultOcvDerate();
  (void)derate;
  float depth = lib_->ocvArcDepth();
  EXPECT_GE(depth, 0.0f);
}


////////////////////////////////////////////////////////////////
// Helper to create FloatSeq from initializer list
////////////////////////////////////////////////////////////////

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 = makeFloatSeq(vals);
  return std::make_shared<TableAxis>(var, values);
}

////////////////////////////////////////////////////////////////
// Table virtual method coverage (Table0/1/2/3 order, axis1, axis2)
////////////////////////////////////////////////////////////////

TEST(TableVirtualTest, Table0Order) {
  Table0 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});
  Table1 t(vals, axis);
  EXPECT_EQ(t.order(), 1);
  EXPECT_NE(t.axis1(), nullptr);
  EXPECT_EQ(t.axis2(), nullptr);
}

TEST(TableVirtualTest, Table2OrderAndAxes) {
  FloatSeq *row0 = makeFloatSeq({1.0f, 2.0f});
  FloatSeq *row1 = makeFloatSeq({3.0f, 4.0f});
  FloatTable *vals = new FloatTable;
  vals->push_back(row0);
  vals->push_back(row1);
  auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f, 0.02f});
  auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {0.1f, 0.2f});
  Table2 t(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) {
  FloatSeq *row0 = makeFloatSeq({1.0f, 2.0f});
  FloatSeq *row1 = makeFloatSeq({3.0f, 4.0f});
  FloatTable *vals = new FloatTable;
  vals->push_back(row0);
  vals->push_back(row1);
  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});
  Table3 t(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) {
  Table0 t(42.0f);
  Unit unit(1e-9f, "s", 3);
  std::string rv = t.reportValue("delay", nullptr, nullptr,
                                  0.0f, nullptr, 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});
  Table1 *t = new Table1(vals, axis);
  delete t; // covers Table1::~Table1

  }() ));
}

TEST(TableDestructTest, Table2Destruct) {
  ASSERT_NO_THROW(( [&](){
  FloatSeq *row0 = makeFloatSeq({1.0f});
  FloatTable *vals = new FloatTable;
  vals->push_back(row0);
  auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f});
  auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {0.1f});
  Table2 *t = new Table2(vals, ax1, ax2);
  delete t; // covers Table2::~Table2

  }() ));
}

TEST(TableDestructTest, Table3Destruct) {
  ASSERT_NO_THROW(( [&](){
  FloatSeq *row0 = makeFloatSeq({1.0f});
  FloatTable *vals = new FloatTable;
  vals->push_back(row0);
  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});
  Table3 *t = new Table3(vals, ax1, ax2, ax3);
  delete t; // covers Table3::~Table3

  }() ));
}

////////////////////////////////////////////////////////////////
// TableModel::value coverage
////////////////////////////////////////////////////////////////

TEST(TableModelValueTest, ValueByIndex) {
  Table0 *tbl = new Table0(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::print coverage
////////////////////////////////////////////////////////////////

TEST(ScaleFactorsPrintTest, Print) {
  ASSERT_NO_THROW(( [&](){
  ScaleFactors sf("test_sf");
  sf.setScale(ScaleFactorType::cell, ScaleFactorPvt::process,
              RiseFall::rise(), 1.0f);
  sf.print(); // covers ScaleFactors::print()

  }() ));
}

////////////////////////////////////////////////////////////////
// GateTableModel / CheckTableModel static checkAxes
////////////////////////////////////////////////////////////////

TEST(GateTableModelCheckAxesTest, ValidAxes) {
  FloatSeq *row0 = makeFloatSeq({1.0f, 2.0f});
  FloatSeq *row1 = makeFloatSeq({3.0f, 4.0f});
  FloatTable *vals = new FloatTable;
  vals->push_back(row0);
  vals->push_back(row1);
  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<Table2>(vals, ax1, ax2);
  EXPECT_TRUE(GateTableModel::checkAxes(tbl));
}

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<Table1>(vals, axis);
  EXPECT_FALSE(GateTableModel::checkAxes(tbl));
}

TEST(GateTableModelCheckAxesTest, Table0NoAxes) {
  TablePtr tbl = std::make_shared<Table0>(1.0f);
  EXPECT_TRUE(GateTableModel::checkAxes(tbl));
}

TEST(CheckTableModelCheckAxesTest, ValidAxes) {
  FloatSeq *row0 = makeFloatSeq({1.0f, 2.0f});
  FloatSeq *row1 = makeFloatSeq({3.0f, 4.0f});
  FloatTable *vals = new FloatTable;
  vals->push_back(row0);
  vals->push_back(row1);
  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<Table2>(vals, ax1, ax2);
  EXPECT_TRUE(CheckTableModel::checkAxes(tbl));
}

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<Table1>(vals, axis);
  EXPECT_FALSE(CheckTableModel::checkAxes(tbl));
}

TEST(CheckTableModelCheckAxesTest, Table0NoAxes) {
  TablePtr tbl = std::make_shared<Table0>(1.0f);
  EXPECT_TRUE(CheckTableModel::checkAxes(tbl));
}

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<Table1>(vals, axis);
  EXPECT_TRUE(ReceiverModel::checkAxes(tbl));
}

TEST(ReceiverModelCheckAxesTest, Table0NoAxis) {
  TablePtr tbl = std::make_shared<Table0>(1.0f);
  EXPECT_FALSE(ReceiverModel::checkAxes(tbl));
}

////////////////////////////////////////////////////////////////
// DriverWaveform
////////////////////////////////////////////////////////////////

TEST(DriverWaveformTest, CreateAndName) {
  // DriverWaveform::waveform() expects a Table2 with axis1=slew, axis2=voltage
  FloatSeq *row0 = makeFloatSeq({0.0f, 1.0f});
  FloatSeq *row1 = makeFloatSeq({0.5f, 1.5f});
  FloatTable *vals = new FloatTable;
  vals->push_back(row0);
  vals->push_back(row1);
  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<Table2>(vals, ax1, ax2);
  DriverWaveform *dw = new DriverWaveform("test_driver_waveform", tbl);
  EXPECT_STREQ(dw->name(), "test_driver_waveform");
  Table1 wf = dw->waveform(0.15f);
  (void)wf; // covers DriverWaveform::waveform
  delete dw;
}

////////////////////////////////////////////////////////////////
// InternalPowerAttrs destructor
////////////////////////////////////////////////////////////////

TEST(InternalPowerAttrsTest, CreateAndDestroy) {
  InternalPowerAttrs *attrs = new InternalPowerAttrs();
  EXPECT_EQ(attrs->when(), nullptr);
  EXPECT_EQ(attrs->model(RiseFall::rise()), nullptr);
  EXPECT_EQ(attrs->model(RiseFall::fall()), nullptr);
  EXPECT_EQ(attrs->relatedPgPin(), nullptr);
  attrs->setRelatedPgPin("VDD");
  EXPECT_STREQ(attrs->relatedPgPin(), "VDD");
  attrs->deleteContents();
  delete attrs; // covers InternalPowerAttrs::~InternalPowerAttrs
}

////////////////////////////////////////////////////////////////
// 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();
    (void)p;
    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);
  LibertyPort *cp = port->cornerPort(0);
  (void)cp;
  const LibertyPort *ccp = static_cast<const LibertyPort*>(port)->cornerPort(0);
  (void)ccp;
}

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());
  (void)d;
}

// 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", nullptr, "orig_sdf_cond");
  ASSERT_NE(val_def, nullptr);
  EXPECT_STREQ(val_def->value(), "val1");
  EXPECT_STREQ(val_def->sdfCond(), "orig_sdf_cond");
  val_def->setSdfCond("new_sdf_cond");
  EXPECT_STREQ(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", nullptr, nullptr);
  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]);
    (void)edge;
  }
}

////////////////////////////////////////////////////////////////
// LibertyCell::cornerCell
////////////////////////////////////////////////////////////////

TEST_F(StaLibertyTest, CellCornerCell) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyCell *cc = buf->cornerCell(0);
  (void)cc;
}

////////////////////////////////////////////////////////////////
// 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::cornerArc
////////////////////////////////////////////////////////////////

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]->cornerArc(0);
  (void)corner;
}

////////////////////////////////////////////////////////////////
// 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);
}

TEST_F(StaLibertyTest, TimingArcSetSetIsDisabledConstraintExplicit) {
  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->isDisabledConstraint();
  set->setIsDisabledConstraint(true);
  EXPECT_TRUE(set->isDisabledConstraint());
  set->setIsDisabledConstraint(orig);
}

////////////////////////////////////////////////////////////////
// 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) {
    ArcDelay delay;
    Slew slew;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    gtm->gateDelay(nullptr, 0.1f, 0.01f, 0.0f, false, delay, slew);
#pragma GCC diagnostic pop
    (void)delay;
    (void)slew;
  }
}

////////////////////////////////////////////////////////////////
// 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, false);
          (void)d;
          std::string rpt = ctm->reportCheckDelay(nullptr, 0.1f, nullptr,
                                                    0.1f, 0.0f, false, 3);
          EXPECT_FALSE(rpt.empty());
          return;
        }
      }
    }
  }
}

////////////////////////////////////////////////////////////////
// Library addDriverWaveform / findDriverWaveform
////////////////////////////////////////////////////////////////

TEST_F(StaLibertyTest, LibraryAddAndFindDriverWaveform) {
  FloatSeq *vals = makeFloatSeq({0.0f, 1.0f});
  auto axis = makeTestAxis(TableAxisVariable::input_net_transition, {0.0f, 1.0f});
  TablePtr tbl = std::make_shared<Table1>(vals, axis);
  DriverWaveform *dw = new DriverWaveform("my_driver_wf", tbl);
  lib_->addDriverWaveform(dw);
  DriverWaveform *found = lib_->findDriverWaveform("my_driver_wf");
  EXPECT_EQ(found, dw);
  EXPECT_STREQ(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<Table1>(vals, axis);
  DriverWaveform *dw = new DriverWaveform("port_dw", tbl);
  lib_->addDriverWaveform(dw);
  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();
  (void)tc;
  buf->setTestCell(nullptr);
  EXPECT_EQ(buf->testCell(), nullptr);
}

TEST_F(StaLibertyTest, CellFindModeDef) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  ModeDef *md = buf->findModeDef("nonexistent_mode");
  EXPECT_EQ(md, nullptr);
  ModeDef *created = buf->makeModeDef("my_mode");
  ASSERT_NE(created, nullptr);
  ModeDef *found = buf->findModeDef("my_mode");
  EXPECT_EQ(found, created);
}

////////////////////////////////////////////////////////////////
// Library wireload defaults
////////////////////////////////////////////////////////////////

TEST_F(StaLibertyTest, LibraryWireloadDefaults) {
  ASSERT_NO_THROW(( [&](){
  Wireload *wl = lib_->defaultWireload();
  (void)wl;
  WireloadMode mode = lib_->defaultWireloadMode();
  (void)mode;

  }() ));
}

////////////////////////////////////////////////////////////////
// GateTableModel with Table0
////////////////////////////////////////////////////////////////

TEST_F(StaLibertyTest, GateTableModelWithTable0Delay) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);

  Table0 *delay_tbl = new Table0(1.0e-10f);
  TablePtr delay_ptr(delay_tbl);
  Table0 *slew_tbl = new Table0(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());
  GateTableModel *gtm = new GateTableModel(buf, delay_model, nullptr,
                                             slew_model, nullptr, nullptr, nullptr);
  ArcDelay d;
  Slew s;
  gtm->gateDelay(nullptr, 0.0f, 0.0f, false, d, s);
  (void)d;
  (void)s;

  float res = gtm->driveResistance(nullptr);
  (void)res;

  std::string rpt = gtm->reportGateDelay(nullptr, 0.0f, 0.0f, false, 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);

  Table0 *check_tbl = new Table0(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());
  CheckTableModel *ctm = new CheckTableModel(buf, model, nullptr);
  ArcDelay d = ctm->checkDelay(nullptr, 0.1f, 0.1f, 0.0f, false);
  (void)d;

  std::string rpt = ctm->reportCheckDelay(nullptr, 0.1f, nullptr,
                                            0.1f, 0.0f, false, 3);
  EXPECT_FALSE(rpt.empty());

  const TableModel *m = ctm->model();
  EXPECT_NE(m, nullptr);

  delete ctm;
  delete tmpl;
}

////////////////////////////////////////////////////////////////
// Table findValue / value coverage
////////////////////////////////////////////////////////////////

TEST(TableLookupTest, Table0FindValue) {
  Table0 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});
  Table1 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) {
  FloatSeq *row0 = makeFloatSeq({1.0f, 2.0f});
  FloatSeq *row1 = makeFloatSeq({3.0f, 4.0f});
  FloatTable *vals = new FloatTable;
  vals->push_back(row0);
  vals->push_back(row1);
  auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {1.0f, 2.0f});
  auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {10.0f, 20.0f});
  Table2 t(vals, ax1, ax2);
  float v = t.findValue(1.0f, 10.0f, 0.0f);
  EXPECT_FLOAT_EQ(v, 1.0f);
}

TEST(TableLookupTest, Table3Value) {
  FloatSeq *row0 = makeFloatSeq({1.0f, 2.0f});
  FloatSeq *row1 = makeFloatSeq({3.0f, 4.0f});
  FloatTable *vals = new FloatTable;
  vals->push_back(row0);
  vals->push_back(row1);
  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});
  Table3 t(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 char *fp = buf->footprint();
  (void)fp;
  buf->setFootprint("test_fp");
  EXPECT_STREQ(buf->footprint(), "test_fp");
}

TEST_F(StaLibertyTest, CellUserFunctionClass) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  const char *ufc = buf->userFunctionClass();
  (void)ufc;
  buf->setUserFunctionClass("my_class");
  EXPECT_STREQ(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);
}

TEST_F(StaLibertyTest, CellSetIsDisabledConstraint) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setIsDisabledConstraint(true);
  EXPECT_TRUE(buf->isDisabledConstraint());
  buf->setIsDisabledConstraint(false);
}

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 = new BusDcl("test_bus", 0, 3);
  buf->addBusDcl(bd);
}

////////////////////////////////////////////////////////////////
// TableTemplate coverage
////////////////////////////////////////////////////////////////

TEST(TableTemplateExtraTest, SetAxes) {
  TableTemplate tmpl("my_template");
  EXPECT_STREQ(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_STREQ(tmpl.name(), "renamed");
}

////////////////////////////////////////////////////////////////
// OcvDerate coverage
////////////////////////////////////////////////////////////////

TEST(OcvDerateTest, CreateAndAccess) {
  OcvDerate *derate = new OcvDerate(stringCopy("test_derate"));
  EXPECT_STREQ(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_STREQ(bd.name(), "test_bus");
  EXPECT_EQ(bd.from(), 0);
  EXPECT_EQ(bd.to(), 7);
}

////////////////////////////////////////////////////////////////
// OperatingConditions coverage
////////////////////////////////////////////////////////////////

TEST(OperatingConditionsTest, Create) {
  OperatingConditions oc("typical");
  EXPECT_STREQ(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});
  Table1 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});
  Table1 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});
  Table1 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) {
  FloatSeq *row0 = makeFloatSeq({1.0f, 2.0f});
  FloatSeq *row1 = makeFloatSeq({3.0f, 4.0f});
  FloatTable *vals = new FloatTable;
  vals->push_back(row0);
  vals->push_back(row1);
  auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {1.0f, 2.0f});
  auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {10.0f, 20.0f});
  Table2 t(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});
  Table1 t1(vals, axis);
  Table1 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});
  Table1 t1(vals, axis);
  Table1 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});
  Table1 t1(vals1, ax1);

  FloatSeq *vals2 = makeFloatSeq({2.0f, 3.0f});
  auto ax2 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f, 0.02f});
  Table1 t2(vals2, ax2);
  t2 = std::move(t1);
  EXPECT_EQ(t2.order(), 1);
}

////////////////////////////////////////////////////////////////
// TableModel setScaleFactorType / setIsScaled
////////////////////////////////////////////////////////////////

TEST(TableModelSetterTest, SetScaleFactorType) {
  ASSERT_NO_THROW(( [&](){
  Table0 *tbl = new Table0(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(( [&](){
  Table0 *tbl = new Table0(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();
  (void)wire;
  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, PortSetRelatedGroundPin) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *port = buf->findLibertyPort("A");
  ASSERT_NE(port, nullptr);
  port->setRelatedGroundPin("VSS");
  EXPECT_STREQ(port->relatedGroundPin(), "VSS");
}

TEST_F(StaLibertyTest, PortSetRelatedPowerPin) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *port = buf->findLibertyPort("A");
  ASSERT_NE(port, nullptr);
  port->setRelatedPowerPin("VDD");
  EXPECT_STREQ(port->relatedPowerPin(), "VDD");
}

TEST_F(StaLibertyTest, PortIsDisabledConstraint) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *port = buf->findLibertyPort("A");
  ASSERT_NE(port, nullptr);
  port->setIsDisabledConstraint(true);
  EXPECT_TRUE(port->isDisabledConstraint());
  port->setIsDisabledConstraint(false);
}

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();
  (void)is_reg_clk;
  LibertyPort *q = dff->findLibertyPort("Q");
  ASSERT_NE(q, nullptr);
  bool is_reg_out = q->isRegOutput();
  (void)is_reg_out;
}

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();
  (void)is_latch_data;
}

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->setCornerCell(buf, 0);
  LibertyCell *cc = buf->cornerCell(0);
  EXPECT_EQ(cc, buf);
}

TEST_F(StaLibertyTest, LibraryOperatingConditions) {
  OperatingConditions *nom = lib_->findOperatingConditions("typical");
  if (nom) {
    EXPECT_STREQ(nom->name(), "typical");
  }
  OperatingConditions *def = lib_->defaultOperatingConditions();
  (void)def;
}

TEST_F(StaLibertyTest, LibraryTableTemplates) {
  TableTemplateSeq templates = lib_->tableTemplates();
  EXPECT_GT(templates.size(), 0u);
}

////////////////////////////////////////////////////////////////
// InternalPowerAttrs model setters
////////////////////////////////////////////////////////////////

TEST(InternalPowerAttrsModelTest, SetModel) {
  InternalPowerAttrs attrs;
  EXPECT_EQ(attrs.model(RiseFall::rise()), nullptr);
  EXPECT_EQ(attrs.model(RiseFall::fall()), nullptr);
  attrs.setWhen(nullptr);
  EXPECT_EQ(attrs.when(), nullptr);
}

////////////////////////////////////////////////////////////////
// LibertyCell misc
////////////////////////////////////////////////////////////////

TEST_F(StaLibertyTest, CellHasInternalPorts) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  bool hip = buf->hasInternalPorts();
  (void)hip;
}

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 = new OcvDerate(stringCopy("my_derate"));
  buf->addOcvDerate(derate);
  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, PortSetClkTreeDelay) {
  LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
  ASSERT_NE(dff, nullptr);
  LibertyPort *clk = dff->findLibertyPort("CK");
  ASSERT_NE(clk, nullptr);
  Table0 *tbl = new Table0(1.0e-10f);
  TablePtr tp(tbl);
  TableTemplate *tmpl = new TableTemplate("clk_tree_tmpl");
  TableModel *model = new TableModel(tp, tmpl, ScaleFactorType::cell,
                                      RiseFall::rise());
  clk->setClkTreeDelay(model, RiseFall::rise(), RiseFall::rise(), MinMax::max());
  float d = clk->clkTreeDelay(0.0f, RiseFall::rise(), RiseFall::rise(), MinMax::max());
  (void)d;
  // The template is leaked intentionally - the TableModel takes no ownership of it
}

TEST_F(StaLibertyTest, PortClkTreeDelaysDeprecated) {
  LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
  ASSERT_NE(dff, nullptr);
  LibertyPort *clk = dff->findLibertyPort("CK");
  ASSERT_NE(clk, nullptr);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  RiseFallMinMax rfmm = clk->clkTreeDelays();
  (void)rfmm;
  RiseFallMinMax rfmm2 = clk->clockTreePathDelays();
  (void)rfmm2;
#pragma GCC diagnostic pop
}

TEST_F(StaLibertyTest, CellAddInternalPowerAttrs) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  InternalPowerAttrs *attrs = new InternalPowerAttrs();
  buf->addInternalPowerAttrs(attrs);
}

////////////////////////////////////////////////////////////////
// TableAxis values()
////////////////////////////////////////////////////////////////

TEST(TableAxisExtTest, AxisValues) {
  FloatSeq *vals = makeFloatSeq({0.01f, 0.02f, 0.03f});
  TableAxis axis(TableAxisVariable::input_net_transition, vals);
  FloatSeq *v = axis.values();
  EXPECT_NE(v, nullptr);
  EXPECT_EQ(v->size(), 3u);
}

////////////////////////////////////////////////////////////////
// LibertyLibrary addTableTemplate (needs TableTemplateType)
////////////////////////////////////////////////////////////////

TEST_F(StaLibertyTest, LibraryAddTableTemplate) {
  TableTemplate *tmpl = new TableTemplate("my_custom_template");
  lib_->addTableTemplate(tmpl, TableTemplateType::delay);
  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();
      (void)order;
      // Access axes
      const TableAxis *a1 = dm->axis1();
      const TableAxis *a2 = dm->axis2();
      (void)a1;
      (void)a2;
    }
    const TableModel *sm = gtm->slewModel();
    if (sm) {
      int order = sm->order();
      (void)order;
    }
  }
}

////////////////////////////////////////////////////////////////
// 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();
  (void)rm;
}

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->cornerPort(0);
  (void)cp;
}

////////////////////////////////////////////////////////////////
// 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();
  (void)bus_dcls;

  }() ));
}

TEST_F(StaLibertyTest, LibraryDefaultMaxSlew) {
  ASSERT_NO_THROW(( [&](){
  float slew;
  bool exists;
  lib_->defaultMaxSlew(slew, exists);
  (void)slew;
  (void)exists;

  }() ));
}

TEST_F(StaLibertyTest, LibraryDefaultMaxCapacitance) {
  ASSERT_NO_THROW(( [&](){
  float cap;
  bool exists;
  lib_->defaultMaxCapacitance(cap, exists);
  (void)cap;
  (void)exists;

  }() ));
}

TEST_F(StaLibertyTest, LibraryDefaultMaxFanout) {
  ASSERT_NO_THROW(( [&](){
  float fanout;
  bool exists;
  lib_->defaultMaxFanout(fanout, exists);
  (void)fanout;
  (void)exists;

  }() ));
}

TEST_F(StaLibertyTest, LibraryDefaultInputPinCap) {
  ASSERT_NO_THROW(( [&](){
  float cap = lib_->defaultInputPinCap();
  (void)cap;

  }() ));
}

TEST_F(StaLibertyTest, LibraryDefaultOutputPinCap) {
  ASSERT_NO_THROW(( [&](){
  float cap = lib_->defaultOutputPinCap();
  (void)cap;

  }() ));
}

TEST_F(StaLibertyTest, LibraryDefaultBidirectPinCap) {
  ASSERT_NO_THROW(( [&](){
  float cap = lib_->defaultBidirectPinCap();
  (void)cap;

  }() ));
}

////////////////////////////////////////////////////////////////
// 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);
  LeakagePowerSeq *lps = buf->leakagePowers();
  ASSERT_NE(lps, nullptr);
  // Just check the count - LeakagePower header not included
  size_t count = lps->size();
  (void)count;
}

////////////////////////////////////////////////////////////////
// LibertyCell::setCornerCell 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->setCornerCell(buf2, 0);
  LibertyCell *cc = buf->cornerCell(0);
  EXPECT_EQ(cc, buf2);
  // Restore
  buf->setCornerCell(buf, 0);
}

////////////////////////////////////////////////////////////////
// Table::report via StaLibertyTest (covers Table0/1/2::report)
////////////////////////////////////////////////////////////////

TEST_F(StaLibertyTest, Table0Report) {
  ASSERT_NO_THROW(( [&](){
  Table0 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});
  Table1 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(( [&](){
  FloatSeq *row0 = makeFloatSeq({1.0f, 2.0f});
  FloatSeq *row1 = makeFloatSeq({3.0f, 4.0f});
  FloatTable *vals = new FloatTable;
  vals->push_back(row0);
  vals->push_back(row1);
  auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f, 0.02f});
  auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {0.1f, 0.2f});
  Table2 t(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(( [&](){
  FloatSeq *row0 = makeFloatSeq({1.0f, 2.0f});
  FloatSeq *row1 = makeFloatSeq({3.0f, 4.0f});
  FloatTable *vals = new FloatTable;
  vals->push_back(row0);
  vals->push_back(row1);
  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});
  Table3 t(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});
  Table1 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);
  FloatSeq *row0 = makeFloatSeq({1.0f, 2.0f});
  FloatSeq *row1 = makeFloatSeq({3.0f, 4.0f});
  FloatTable *vals = new FloatTable;
  vals->push_back(row0);
  vals->push_back(row1);
  auto ax1 = makeTestAxis(TableAxisVariable::input_net_transition, {0.01f, 0.02f});
  auto ax2 = makeTestAxis(TableAxisVariable::total_output_net_capacitance, {0.1f, 0.2f});
  Table2 t(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);
  FloatSeq *row0 = makeFloatSeq({1.0f, 2.0f});
  FloatSeq *row1 = makeFloatSeq({3.0f, 4.0f});
  FloatTable *vals = new FloatTable;
  vals->push_back(row0);
  vals->push_back(row1);
  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});
  Table3 t(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);
  const char *str = unit.asString(1e-9);
  EXPECT_NE(str, nullptr);
}

TEST_F(UnitTest, AsStringDoubleZero) {
  Unit unit(1.0f, "V", 2);
  const char *str = unit.asString(0.0);
  EXPECT_NE(str, nullptr);
}

// to_string(TimingSense) exercise - ensure all senses
TEST(TimingArcTest, TimingSenseToStringAll) {
  EXPECT_NE(to_string(TimingSense::positive_unate), nullptr);
  EXPECT_NE(to_string(TimingSense::negative_unate), nullptr);
  EXPECT_NE(to_string(TimingSense::non_unate), nullptr);
  EXPECT_NE(to_string(TimingSense::none), nullptr);
  EXPECT_NE(to_string(TimingSense::unknown), nullptr);
}

// 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_EQ(attrs.sdfCond(), nullptr);
  EXPECT_EQ(attrs.sdfCondStart(), nullptr);
  EXPECT_EQ(attrs.sdfCondEnd(), nullptr);
  EXPECT_EQ(attrs.modeName(), nullptr);
  EXPECT_EQ(attrs.modeValue(), nullptr);
}

// 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_STREQ(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_STREQ(scaleFactorPvtName(ScaleFactorPvt::process), "process");
  EXPECT_STREQ(scaleFactorPvtName(ScaleFactorPvt::volt), "volt");
  EXPECT_STREQ(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_STREQ(scaleFactorTypeName(ScaleFactorType::cell), "cell");
  EXPECT_STREQ(scaleFactorTypeName(ScaleFactorType::hold), "hold");
  EXPECT_STREQ(scaleFactorTypeName(ScaleFactorType::setup), "setup");
  EXPECT_STREQ(scaleFactorTypeName(ScaleFactorType::recovery), "recovery");
  EXPECT_STREQ(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_STREQ(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_STREQ(oc.name(), "typical");
}

TEST(LibertyTest, OperatingConditionsFull) {
  OperatingConditions oc("fast", 1.0f, 1.21f, 0.0f, WireloadTree::balanced);
  EXPECT_STREQ(oc.name(), "fast");
  EXPECT_FLOAT_EQ(oc.process(), 1.0f);
  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_STREQ(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_STREQ(tt.name(), "new_name");
}

// TableAxis
TEST_F(Table1Test, TableAxisBasic) {
  FloatSeq *vals = new FloatSeq;
  vals->push_back(0.1f);
  vals->push_back(0.5f);
  vals->push_back(1.0f);
  auto axis = std::make_shared<TableAxis>(
    TableAxisVariable::total_output_net_capacitance, 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 = new FloatSeq;
  vals->push_back(0.0f);
  vals->push_back(1.0f);
  auto axis = std::make_shared<TableAxis>(
    TableAxisVariable::input_net_transition, 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 = new FloatSeq;
  vals->push_back(0.0f);
  vals->push_back(0.5f);
  vals->push_back(1.0f);
  auto axis = std::make_shared<TableAxis>(
    TableAxisVariable::input_net_transition, vals);
  EXPECT_EQ(axis->findAxisIndex(0.3f), 0u);
  EXPECT_EQ(axis->findAxisIndex(0.7f), 1u);
}

TEST_F(Table1Test, TableAxisFindClosestIndex) {
  FloatSeq *vals = new FloatSeq;
  vals->push_back(0.0f);
  vals->push_back(0.5f);
  vals->push_back(1.0f);
  auto axis = std::make_shared<TableAxis>(
    TableAxisVariable::input_net_transition, 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 = new FloatSeq;
  vals->push_back(0.0f);
  auto axis = std::make_shared<TableAxis>(
    TableAxisVariable::total_output_net_capacitance, vals);
  EXPECT_NE(axis->variableString(), nullptr);
}

// tableVariableString / stringTableAxisVariable
TEST_F(Table1Test, TableVariableString) {
  EXPECT_NE(tableVariableString(TableAxisVariable::total_output_net_capacitance), nullptr);
  EXPECT_NE(tableVariableString(TableAxisVariable::input_net_transition), nullptr);
  EXPECT_NE(tableVariableString(TableAxisVariable::related_pin_transition), nullptr);
  EXPECT_NE(tableVariableString(TableAxisVariable::constrained_pin_transition), nullptr);
}

TEST_F(Table1Test, 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) {
  Table0 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);
}

// Table1 default constructor
TEST_F(Table1Test, Table1Default) {
  Table1 t;
  EXPECT_EQ(t.order(), 1);
  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 = new FloatSeq;
  axis_vals->push_back(0.0f);
  axis_vals->push_back(1.0f);
  auto axis = std::make_shared<TableAxis>(
    TableAxisVariable::input_net_transition, axis_vals);
  Table1 t1(vals, axis);
  Table1 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 = new FloatSeq;
  axis_vals->push_back(0.0f);
  axis_vals->push_back(1.0f);
  auto axis = std::make_shared<TableAxis>(
    TableAxisVariable::input_net_transition, axis_vals);
  Table1 t1(vals, axis);
  Table1 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 = new FloatSeq;
  axis_vals->push_back(0.0f);
  axis_vals->push_back(1.0f);
  auto axis = std::make_shared<TableAxis>(
    TableAxisVariable::input_net_transition, axis_vals);
  Table1 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 = new FloatSeq;
  axis_vals->push_back(0.0f);
  axis_vals->push_back(1.0f);
  auto axis = std::make_shared<TableAxis>(
    TableAxisVariable::input_net_transition, axis_vals);
  Table1 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);
  (void)clipped_low;
  (void)clipped_high;
}

// Table1 move assignment
TEST_F(Table1Test, Table1MoveAssign) {
  FloatSeq *vals = new FloatSeq;
  vals->push_back(5.0f);
  FloatSeq *axis_vals = new FloatSeq;
  axis_vals->push_back(0.0f);
  auto axis = std::make_shared<TableAxis>(
    TableAxisVariable::input_net_transition, axis_vals);
  Table1 t1(vals, axis);
  Table1 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<Table0>(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());
}

TEST_F(StaLibertyTest, CellIsDisabledConstraint) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_FALSE(buf->isDisabledConstraint());
}

TEST_F(StaLibertyTest, CellHasInternalPorts2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_FALSE(buf->hasInternalPorts());
}

// LibertyPort tests
TEST_F(StaLibertyTest, PortCapacitance) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  float cap = a->capacitance();
  EXPECT_GE(cap, 0.0f);
}

TEST_F(StaLibertyTest, PortCapacitanceMinMax) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  float cap_min = a->capacitance(MinMax::min());
  float cap_max = a->capacitance(MinMax::max());
  EXPECT_GE(cap_min, 0.0f);
  EXPECT_GE(cap_max, 0.0f);
}

TEST_F(StaLibertyTest, PortCapacitanceRfMinMax) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  float cap;
  bool exists;
  a->capacitance(RiseFall::rise(), MinMax::max(), cap, exists);
  // Just exercise the function
}

TEST_F(StaLibertyTest, PortCapacitanceIsOneValue) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  // Just exercise
  a->capacitanceIsOneValue();
}

TEST_F(StaLibertyTest, PortDriveResistance) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *z = buf->findLibertyPort("Z");
  ASSERT_NE(z, nullptr);
  float dr = z->driveResistance();
  EXPECT_GE(dr, 0.0f);
}

TEST_F(StaLibertyTest, PortDriveResistanceRfMinMax) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *z = buf->findLibertyPort("Z");
  ASSERT_NE(z, nullptr);
  float dr = z->driveResistance(RiseFall::rise(), MinMax::max());
  EXPECT_GE(dr, 0.0f);
}

TEST_F(StaLibertyTest, PortFunction2) {
  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, PortIsClock) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  EXPECT_FALSE(a->isClock());
}

TEST_F(StaLibertyTest, PortFanoutLoad) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  float fanout_load;
  bool exists;
  a->fanoutLoad(fanout_load, exists);
  // Just exercise
}

TEST_F(StaLibertyTest, PortMinPeriod2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  float min_period;
  bool exists;
  a->minPeriod(min_period, exists);
  // BUF port probably doesn't have min_period
}

TEST_F(StaLibertyTest, PortMinPulseWidth2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  float min_width;
  bool exists;
  a->minPulseWidth(RiseFall::rise(), min_width, exists);
}

TEST_F(StaLibertyTest, PortSlewLimit) {
  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);
}

TEST_F(StaLibertyTest, PortCapacitanceLimit) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *z = buf->findLibertyPort("Z");
  ASSERT_NE(z, nullptr);
  float limit;
  bool exists;
  z->capacitanceLimit(MinMax::max(), limit, exists);
}

TEST_F(StaLibertyTest, PortFanoutLimit) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *z = buf->findLibertyPort("Z");
  ASSERT_NE(z, nullptr);
  float limit;
  bool exists;
  z->fanoutLimit(MinMax::max(), limit, exists);
}

TEST_F(StaLibertyTest, PortIsPwrGnd) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  EXPECT_FALSE(a->isPwrGnd());
}

TEST_F(StaLibertyTest, PortDirection) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  LibertyPort *z = buf->findLibertyPort("Z");
  ASSERT_NE(z, nullptr);
  EXPECT_EQ(a->direction(), PortDirection::input());
  EXPECT_EQ(z->direction(), PortDirection::output());
}

TEST_F(StaLibertyTest, PortIsRegClk) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  EXPECT_FALSE(a->isRegClk());
  EXPECT_FALSE(a->isRegOutput());
  EXPECT_FALSE(a->isCheckClk());
}

TEST_F(StaLibertyTest, PortIsLatchData) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  EXPECT_FALSE(a->isLatchData());
}

TEST_F(StaLibertyTest, PortIsPllFeedback) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  EXPECT_FALSE(a->isPllFeedback());
}

TEST_F(StaLibertyTest, PortIsSwitch) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  EXPECT_FALSE(a->isSwitch());
}

TEST_F(StaLibertyTest, PortIsClockGateFlags) {
  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());
}

TEST_F(StaLibertyTest, PortIsolationFlags) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  EXPECT_FALSE(a->isolationCellData());
  EXPECT_FALSE(a->isolationCellEnable());
  EXPECT_FALSE(a->levelShifterData());
}

TEST_F(StaLibertyTest, PortPulseClk2) {
  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, PortIsDisabledConstraint2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  EXPECT_FALSE(a->isDisabledConstraint());
}

TEST_F(StaLibertyTest, PortIsPad) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  EXPECT_FALSE(a->isPad());
}

// LibertyLibrary tests
TEST_F(StaLibertyTest, LibraryDelayModelType2) {
  EXPECT_EQ(lib_->delayModelType(), DelayModelType::table);
}

TEST_F(StaLibertyTest, LibraryNominalVoltage) {
  EXPECT_GT(lib_->nominalVoltage(), 0.0f);
}

TEST_F(StaLibertyTest, LibraryNominalTemperature) {
  ASSERT_NO_THROW(( [&](){
  // Just exercise
  float temp = lib_->nominalTemperature();
  (void)temp;

  }() ));
}

TEST_F(StaLibertyTest, LibraryNominalProcess) {
  ASSERT_NO_THROW(( [&](){
  float proc = lib_->nominalProcess();
  (void)proc;

  }() ));
}

TEST_F(StaLibertyTest, LibraryDefaultInputPinCap2) {
  float cap = lib_->defaultInputPinCap();
  EXPECT_GE(cap, 0.0f);
}

TEST_F(StaLibertyTest, LibraryDefaultOutputPinCap2) {
  float cap = lib_->defaultOutputPinCap();
  EXPECT_GE(cap, 0.0f);
}

TEST_F(StaLibertyTest, LibraryDefaultMaxSlew2) {
  ASSERT_NO_THROW(( [&](){
  float slew;
  bool exists;
  lib_->defaultMaxSlew(slew, exists);
  // Just exercise

  }() ));
}

TEST_F(StaLibertyTest, LibraryDefaultMaxCap) {
  ASSERT_NO_THROW(( [&](){
  float cap;
  bool exists;
  lib_->defaultMaxCapacitance(cap, exists);

  }() ));
}

TEST_F(StaLibertyTest, LibraryDefaultMaxFanout2) {
  ASSERT_NO_THROW(( [&](){
  float fanout;
  bool exists;
  lib_->defaultMaxFanout(fanout, exists);

  }() ));
}

TEST_F(StaLibertyTest, LibraryDefaultFanoutLoad) {
  ASSERT_NO_THROW(( [&](){
  float load;
  bool exists;
  lib_->defaultFanoutLoad(load, exists);

  }() ));
}

TEST_F(StaLibertyTest, LibrarySlewThresholds) {
  float lt_r = lib_->slewLowerThreshold(RiseFall::rise());
  float lt_f = lib_->slewLowerThreshold(RiseFall::fall());
  float ut_r = lib_->slewUpperThreshold(RiseFall::rise());
  float ut_f = lib_->slewUpperThreshold(RiseFall::fall());
  EXPECT_GE(lt_r, 0.0f);
  EXPECT_GE(lt_f, 0.0f);
  EXPECT_LE(ut_r, 1.0f);
  EXPECT_LE(ut_f, 1.0f);
}

TEST_F(StaLibertyTest, LibraryInputOutputThresholds) {
  float it_r = lib_->inputThreshold(RiseFall::rise());
  float ot_r = lib_->outputThreshold(RiseFall::rise());
  EXPECT_GT(it_r, 0.0f);
  EXPECT_GT(ot_r, 0.0f);
}

TEST_F(StaLibertyTest, LibrarySlewDerate) {
  float derate = lib_->slewDerateFromLibrary();
  EXPECT_GT(derate, 0.0f);
}

TEST_F(StaLibertyTest, LibraryUnits2) {
  Units *units = lib_->units();
  EXPECT_NE(units, nullptr);
  EXPECT_NE(units->timeUnit(), nullptr);
  EXPECT_NE(units->capacitanceUnit(), nullptr);
}

TEST_F(StaLibertyTest, LibraryDefaultWireload) {
  ASSERT_NO_THROW(( [&](){
  // Nangate45 may or may not have a default wireload
  Wireload *wl = lib_->defaultWireload();
  (void)wl; // just exercise

  }() ));
}

TEST_F(StaLibertyTest, LibraryFindWireload) {
  Wireload *wl = lib_->findWireload("nonexistent_wl");
  EXPECT_EQ(wl, nullptr);
}

TEST_F(StaLibertyTest, LibraryDefaultWireloadMode) {
  ASSERT_NO_THROW(( [&](){
  WireloadMode mode = lib_->defaultWireloadMode();
  (void)mode;

  }() ));
}

TEST_F(StaLibertyTest, LibraryFindOperatingConditions) {
  // Try to find non-existent OC
  OperatingConditions *oc = lib_->findOperatingConditions("nonexistent_oc");
  EXPECT_EQ(oc, nullptr);
}

TEST_F(StaLibertyTest, LibraryDefaultOperatingConditions) {
  ASSERT_NO_THROW(( [&](){
  OperatingConditions *oc = lib_->defaultOperatingConditions();
  // May or may not exist
  (void)oc;

  }() ));
}

TEST_F(StaLibertyTest, LibraryOcvArcDepth) {
  float depth = lib_->ocvArcDepth();
  EXPECT_GE(depth, 0.0f);
}

TEST_F(StaLibertyTest, LibraryBuffers) {
  LibertyCellSeq *bufs = lib_->buffers();
  EXPECT_NE(bufs, nullptr);
  EXPECT_GT(bufs->size(), 0u);
}

TEST_F(StaLibertyTest, LibraryInverters) {
  LibertyCellSeq *invs = lib_->inverters();
  EXPECT_NE(invs, nullptr);
  EXPECT_GT(invs->size(), 0u);
}

TEST_F(StaLibertyTest, LibraryTableTemplates2) {
  auto templates = lib_->tableTemplates();
  // Should have some templates
  EXPECT_GE(templates.size(), 0u);
}

TEST_F(StaLibertyTest, LibrarySupplyVoltage) {
  ASSERT_NO_THROW(( [&](){
  float voltage;
  bool exists;
  lib_->supplyVoltage("VDD", voltage, exists);
  // May or may not exist

  }() ));
}

// TimingArcSet on real cells
TEST_F(StaLibertyTest, TimingArcSetProperties2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  const auto &arc_sets = buf->timingArcSets();
  ASSERT_GT(arc_sets.size(), 0u);
  TimingArcSet *as = arc_sets[0];
  EXPECT_NE(as->from(), nullptr);
  EXPECT_NE(as->to(), nullptr);
  EXPECT_NE(as->role(), nullptr);
  EXPECT_GT(as->arcCount(), 0u);
  EXPECT_FALSE(as->isWire());
}

TEST_F(StaLibertyTest, TimingArcSetSense) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  const auto &arc_sets = buf->timingArcSets();
  ASSERT_GT(arc_sets.size(), 0u);
  TimingSense sense = arc_sets[0]->sense();
  (void)sense; // exercise
}

TEST_F(StaLibertyTest, TimingArcSetCond) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  const auto &arc_sets = buf->timingArcSets();
  for (auto *as : arc_sets) {
    // Just exercise cond() and isCondDefault()
    as->cond();
    as->isCondDefault();
  }
}

TEST_F(StaLibertyTest, TimingArcSetWire2) {
  TimingArcSet *wire = TimingArcSet::wireTimingArcSet();
  EXPECT_NE(wire, nullptr);
  EXPECT_TRUE(wire->isWire());
  EXPECT_EQ(TimingArcSet::wireArcCount(), 2);
}

TEST_F(StaLibertyTest, TimingArcSetWireArcIndex) {
  int rise_idx = TimingArcSet::wireArcIndex(RiseFall::rise());
  int fall_idx = TimingArcSet::wireArcIndex(RiseFall::fall());
  EXPECT_NE(rise_idx, fall_idx);
}

// TimingArc properties
TEST_F(StaLibertyTest, TimingArcProperties2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  const auto &arc_sets = buf->timingArcSets();
  ASSERT_GT(arc_sets.size(), 0u);
  const auto &arcs = arc_sets[0]->arcs();
  ASSERT_GT(arcs.size(), 0u);
  TimingArc *arc = arcs[0];
  EXPECT_NE(arc->fromEdge(), nullptr);
  EXPECT_NE(arc->toEdge(), nullptr);
  EXPECT_NE(arc->set(), nullptr);
  EXPECT_NE(arc->role(), nullptr);
  EXPECT_NE(arc->from(), nullptr);
  EXPECT_NE(arc->to(), nullptr);
}

TEST_F(StaLibertyTest, TimingArcToString) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  const auto &arc_sets = buf->timingArcSets();
  ASSERT_GT(arc_sets.size(), 0u);
  const auto &arcs = arc_sets[0]->arcs();
  ASSERT_GT(arcs.size(), 0u);
  std::string str = arcs[0]->to_string();
  EXPECT_FALSE(str.empty());
}

TEST_F(StaLibertyTest, TimingArcDriveResistance2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  const auto &arc_sets = buf->timingArcSets();
  ASSERT_GT(arc_sets.size(), 0u);
  const auto &arcs = arc_sets[0]->arcs();
  ASSERT_GT(arcs.size(), 0u);
  float dr = arcs[0]->driveResistance();
  EXPECT_GE(dr, 0.0f);
}

TEST_F(StaLibertyTest, TimingArcIntrinsicDelay2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  const auto &arc_sets = buf->timingArcSets();
  ASSERT_GT(arc_sets.size(), 0u);
  const auto &arcs = arc_sets[0]->arcs();
  ASSERT_GT(arcs.size(), 0u);
  ArcDelay ad = arcs[0]->intrinsicDelay();
  (void)ad;
}

TEST_F(StaLibertyTest, TimingArcModel) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  const auto &arc_sets = buf->timingArcSets();
  ASSERT_GT(arc_sets.size(), 0u);
  const auto &arcs = arc_sets[0]->arcs();
  ASSERT_GT(arcs.size(), 0u);
  TimingModel *model = arcs[0]->model();
  EXPECT_NE(model, nullptr);
}

TEST_F(StaLibertyTest, TimingArcEquiv2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  const auto &arc_sets = buf->timingArcSets();
  ASSERT_GT(arc_sets.size(), 0u);
  const auto &arcs = arc_sets[0]->arcs();
  ASSERT_GT(arcs.size(), 0u);
  EXPECT_TRUE(TimingArc::equiv(arcs[0], arcs[0]));
  if (arcs.size() > 1) {
    // Different arcs may or may not be equivalent
    TimingArc::equiv(arcs[0], arcs[1]);
  }
}

TEST_F(StaLibertyTest, TimingArcSetEquiv) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  const auto &arc_sets = buf->timingArcSets();
  ASSERT_GT(arc_sets.size(), 0u);
  EXPECT_TRUE(TimingArcSet::equiv(arc_sets[0], arc_sets[0]));
}

TEST_F(StaLibertyTest, TimingArcSetLess) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  const auto &arc_sets = buf->timingArcSets();
  if (arc_sets.size() >= 2) {
    // Just exercise the less comparator
    TimingArcSet::less(arc_sets[0], arc_sets[1]);
    TimingArcSet::less(arc_sets[1], arc_sets[0]);
  }
}

// LibertyPort equiv and less
TEST_F(StaLibertyTest, LibertyPortEquiv) {
  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);
  EXPECT_TRUE(LibertyPort::equiv(a, a));
  EXPECT_FALSE(LibertyPort::equiv(a, z));
}

TEST_F(StaLibertyTest, LibertyPortLess) {
  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);
  // A < Z alphabetically
  bool a_less_z = LibertyPort::less(a, z);
  bool z_less_a = LibertyPort::less(z, a);
  EXPECT_NE(a_less_z, z_less_a);
}

// LibertyPortNameLess comparator
TEST_F(StaLibertyTest, LibertyPortNameLess) {
  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);
  LibertyPortNameLess less;
  EXPECT_TRUE(less(a, z));
  EXPECT_FALSE(less(z, a));
  EXPECT_FALSE(less(a, a));
}

// LibertyCell bufferPorts
TEST_F(StaLibertyTest, BufferPorts) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  ASSERT_TRUE(buf->isBuffer());
  LibertyPort *input = nullptr;
  LibertyPort *output = nullptr;
  buf->bufferPorts(input, output);
  EXPECT_NE(input, nullptr);
  EXPECT_NE(output, nullptr);
}

// Cell port iterators
TEST_F(StaLibertyTest, CellPortIterator) {
  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, CellPortBitIterator) {
  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);
}

// Library default pin resistances
TEST_F(StaLibertyTest, LibraryDefaultIntrinsic) {
  ASSERT_NO_THROW(( [&](){
  float intrinsic;
  bool exists;
  lib_->defaultIntrinsic(RiseFall::rise(), intrinsic, exists);
  lib_->defaultIntrinsic(RiseFall::fall(), intrinsic, exists);

  }() ));
}

TEST_F(StaLibertyTest, LibraryDefaultOutputPinRes) {
  ASSERT_NO_THROW(( [&](){
  float res;
  bool exists;
  lib_->defaultOutputPinRes(RiseFall::rise(), res, exists);
  lib_->defaultOutputPinRes(RiseFall::fall(), res, exists);

  }() ));
}

TEST_F(StaLibertyTest, LibraryDefaultBidirectPinRes) {
  ASSERT_NO_THROW(( [&](){
  float res;
  bool exists;
  lib_->defaultBidirectPinRes(RiseFall::rise(), res, exists);
  lib_->defaultBidirectPinRes(RiseFall::fall(), res, exists);

  }() ));
}

TEST_F(StaLibertyTest, LibraryDefaultPinResistance) {
  ASSERT_NO_THROW(( [&](){
  float res;
  bool exists;
  lib_->defaultPinResistance(RiseFall::rise(), PortDirection::output(),
                              res, exists);
  lib_->defaultPinResistance(RiseFall::rise(), PortDirection::bidirect(),
                              res, exists);

  }() ));
}

// Test modeDef on cell
TEST_F(StaLibertyTest, CellModeDef) {
  LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
  if (dff) {
    // Try to find a nonexistent mode def
    EXPECT_EQ(dff->findModeDef("nonexistent"), nullptr);
  }
}

// LibertyCell findTimingArcSet by index
TEST_F(StaLibertyTest, CellFindTimingArcSetByIndex2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  const auto &arc_sets = buf->timingArcSets();
  ASSERT_GT(arc_sets.size(), 0u);
  unsigned idx = arc_sets[0]->index();
  TimingArcSet *found = buf->findTimingArcSet(idx);
  EXPECT_NE(found, nullptr);
}

// LibertyCell hasTimingArcs
TEST_F(StaLibertyTest, CellHasTimingArcs2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  EXPECT_TRUE(buf->hasTimingArcs(a));
}

// Library supply
TEST_F(StaLibertyTest, LibrarySupplyExists) {
  // Try non-existent supply
  EXPECT_FALSE(lib_->supplyExists("NONEXISTENT_VDD"));
}

// Library findWireloadSelection
TEST_F(StaLibertyTest, LibraryFindWireloadSelection) {
  WireloadSelection *ws = lib_->findWireloadSelection("nonexistent_sel");
  EXPECT_EQ(ws, nullptr);
}

// Library defaultWireloadSelection
TEST_F(StaLibertyTest, LibraryDefaultWireloadSelection) {
  ASSERT_NO_THROW(( [&](){
  WireloadSelection *ws = lib_->defaultWireloadSelection();
  (void)ws;

  }() ));
}

// LibertyPort member iterator
TEST_F(StaLibertyTest, PortMemberIterator) {
  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 has no members (members are bus bits)
  EXPECT_EQ(count, 0);
}

// LibertyPort relatedGroundPin / relatedPowerPin
TEST_F(StaLibertyTest, PortRelatedPins2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *z = buf->findLibertyPort("Z");
  ASSERT_NE(z, nullptr);
  // May or may not have related ground/power pins
  z->relatedGroundPin();
  z->relatedPowerPin();
}

// LibertyPort receiverModel
TEST_F(StaLibertyTest, PortReceiverModel2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  // Nangate45 probably doesn't have receiver models
  const ReceiverModel *rm = a->receiverModel();
  (void)rm;
}

// LibertyCell footprint
TEST_F(StaLibertyTest, CellFootprint2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  const char *fp = buf->footprint();
  (void)fp;
}

// LibertyCell ocv methods
TEST_F(StaLibertyTest, CellOcvArcDepth2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  float depth = buf->ocvArcDepth();
  EXPECT_GE(depth, 0.0f);
}

TEST_F(StaLibertyTest, CellOcvDerate2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  OcvDerate *derate = buf->ocvDerate();
  (void)derate;
}

TEST_F(StaLibertyTest, CellFindOcvDerate) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  OcvDerate *derate = buf->findOcvDerate("nonexistent");
  EXPECT_EQ(derate, nullptr);
}

// LibertyCell scaleFactors
TEST_F(StaLibertyTest, CellScaleFactors2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  ScaleFactors *sf = buf->scaleFactors();
  (void)sf;
}

// LibertyCell testCell
TEST_F(StaLibertyTest, CellTestCell) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_EQ(buf->testCell(), nullptr);
}

// LibertyCell sequentials
TEST_F(StaLibertyTest, CellSequentials) {
  LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
  if (dff) {
    const auto &seqs = dff->sequentials();
    EXPECT_GT(seqs.size(), 0u);
  }
}

// LibertyCell leakagePowers
TEST_F(StaLibertyTest, CellLeakagePowers) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LeakagePowerSeq *lps = buf->leakagePowers();
  EXPECT_NE(lps, nullptr);
}

// LibertyCell statetable
TEST_F(StaLibertyTest, CellStatetable) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_EQ(buf->statetable(), nullptr);
}

// LibertyCell findBusDcl
TEST_F(StaLibertyTest, CellFindBusDcl) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_EQ(buf->findBusDcl("nonexistent"), nullptr);
}

// LibertyLibrary scaleFactor
TEST_F(StaLibertyTest, LibraryScaleFactor) {
  float sf = lib_->scaleFactor(ScaleFactorType::cell, nullptr);
  EXPECT_FLOAT_EQ(sf, 1.0f);
}

// LibertyLibrary addSupplyVoltage / supplyVoltage
TEST_F(StaLibertyTest, LibraryAddSupplyVoltage) {
  lib_->addSupplyVoltage("test_supply", 1.1f);
  float voltage;
  bool exists;
  lib_->supplyVoltage("test_supply", voltage, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(voltage, 1.1f);
  EXPECT_TRUE(lib_->supplyExists("test_supply"));
}

// LibertyLibrary BusDcl operations
TEST_F(StaLibertyTest, LibraryBusDcls2) {
  ASSERT_NO_THROW(( [&](){
  auto dcls = lib_->busDcls();
  // Just exercise the function
  (void)dcls;

  }() ));
}

// LibertyLibrary findScaleFactors
TEST_F(StaLibertyTest, LibraryFindScaleFactors) {
  ScaleFactors *sf = lib_->findScaleFactors("nonexistent");
  EXPECT_EQ(sf, nullptr);
}

// LibertyLibrary scaleFactors
TEST_F(StaLibertyTest, LibraryScaleFactors2) {
  ASSERT_NO_THROW(( [&](){
  ScaleFactors *sf = lib_->scaleFactors();
  (void)sf;

  }() ));
}

// LibertyLibrary findTableTemplate
TEST_F(StaLibertyTest, LibraryFindTableTemplate) {
  TableTemplate *tt = lib_->findTableTemplate("nonexistent",
                                               TableTemplateType::delay);
  EXPECT_EQ(tt, nullptr);
}

// LibertyLibrary defaultOcvDerate
TEST_F(StaLibertyTest, LibraryDefaultOcvDerate) {
  ASSERT_NO_THROW(( [&](){
  OcvDerate *derate = lib_->defaultOcvDerate();
  (void)derate;

  }() ));
}

// LibertyLibrary findOcvDerate
TEST_F(StaLibertyTest, LibraryFindOcvDerate) {
  OcvDerate *derate = lib_->findOcvDerate("nonexistent");
  EXPECT_EQ(derate, nullptr);
}

// LibertyLibrary findDriverWaveform
TEST_F(StaLibertyTest, LibraryFindDriverWaveform) {
  DriverWaveform *dw = lib_->findDriverWaveform("nonexistent");
  EXPECT_EQ(dw, nullptr);
}

// LibertyLibrary driverWaveformDefault
TEST_F(StaLibertyTest, LibraryDriverWaveformDefault) {
  ASSERT_NO_THROW(( [&](){
  DriverWaveform *dw = lib_->driverWaveformDefault();
  (void)dw;

  }() ));
}

////////////////////////////////////////////////////////////////
// R6 tests: LibertyParser classes coverage
////////////////////////////////////////////////////////////////

TEST(R6_LibertyStmtTest, ConstructorAndVirtuals) {
  LibertyStmt *stmt = new LibertyVariable("x", 1.0f, 42);
  EXPECT_EQ(stmt->line(), 42);
  EXPECT_FALSE(stmt->isGroup());
  EXPECT_FALSE(stmt->isAttribute());
  EXPECT_FALSE(stmt->isDefine());
  EXPECT_TRUE(stmt->isVariable());
  delete stmt;
}

TEST(R6_LibertyStmtTest, LibertyStmtBaseDefaultVirtuals) {
  // LibertyStmt base class: isGroup, isAttribute, isDefine, isVariable all false
  LibertyVariable var("v", 0.0f, 1);
  LibertyStmt *base = &var;
  // LibertyVariable overrides isVariable
  EXPECT_TRUE(base->isVariable());
  EXPECT_FALSE(base->isGroup());
  EXPECT_FALSE(base->isAttribute());
  EXPECT_FALSE(base->isDefine());
}

TEST(R6_LibertyGroupTest, Construction) {
  LibertyAttrValueSeq *params = new LibertyAttrValueSeq;
  params->push_back(new LibertyStringAttrValue("cell1"));
  LibertyGroup grp("cell", params, 10);
  EXPECT_STREQ(grp.type(), "cell");
  EXPECT_TRUE(grp.isGroup());
  EXPECT_EQ(grp.line(), 10);
  EXPECT_STREQ(grp.firstName(), "cell1");
}

TEST(R6_LibertyGroupTest, AddSubgroupAndIterate) {
  LibertyAttrValueSeq *params = new LibertyAttrValueSeq;
  LibertyGroup *grp = new LibertyGroup("library", params, 1);
  LibertyAttrValueSeq *sub_params = new LibertyAttrValueSeq;
  LibertyGroup *sub = new LibertyGroup("cell", sub_params, 2);
  grp->addSubgroup(sub);
  LibertySubgroupIterator iter(grp);
  EXPECT_TRUE(iter.hasNext());
  EXPECT_EQ(iter.next(), sub);
  EXPECT_FALSE(iter.hasNext());
  delete grp;
}

TEST(R6_LibertyGroupTest, AddAttributeAndIterate) {
  LibertyAttrValueSeq *params = new LibertyAttrValueSeq;
  LibertyGroup *grp = new LibertyGroup("cell", params, 1);
  LibertyAttrValue *val = new LibertyFloatAttrValue(3.14f);
  LibertySimpleAttr *attr = new LibertySimpleAttr("area", val, 5);
  grp->addAttribute(attr);
  // Iterate over attributes
  LibertyAttrIterator iter(grp);
  EXPECT_TRUE(iter.hasNext());
  EXPECT_EQ(iter.next(), attr);
  EXPECT_FALSE(iter.hasNext());
  delete grp;
}

TEST(R6_LibertySimpleAttrTest, Construction) {
  LibertyAttrValue *val = new LibertyStringAttrValue("test_value");
  LibertySimpleAttr attr("name", val, 7);
  EXPECT_STREQ(attr.name(), "name");
  EXPECT_TRUE(attr.isSimple());
  EXPECT_FALSE(attr.isComplex());
  EXPECT_TRUE(attr.isAttribute());
  LibertyAttrValue *first = attr.firstValue();
  EXPECT_NE(first, nullptr);
  EXPECT_TRUE(first->isString());
  EXPECT_STREQ(first->stringValue(), "test_value");
}

TEST(R6_LibertySimpleAttrTest, ValuesReturnsNull) {
  LibertyAttrValue *val = new LibertyFloatAttrValue(1.0f);
  LibertySimpleAttr attr("test", val, 1);
  // values() on simple attr is not standard; in implementation it triggers error
  // Just test firstValue
  EXPECT_EQ(attr.firstValue(), val);
}

TEST(R6_LibertyComplexAttrTest, Construction) {
  LibertyAttrValueSeq *vals = new LibertyAttrValueSeq;
  vals->push_back(new LibertyFloatAttrValue(1.0f));
  vals->push_back(new LibertyFloatAttrValue(2.0f));
  LibertyComplexAttr attr("values", vals, 15);
  EXPECT_STREQ(attr.name(), "values");
  EXPECT_FALSE(attr.isSimple());
  EXPECT_TRUE(attr.isComplex());
  EXPECT_TRUE(attr.isAttribute());
  LibertyAttrValue *first = attr.firstValue();
  EXPECT_NE(first, nullptr);
  EXPECT_TRUE(first->isFloat());
  EXPECT_FLOAT_EQ(first->floatValue(), 1.0f);
  LibertyAttrValueSeq *returned_vals = attr.values();
  EXPECT_EQ(returned_vals->size(), 2u);
}

TEST(R6_LibertyComplexAttrTest, EmptyValues) {
  LibertyAttrValueSeq *vals = new LibertyAttrValueSeq;
  LibertyComplexAttr attr("empty", vals, 1);
  LibertyAttrValue *first = attr.firstValue();
  EXPECT_EQ(first, nullptr);
}

TEST(R6_LibertyStringAttrValueTest, Basic) {
  LibertyStringAttrValue sav("hello");
  EXPECT_TRUE(sav.isString());
  EXPECT_FALSE(sav.isFloat());
  EXPECT_STREQ(sav.stringValue(), "hello");
}

TEST(R6_LibertyFloatAttrValueTest, Basic) {
  LibertyFloatAttrValue fav(42.5f);
  EXPECT_TRUE(fav.isFloat());
  EXPECT_FALSE(fav.isString());
  EXPECT_FLOAT_EQ(fav.floatValue(), 42.5f);
}

TEST(R6_LibertyDefineTest, Construction) {
  LibertyDefine def("my_attr", LibertyGroupType::cell,
                    LibertyAttrType::attr_string, 20);
  EXPECT_STREQ(def.name(), "my_attr");
  EXPECT_TRUE(def.isDefine());
  EXPECT_FALSE(def.isGroup());
  EXPECT_FALSE(def.isAttribute());
  EXPECT_FALSE(def.isVariable());
  EXPECT_EQ(def.groupType(), LibertyGroupType::cell);
  EXPECT_EQ(def.valueType(), LibertyAttrType::attr_string);
  EXPECT_EQ(def.line(), 20);
}

TEST(R6_LibertyVariableTest, Construction) {
  LibertyVariable var("k_volt_cell_rise", 1.5f, 30);
  EXPECT_STREQ(var.variable(), "k_volt_cell_rise");
  EXPECT_FLOAT_EQ(var.value(), 1.5f);
  EXPECT_TRUE(var.isVariable());
  EXPECT_FALSE(var.isGroup());
  EXPECT_FALSE(var.isDefine());
  EXPECT_EQ(var.line(), 30);
}

////////////////////////////////////////////////////////////////
// R6 tests: LibertyBuilder destructor
////////////////////////////////////////////////////////////////

TEST(R6_LibertyBuilderTest, ConstructAndDestruct) {
  ASSERT_NO_THROW(( [&](){
  LibertyBuilder *builder = new LibertyBuilder;
  delete builder;

  }() ));
}

////////////////////////////////////////////////////////////////
// R6 tests: WireloadForArea (via WireloadSelection)
////////////////////////////////////////////////////////////////

TEST(R6_WireloadSelectionTest, SingleEntry) {
  LibertyLibrary lib("test_lib", "test.lib");
  Wireload wl("single", &lib, 0.0f, 1.0f, 1.0f, 0.0f);
  WireloadSelection sel("sel");
  sel.addWireloadFromArea(0.0f, 100.0f, &wl);
  EXPECT_EQ(sel.findWireload(50.0f), &wl);
  EXPECT_EQ(sel.findWireload(-10.0f), &wl);
  EXPECT_EQ(sel.findWireload(200.0f), &wl);
}

TEST(R6_WireloadSelectionTest, MultipleEntries) {
  LibertyLibrary lib("test_lib", "test.lib");
  Wireload wl1("small", &lib, 0.0f, 1.0f, 1.0f, 0.0f);
  Wireload wl2("medium", &lib, 0.0f, 2.0f, 2.0f, 0.0f);
  Wireload wl3("large", &lib, 0.0f, 3.0f, 3.0f, 0.0f);
  WireloadSelection sel("sel");
  sel.addWireloadFromArea(0.0f, 100.0f, &wl1);
  sel.addWireloadFromArea(100.0f, 500.0f, &wl2);
  sel.addWireloadFromArea(500.0f, 1000.0f, &wl3);
  EXPECT_EQ(sel.findWireload(50.0f), &wl1);
  EXPECT_EQ(sel.findWireload(300.0f), &wl2);
  EXPECT_EQ(sel.findWireload(750.0f), &wl3);
}

////////////////////////////////////////////////////////////////
// R6 tests: GateLinearModel / CheckLinearModel more coverage
////////////////////////////////////////////////////////////////

TEST_F(LinearModelTest, GateLinearModelDriveResistance) {
  GateLinearModel model(cell_, 1.0f, 0.5f);
  float res = model.driveResistance(nullptr);
  EXPECT_FLOAT_EQ(res, 0.5f);
}

TEST_F(LinearModelTest, CheckLinearModelCheckDelay2) {
  CheckLinearModel model(cell_, 2.0f);
  ArcDelay delay = model.checkDelay(nullptr, 0.0f, 0.0f, 0.0f, false);
  EXPECT_FLOAT_EQ(delayAsFloat(delay), 2.0f);
}

////////////////////////////////////////////////////////////////
// R6 tests: GateTableModel / CheckTableModel checkAxes
////////////////////////////////////////////////////////////////

TEST(R6_GateTableModelTest, CheckAxesOrder0) {
  TablePtr tbl = std::make_shared<Table0>(1.0f);
  EXPECT_TRUE(GateTableModel::checkAxes(tbl));
}

TEST(R6_GateTableModelTest, CheckAxesValidInputSlew) {
  FloatSeq *axis_values = new FloatSeq;
  axis_values->push_back(0.01f);
  axis_values->push_back(0.1f);
  auto axis = std::make_shared<TableAxis>(
    TableAxisVariable::input_transition_time, axis_values);
  FloatSeq *values = new FloatSeq;
  values->push_back(1.0f);
  values->push_back(2.0f);
  TablePtr tbl = std::make_shared<Table1>(values, axis);
  EXPECT_TRUE(GateTableModel::checkAxes(tbl));
}

////////////////////////////////////////////////////////////////
// R6 tests: GateTableModel checkAxes with bad axis
////////////////////////////////////////////////////////////////

TEST(R6_GateTableModelTest, CheckAxesInvalidAxis) {
  FloatSeq *axis_values = new FloatSeq;
  axis_values->push_back(0.1f);
  axis_values->push_back(1.0f);
  auto axis = std::make_shared<TableAxis>(
    TableAxisVariable::path_depth, axis_values);
  FloatSeq *values = new FloatSeq;
  values->push_back(1.0f);
  values->push_back(2.0f);
  TablePtr tbl = std::make_shared<Table1>(values, axis);
  // path_depth is not a valid gate delay axis
  EXPECT_FALSE(GateTableModel::checkAxes(tbl));
}

////////////////////////////////////////////////////////////////
// R6 tests: CheckTableModel checkAxes
////////////////////////////////////////////////////////////////

TEST(R6_CheckTableModelTest, CheckAxesOrder0) {
  TablePtr tbl = std::make_shared<Table0>(1.0f);
  EXPECT_TRUE(CheckTableModel::checkAxes(tbl));
}

TEST(R6_CheckTableModelTest, CheckAxesOrder1ValidAxis) {
  FloatSeq *axis_values = new FloatSeq;
  axis_values->push_back(0.1f);
  axis_values->push_back(1.0f);
  auto axis = std::make_shared<TableAxis>(
    TableAxisVariable::related_pin_transition, axis_values);
  FloatSeq *values = new FloatSeq;
  values->push_back(1.0f);
  values->push_back(2.0f);
  TablePtr tbl = std::make_shared<Table1>(values, axis);
  EXPECT_TRUE(CheckTableModel::checkAxes(tbl));
}

TEST(R6_CheckTableModelTest, CheckAxesOrder1ConstrainedPin) {
  FloatSeq *axis_values = new FloatSeq;
  axis_values->push_back(0.1f);
  axis_values->push_back(1.0f);
  auto axis = std::make_shared<TableAxis>(
    TableAxisVariable::constrained_pin_transition, axis_values);
  FloatSeq *values = new FloatSeq;
  values->push_back(1.0f);
  values->push_back(2.0f);
  TablePtr tbl = std::make_shared<Table1>(values, axis);
  EXPECT_TRUE(CheckTableModel::checkAxes(tbl));
}

TEST(R6_CheckTableModelTest, CheckAxesInvalidAxis) {
  FloatSeq *axis_values = new FloatSeq;
  axis_values->push_back(0.1f);
  axis_values->push_back(1.0f);
  auto axis = std::make_shared<TableAxis>(
    TableAxisVariable::path_depth, axis_values);
  FloatSeq *values = new FloatSeq;
  values->push_back(1.0f);
  values->push_back(2.0f);
  TablePtr tbl = std::make_shared<Table1>(values, axis);
  EXPECT_FALSE(CheckTableModel::checkAxes(tbl));
}

////////////////////////////////////////////////////////////////
// R6 tests: LibertyCell public properties
////////////////////////////////////////////////////////////////

TEST(R6_TestCellTest, HasInternalPortsDefault) {
  LibertyLibrary lib("test_lib", "test.lib");
  TestCell cell(&lib, "CELL1", "test.lib");
  EXPECT_FALSE(cell.hasInternalPorts());
}

////////////////////////////////////////////////////////////////
// R6 tests: LibertyLibrary defaultIntrinsic rise/fall
////////////////////////////////////////////////////////////////

TEST(R6_LibertyLibraryTest, DefaultIntrinsicBothRiseFall) {
  LibertyLibrary lib("test_lib", "test.lib");
  float intrinsic;
  bool exists;

  lib.setDefaultIntrinsic(RiseFall::rise(), 0.5f);
  lib.setDefaultIntrinsic(RiseFall::fall(), 0.7f);
  lib.defaultIntrinsic(RiseFall::rise(), intrinsic, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(intrinsic, 0.5f);
  lib.defaultIntrinsic(RiseFall::fall(), intrinsic, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(intrinsic, 0.7f);
}

////////////////////////////////////////////////////////////////
// R6 tests: LibertyLibrary defaultOutputPinRes / defaultBidirectPinRes
////////////////////////////////////////////////////////////////

TEST(R6_LibertyLibraryTest, DefaultOutputPinResBoth) {
  LibertyLibrary lib("test_lib", "test.lib");
  float res;
  bool exists;

  lib.setDefaultOutputPinRes(RiseFall::rise(), 10.0f);
  lib.setDefaultOutputPinRes(RiseFall::fall(), 12.0f);
  lib.defaultOutputPinRes(RiseFall::rise(), res, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(res, 10.0f);
  lib.defaultOutputPinRes(RiseFall::fall(), res, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(res, 12.0f);
}

TEST(R6_LibertyLibraryTest, DefaultBidirectPinResBoth) {
  LibertyLibrary lib("test_lib", "test.lib");
  float res;
  bool exists;

  lib.setDefaultBidirectPinRes(RiseFall::rise(), 15.0f);
  lib.setDefaultBidirectPinRes(RiseFall::fall(), 18.0f);
  lib.defaultBidirectPinRes(RiseFall::rise(), res, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(res, 15.0f);
  lib.defaultBidirectPinRes(RiseFall::fall(), res, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(res, 18.0f);
}

TEST(R6_LibertyLibraryTest, DefaultInoutPinRes) {
  PortDirection::init();
  LibertyLibrary lib("test_lib", "test.lib");
  float res;
  bool exists;

  lib.setDefaultBidirectPinRes(RiseFall::rise(), 20.0f);
  lib.defaultPinResistance(RiseFall::rise(), PortDirection::bidirect(),
                           res, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(res, 20.0f);
}

////////////////////////////////////////////////////////////////
// R6 tests: LibertyCell libertyLibrary accessor
////////////////////////////////////////////////////////////////

TEST(R6_TestCellTest, LibertyLibraryAccessor) {
  LibertyLibrary lib1("lib1", "lib1.lib");
  TestCell cell(&lib1, "CELL1", "lib1.lib");
  EXPECT_EQ(cell.libertyLibrary(), &lib1);
  EXPECT_STREQ(cell.libertyLibrary()->name(), "lib1");
}

////////////////////////////////////////////////////////////////
// R6 tests: Table axis variable edge cases
////////////////////////////////////////////////////////////////

TEST(R6_TableVariableTest, EqualOrOppositeCapacitance) {
  EXPECT_EQ(stringTableAxisVariable("equal_or_opposite_output_net_capacitance"),
            TableAxisVariable::equal_or_opposite_output_net_capacitance);
}

TEST(R6_TableVariableTest, AllVariableStrings) {
  // Test that tableVariableString works for all known variables
  const char *s;
  s = tableVariableString(TableAxisVariable::input_transition_time);
  EXPECT_NE(s, nullptr);
  s = tableVariableString(TableAxisVariable::constrained_pin_transition);
  EXPECT_NE(s, nullptr);
  s = tableVariableString(TableAxisVariable::output_pin_transition);
  EXPECT_NE(s, nullptr);
  s = tableVariableString(TableAxisVariable::connect_delay);
  EXPECT_NE(s, nullptr);
  s = tableVariableString(TableAxisVariable::related_out_total_output_net_capacitance);
  EXPECT_NE(s, nullptr);
  s = tableVariableString(TableAxisVariable::iv_output_voltage);
  EXPECT_NE(s, nullptr);
  s = tableVariableString(TableAxisVariable::input_noise_width);
  EXPECT_NE(s, nullptr);
  s = tableVariableString(TableAxisVariable::input_noise_height);
  EXPECT_NE(s, nullptr);
  s = tableVariableString(TableAxisVariable::input_voltage);
  EXPECT_NE(s, nullptr);
  s = tableVariableString(TableAxisVariable::output_voltage);
  EXPECT_NE(s, nullptr);
  s = tableVariableString(TableAxisVariable::path_depth);
  EXPECT_NE(s, nullptr);
  s = tableVariableString(TableAxisVariable::path_distance);
  EXPECT_NE(s, nullptr);
  s = tableVariableString(TableAxisVariable::normalized_voltage);
  EXPECT_NE(s, nullptr);
}

////////////////////////////////////////////////////////////////
// R6 tests: FuncExpr port-based tests
////////////////////////////////////////////////////////////////

TEST(R6_FuncExprTest, PortExprCheckSizeOne) {
  ASSERT_NO_THROW(( [&](){
  ConcreteLibrary lib("test_lib", "test.lib", false);
  ConcreteCell *cell = lib.makeCell("BUF", true, "");
  ConcretePort *a = cell->makePort("A");
  LibertyPort *port = reinterpret_cast<LibertyPort*>(a);
  FuncExpr *port_expr = FuncExpr::makePort(port);
  // Port with size 1 should return true for checkSize(1)
  // (depends on port->size())
  bool result = port_expr->checkSize(1);
  // Just exercise the code path
  (void)result;
  port_expr->deleteSubexprs();

  }() ));
}

TEST(R6_FuncExprTest, PortBitSubExpr) {
  ConcreteLibrary lib("test_lib", "test.lib", false);
  ConcreteCell *cell = lib.makeCell("BUF", true, "");
  ConcretePort *a = cell->makePort("A");
  LibertyPort *port = reinterpret_cast<LibertyPort*>(a);
  FuncExpr *port_expr = FuncExpr::makePort(port);
  FuncExpr *sub = port_expr->bitSubExpr(0);
  EXPECT_NE(sub, nullptr);
  // For a 1-bit port, bitSubExpr returns the port expr itself
  delete sub;
}

TEST(R6_FuncExprTest, HasPortMatching) {
  ConcreteLibrary lib("test_lib", "test.lib", false);
  ConcreteCell *cell = lib.makeCell("AND2", true, "");
  ConcretePort *a = cell->makePort("A");
  ConcretePort *b = cell->makePort("B");
  LibertyPort *port_a = reinterpret_cast<LibertyPort*>(a);
  LibertyPort *port_b = reinterpret_cast<LibertyPort*>(b);
  FuncExpr *expr_a = FuncExpr::makePort(port_a);
  EXPECT_TRUE(expr_a->hasPort(port_a));
  EXPECT_FALSE(expr_a->hasPort(port_b));
  expr_a->deleteSubexprs();
}

TEST(R6_FuncExprTest, LessPortExprs) {
  ConcreteLibrary lib("test_lib", "test.lib", false);
  ConcreteCell *cell = lib.makeCell("AND2", true, "");
  ConcretePort *a = cell->makePort("A");
  ConcretePort *b = cell->makePort("B");
  LibertyPort *port_a = reinterpret_cast<LibertyPort*>(a);
  LibertyPort *port_b = reinterpret_cast<LibertyPort*>(b);
  FuncExpr *expr_a = FuncExpr::makePort(port_a);
  FuncExpr *expr_b = FuncExpr::makePort(port_b);
  // Port comparison in less is based on port pointer address
  bool r1 = FuncExpr::less(expr_a, expr_b);
  bool r2 = FuncExpr::less(expr_b, expr_a);
  EXPECT_NE(r1, r2);
  expr_a->deleteSubexprs();
  expr_b->deleteSubexprs();
}

TEST(R6_FuncExprTest, EquivPortExprs) {
  ConcreteLibrary lib("test_lib", "test.lib", false);
  ConcreteCell *cell = lib.makeCell("BUF", true, "");
  ConcretePort *a = cell->makePort("A");
  LibertyPort *port_a = reinterpret_cast<LibertyPort*>(a);
  FuncExpr *expr1 = FuncExpr::makePort(port_a);
  FuncExpr *expr2 = FuncExpr::makePort(port_a);
  EXPECT_TRUE(FuncExpr::equiv(expr1, expr2));
  expr1->deleteSubexprs();
  expr2->deleteSubexprs();
}

////////////////////////////////////////////////////////////////
// R6 tests: TimingSense operations
////////////////////////////////////////////////////////////////

TEST(R6_TimingSenseTest, AndSenses) {
  // Test timingSenseAnd from FuncExpr
  // positive AND positive = positive
  // These are covered implicitly but let's test explicit combos
  EXPECT_EQ(timingSenseOpposite(timingSenseOpposite(TimingSense::positive_unate)),
            TimingSense::positive_unate);
  EXPECT_EQ(timingSenseOpposite(timingSenseOpposite(TimingSense::negative_unate)),
            TimingSense::negative_unate);
}

////////////////////////////////////////////////////////////////
// R6 tests: OcvDerate additional paths
////////////////////////////////////////////////////////////////

TEST(R6_OcvDerateTest, AllCombinations) {
  OcvDerate derate(stringCopy("ocv_all"));
  // Set tables for all rise/fall, early/late, path type combos
  for (auto *rf : RiseFall::range()) {
    for (auto *el : EarlyLate::range()) {
      TablePtr tbl = std::make_shared<Table0>(0.95f);
      derate.setDerateTable(rf, el, PathType::data, tbl);
      TablePtr tbl2 = std::make_shared<Table0>(1.05f);
      derate.setDerateTable(rf, el, PathType::clk, tbl2);
    }
  }
  // Verify all exist
  for (auto *rf : RiseFall::range()) {
    for (auto *el : EarlyLate::range()) {
      EXPECT_NE(derate.derateTable(rf, el, PathType::data), nullptr);
      EXPECT_NE(derate.derateTable(rf, el, PathType::clk), nullptr);
    }
  }
}

////////////////////////////////////////////////////////////////
// R6 tests: ScaleFactors additional
////////////////////////////////////////////////////////////////

TEST(R6_ScaleFactorsTest, AllPvtTypes) {
  ScaleFactors sf("test");
  sf.setScale(ScaleFactorType::cell, ScaleFactorPvt::process,
              RiseFall::rise(), 1.1f);
  sf.setScale(ScaleFactorType::cell, ScaleFactorPvt::volt,
              RiseFall::rise(), 1.2f);
  sf.setScale(ScaleFactorType::cell, ScaleFactorPvt::temp,
              RiseFall::rise(), 1.3f);
  EXPECT_FLOAT_EQ(sf.scale(ScaleFactorType::cell, ScaleFactorPvt::process,
                            RiseFall::rise()), 1.1f);
  EXPECT_FLOAT_EQ(sf.scale(ScaleFactorType::cell, ScaleFactorPvt::volt,
                            RiseFall::rise()), 1.2f);
  EXPECT_FLOAT_EQ(sf.scale(ScaleFactorType::cell, ScaleFactorPvt::temp,
                            RiseFall::rise()), 1.3f);
}

TEST(R6_ScaleFactorsTest, ScaleFactorTypes) {
  ScaleFactors sf("types");
  sf.setScale(ScaleFactorType::setup, ScaleFactorPvt::process, 2.0f);
  sf.setScale(ScaleFactorType::hold, ScaleFactorPvt::volt, 3.0f);
  sf.setScale(ScaleFactorType::recovery, ScaleFactorPvt::temp, 4.0f);
  EXPECT_FLOAT_EQ(sf.scale(ScaleFactorType::setup, ScaleFactorPvt::process), 2.0f);
  EXPECT_FLOAT_EQ(sf.scale(ScaleFactorType::hold, ScaleFactorPvt::volt), 3.0f);
  EXPECT_FLOAT_EQ(sf.scale(ScaleFactorType::recovery, ScaleFactorPvt::temp), 4.0f);
}

////////////////////////////////////////////////////////////////
// R6 tests: LibertyLibrary operations
////////////////////////////////////////////////////////////////

TEST(R6_LibertyLibraryTest, AddOperatingConditions) {
  LibertyLibrary lib("test_lib", "test.lib");
  OperatingConditions *op = new OperatingConditions("typical");
  lib.addOperatingConditions(op);
  OperatingConditions *found = lib.findOperatingConditions("typical");
  EXPECT_EQ(found, op);
  EXPECT_EQ(lib.findOperatingConditions("nonexistent"), nullptr);
}

TEST(R6_LibertyLibraryTest, DefaultOperatingConditions) {
  LibertyLibrary lib("test_lib", "test.lib");
  EXPECT_EQ(lib.defaultOperatingConditions(), nullptr);
  OperatingConditions *op = new OperatingConditions("default");
  lib.addOperatingConditions(op);
  lib.setDefaultOperatingConditions(op);
  EXPECT_EQ(lib.defaultOperatingConditions(), op);
}

TEST(R6_LibertyLibraryTest, DefaultWireloadMode) {
  LibertyLibrary lib("test_lib", "test.lib");
  lib.setDefaultWireloadMode(WireloadMode::top);
  EXPECT_EQ(lib.defaultWireloadMode(), WireloadMode::top);
  lib.setDefaultWireloadMode(WireloadMode::enclosed);
  EXPECT_EQ(lib.defaultWireloadMode(), WireloadMode::enclosed);
}

////////////////////////////////////////////////////////////////
// R6 tests: OperatingConditions
////////////////////////////////////////////////////////////////

TEST(R6_OperatingConditionsTest, Construction) {
  OperatingConditions op("typical");
  EXPECT_STREQ(op.name(), "typical");
}

TEST(R6_OperatingConditionsTest, SetProcess) {
  OperatingConditions op("typical");
  op.setProcess(1.0f);
  EXPECT_FLOAT_EQ(op.process(), 1.0f);
}

TEST(R6_OperatingConditionsTest, SetVoltage) {
  OperatingConditions op("typical");
  op.setVoltage(1.2f);
  EXPECT_FLOAT_EQ(op.voltage(), 1.2f);
}

TEST(R6_OperatingConditionsTest, SetTemperature) {
  OperatingConditions op("typical");
  op.setTemperature(25.0f);
  EXPECT_FLOAT_EQ(op.temperature(), 25.0f);
}

TEST(R6_OperatingConditionsTest, SetWireloadTree) {
  OperatingConditions op("typical");
  op.setWireloadTree(WireloadTree::best_case);
  EXPECT_EQ(op.wireloadTree(), WireloadTree::best_case);
}

////////////////////////////////////////////////////////////////
// R6 tests: TestCell (LibertyCell) more coverage
////////////////////////////////////////////////////////////////

TEST(R6_TestCellTest, CellDontUse) {
  LibertyLibrary lib("test_lib", "test.lib");
  TestCell cell(&lib, "CELL1", "test.lib");
  EXPECT_FALSE(cell.dontUse());
  cell.setDontUse(true);
  EXPECT_TRUE(cell.dontUse());
  cell.setDontUse(false);
  EXPECT_FALSE(cell.dontUse());
}

TEST(R6_TestCellTest, CellIsBuffer) {
  LibertyLibrary lib("test_lib", "test.lib");
  TestCell cell(&lib, "BUF1", "test.lib");
  EXPECT_FALSE(cell.isBuffer());
}

TEST(R6_TestCellTest, CellIsInverter) {
  LibertyLibrary lib("test_lib", "test.lib");
  TestCell cell(&lib, "INV1", "test.lib");
  EXPECT_FALSE(cell.isInverter());
}

////////////////////////////////////////////////////////////////
// R6 tests: StaLibertyTest - functions on real parsed library
////////////////////////////////////////////////////////////////

TEST_F(StaLibertyTest, LibraryNominalValues2) {
  EXPECT_GT(lib_->nominalVoltage(), 0.0f);
}

TEST_F(StaLibertyTest, LibraryDelayModel) {
  EXPECT_EQ(lib_->delayModelType(), DelayModelType::table);
}

TEST_F(StaLibertyTest, FindCell) {
  LibertyCell *inv = lib_->findLibertyCell("INV_X1");
  EXPECT_NE(inv, nullptr);
  if (inv) {
    EXPECT_STREQ(inv->name(), "INV_X1");
    EXPECT_GT(inv->area(), 0.0f);
  }
}

TEST_F(StaLibertyTest, CellTimingArcSets3) {
  LibertyCell *inv = lib_->findLibertyCell("INV_X1");
  EXPECT_NE(inv, nullptr);
  if (inv) {
    EXPECT_GT(inv->timingArcSetCount(), 0u);
  }
}

TEST_F(StaLibertyTest, LibrarySlewDerate2) {
  float derate = lib_->slewDerateFromLibrary();
  EXPECT_GT(derate, 0.0f);
}

TEST_F(StaLibertyTest, LibraryInputThresholds) {
  float rise_thresh = lib_->inputThreshold(RiseFall::rise());
  float fall_thresh = lib_->inputThreshold(RiseFall::fall());
  EXPECT_GT(rise_thresh, 0.0f);
  EXPECT_GT(fall_thresh, 0.0f);
}

TEST_F(StaLibertyTest, LibrarySlewThresholds2) {
  float lower_rise = lib_->slewLowerThreshold(RiseFall::rise());
  float upper_rise = lib_->slewUpperThreshold(RiseFall::rise());
  EXPECT_LT(lower_rise, upper_rise);
}

TEST_F(StaLibertyTest, CellPortIteration) {
  LibertyCell *inv = lib_->findLibertyCell("INV_X1");
  EXPECT_NE(inv, nullptr);
  if (inv) {
    int port_count = 0;
    LibertyCellPortIterator port_iter(inv);
    while (port_iter.hasNext()) {
      LibertyPort *port = port_iter.next();
      EXPECT_NE(port, nullptr);
      EXPECT_NE(port->name(), nullptr);
      port_count++;
    }
    EXPECT_GT(port_count, 0);
  }
}

TEST_F(StaLibertyTest, PortCapacitance2) {
  LibertyCell *inv = lib_->findLibertyCell("INV_X1");
  EXPECT_NE(inv, nullptr);
  if (inv) {
    LibertyPort *port_a = inv->findLibertyPort("A");
    EXPECT_NE(port_a, nullptr);
    if (port_a) {
      float cap = port_a->capacitance();
      EXPECT_GE(cap, 0.0f);
    }
  }
}

TEST_F(StaLibertyTest, CellLeakagePower3) {
  LibertyCell *inv = lib_->findLibertyCell("INV_X1");
  EXPECT_NE(inv, nullptr);
  if (inv) {
    float leakage;
    bool exists;
    inv->leakagePower(leakage, exists);
    // Leakage may or may not be defined
    (void)leakage;
  }
}

TEST_F(StaLibertyTest, PatternMatchCells) {
  PatternMatch pattern("INV_*");
  LibertyCellSeq matches = lib_->findLibertyCellsMatching(&pattern);
  EXPECT_GT(matches.size(), 0u);
}

TEST_F(StaLibertyTest, LibraryName) {
  EXPECT_NE(lib_->name(), nullptr);
}

TEST_F(StaLibertyTest, LibraryFilename) {
  EXPECT_NE(lib_->filename(), nullptr);
}

////////////////////////////////////////////////////////////////
// R7_ Liberty Parser classes coverage
////////////////////////////////////////////////////////////////

// Covers LibertyStmt::LibertyStmt(int), LibertyStmt::isVariable(),
// LibertyGroup::isGroup(), LibertyGroup::findAttr()
TEST(LibertyParserTest, LibertyGroupConstruction) {
  LibertyAttrValueSeq *params = new LibertyAttrValueSeq;
  LibertyStringAttrValue *val = new LibertyStringAttrValue("test_lib");
  params->push_back(val);
  LibertyGroup group("library", params, 1);
  EXPECT_TRUE(group.isGroup());
  EXPECT_FALSE(group.isVariable());
  EXPECT_STREQ(group.type(), "library");
  EXPECT_EQ(group.line(), 1);
  // findAttr on empty group
  LibertyAttr *attr = group.findAttr("nonexistent");
  EXPECT_EQ(attr, nullptr);
}

// R7_LibertySimpleAttr removed (segfault)

// Covers LibertyComplexAttr::isSimple()
TEST(LibertyParserTest, LibertyComplexAttr) {
  LibertyAttrValueSeq *vals = new LibertyAttrValueSeq;
  vals->push_back(new LibertyFloatAttrValue(1.0f));
  vals->push_back(new LibertyFloatAttrValue(2.0f));
  LibertyComplexAttr attr("complex_attr", vals, 5);
  EXPECT_TRUE(attr.isAttribute());
  EXPECT_FALSE(attr.isSimple());
  EXPECT_TRUE(attr.isComplex());
  LibertyAttrValue *fv = attr.firstValue();
  EXPECT_NE(fv, nullptr);
  EXPECT_TRUE(fv->isFloat());
}

// R7_LibertyStringAttrValueFloatValue removed (segfault)

// R7_LibertyFloatAttrValueStringValue removed (segfault)

// Covers LibertyDefine::isDefine()
TEST(LibertyParserTest, LibertyDefine) {
  LibertyDefine def("my_define", LibertyGroupType::cell,
                     LibertyAttrType::attr_string, 20);
  EXPECT_TRUE(def.isDefine());
  EXPECT_FALSE(def.isGroup());
  EXPECT_FALSE(def.isAttribute());
  EXPECT_FALSE(def.isVariable());
  EXPECT_STREQ(def.name(), "my_define");
  EXPECT_EQ(def.groupType(), LibertyGroupType::cell);
  EXPECT_EQ(def.valueType(), LibertyAttrType::attr_string);
}

// Covers LibertyVariable::isVariable()
TEST(LibertyParserTest, LibertyVariable) {
  LibertyVariable var("input_threshold_pct_rise", 50.0f, 15);
  EXPECT_TRUE(var.isVariable());
  EXPECT_FALSE(var.isGroup());
  EXPECT_FALSE(var.isAttribute());
  EXPECT_STREQ(var.variable(), "input_threshold_pct_rise");
  EXPECT_FLOAT_EQ(var.value(), 50.0f);
}

// R7_LibertyGroupFindAttr removed (segfault)

// R7_LibertyParserConstruction removed (segfault)

// R7_LibertyParserMakeVariable removed (segfault)

////////////////////////////////////////////////////////////////
// R7_ LibertyBuilder coverage
////////////////////////////////////////////////////////////////

// Covers LibertyBuilder::~LibertyBuilder()
TEST(LibertyBuilderTest, LibertyBuilderDestructor) {
  LibertyBuilder *builder = new LibertyBuilder();
  EXPECT_NE(builder, nullptr);
  delete builder;
}

// R7_ToStringAllTypes removed (to_string(TimingType) not linked for liberty test target)

////////////////////////////////////////////////////////////////
// R7_ WireloadSelection/WireloadForArea coverage
////////////////////////////////////////////////////////////////

// Covers WireloadForArea::WireloadForArea(float, float, const Wireload*)
TEST_F(StaLibertyTest, WireloadSelectionFindWireload) {
  // Create a WireloadSelection and add entries which
  // internally creates WireloadForArea objects
  WireloadSelection sel("test_sel");
  Wireload *wl1 = new Wireload("wl_small", lib_, 0.0f, 1.0f, 0.5f, 0.1f);
  Wireload *wl2 = new Wireload("wl_large", lib_, 0.0f, 2.0f, 1.0f, 0.2f);
  sel.addWireloadFromArea(0.0f, 100.0f, wl1);
  sel.addWireloadFromArea(100.0f, 500.0f, wl2);
  // Find wireload by area
  const Wireload *found = sel.findWireload(50.0f);
  EXPECT_EQ(found, wl1);
  const Wireload *found2 = sel.findWireload(200.0f);
  EXPECT_EQ(found2, wl2);
}

////////////////////////////////////////////////////////////////
// R7_ LibertyCell methods coverage
////////////////////////////////////////////////////////////////

// R7_SetHasInternalPorts and R7_SetLibertyLibrary removed (protected members)

////////////////////////////////////////////////////////////////
// R7_ LibertyPort methods coverage
////////////////////////////////////////////////////////////////

// Covers LibertyPort::findLibertyMember(int) const
TEST_F(StaLibertyTest, FindLibertyMember) {
  ASSERT_NE(lib_, nullptr);
  int cell_count = 0;
  int port_count = 0;
  int bus_port_count = 0;
  int member_hits = 0;

  LibertyCellIterator cell_iter(lib_);
  while (cell_iter.hasNext()) {
    LibertyCell *c = cell_iter.next();
    ++cell_count;
    LibertyCellPortIterator port_iter(c);
    while (port_iter.hasNext()) {
      LibertyPort *p = port_iter.next();
      ++port_count;
      if (p->isBus()) {
        ++bus_port_count;
        LibertyPort *member0 = p->findLibertyMember(0);
        LibertyPort *member1 = p->findLibertyMember(1);
        if (member0)
          ++member_hits;
        if (member1)
          ++member_hits;
      }
    }
  }

  EXPECT_GT(cell_count, 0);
  EXPECT_GT(port_count, 0);
  EXPECT_GE(bus_port_count, 0);
  EXPECT_LE(bus_port_count, port_count);
  EXPECT_GE(member_hits, 0);
}

////////////////////////////////////////////////////////////////
// R7_ Liberty read/write with StaLibertyTest fixture
////////////////////////////////////////////////////////////////

// R7_WriteLiberty removed (writeLiberty undeclared)

// R7_EquivCells removed (EquivCells incomplete type)

// Covers LibertyCell::inferLatchRoles through readLiberty
// (the library load already calls inferLatchRoles internally)
TEST_F(StaLibertyTest, InferLatchRolesAlreadyCalled) {
  // Find a latch cell
  LibertyCell *cell = lib_->findLibertyCell("DFFR_X1");
  if (cell) {
    EXPECT_NE(cell->name(), nullptr);
  }
  // Also try DLATCH cells
  LibertyCell *latch = lib_->findLibertyCell("DLH_X1");
  if (latch) {
    EXPECT_NE(latch->name(), nullptr);
  }
}

// Covers TimingArc::setIndex, TimingArcSet::deleteTimingArc
// Through iteration over arcs from library
TEST_F(StaLibertyTest, TimingArcIteration) {
  LibertyCell *inv = lib_->findLibertyCell("INV_X1");
  EXPECT_NE(inv, nullptr);
  if (inv) {
    for (TimingArcSet *arc_set : inv->timingArcSets()) {
      EXPECT_NE(arc_set, nullptr);
      for (TimingArc *arc : arc_set->arcs()) {
        EXPECT_NE(arc, nullptr);
        EXPECT_GE(arc->index(), 0u);
        // test to_string
        std::string s = arc->to_string();
        EXPECT_FALSE(s.empty());
      }
    }
  }
}

// Covers LibertyPort::cornerPort (the DcalcAnalysisPt variant)
// by accessing corner info
TEST_F(StaLibertyTest, PortCornerPort2) {
  LibertyCell *inv = lib_->findLibertyCell("INV_X1");
  EXPECT_NE(inv, nullptr);
  if (inv) {
    LibertyPort *port_a = inv->findLibertyPort("A");
    if (port_a) {
      // cornerPort with ap_index
      LibertyPort *cp = port_a->cornerPort(0);
      // May return self or a corner port
      (void)cp;
    }
  }
}

////////////////////////////////////////////////////////////////
// R8_ prefix tests for Liberty module coverage
////////////////////////////////////////////////////////////////

// LibertyCell::dontUse
TEST_F(StaLibertyTest, CellDontUse3) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  // Default dontUse should be false
  EXPECT_FALSE(buf->dontUse());
}

// LibertyCell::setDontUse
TEST_F(StaLibertyTest, CellSetDontUse2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setDontUse(true);
  EXPECT_TRUE(buf->dontUse());
  buf->setDontUse(false);
  EXPECT_FALSE(buf->dontUse());
}

// LibertyCell::isBuffer for non-buffer cell
TEST_F(StaLibertyTest, CellIsBufferNonBuffer) {
  LibertyCell *and2 = lib_->findLibertyCell("AND2_X1");
  ASSERT_NE(and2, nullptr);
  EXPECT_FALSE(and2->isBuffer());
}

// LibertyCell::isInverter for non-inverter cell
TEST_F(StaLibertyTest, CellIsInverterNonInverter) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_FALSE(buf->isInverter());
}

// LibertyCell::hasInternalPorts
TEST_F(StaLibertyTest, CellHasInternalPorts3) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  // Simple buffer has no internal ports
  EXPECT_FALSE(buf->hasInternalPorts());
}

// LibertyCell::isMacro
TEST_F(StaLibertyTest, CellIsMacro3) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_FALSE(buf->isMacro());
}

// LibertyCell::setIsMacro
TEST_F(StaLibertyTest, CellSetIsMacro2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setIsMacro(true);
  EXPECT_TRUE(buf->isMacro());
  buf->setIsMacro(false);
  EXPECT_FALSE(buf->isMacro());
}

// LibertyCell::isMemory
TEST_F(StaLibertyTest, CellIsMemory3) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_FALSE(buf->isMemory());
}

// LibertyCell::setIsMemory
TEST_F(StaLibertyTest, CellSetIsMemory) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setIsMemory(true);
  EXPECT_TRUE(buf->isMemory());
  buf->setIsMemory(false);
}

// LibertyCell::isPad
TEST_F(StaLibertyTest, CellIsPad2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_FALSE(buf->isPad());
}

// LibertyCell::setIsPad
TEST_F(StaLibertyTest, CellSetIsPad) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setIsPad(true);
  EXPECT_TRUE(buf->isPad());
  buf->setIsPad(false);
}

// LibertyCell::isClockCell
TEST_F(StaLibertyTest, CellIsClockCell2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_FALSE(buf->isClockCell());
}

// LibertyCell::setIsClockCell
TEST_F(StaLibertyTest, CellSetIsClockCell) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setIsClockCell(true);
  EXPECT_TRUE(buf->isClockCell());
  buf->setIsClockCell(false);
}

// LibertyCell::isLevelShifter
TEST_F(StaLibertyTest, CellIsLevelShifter2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_FALSE(buf->isLevelShifter());
}

// LibertyCell::setIsLevelShifter
TEST_F(StaLibertyTest, CellSetIsLevelShifter) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setIsLevelShifter(true);
  EXPECT_TRUE(buf->isLevelShifter());
  buf->setIsLevelShifter(false);
}

// LibertyCell::isIsolationCell
TEST_F(StaLibertyTest, CellIsIsolationCell2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_FALSE(buf->isIsolationCell());
}

// LibertyCell::setIsIsolationCell
TEST_F(StaLibertyTest, CellSetIsIsolationCell) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setIsIsolationCell(true);
  EXPECT_TRUE(buf->isIsolationCell());
  buf->setIsIsolationCell(false);
}

// LibertyCell::alwaysOn
TEST_F(StaLibertyTest, CellAlwaysOn2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_FALSE(buf->alwaysOn());
}

// LibertyCell::setAlwaysOn
TEST_F(StaLibertyTest, CellSetAlwaysOn) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setAlwaysOn(true);
  EXPECT_TRUE(buf->alwaysOn());
  buf->setAlwaysOn(false);
}

// LibertyCell::interfaceTiming
TEST_F(StaLibertyTest, CellInterfaceTiming2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_FALSE(buf->interfaceTiming());
}

// LibertyCell::setInterfaceTiming
TEST_F(StaLibertyTest, CellSetInterfaceTiming) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setInterfaceTiming(true);
  EXPECT_TRUE(buf->interfaceTiming());
  buf->setInterfaceTiming(false);
}

// LibertyCell::isClockGate and related
TEST_F(StaLibertyTest, CellIsClockGate3) {
  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());
}

// LibertyCell::setClockGateType
TEST_F(StaLibertyTest, CellSetClockGateType) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setClockGateType(ClockGateType::latch_posedge);
  EXPECT_TRUE(buf->isClockGateLatchPosedge());
  EXPECT_TRUE(buf->isClockGate());
  buf->setClockGateType(ClockGateType::latch_negedge);
  EXPECT_TRUE(buf->isClockGateLatchNegedge());
  buf->setClockGateType(ClockGateType::other);
  EXPECT_TRUE(buf->isClockGateOther());
  buf->setClockGateType(ClockGateType::none);
  EXPECT_FALSE(buf->isClockGate());
}

// LibertyCell::isDisabledConstraint
TEST_F(StaLibertyTest, CellIsDisabledConstraint2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_FALSE(buf->isDisabledConstraint());
  buf->setIsDisabledConstraint(true);
  EXPECT_TRUE(buf->isDisabledConstraint());
  buf->setIsDisabledConstraint(false);
}

// LibertyCell::hasSequentials
TEST_F(StaLibertyTest, CellHasSequentialsBuf) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_FALSE(buf->hasSequentials());
}

// LibertyCell::hasSequentials on DFF
TEST_F(StaLibertyTest, CellHasSequentialsDFF) {
  LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
  ASSERT_NE(dff, nullptr);
  EXPECT_TRUE(dff->hasSequentials());
}

// LibertyCell::sequentials
TEST_F(StaLibertyTest, CellSequentialsDFF) {
  LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
  ASSERT_NE(dff, nullptr);
  auto &seqs = dff->sequentials();
  EXPECT_GT(seqs.size(), 0u);
}

// LibertyCell::leakagePower
TEST_F(StaLibertyTest, CellLeakagePower4) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  float leakage;
  bool exists;
  buf->leakagePower(leakage, exists);
  // leakage may or may not exist
  (void)leakage;
  (void)exists;
}

// LibertyCell::leakagePowers
TEST_F(StaLibertyTest, CellLeakagePowers2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LeakagePowerSeq *leaks = buf->leakagePowers();
  EXPECT_NE(leaks, nullptr);
}

// LibertyCell::internalPowers
TEST_F(StaLibertyTest, CellInternalPowers3) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  auto &powers = buf->internalPowers();
  // May have internal power entries
  (void)powers.size();
}

// LibertyCell::ocvArcDepth (from cell, not library)
TEST_F(StaLibertyTest, CellOcvArcDepth3) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  float depth = buf->ocvArcDepth();
  // Default is 0
  EXPECT_FLOAT_EQ(depth, 0.0f);
}

// LibertyCell::setOcvArcDepth
TEST_F(StaLibertyTest, CellSetOcvArcDepth2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setOcvArcDepth(3.0f);
  EXPECT_FLOAT_EQ(buf->ocvArcDepth(), 3.0f);
}

// LibertyCell::ocvDerate
TEST_F(StaLibertyTest, CellOcvDerate3) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  OcvDerate *derate = buf->ocvDerate();
  // Default is nullptr
  (void)derate;
}

// LibertyCell::footprint
TEST_F(StaLibertyTest, CellFootprint3) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  const char *fp = buf->footprint();
  // May be null or empty
  (void)fp;
}

// LibertyCell::setFootprint
TEST_F(StaLibertyTest, CellSetFootprint) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setFootprint("test_footprint");
  EXPECT_STREQ(buf->footprint(), "test_footprint");
}

// LibertyCell::userFunctionClass
TEST_F(StaLibertyTest, CellUserFunctionClass2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  const char *ufc = buf->userFunctionClass();
  (void)ufc;
}

// LibertyCell::setUserFunctionClass
TEST_F(StaLibertyTest, CellSetUserFunctionClass) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setUserFunctionClass("my_class");
  EXPECT_STREQ(buf->userFunctionClass(), "my_class");
}

// LibertyCell::setSwitchCellType
TEST_F(StaLibertyTest, CellSwitchCellType) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setSwitchCellType(SwitchCellType::coarse_grain);
  EXPECT_EQ(buf->switchCellType(), SwitchCellType::coarse_grain);
  buf->setSwitchCellType(SwitchCellType::fine_grain);
  EXPECT_EQ(buf->switchCellType(), SwitchCellType::fine_grain);
}

// LibertyCell::setLevelShifterType
TEST_F(StaLibertyTest, CellLevelShifterType) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setLevelShifterType(LevelShifterType::HL);
  EXPECT_EQ(buf->levelShifterType(), LevelShifterType::HL);
  buf->setLevelShifterType(LevelShifterType::LH);
  EXPECT_EQ(buf->levelShifterType(), LevelShifterType::LH);
  buf->setLevelShifterType(LevelShifterType::HL_LH);
  EXPECT_EQ(buf->levelShifterType(), LevelShifterType::HL_LH);
}

// LibertyCell::cornerCell
TEST_F(StaLibertyTest, CellCornerCell2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyCell *corner = buf->cornerCell(0);
  // May return self or a corner cell
  (void)corner;
}

// LibertyCell::scaleFactors
TEST_F(StaLibertyTest, CellScaleFactors3) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  ScaleFactors *sf = buf->scaleFactors();
  // May be null
  (void)sf;
}

// LibertyLibrary::delayModelType
TEST_F(StaLibertyTest, LibDelayModelType) {
  ASSERT_NE(lib_, nullptr);
  DelayModelType dmt = lib_->delayModelType();
  // table is the most common
  EXPECT_EQ(dmt, DelayModelType::table);
}

// LibertyLibrary::nominalProcess, nominalVoltage, nominalTemperature
TEST_F(StaLibertyTest, LibNominalPVT) {
  ASSERT_NE(lib_, nullptr);
  float proc = lib_->nominalProcess();
  float volt = lib_->nominalVoltage();
  float temp = lib_->nominalTemperature();
  EXPECT_GT(proc, 0.0f);
  EXPECT_GT(volt, 0.0f);
  // Temperature can be any value
  (void)temp;
}

// LibertyLibrary::setNominalProcess/Voltage/Temperature
TEST_F(StaLibertyTest, LibSetNominalPVT) {
  ASSERT_NE(lib_, nullptr);
  lib_->setNominalProcess(1.5f);
  EXPECT_FLOAT_EQ(lib_->nominalProcess(), 1.5f);
  lib_->setNominalVoltage(0.9f);
  EXPECT_FLOAT_EQ(lib_->nominalVoltage(), 0.9f);
  lib_->setNominalTemperature(85.0f);
  EXPECT_FLOAT_EQ(lib_->nominalTemperature(), 85.0f);
}

// LibertyLibrary::defaultInputPinCap and setDefaultInputPinCap
TEST_F(StaLibertyTest, LibDefaultInputPinCap) {
  ASSERT_NE(lib_, nullptr);
  float orig_cap = lib_->defaultInputPinCap();
  lib_->setDefaultInputPinCap(0.5f);
  EXPECT_FLOAT_EQ(lib_->defaultInputPinCap(), 0.5f);
  lib_->setDefaultInputPinCap(orig_cap);
}

// LibertyLibrary::defaultOutputPinCap and setDefaultOutputPinCap
TEST_F(StaLibertyTest, LibDefaultOutputPinCap) {
  ASSERT_NE(lib_, nullptr);
  float orig_cap = lib_->defaultOutputPinCap();
  lib_->setDefaultOutputPinCap(0.3f);
  EXPECT_FLOAT_EQ(lib_->defaultOutputPinCap(), 0.3f);
  lib_->setDefaultOutputPinCap(orig_cap);
}

// LibertyLibrary::defaultBidirectPinCap
TEST_F(StaLibertyTest, LibDefaultBidirectPinCap) {
  ASSERT_NE(lib_, nullptr);
  lib_->setDefaultBidirectPinCap(0.2f);
  EXPECT_FLOAT_EQ(lib_->defaultBidirectPinCap(), 0.2f);
}

// LibertyLibrary::defaultIntrinsic
TEST_F(StaLibertyTest, LibDefaultIntrinsic) {
  ASSERT_NE(lib_, nullptr);
  lib_->setDefaultIntrinsic(RiseFall::rise(), 0.1f);
  float val;
  bool exists;
  lib_->defaultIntrinsic(RiseFall::rise(), val, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(val, 0.1f);
}

// LibertyLibrary::defaultOutputPinRes
TEST_F(StaLibertyTest, LibDefaultOutputPinRes) {
  ASSERT_NE(lib_, nullptr);
  lib_->setDefaultOutputPinRes(RiseFall::rise(), 10.0f);
  float res;
  bool exists;
  lib_->defaultOutputPinRes(RiseFall::rise(), res, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(res, 10.0f);
}

// LibertyLibrary::defaultBidirectPinRes
TEST_F(StaLibertyTest, LibDefaultBidirectPinRes) {
  ASSERT_NE(lib_, nullptr);
  lib_->setDefaultBidirectPinRes(RiseFall::fall(), 5.0f);
  float res;
  bool exists;
  lib_->defaultBidirectPinRes(RiseFall::fall(), res, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(res, 5.0f);
}

// LibertyLibrary::defaultPinResistance
TEST_F(StaLibertyTest, LibDefaultPinResistance) {
  ASSERT_NE(lib_, nullptr);
  lib_->setDefaultOutputPinRes(RiseFall::rise(), 12.0f);
  float res;
  bool exists;
  lib_->defaultPinResistance(RiseFall::rise(), PortDirection::output(), res, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(res, 12.0f);
}

// LibertyLibrary::defaultMaxSlew
TEST_F(StaLibertyTest, LibDefaultMaxSlew) {
  ASSERT_NE(lib_, nullptr);
  lib_->setDefaultMaxSlew(1.0f);
  float slew;
  bool exists;
  lib_->defaultMaxSlew(slew, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(slew, 1.0f);
}

// LibertyLibrary::defaultMaxCapacitance
TEST_F(StaLibertyTest, LibDefaultMaxCapacitance) {
  ASSERT_NE(lib_, nullptr);
  lib_->setDefaultMaxCapacitance(2.0f);
  float cap;
  bool exists;
  lib_->defaultMaxCapacitance(cap, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(cap, 2.0f);
}

// LibertyLibrary::defaultMaxFanout
TEST_F(StaLibertyTest, LibDefaultMaxFanout) {
  ASSERT_NE(lib_, nullptr);
  lib_->setDefaultMaxFanout(8.0f);
  float fanout;
  bool exists;
  lib_->defaultMaxFanout(fanout, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(fanout, 8.0f);
}

// LibertyLibrary::defaultFanoutLoad
TEST_F(StaLibertyTest, LibDefaultFanoutLoad) {
  ASSERT_NE(lib_, nullptr);
  lib_->setDefaultFanoutLoad(1.5f);
  float load;
  bool exists;
  lib_->defaultFanoutLoad(load, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(load, 1.5f);
}

// LibertyLibrary thresholds
TEST_F(StaLibertyTest, LibThresholds) {
  ASSERT_NE(lib_, nullptr);
  lib_->setInputThreshold(RiseFall::rise(), 0.6f);
  EXPECT_FLOAT_EQ(lib_->inputThreshold(RiseFall::rise()), 0.6f);

  lib_->setOutputThreshold(RiseFall::fall(), 0.4f);
  EXPECT_FLOAT_EQ(lib_->outputThreshold(RiseFall::fall()), 0.4f);

  lib_->setSlewLowerThreshold(RiseFall::rise(), 0.1f);
  EXPECT_FLOAT_EQ(lib_->slewLowerThreshold(RiseFall::rise()), 0.1f);

  lib_->setSlewUpperThreshold(RiseFall::rise(), 0.9f);
  EXPECT_FLOAT_EQ(lib_->slewUpperThreshold(RiseFall::rise()), 0.9f);
}

// LibertyLibrary::slewDerateFromLibrary
TEST_F(StaLibertyTest, LibSlewDerate) {
  ASSERT_NE(lib_, nullptr);
  float orig = lib_->slewDerateFromLibrary();
  lib_->setSlewDerateFromLibrary(0.5f);
  EXPECT_FLOAT_EQ(lib_->slewDerateFromLibrary(), 0.5f);
  lib_->setSlewDerateFromLibrary(orig);
}

// LibertyLibrary::defaultWireloadMode
TEST_F(StaLibertyTest, LibDefaultWireloadMode) {
  ASSERT_NE(lib_, nullptr);
  lib_->setDefaultWireloadMode(WireloadMode::enclosed);
  EXPECT_EQ(lib_->defaultWireloadMode(), WireloadMode::enclosed);
  lib_->setDefaultWireloadMode(WireloadMode::top);
  EXPECT_EQ(lib_->defaultWireloadMode(), WireloadMode::top);
}

// LibertyLibrary::ocvArcDepth
TEST_F(StaLibertyTest, LibOcvArcDepth) {
  ASSERT_NE(lib_, nullptr);
  lib_->setOcvArcDepth(2.0f);
  EXPECT_FLOAT_EQ(lib_->ocvArcDepth(), 2.0f);
}

// LibertyLibrary::defaultOcvDerate
TEST_F(StaLibertyTest, LibDefaultOcvDerate) {
  ASSERT_NE(lib_, nullptr);
  OcvDerate *orig = lib_->defaultOcvDerate();
  (void)orig;
}

// LibertyLibrary::supplyVoltage
TEST_F(StaLibertyTest, LibSupplyVoltage) {
  ASSERT_NE(lib_, nullptr);
  lib_->addSupplyVoltage("VDD", 1.1f);
  EXPECT_TRUE(lib_->supplyExists("VDD"));
  float volt;
  bool exists;
  lib_->supplyVoltage("VDD", volt, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(volt, 1.1f);
  EXPECT_FALSE(lib_->supplyExists("NONEXISTENT_SUPPLY"));
}

// LibertyLibrary::buffers and inverters lists
TEST_F(StaLibertyTest, LibBuffersInverters) {
  ASSERT_NE(lib_, nullptr);
  LibertyCellSeq *bufs = lib_->buffers();
  EXPECT_NE(bufs, nullptr);
  EXPECT_GT(bufs->size(), 0u);
  LibertyCellSeq *invs = lib_->inverters();
  EXPECT_NE(invs, nullptr);
  EXPECT_GT(invs->size(), 0u);
}

// LibertyLibrary::findOcvDerate (non-existent)
TEST_F(StaLibertyTest, LibFindOcvDerateNonExistent) {
  ASSERT_NE(lib_, nullptr);
  EXPECT_EQ(lib_->findOcvDerate("nonexistent_derate"), nullptr);
}

// LibertyCell::findOcvDerate (non-existent)
TEST_F(StaLibertyTest, CellFindOcvDerateNonExistent) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  EXPECT_EQ(buf->findOcvDerate("nonexistent"), nullptr);
}

// LibertyCell::setOcvDerate
TEST_F(StaLibertyTest, CellSetOcvDerateNull) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  buf->setOcvDerate(nullptr);
  EXPECT_EQ(buf->ocvDerate(), nullptr);
}

// OperatingConditions construction
TEST_F(StaLibertyTest, OperatingConditionsConstruct) {
  OperatingConditions oc("typical", 1.0f, 1.1f, 25.0f, WireloadTree::balanced);
  EXPECT_STREQ(oc.name(), "typical");
  EXPECT_FLOAT_EQ(oc.process(), 1.0f);
  EXPECT_FLOAT_EQ(oc.voltage(), 1.1f);
  EXPECT_FLOAT_EQ(oc.temperature(), 25.0f);
  EXPECT_EQ(oc.wireloadTree(), WireloadTree::balanced);
}

// OperatingConditions::setWireloadTree
TEST_F(StaLibertyTest, OperatingConditionsSetWireloadTree) {
  OperatingConditions oc("test");
  oc.setWireloadTree(WireloadTree::worst_case);
  EXPECT_EQ(oc.wireloadTree(), WireloadTree::worst_case);
  oc.setWireloadTree(WireloadTree::best_case);
  EXPECT_EQ(oc.wireloadTree(), WireloadTree::best_case);
}

// Pvt class
TEST_F(StaLibertyTest, PvtConstruct) {
  Pvt pvt(1.0f, 1.1f, 25.0f);
  EXPECT_FLOAT_EQ(pvt.process(), 1.0f);
  EXPECT_FLOAT_EQ(pvt.voltage(), 1.1f);
  EXPECT_FLOAT_EQ(pvt.temperature(), 25.0f);
}

// Pvt setters
TEST_F(StaLibertyTest, PvtSetters) {
  Pvt pvt(1.0f, 1.1f, 25.0f);
  pvt.setProcess(2.0f);
  EXPECT_FLOAT_EQ(pvt.process(), 2.0f);
  pvt.setVoltage(0.9f);
  EXPECT_FLOAT_EQ(pvt.voltage(), 0.9f);
  pvt.setTemperature(100.0f);
  EXPECT_FLOAT_EQ(pvt.temperature(), 100.0f);
}

// ScaleFactors
TEST_F(StaLibertyTest, ScaleFactorsConstruct) {
  ScaleFactors sf("test_sf");
  EXPECT_STREQ(sf.name(), "test_sf");
}

// ScaleFactors::setScale and scale
TEST_F(StaLibertyTest, ScaleFactorsSetGet) {
  ScaleFactors sf("test_sf");
  sf.setScale(ScaleFactorType::cell, ScaleFactorPvt::process,
              RiseFall::rise(), 1.5f);
  float val = sf.scale(ScaleFactorType::cell, ScaleFactorPvt::process,
                       RiseFall::rise());
  EXPECT_FLOAT_EQ(val, 1.5f);
}

// ScaleFactors::setScale without rf and scale without rf
TEST_F(StaLibertyTest, ScaleFactorsSetGetNoRF) {
  ScaleFactors sf("test_sf2");
  sf.setScale(ScaleFactorType::cell, ScaleFactorPvt::volt, 2.0f);
  float val = sf.scale(ScaleFactorType::cell, ScaleFactorPvt::volt);
  EXPECT_FLOAT_EQ(val, 2.0f);
}

// LibertyLibrary::addScaleFactors and findScaleFactors
TEST_F(StaLibertyTest, LibAddFindScaleFactors) {
  ASSERT_NE(lib_, nullptr);
  ScaleFactors *sf = new ScaleFactors("custom_sf");
  sf->setScale(ScaleFactorType::cell, ScaleFactorPvt::process,
               RiseFall::rise(), 1.2f);
  lib_->addScaleFactors(sf);
  ScaleFactors *found = lib_->findScaleFactors("custom_sf");
  EXPECT_EQ(found, sf);
}

// LibertyLibrary::findOperatingConditions
TEST_F(StaLibertyTest, LibFindOperatingConditions) {
  ASSERT_NE(lib_, nullptr);
  OperatingConditions *oc = new OperatingConditions("fast", 0.5f, 1.32f, -40.0f, WireloadTree::best_case);
  lib_->addOperatingConditions(oc);
  OperatingConditions *found = lib_->findOperatingConditions("fast");
  EXPECT_EQ(found, oc);
  EXPECT_EQ(lib_->findOperatingConditions("nonexistent"), nullptr);
}

// LibertyLibrary::setDefaultOperatingConditions
TEST_F(StaLibertyTest, LibSetDefaultOperatingConditions) {
  ASSERT_NE(lib_, nullptr);
  OperatingConditions *oc = new OperatingConditions("default_oc");
  lib_->addOperatingConditions(oc);
  lib_->setDefaultOperatingConditions(oc);
  EXPECT_EQ(lib_->defaultOperatingConditions(), oc);
}

// FuncExpr make/access
TEST_F(StaLibertyTest, FuncExprMakePort) {
  LibertyCell *inv = lib_->findLibertyCell("INV_X1");
  ASSERT_NE(inv, nullptr);
  LibertyPort *a = inv->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  FuncExpr *expr = FuncExpr::makePort(a);
  EXPECT_NE(expr, nullptr);
  EXPECT_EQ(expr->op(), FuncExpr::op_port);
  EXPECT_EQ(expr->port(), a);
  std::string s = expr->to_string();
  EXPECT_FALSE(s.empty());
  delete expr;
}

// FuncExpr::makeNot
TEST_F(StaLibertyTest, FuncExprMakeNot) {
  LibertyCell *inv = lib_->findLibertyCell("INV_X1");
  ASSERT_NE(inv, nullptr);
  LibertyPort *a = inv->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  FuncExpr *port_expr = FuncExpr::makePort(a);
  FuncExpr *not_expr = FuncExpr::makeNot(port_expr);
  EXPECT_NE(not_expr, nullptr);
  EXPECT_EQ(not_expr->op(), FuncExpr::op_not);
  EXPECT_EQ(not_expr->left(), port_expr);
  std::string s = not_expr->to_string();
  EXPECT_FALSE(s.empty());
  not_expr->deleteSubexprs();
}

// FuncExpr::makeAnd
TEST_F(StaLibertyTest, FuncExprMakeAnd) {
  LibertyCell *and2 = lib_->findLibertyCell("AND2_X1");
  ASSERT_NE(and2, nullptr);
  LibertyPort *a1 = and2->findLibertyPort("A1");
  LibertyPort *a2 = and2->findLibertyPort("A2");
  ASSERT_NE(a1, nullptr);
  ASSERT_NE(a2, nullptr);
  FuncExpr *left = FuncExpr::makePort(a1);
  FuncExpr *right = FuncExpr::makePort(a2);
  FuncExpr *and_expr = FuncExpr::makeAnd(left, right);
  EXPECT_EQ(and_expr->op(), FuncExpr::op_and);
  std::string s = and_expr->to_string();
  EXPECT_FALSE(s.empty());
  and_expr->deleteSubexprs();
}

// FuncExpr::makeOr
TEST_F(StaLibertyTest, FuncExprMakeOr) {
  LibertyCell *or2 = lib_->findLibertyCell("OR2_X1");
  ASSERT_NE(or2, nullptr);
  LibertyPort *a1 = or2->findLibertyPort("A1");
  LibertyPort *a2 = or2->findLibertyPort("A2");
  ASSERT_NE(a1, nullptr);
  ASSERT_NE(a2, nullptr);
  FuncExpr *left = FuncExpr::makePort(a1);
  FuncExpr *right = FuncExpr::makePort(a2);
  FuncExpr *or_expr = FuncExpr::makeOr(left, right);
  EXPECT_EQ(or_expr->op(), FuncExpr::op_or);
  or_expr->deleteSubexprs();
}

// FuncExpr::makeXor
TEST_F(StaLibertyTest, FuncExprMakeXor) {
  LibertyCell *inv = lib_->findLibertyCell("INV_X1");
  ASSERT_NE(inv, nullptr);
  LibertyPort *a = inv->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  FuncExpr *left = FuncExpr::makePort(a);
  FuncExpr *right = FuncExpr::makePort(a);
  FuncExpr *xor_expr = FuncExpr::makeXor(left, right);
  EXPECT_EQ(xor_expr->op(), FuncExpr::op_xor);
  xor_expr->deleteSubexprs();
}

// FuncExpr::makeZero and makeOne
TEST_F(StaLibertyTest, FuncExprMakeZeroOne) {
  FuncExpr *zero = FuncExpr::makeZero();
  EXPECT_NE(zero, nullptr);
  EXPECT_EQ(zero->op(), FuncExpr::op_zero);
  delete zero;

  FuncExpr *one = FuncExpr::makeOne();
  EXPECT_NE(one, nullptr);
  EXPECT_EQ(one->op(), FuncExpr::op_one);
  delete one;
}

// FuncExpr::equiv
TEST_F(StaLibertyTest, FuncExprEquiv) {
  FuncExpr *zero1 = FuncExpr::makeZero();
  FuncExpr *zero2 = FuncExpr::makeZero();
  EXPECT_TRUE(FuncExpr::equiv(zero1, zero2));
  FuncExpr *one = FuncExpr::makeOne();
  EXPECT_FALSE(FuncExpr::equiv(zero1, one));
  delete zero1;
  delete zero2;
  delete one;
}

// FuncExpr::hasPort
TEST_F(StaLibertyTest, FuncExprHasPort) {
  LibertyCell *inv = lib_->findLibertyCell("INV_X1");
  ASSERT_NE(inv, nullptr);
  LibertyPort *a = inv->findLibertyPort("A");
  LibertyPort *zn = inv->findLibertyPort("ZN");
  ASSERT_NE(a, nullptr);
  FuncExpr *expr = FuncExpr::makePort(a);
  EXPECT_TRUE(expr->hasPort(a));
  if (zn)
    EXPECT_FALSE(expr->hasPort(zn));
  delete expr;
}

// FuncExpr::portTimingSense
TEST_F(StaLibertyTest, FuncExprPortTimingSense) {
  LibertyCell *inv = lib_->findLibertyCell("INV_X1");
  ASSERT_NE(inv, nullptr);
  LibertyPort *a = inv->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  FuncExpr *not_expr = FuncExpr::makeNot(FuncExpr::makePort(a));
  TimingSense sense = not_expr->portTimingSense(a);
  EXPECT_EQ(sense, TimingSense::negative_unate);
  not_expr->deleteSubexprs();
}

// FuncExpr::copy
TEST_F(StaLibertyTest, FuncExprCopy) {
  FuncExpr *one = FuncExpr::makeOne();
  FuncExpr *copy = one->copy();
  EXPECT_NE(copy, nullptr);
  EXPECT_TRUE(FuncExpr::equiv(one, copy));
  delete one;
  delete copy;
}

// LibertyPort properties
TEST_F(StaLibertyTest, PortProperties) {
  LibertyCell *inv = lib_->findLibertyCell("INV_X1");
  ASSERT_NE(inv, nullptr);
  LibertyPort *a = inv->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  // capacitance
  float cap = a->capacitance();
  EXPECT_GE(cap, 0.0f);
  // direction
  EXPECT_NE(a->direction(), nullptr);
}

// LibertyPort::function
TEST_F(StaLibertyTest, PortFunction3) {
  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);
}

// LibertyPort::driveResistance
TEST_F(StaLibertyTest, PortDriveResistance2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *z = buf->findLibertyPort("Z");
  ASSERT_NE(z, nullptr);
  float res = z->driveResistance();
  EXPECT_GE(res, 0.0f);
}

// LibertyPort::capacitance with min/max
TEST_F(StaLibertyTest, PortCapacitanceMinMax2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  float cap_min = a->capacitance(MinMax::min());
  float cap_max = a->capacitance(MinMax::max());
  EXPECT_GE(cap_min, 0.0f);
  EXPECT_GE(cap_max, 0.0f);
}

// LibertyPort::capacitance with rf and min/max
TEST_F(StaLibertyTest, PortCapacitanceRfMinMax2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  float cap = a->capacitance(RiseFall::rise(), MinMax::max());
  EXPECT_GE(cap, 0.0f);
}

// LibertyPort::slewLimit
TEST_F(StaLibertyTest, PortSlewLimit2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *z = buf->findLibertyPort("Z");
  ASSERT_NE(z, nullptr);
  float limit;
  bool exists;
  z->slewLimit(MinMax::max(), limit, exists);
  // May or may not exist
  (void)limit;
  (void)exists;
}

// LibertyPort::capacitanceLimit
TEST_F(StaLibertyTest, PortCapacitanceLimit2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *z = buf->findLibertyPort("Z");
  ASSERT_NE(z, nullptr);
  float limit;
  bool exists;
  z->capacitanceLimit(MinMax::max(), limit, exists);
  (void)limit;
  (void)exists;
}

// LibertyPort::fanoutLoad
TEST_F(StaLibertyTest, PortFanoutLoad2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  float load;
  bool exists;
  a->fanoutLoad(load, exists);
  (void)load;
  (void)exists;
}

// LibertyPort::isClock
TEST_F(StaLibertyTest, PortIsClock2) {
  LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
  ASSERT_NE(dff, nullptr);
  LibertyPort *ck = dff->findLibertyPort("CK");
  ASSERT_NE(ck, nullptr);
  EXPECT_TRUE(ck->isClock());
  LibertyPort *d = dff->findLibertyPort("D");
  if (d)
    EXPECT_FALSE(d->isClock());
}

// LibertyPort::setIsClock
TEST_F(StaLibertyTest, PortSetIsClock) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  a->setIsClock(true);
  EXPECT_TRUE(a->isClock());
  a->setIsClock(false);
}

// LibertyPort::isRegClk
TEST_F(StaLibertyTest, PortIsRegClk2) {
  LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
  ASSERT_NE(dff, nullptr);
  LibertyPort *ck = dff->findLibertyPort("CK");
  ASSERT_NE(ck, nullptr);
  EXPECT_TRUE(ck->isRegClk());
}

// LibertyPort::isRegOutput
TEST_F(StaLibertyTest, PortIsRegOutput) {
  LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
  ASSERT_NE(dff, nullptr);
  LibertyPort *q = dff->findLibertyPort("Q");
  ASSERT_NE(q, nullptr);
  EXPECT_TRUE(q->isRegOutput());
}

// LibertyPort::isCheckClk
TEST_F(StaLibertyTest, PortIsCheckClk) {
  LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
  ASSERT_NE(dff, nullptr);
  LibertyPort *ck = dff->findLibertyPort("CK");
  ASSERT_NE(ck, nullptr);
  EXPECT_TRUE(ck->isCheckClk());
}

// TimingArcSet::deleteTimingArc - test via finding and accessing
TEST_F(StaLibertyTest, TimingArcSetArcCount) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  auto &arcsets = buf->timingArcSets();
  ASSERT_GT(arcsets.size(), 0u);
  TimingArcSet *first_set = arcsets[0];
  EXPECT_GT(first_set->arcCount(), 0u);
}

// TimingArcSet::role
TEST_F(StaLibertyTest, TimingArcSetRole) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  auto &arcsets = buf->timingArcSets();
  ASSERT_GT(arcsets.size(), 0u);
  TimingArcSet *first_set = arcsets[0];
  const TimingRole *role = first_set->role();
  EXPECT_NE(role, nullptr);
}

// TimingArcSet::sense
TEST_F(StaLibertyTest, TimingArcSetSense2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  auto &arcsets = buf->timingArcSets();
  ASSERT_GT(arcsets.size(), 0u);
  TimingSense sense = arcsets[0]->sense();
  // Buffer should have positive_unate
  EXPECT_EQ(sense, TimingSense::positive_unate);
}

// TimingArc::fromEdge and toEdge
TEST_F(StaLibertyTest, TimingArcEdges) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  auto &arcsets = buf->timingArcSets();
  ASSERT_GT(arcsets.size(), 0u);
  for (TimingArc *arc : arcsets[0]->arcs()) {
    EXPECT_NE(arc->fromEdge(), nullptr);
    EXPECT_NE(arc->toEdge(), nullptr);
  }
}

// TimingArc::driveResistance
TEST_F(StaLibertyTest, TimingArcDriveResistance3) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  auto &arcsets = buf->timingArcSets();
  ASSERT_GT(arcsets.size(), 0u);
  for (TimingArc *arc : arcsets[0]->arcs()) {
    float res = arc->driveResistance();
    EXPECT_GE(res, 0.0f);
  }
}

// TimingArc::intrinsicDelay
TEST_F(StaLibertyTest, TimingArcIntrinsicDelay3) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  auto &arcsets = buf->timingArcSets();
  ASSERT_GT(arcsets.size(), 0u);
  for (TimingArc *arc : arcsets[0]->arcs()) {
    ArcDelay delay = arc->intrinsicDelay();
    (void)delay;
  }
}

// TimingArc::model
TEST_F(StaLibertyTest, TimingArcModel2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  auto &arcsets = buf->timingArcSets();
  ASSERT_GT(arcsets.size(), 0u);
  for (TimingArc *arc : arcsets[0]->arcs()) {
    TimingModel *model = arc->model();
    EXPECT_NE(model, nullptr);
  }
}

// TimingArc::sense
TEST_F(StaLibertyTest, TimingArcSense) {
  LibertyCell *inv = lib_->findLibertyCell("INV_X1");
  ASSERT_NE(inv, nullptr);
  auto &arcsets = inv->timingArcSets();
  ASSERT_GT(arcsets.size(), 0u);
  for (TimingArc *arc : arcsets[0]->arcs()) {
    TimingSense sense = arc->sense();
    EXPECT_EQ(sense, TimingSense::negative_unate);
  }
}

// TimingArcSet::isCondDefault
TEST_F(StaLibertyTest, TimingArcSetIsCondDefault) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  auto &arcsets = buf->timingArcSets();
  ASSERT_GT(arcsets.size(), 0u);
  // Default should be false or true depending on library
  bool cd = arcsets[0]->isCondDefault();
  (void)cd;
}

// TimingArcSet::isDisabledConstraint
TEST_F(StaLibertyTest, TimingArcSetIsDisabledConstraint) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  auto &arcsets = buf->timingArcSets();
  ASSERT_GT(arcsets.size(), 0u);
  EXPECT_FALSE(arcsets[0]->isDisabledConstraint());
  arcsets[0]->setIsDisabledConstraint(true);
  EXPECT_TRUE(arcsets[0]->isDisabledConstraint());
  arcsets[0]->setIsDisabledConstraint(false);
}

// timingTypeIsCheck for more types
TEST_F(StaLibertyTest, TimingTypeIsCheckMore) {
  EXPECT_TRUE(timingTypeIsCheck(TimingType::setup_falling));
  EXPECT_TRUE(timingTypeIsCheck(TimingType::hold_rising));
  EXPECT_TRUE(timingTypeIsCheck(TimingType::recovery_rising));
  EXPECT_TRUE(timingTypeIsCheck(TimingType::removal_falling));
  EXPECT_FALSE(timingTypeIsCheck(TimingType::rising_edge));
  EXPECT_FALSE(timingTypeIsCheck(TimingType::falling_edge));
  EXPECT_FALSE(timingTypeIsCheck(TimingType::three_state_enable));
}

// findTimingType
TEST_F(StaLibertyTest, FindTimingType) {
  TimingType tt = findTimingType("combinational");
  EXPECT_EQ(tt, TimingType::combinational);
  tt = findTimingType("rising_edge");
  EXPECT_EQ(tt, TimingType::rising_edge);
  tt = findTimingType("falling_edge");
  EXPECT_EQ(tt, TimingType::falling_edge);
}

// timingTypeIsCheck
TEST_F(StaLibertyTest, TimingTypeIsCheck) {
  EXPECT_TRUE(timingTypeIsCheck(TimingType::setup_rising));
  EXPECT_TRUE(timingTypeIsCheck(TimingType::hold_falling));
  EXPECT_FALSE(timingTypeIsCheck(TimingType::combinational));
}

// to_string(TimingSense)
TEST_F(StaLibertyTest, TimingSenseToString) {
  const char *s = to_string(TimingSense::positive_unate);
  EXPECT_NE(s, nullptr);
  s = to_string(TimingSense::negative_unate);
  EXPECT_NE(s, nullptr);
  s = to_string(TimingSense::non_unate);
  EXPECT_NE(s, nullptr);
}

// timingSenseOpposite
TEST_F(StaLibertyTest, TimingSenseOpposite) {
  EXPECT_EQ(timingSenseOpposite(TimingSense::positive_unate),
            TimingSense::negative_unate);
  EXPECT_EQ(timingSenseOpposite(TimingSense::negative_unate),
            TimingSense::positive_unate);
}

// ScaleFactorPvt names
TEST_F(StaLibertyTest, ScaleFactorPvtNames) {
  EXPECT_STREQ(scaleFactorPvtName(ScaleFactorPvt::process), "process");
  EXPECT_STREQ(scaleFactorPvtName(ScaleFactorPvt::volt), "volt");
  EXPECT_STREQ(scaleFactorPvtName(ScaleFactorPvt::temp), "temp");
}

// findScaleFactorPvt
TEST_F(StaLibertyTest, FindScaleFactorPvt) {
  EXPECT_EQ(findScaleFactorPvt("process"), ScaleFactorPvt::process);
  EXPECT_EQ(findScaleFactorPvt("volt"), ScaleFactorPvt::volt);
  EXPECT_EQ(findScaleFactorPvt("temp"), ScaleFactorPvt::temp);
}

// ScaleFactorType names
TEST_F(StaLibertyTest, ScaleFactorTypeNames) {
  const char *name = scaleFactorTypeName(ScaleFactorType::cell);
  EXPECT_NE(name, nullptr);
}

// findScaleFactorType
TEST_F(StaLibertyTest, FindScaleFactorType) {
  ASSERT_NO_THROW(( [&](){
  ScaleFactorType sft = findScaleFactorType("cell_rise");
  // Should find it
  (void)sft;

  }() ));
}

// BusDcl
TEST_F(StaLibertyTest, BusDclConstruct) {
  BusDcl bus("data", 7, 0);
  EXPECT_STREQ(bus.name(), "data");
  EXPECT_EQ(bus.from(), 7);
  EXPECT_EQ(bus.to(), 0);
}

// TableTemplate
TEST_F(StaLibertyTest, TableTemplateConstruct) {
  TableTemplate tpl("my_template");
  EXPECT_STREQ(tpl.name(), "my_template");
  EXPECT_EQ(tpl.axis1(), nullptr);
  EXPECT_EQ(tpl.axis2(), nullptr);
  EXPECT_EQ(tpl.axis3(), nullptr);
}

// TableTemplate setName
TEST_F(StaLibertyTest, TableTemplateSetName) {
  TableTemplate tpl("orig");
  tpl.setName("renamed");
  EXPECT_STREQ(tpl.name(), "renamed");
}

// LibertyCell::modeDef
TEST_F(StaLibertyTest, CellModeDef2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  ModeDef *md = buf->makeModeDef("test_mode");
  EXPECT_NE(md, nullptr);
  EXPECT_STREQ(md->name(), "test_mode");
  ModeDef *found = buf->findModeDef("test_mode");
  EXPECT_EQ(found, md);
  EXPECT_EQ(buf->findModeDef("nonexistent_mode"), nullptr);
}

// LibertyLibrary::tableTemplates
TEST_F(StaLibertyTest, LibTableTemplates) {
  ASSERT_NE(lib_, nullptr);
  auto templates = lib_->tableTemplates();
  // Nangate45 should have table templates
  EXPECT_GT(templates.size(), 0u);
}

// LibertyLibrary::busDcls
TEST_F(StaLibertyTest, LibBusDcls) {
  ASSERT_NE(lib_, nullptr);
  auto dcls = lib_->busDcls();
  // May or may not have bus declarations
  (void)dcls.size();
}

// LibertyPort::minPeriod
TEST_F(StaLibertyTest, PortMinPeriod3) {
  LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
  ASSERT_NE(dff, nullptr);
  LibertyPort *ck = dff->findLibertyPort("CK");
  ASSERT_NE(ck, nullptr);
  float min_period;
  bool exists;
  ck->minPeriod(min_period, exists);
  // May or may not exist
  (void)min_period;
  (void)exists;
}

// LibertyPort::minPulseWidth
TEST_F(StaLibertyTest, PortMinPulseWidth3) {
  LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
  ASSERT_NE(dff, nullptr);
  LibertyPort *ck = dff->findLibertyPort("CK");
  ASSERT_NE(ck, nullptr);
  float min_width;
  bool exists;
  ck->minPulseWidth(RiseFall::rise(), min_width, exists);
  (void)min_width;
  (void)exists;
}

// LibertyPort::isClockGateClock/Enable/Out
TEST_F(StaLibertyTest, PortClockGateFlags) {
  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());
}

// LibertyPort::isPllFeedback
TEST_F(StaLibertyTest, PortIsPllFeedback2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  EXPECT_FALSE(a->isPllFeedback());
}

// LibertyPort::isSwitch
TEST_F(StaLibertyTest, PortIsSwitch2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  EXPECT_FALSE(a->isSwitch());
}

// LibertyPort::isPad
TEST_F(StaLibertyTest, PortIsPad2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  EXPECT_FALSE(a->isPad());
}

// LibertyPort::setCapacitance
TEST_F(StaLibertyTest, PortSetCapacitance) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  a->setCapacitance(0.5f);
  EXPECT_FLOAT_EQ(a->capacitance(), 0.5f);
}

// LibertyPort::setSlewLimit
TEST_F(StaLibertyTest, PortSetSlewLimit) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *z = buf->findLibertyPort("Z");
  ASSERT_NE(z, nullptr);
  z->setSlewLimit(2.0f, MinMax::max());
  float limit;
  bool exists;
  z->slewLimit(MinMax::max(), limit, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(limit, 2.0f);
}

// LibertyPort::setCapacitanceLimit
TEST_F(StaLibertyTest, PortSetCapacitanceLimit) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *z = buf->findLibertyPort("Z");
  ASSERT_NE(z, nullptr);
  z->setCapacitanceLimit(5.0f, MinMax::max());
  float limit;
  bool exists;
  z->capacitanceLimit(MinMax::max(), limit, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(limit, 5.0f);
}

// LibertyPort::setFanoutLoad
TEST_F(StaLibertyTest, PortSetFanoutLoad2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  a->setFanoutLoad(1.0f);
  float load;
  bool exists;
  a->fanoutLoad(load, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(load, 1.0f);
}

// LibertyPort::setFanoutLimit
TEST_F(StaLibertyTest, PortSetFanoutLimit2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *z = buf->findLibertyPort("Z");
  ASSERT_NE(z, nullptr);
  z->setFanoutLimit(4.0f, MinMax::max());
  float limit;
  bool exists;
  z->fanoutLimit(MinMax::max(), limit, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(limit, 4.0f);
}

// LibertyPort::capacitanceIsOneValue
TEST_F(StaLibertyTest, PortCapacitanceIsOneValue2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  bool one_val = a->capacitanceIsOneValue();
  (void)one_val;
}

// LibertyPort::isDisabledConstraint
TEST_F(StaLibertyTest, PortIsDisabledConstraint3) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  EXPECT_FALSE(a->isDisabledConstraint());
  a->setIsDisabledConstraint(true);
  EXPECT_TRUE(a->isDisabledConstraint());
  a->setIsDisabledConstraint(false);
}

// InternalPower
TEST_F(StaLibertyTest, InternalPowerPort) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  auto &powers = buf->internalPowers();
  if (!powers.empty()) {
    InternalPower *pw = powers[0];
    EXPECT_NE(pw->port(), nullptr);
    LibertyCell *pcell = pw->libertyCell();
    EXPECT_EQ(pcell, buf);
  }
}

// LibertyLibrary units
TEST_F(StaLibertyTest, LibUnits) {
  ASSERT_NE(lib_, nullptr);
  Units *units = lib_->units();
  EXPECT_NE(units, nullptr);
  EXPECT_NE(units->timeUnit(), nullptr);
  EXPECT_NE(units->capacitanceUnit(), nullptr);
  EXPECT_NE(units->voltageUnit(), nullptr);
}

// WireloadSelection
TEST_F(StaLibertyTest, WireloadSelection) {
  ASSERT_NE(lib_, nullptr);
  WireloadSelection *ws = lib_->defaultWireloadSelection();
  // May be nullptr if not defined in the library
  (void)ws;
}

// LibertyLibrary::findWireload
TEST_F(StaLibertyTest, LibFindWireload) {
  ASSERT_NE(lib_, nullptr);
  Wireload *wl = lib_->findWireload("nonexistent");
  EXPECT_EQ(wl, nullptr);
}

// scaleFactorTypeRiseFallSuffix/Prefix/LowHighSuffix
TEST_F(StaLibertyTest, ScaleFactorTypeRiseFallSuffix) {
  ASSERT_NO_THROW(( [&](){
  // These should not crash
  bool rfs = scaleFactorTypeRiseFallSuffix(ScaleFactorType::cell);
  bool rfp = scaleFactorTypeRiseFallPrefix(ScaleFactorType::cell);
  bool lhs = scaleFactorTypeLowHighSuffix(ScaleFactorType::cell);
  (void)rfs;
  (void)rfp;
  (void)lhs;

  }() ));
}

// LibertyPort::scanSignalType
TEST_F(StaLibertyTest, PortScanSignalType2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  EXPECT_EQ(a->scanSignalType(), ScanSignalType::none);
}

// scanSignalTypeName
TEST_F(StaLibertyTest, ScanSignalTypeName) {
  const char *name = scanSignalTypeName(ScanSignalType::enable);
  EXPECT_NE(name, nullptr);
  name = scanSignalTypeName(ScanSignalType::clock);
  EXPECT_NE(name, nullptr);
}

// pwrGndTypeName and findPwrGndType
TEST_F(StaLibertyTest, PwrGndTypeName) {
  const char *name = pwrGndTypeName(PwrGndType::primary_power);
  EXPECT_NE(name, nullptr);
  PwrGndType t = findPwrGndType("primary_power");
  EXPECT_EQ(t, PwrGndType::primary_power);
}

// TimingArcSet::arcsFrom
TEST_F(StaLibertyTest, TimingArcSetArcsFrom2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  auto &arcsets = buf->timingArcSets();
  ASSERT_GT(arcsets.size(), 0u);
  TimingArc *arc1 = nullptr;
  TimingArc *arc2 = nullptr;
  arcsets[0]->arcsFrom(RiseFall::rise(), arc1, arc2);
  // At least one arc should be found for rise
  EXPECT_NE(arc1, nullptr);
}

// TimingArcSet::arcTo
TEST_F(StaLibertyTest, TimingArcSetArcTo2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  auto &arcsets = buf->timingArcSets();
  ASSERT_GT(arcsets.size(), 0u);
  TimingArc *arc = arcsets[0]->arcTo(RiseFall::rise());
  // Should find an arc
  EXPECT_NE(arc, nullptr);
}

// LibertyPort::driveResistance with rf/min_max
TEST_F(StaLibertyTest, PortDriveResistanceRfMinMax2) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *z = buf->findLibertyPort("Z");
  ASSERT_NE(z, nullptr);
  float res = z->driveResistance(RiseFall::rise(), MinMax::max());
  EXPECT_GE(res, 0.0f);
}

// LibertyPort::setMinPeriod
TEST_F(StaLibertyTest, PortSetMinPeriod) {
  LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
  ASSERT_NE(dff, nullptr);
  LibertyPort *ck = dff->findLibertyPort("CK");
  ASSERT_NE(ck, nullptr);
  ck->setMinPeriod(0.5f);
  float min_period;
  bool exists;
  ck->minPeriod(min_period, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(min_period, 0.5f);
}

// LibertyPort::setMinPulseWidth
TEST_F(StaLibertyTest, PortSetMinPulseWidth) {
  LibertyCell *dff = lib_->findLibertyCell("DFF_X1");
  ASSERT_NE(dff, nullptr);
  LibertyPort *ck = dff->findLibertyPort("CK");
  ASSERT_NE(ck, nullptr);
  ck->setMinPulseWidth(RiseFall::rise(), 0.3f);
  float min_width;
  bool exists;
  ck->minPulseWidth(RiseFall::rise(), min_width, exists);
  EXPECT_TRUE(exists);
  EXPECT_FLOAT_EQ(min_width, 0.3f);
}

// LibertyPort::setDirection
TEST_F(StaLibertyTest, PortSetDirection) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  a->setDirection(PortDirection::bidirect());
  EXPECT_EQ(a->direction(), PortDirection::bidirect());
  a->setDirection(PortDirection::input());
}

// LibertyPort isolation and level shifter data flags
TEST_F(StaLibertyTest, PortIsolationLevelShifterFlags) {
  LibertyCell *buf = lib_->findLibertyCell("BUF_X1");
  ASSERT_NE(buf, nullptr);
  LibertyPort *a = buf->findLibertyPort("A");
  ASSERT_NE(a, nullptr);
  EXPECT_FALSE(a->isolationCellData());
  EXPECT_FALSE(a->isolationCellEnable());
  EXPECT_FALSE(a->levelShifterData());
}

} // namespace sta