caiyu/nextpnr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

clangformat cleanup

Browse Source
This commit is contained in:
Miodrag Milanovic 2018-06-12 20:44:05 +02:00
parent b7c747f15b
commit 7b1c599947
9 changed files with 405 additions and 410 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
gui/mainwindow.cc
View File

@ -25,8 +25,8 @@ MainWindow::MainWindow(Design *_design, QWidget *parent)
QList<QTreeWidgetItem *> bel_items;
for (auto bel : design->chip.getBels()) {
auto name = design->chip.getBelName(bel);
bel_items.append(new QTreeWidgetItem((QTreeWidget *)nullptr,
QStringList(QString(name.c_str()))));
bel_items.append(new QTreeWidgetItem(
(QTreeWidget *)nullptr, QStringList(QString(name.c_str()))));
}
bel_root->addChildren(bel_items);
@ -36,8 +36,8 @@ MainWindow::MainWindow(Design *_design, QWidget *parent)
ui->treeWidget->insertTopLevelItem(0, wire_root);
for (auto wire : design->chip.getWires()) {
auto name = design->chip.getWireName(wire);
wire_items.append(new QTreeWidgetItem((QTreeWidget *)nullptr,
QStringList(QString(name.c_str()))));
wire_items.append(new QTreeWidgetItem(
(QTreeWidget *)nullptr, QStringList(QString(name.c_str()))));
}
wire_root->addChildren(wire_items);
@ -47,12 +47,11 @@ MainWindow::MainWindow(Design *_design, QWidget *parent)
ui->treeWidget->insertTopLevelItem(0, pip_root);
for (auto pip : design->chip.getPips()) {
auto name = design->chip.getPipName(pip);
pip_items.append(new QTreeWidgetItem((QTreeWidget *)nullptr,
QStringList(QString(name.c_str()))));
pip_items.append(new QTreeWidgetItem(
(QTreeWidget *)nullptr, QStringList(QString(name.c_str()))));
}
pip_root->addChildren(pip_items);
PyImport_ImportModule("emb");
write = [this](std::string s) {

7
tests/dummy/main.cc
View File

@ -2,7 +2,8 @@
#include <vector>
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
int main(int argc, char **argv)
{
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

131
tests/ice40/hx1k.cc
View File

@ -1,88 +1,87 @@
#include <vector>
#include "gtest/gtest.h"
#include "nextpnr.h"
#include <vector>
USING_NEXTPNR_NAMESPACE
class HX1KTest : public ::testing::Test {
protected:
virtual void SetUp()
{
chipArgs.type = ChipArgs::HX1K;
design = new Design(chipArgs);
}
virtual void TearDown() {
delete design;
}
class HX1KTest : public ::testing::Test
{
protected:
virtual void SetUp()
{
chipArgs.type = ChipArgs::HX1K;
design = new Design(chipArgs);
}
ChipArgs chipArgs;
Design *design;
virtual void TearDown() { delete design; }
ChipArgs chipArgs;
Design *design;
};
TEST_F(HX1KTest, bel_names)
TEST_F(HX1KTest, bel_names)
{
int bel_count = 0;
for (auto bel : design->chip.getBels()) {
auto name = design->chip.getBelName(bel);
ASSERT_EQ(bel,design->chip.getBelByName(name));
bel_count++;
}
ASSERT_EQ(bel_count,1416);
int bel_count = 0;
for (auto bel : design->chip.getBels()) {
auto name = design->chip.getBelName(bel);
ASSERT_EQ(bel, design->chip.getBelByName(name));
bel_count++;
}
ASSERT_EQ(bel_count, 1416);
}
TEST_F(HX1KTest, wire_names)
TEST_F(HX1KTest, wire_names)
{
int wire_count = 0;
for (auto wire : design->chip.getWires()) {
auto name = design->chip.getWireName(wire);
assert(wire == design->chip.getWireByName(name));
wire_count++;
}
ASSERT_EQ(wire_count,27682);
int wire_count = 0;
for (auto wire : design->chip.getWires()) {
auto name = design->chip.getWireName(wire);
assert(wire == design->chip.getWireByName(name));
wire_count++;
}
ASSERT_EQ(wire_count, 27682);
}
TEST_F(HX1KTest, pip_names)
TEST_F(HX1KTest, pip_names)
{
int pip_count = 0;
for (auto pip : design->chip.getPips()) {
auto name = design->chip.getPipName(pip);
assert(pip == design->chip.getPipByName(name));
pip_count++;
}
ASSERT_EQ(pip_count,319904);
int pip_count = 0;
for (auto pip : design->chip.getPips()) {
auto name = design->chip.getPipName(pip);
assert(pip == design->chip.getPipByName(name));
pip_count++;
}
ASSERT_EQ(pip_count, 319904);
}
TEST_F(HX1KTest, uphill_to_downhill)
TEST_F(HX1KTest, uphill_to_downhill)
{
for (auto dst : design->chip.getWires()) {
for (auto uphill_pip : design->chip.getPipsUphill(dst)) {
bool found_downhill = false;
for (auto downhill_pip : design->chip.getPipsDownhill(
design->chip.getPipSrcWire(uphill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_downhill);
found_downhill = true;
}
}
ASSERT_TRUE(found_downhill);
}
}
for (auto dst : design->chip.getWires()) {
for (auto uphill_pip : design->chip.getPipsUphill(dst)) {
bool found_downhill = false;
for (auto downhill_pip : design->chip.getPipsDownhill(
design->chip.getPipSrcWire(uphill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_downhill);
found_downhill = true;
}
}
ASSERT_TRUE(found_downhill);
}
}
}
TEST_F(HX1KTest, downhill_to_uphill)
TEST_F(HX1KTest, downhill_to_uphill)
{
for (auto dst : design->chip.getWires()) {
for (auto downhill_pip : design->chip.getPipsDownhill(dst)) {
bool found_uphill = false;
for (auto uphill_pip : design->chip.getPipsUphill(
design->chip.getPipDstWire(downhill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_uphill);
found_uphill = true;
}
}
ASSERT_TRUE(found_uphill);
}
}
for (auto dst : design->chip.getWires()) {
for (auto downhill_pip : design->chip.getPipsDownhill(dst)) {
bool found_uphill = false;
for (auto uphill_pip : design->chip.getPipsUphill(
design->chip.getPipDstWire(downhill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_uphill);
found_uphill = true;
}
}
ASSERT_TRUE(found_uphill);
}
}
}

131
tests/ice40/hx8k.cc
View File

@ -1,88 +1,87 @@
#include <vector>
#include "gtest/gtest.h"
#include "nextpnr.h"
#include <vector>
USING_NEXTPNR_NAMESPACE
class HX8KTest : public ::testing::Test {
protected:
virtual void SetUp()
{
chipArgs.type = ChipArgs::HX8K;
design = new Design(chipArgs);
}
virtual void TearDown() {
delete design;
}
class HX8KTest : public ::testing::Test
{
protected:
virtual void SetUp()
{
chipArgs.type = ChipArgs::HX8K;
design = new Design(chipArgs);
}
ChipArgs chipArgs;
Design *design;
virtual void TearDown() { delete design; }
ChipArgs chipArgs;
Design *design;
};
TEST_F(HX8KTest, bel_names)
TEST_F(HX8KTest, bel_names)
{
int bel_count = 0;
for (auto bel : design->chip.getBels()) {
auto name = design->chip.getBelName(bel);
ASSERT_EQ(bel,design->chip.getBelByName(name));
bel_count++;
}
ASSERT_EQ(bel_count,7968);
int bel_count = 0;
for (auto bel : design->chip.getBels()) {
auto name = design->chip.getBelName(bel);
ASSERT_EQ(bel, design->chip.getBelByName(name));
bel_count++;
}
ASSERT_EQ(bel_count, 7968);
}
TEST_F(HX8KTest, wire_names)
TEST_F(HX8KTest, wire_names)
{
int wire_count = 0;
for (auto wire : design->chip.getWires()) {
auto name = design->chip.getWireName(wire);
assert(wire == design->chip.getWireByName(name));
wire_count++;
}
ASSERT_EQ(wire_count,135174);
int wire_count = 0;
for (auto wire : design->chip.getWires()) {
auto name = design->chip.getWireName(wire);
assert(wire == design->chip.getWireByName(name));
wire_count++;
}
ASSERT_EQ(wire_count, 135174);
}
TEST_F(HX8KTest, pip_names)
TEST_F(HX8KTest, pip_names)
{
int pip_count = 0;
for (auto pip : design->chip.getPips()) {
auto name = design->chip.getPipName(pip);
assert(pip == design->chip.getPipByName(name));
pip_count++;
}
ASSERT_EQ(pip_count,1652480);
int pip_count = 0;
for (auto pip : design->chip.getPips()) {
auto name = design->chip.getPipName(pip);
assert(pip == design->chip.getPipByName(name));
pip_count++;
}
ASSERT_EQ(pip_count, 1652480);
}
TEST_F(HX8KTest, uphill_to_downhill)
TEST_F(HX8KTest, uphill_to_downhill)
{
for (auto dst : design->chip.getWires()) {
for (auto uphill_pip : design->chip.getPipsUphill(dst)) {
bool found_downhill = false;
for (auto downhill_pip : design->chip.getPipsDownhill(
design->chip.getPipSrcWire(uphill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_downhill);
found_downhill = true;
}
}
ASSERT_TRUE(found_downhill);
}
}
for (auto dst : design->chip.getWires()) {
for (auto uphill_pip : design->chip.getPipsUphill(dst)) {
bool found_downhill = false;
for (auto downhill_pip : design->chip.getPipsDownhill(
design->chip.getPipSrcWire(uphill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_downhill);
found_downhill = true;
}
}
ASSERT_TRUE(found_downhill);
}
}
}
TEST_F(HX8KTest, downhill_to_uphill)
TEST_F(HX8KTest, downhill_to_uphill)
{
for (auto dst : design->chip.getWires()) {
for (auto downhill_pip : design->chip.getPipsDownhill(dst)) {
bool found_uphill = false;
for (auto uphill_pip : design->chip.getPipsUphill(
design->chip.getPipDstWire(downhill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_uphill);
found_uphill = true;
}
}
ASSERT_TRUE(found_uphill);
}
}
for (auto dst : design->chip.getWires()) {
for (auto downhill_pip : design->chip.getPipsDownhill(dst)) {
bool found_uphill = false;
for (auto uphill_pip : design->chip.getPipsUphill(
design->chip.getPipDstWire(downhill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_uphill);
found_uphill = true;
}
}
ASSERT_TRUE(found_uphill);
}
}
}

131
tests/ice40/lp1k.cc
View File

@ -1,88 +1,87 @@
#include <vector>
#include "gtest/gtest.h"
#include "nextpnr.h"
#include <vector>
USING_NEXTPNR_NAMESPACE
class LP1KTest : public ::testing::Test {
protected:
virtual void SetUp()
{
chipArgs.type = ChipArgs::LP1K;
design = new Design(chipArgs);
}
virtual void TearDown() {
delete design;
}
class LP1KTest : public ::testing::Test
{
protected:
virtual void SetUp()
{
chipArgs.type = ChipArgs::LP1K;
design = new Design(chipArgs);
}
ChipArgs chipArgs;
Design *design;
virtual void TearDown() { delete design; }
ChipArgs chipArgs;
Design *design;
};
TEST_F(LP1KTest, bel_names)
TEST_F(LP1KTest, bel_names)
{
int bel_count = 0;
for (auto bel : design->chip.getBels()) {
auto name = design->chip.getBelName(bel);
ASSERT_EQ(bel,design->chip.getBelByName(name));
bel_count++;
}
ASSERT_EQ(bel_count,1416);
int bel_count = 0;
for (auto bel : design->chip.getBels()) {
auto name = design->chip.getBelName(bel);
ASSERT_EQ(bel, design->chip.getBelByName(name));
bel_count++;
}
ASSERT_EQ(bel_count, 1416);
}
TEST_F(LP1KTest, wire_names)
TEST_F(LP1KTest, wire_names)
{
int wire_count = 0;
for (auto wire : design->chip.getWires()) {
auto name = design->chip.getWireName(wire);
assert(wire == design->chip.getWireByName(name));
wire_count++;
}
ASSERT_EQ(wire_count,27682);
int wire_count = 0;
for (auto wire : design->chip.getWires()) {
auto name = design->chip.getWireName(wire);
assert(wire == design->chip.getWireByName(name));
wire_count++;
}
ASSERT_EQ(wire_count, 27682);
}
TEST_F(LP1KTest, pip_names)
TEST_F(LP1KTest, pip_names)
{
int pip_count = 0;
for (auto pip : design->chip.getPips()) {
auto name = design->chip.getPipName(pip);
assert(pip == design->chip.getPipByName(name));
pip_count++;
}
ASSERT_EQ(pip_count,319904);
int pip_count = 0;
for (auto pip : design->chip.getPips()) {
auto name = design->chip.getPipName(pip);
assert(pip == design->chip.getPipByName(name));
pip_count++;
}
ASSERT_EQ(pip_count, 319904);
}
TEST_F(LP1KTest, uphill_to_downhill)
TEST_F(LP1KTest, uphill_to_downhill)
{
for (auto dst : design->chip.getWires()) {
for (auto uphill_pip : design->chip.getPipsUphill(dst)) {
bool found_downhill = false;
for (auto downhill_pip : design->chip.getPipsDownhill(
design->chip.getPipSrcWire(uphill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_downhill);
found_downhill = true;
}
}
ASSERT_TRUE(found_downhill);
}
}
for (auto dst : design->chip.getWires()) {
for (auto uphill_pip : design->chip.getPipsUphill(dst)) {
bool found_downhill = false;
for (auto downhill_pip : design->chip.getPipsDownhill(
design->chip.getPipSrcWire(uphill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_downhill);
found_downhill = true;
}
}
ASSERT_TRUE(found_downhill);
}
}
}
TEST_F(LP1KTest, downhill_to_uphill)
TEST_F(LP1KTest, downhill_to_uphill)
{
for (auto dst : design->chip.getWires()) {
for (auto downhill_pip : design->chip.getPipsDownhill(dst)) {
bool found_uphill = false;
for (auto uphill_pip : design->chip.getPipsUphill(
design->chip.getPipDstWire(downhill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_uphill);
found_uphill = true;
}
}
ASSERT_TRUE(found_uphill);
}
}
for (auto dst : design->chip.getWires()) {
for (auto downhill_pip : design->chip.getPipsDownhill(dst)) {
bool found_uphill = false;
for (auto uphill_pip : design->chip.getPipsUphill(
design->chip.getPipDstWire(downhill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_uphill);
found_uphill = true;
}
}
ASSERT_TRUE(found_uphill);
}
}
}

131
tests/ice40/lp384.cc
View File

@ -1,88 +1,87 @@
#include <vector>
#include "gtest/gtest.h"
#include "nextpnr.h"
#include <vector>
USING_NEXTPNR_NAMESPACE
class LP384Test : public ::testing::Test {
protected:
virtual void SetUp()
{
chipArgs.type = ChipArgs::LP384;
design = new Design(chipArgs);
}
virtual void TearDown() {
delete design;
}
class LP384Test : public ::testing::Test
{
protected:
virtual void SetUp()
{
chipArgs.type = ChipArgs::LP384;
design = new Design(chipArgs);
}
ChipArgs chipArgs;
Design *design;
virtual void TearDown() { delete design; }
ChipArgs chipArgs;
Design *design;
};
TEST_F(LP384Test, bel_names)
TEST_F(LP384Test, bel_names)
{
int bel_count = 0;
for (auto bel : design->chip.getBels()) {
auto name = design->chip.getBelName(bel);
ASSERT_EQ(bel,design->chip.getBelByName(name));
bel_count++;
}
ASSERT_EQ(bel_count,440);
int bel_count = 0;
for (auto bel : design->chip.getBels()) {
auto name = design->chip.getBelName(bel);
ASSERT_EQ(bel, design->chip.getBelByName(name));
bel_count++;
}
ASSERT_EQ(bel_count, 440);
}
TEST_F(LP384Test, wire_names)
TEST_F(LP384Test, wire_names)
{
int wire_count = 0;
for (auto wire : design->chip.getWires()) {
auto name = design->chip.getWireName(wire);
assert(wire == design->chip.getWireByName(name));
wire_count++;
}
ASSERT_EQ(wire_count,8294);
int wire_count = 0;
for (auto wire : design->chip.getWires()) {
auto name = design->chip.getWireName(wire);
assert(wire == design->chip.getWireByName(name));
wire_count++;
}
ASSERT_EQ(wire_count, 8294);
}
TEST_F(LP384Test, pip_names)
TEST_F(LP384Test, pip_names)
{
int pip_count = 0;
for (auto pip : design->chip.getPips()) {
auto name = design->chip.getPipName(pip);
assert(pip == design->chip.getPipByName(name));
pip_count++;
}
ASSERT_EQ(pip_count,86864);
int pip_count = 0;
for (auto pip : design->chip.getPips()) {
auto name = design->chip.getPipName(pip);
assert(pip == design->chip.getPipByName(name));
pip_count++;
}
ASSERT_EQ(pip_count, 86864);
}
TEST_F(LP384Test, uphill_to_downhill)
TEST_F(LP384Test, uphill_to_downhill)
{
for (auto dst : design->chip.getWires()) {
for (auto uphill_pip : design->chip.getPipsUphill(dst)) {
bool found_downhill = false;
for (auto downhill_pip : design->chip.getPipsDownhill(
design->chip.getPipSrcWire(uphill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_downhill);
found_downhill = true;
}
}
ASSERT_TRUE(found_downhill);
}
}
for (auto dst : design->chip.getWires()) {
for (auto uphill_pip : design->chip.getPipsUphill(dst)) {
bool found_downhill = false;
for (auto downhill_pip : design->chip.getPipsDownhill(
design->chip.getPipSrcWire(uphill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_downhill);
found_downhill = true;
}
}
ASSERT_TRUE(found_downhill);
}
}
}
TEST_F(LP384Test, downhill_to_uphill)
TEST_F(LP384Test, downhill_to_uphill)
{
for (auto dst : design->chip.getWires()) {
for (auto downhill_pip : design->chip.getPipsDownhill(dst)) {
bool found_uphill = false;
for (auto uphill_pip : design->chip.getPipsUphill(
design->chip.getPipDstWire(downhill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_uphill);
found_uphill = true;
}
}
ASSERT_TRUE(found_uphill);
}
}
for (auto dst : design->chip.getWires()) {
for (auto downhill_pip : design->chip.getPipsDownhill(dst)) {
bool found_uphill = false;
for (auto uphill_pip : design->chip.getPipsUphill(
design->chip.getPipDstWire(downhill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_uphill);
found_uphill = true;
}
}
ASSERT_TRUE(found_uphill);
}
}
}

131
tests/ice40/lp8k.cc
View File

@ -1,88 +1,87 @@
#include <vector>
#include "gtest/gtest.h"
#include "nextpnr.h"
#include <vector>
USING_NEXTPNR_NAMESPACE
class LP8KTest : public ::testing::Test {
protected:
virtual void SetUp()
{
chipArgs.type = ChipArgs::LP8K;
design = new Design(chipArgs);
}
virtual void TearDown() {
delete design;
}
class LP8KTest : public ::testing::Test
{
protected:
virtual void SetUp()
{
chipArgs.type = ChipArgs::LP8K;
design = new Design(chipArgs);
}
ChipArgs chipArgs;
Design *design;
virtual void TearDown() { delete design; }
ChipArgs chipArgs;
Design *design;
};
TEST_F(LP8KTest, bel_names)
TEST_F(LP8KTest, bel_names)
{
int bel_count = 0;
for (auto bel : design->chip.getBels()) {
auto name = design->chip.getBelName(bel);
ASSERT_EQ(bel,design->chip.getBelByName(name));
bel_count++;
}
ASSERT_EQ(bel_count,7968);
int bel_count = 0;
for (auto bel : design->chip.getBels()) {
auto name = design->chip.getBelName(bel);
ASSERT_EQ(bel, design->chip.getBelByName(name));
bel_count++;
}
ASSERT_EQ(bel_count, 7968);
}
TEST_F(LP8KTest, wire_names)
TEST_F(LP8KTest, wire_names)
{
int wire_count = 0;
for (auto wire : design->chip.getWires()) {
auto name = design->chip.getWireName(wire);
assert(wire == design->chip.getWireByName(name));
wire_count++;
}
ASSERT_EQ(wire_count,135174);
int wire_count = 0;
for (auto wire : design->chip.getWires()) {
auto name = design->chip.getWireName(wire);
assert(wire == design->chip.getWireByName(name));
wire_count++;
}
ASSERT_EQ(wire_count, 135174);
}
TEST_F(LP8KTest, pip_names)
TEST_F(LP8KTest, pip_names)
{
int pip_count = 0;
for (auto pip : design->chip.getPips()) {
auto name = design->chip.getPipName(pip);
assert(pip == design->chip.getPipByName(name));
pip_count++;
}
ASSERT_EQ(pip_count,1652480);
int pip_count = 0;
for (auto pip : design->chip.getPips()) {
auto name = design->chip.getPipName(pip);
assert(pip == design->chip.getPipByName(name));
pip_count++;
}
ASSERT_EQ(pip_count, 1652480);
}
TEST_F(LP8KTest, uphill_to_downhill)
TEST_F(LP8KTest, uphill_to_downhill)
{
for (auto dst : design->chip.getWires()) {
for (auto uphill_pip : design->chip.getPipsUphill(dst)) {
bool found_downhill = false;
for (auto downhill_pip : design->chip.getPipsDownhill(
design->chip.getPipSrcWire(uphill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_downhill);
found_downhill = true;
}
}
ASSERT_TRUE(found_downhill);
}
}
for (auto dst : design->chip.getWires()) {
for (auto uphill_pip : design->chip.getPipsUphill(dst)) {
bool found_downhill = false;
for (auto downhill_pip : design->chip.getPipsDownhill(
design->chip.getPipSrcWire(uphill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_downhill);
found_downhill = true;
}
}
ASSERT_TRUE(found_downhill);
}
}
}
TEST_F(LP8KTest, downhill_to_uphill)
TEST_F(LP8KTest, downhill_to_uphill)
{
for (auto dst : design->chip.getWires()) {
for (auto downhill_pip : design->chip.getPipsDownhill(dst)) {
bool found_uphill = false;
for (auto uphill_pip : design->chip.getPipsUphill(
design->chip.getPipDstWire(downhill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_uphill);
found_uphill = true;
}
}
ASSERT_TRUE(found_uphill);
}
}
for (auto dst : design->chip.getWires()) {
for (auto downhill_pip : design->chip.getPipsDownhill(dst)) {
bool found_uphill = false;
for (auto uphill_pip : design->chip.getPipsUphill(
design->chip.getPipDstWire(downhill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_uphill);
found_uphill = true;
}
}
ASSERT_TRUE(found_uphill);
}
}
}

9
tests/ice40/main.cc
View File

@ -1,7 +1,8 @@
#include "gtest/gtest.h"
#include <vector>
#include "gtest/gtest.h"
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
int main(int argc, char **argv)
{
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

131
tests/ice40/up5k.cc
View File

@ -1,88 +1,87 @@
#include <vector>
#include "gtest/gtest.h"
#include "nextpnr.h"
#include <vector>
USING_NEXTPNR_NAMESPACE
class UP5KTest : public ::testing::Test {
protected:
virtual void SetUp()
{
chipArgs.type = ChipArgs::UP5K;
design = new Design(chipArgs);
}
virtual void TearDown() {
delete design;
}
class UP5KTest : public ::testing::Test
{
protected:
virtual void SetUp()
{
chipArgs.type = ChipArgs::UP5K;
design = new Design(chipArgs);
}
ChipArgs chipArgs;
Design *design;
virtual void TearDown() { delete design; }
ChipArgs chipArgs;
Design *design;
};
TEST_F(UP5KTest, bel_names)
TEST_F(UP5KTest, bel_names)
{
int bel_count = 0;
for (auto bel : design->chip.getBels()) {
auto name = design->chip.getBelName(bel);
ASSERT_EQ(bel,design->chip.getBelByName(name));
bel_count++;
}
ASSERT_EQ(bel_count,5414);
int bel_count = 0;
for (auto bel : design->chip.getBels()) {
auto name = design->chip.getBelName(bel);
ASSERT_EQ(bel, design->chip.getBelByName(name));
bel_count++;
}
ASSERT_EQ(bel_count, 5414);
}
TEST_F(UP5KTest, wire_names)
TEST_F(UP5KTest, wire_names)
{
int wire_count = 0;
for (auto wire : design->chip.getWires()) {
auto name = design->chip.getWireName(wire);
assert(wire == design->chip.getWireByName(name));
wire_count++;
}
ASSERT_EQ(wire_count,103383);
int wire_count = 0;
for (auto wire : design->chip.getWires()) {
auto name = design->chip.getWireName(wire);
assert(wire == design->chip.getWireByName(name));
wire_count++;
}
ASSERT_EQ(wire_count, 103383);
}
TEST_F(UP5KTest, pip_names)
TEST_F(UP5KTest, pip_names)
{
int pip_count = 0;
for (auto pip : design->chip.getPips()) {
auto name = design->chip.getPipName(pip);
assert(pip == design->chip.getPipByName(name));
pip_count++;
}
ASSERT_EQ(pip_count,1219104);
int pip_count = 0;
for (auto pip : design->chip.getPips()) {
auto name = design->chip.getPipName(pip);
assert(pip == design->chip.getPipByName(name));
pip_count++;
}
ASSERT_EQ(pip_count, 1219104);
}
TEST_F(UP5KTest, uphill_to_downhill)
TEST_F(UP5KTest, uphill_to_downhill)
{
for (auto dst : design->chip.getWires()) {
for (auto uphill_pip : design->chip.getPipsUphill(dst)) {
bool found_downhill = false;
for (auto downhill_pip : design->chip.getPipsDownhill(
design->chip.getPipSrcWire(uphill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_downhill);
found_downhill = true;
}
}
ASSERT_TRUE(found_downhill);
}
}
for (auto dst : design->chip.getWires()) {
for (auto uphill_pip : design->chip.getPipsUphill(dst)) {
bool found_downhill = false;
for (auto downhill_pip : design->chip.getPipsDownhill(
design->chip.getPipSrcWire(uphill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_downhill);
found_downhill = true;
}
}
ASSERT_TRUE(found_downhill);
}
}
}
TEST_F(UP5KTest, downhill_to_uphill)
TEST_F(UP5KTest, downhill_to_uphill)
{
for (auto dst : design->chip.getWires()) {
for (auto downhill_pip : design->chip.getPipsDownhill(dst)) {
bool found_uphill = false;
for (auto uphill_pip : design->chip.getPipsUphill(
design->chip.getPipDstWire(downhill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_uphill);
found_uphill = true;
}
}
ASSERT_TRUE(found_uphill);
}
}
for (auto dst : design->chip.getWires()) {
for (auto downhill_pip : design->chip.getPipsDownhill(dst)) {
bool found_uphill = false;
for (auto uphill_pip : design->chip.getPipsUphill(
design->chip.getPipDstWire(downhill_pip))) {
if (uphill_pip == downhill_pip) {
ASSERT_FALSE(found_uphill);
found_uphill = true;
}
}
ASSERT_TRUE(found_uphill);
}
}
}