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

7
tests/dummy/main.cc
View File

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

131
tests/ice40/hx8k.cc
View File

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

131
tests/ice40/lp1k.cc
View File

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

131
tests/ice40/lp384.cc
View File

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

131
tests/ice40/lp8k.cc
View File

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

9
tests/ice40/main.cc
View File

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