Write tests to replace -test option from main

ice40/main.cc

@@ -65,7 +65,6 @@ int main(int argc, char *argv[])
 
     po::options_description options("Allowed options");
     options.add_options()("help,h", "show help");
-    options.add_options()("test", "just a check");
     options.add_options()("gui", "start gui");
     options.add_options()("svg", "dump SVG file");
     options.add_options()("pack", "pack design prior to place and route");
@@ -177,66 +176,6 @@ int main(int argc, char *argv[])
     python_export_global("design", design);
     python_export_global("chip", design.chip);
 
-    if (vm.count("test")) {
-        int bel_count = 0, wire_count = 0, pip_count = 0;
-
-        std::cout << "Checking bel names.\n";
-        for (auto bel : design.chip.getBels()) {
-            auto name = design.chip.getBelName(bel);
-            assert(bel == design.chip.getBelByName(name));
-            bel_count++;
-        }
-        std::cout << "  checked " << bel_count << " bels.\n";
-
-        std::cout << "Checking wire names.\n";
-        for (auto wire : design.chip.getWires()) {
-            auto name = design.chip.getWireName(wire);
-            assert(wire == design.chip.getWireByName(name));
-            wire_count++;
-        }
-        std::cout << "  checked " << wire_count << " wires.\n";
-
-        std::cout << "Checking pip names.\n";
-        for (auto pip : design.chip.getPips()) {
-            auto name = design.chip.getPipName(pip);
-            assert(pip == design.chip.getPipByName(name));
-            pip_count++;
-        }
-        std::cout << "  checked " << pip_count << " pips.\n";
-
-        std::cout << "Checking uphill -> downhill consistency.\n";
-        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(!found_downhill);
-                        found_downhill = true;
-                    }
-                }
-                assert(found_downhill);
-            }
-        }
-
-        std::cout << "Checking downhill -> uphill consistency.\n";
-        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(!found_uphill);
-                        found_uphill = true;
-                    }
-                }
-                assert(found_uphill);
-            }
-        }
-
-        return 0;
-    }
-
     if (vm.count("svg")) {
         std::cout << "<svg xmlns=\"http://www.w3.org/2000/svg\" "
                      "xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n";

tests/dummy/main.cc

@@ -6,13 +6,3 @@ int main(int argc, char **argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
-
-TEST(example, sum_zero) {
-  auto result = 0;
-  ASSERT_EQ(result, 0);
-}
-
-TEST(example, sum_five) {
-  auto result = 15;
-  ASSERT_EQ(result, 15);
-}

tests/ice40/hx1k.cc

@@ -0,0 +1,88 @@
+#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;
+  }
+
+  ChipArgs chipArgs;
+  Design *design;
+};
+
+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);
+}
+
+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);
+}
+
+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);
+}
+
+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);
+      }
+  }
+}
+
+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);
+      }
+  }
+}

tests/ice40/hx8k.cc

@@ -0,0 +1,88 @@
+#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;
+  }
+
+  ChipArgs chipArgs;
+  Design *design;
+};
+
+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);
+}
+
+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);
+}
+
+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);
+}
+
+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);
+      }
+  }
+}
+
+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);
+      }
+  }
+}

tests/ice40/lp1k.cc

@@ -0,0 +1,88 @@
+#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;
+  }
+
+  ChipArgs chipArgs;
+  Design *design;
+};
+
+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);
+}
+
+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);
+}
+
+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);
+}
+
+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);
+      }
+  }
+}
+
+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);
+      }
+  }
+}

tests/ice40/lp384.cc

@@ -0,0 +1,88 @@
+#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;
+  }
+
+  ChipArgs chipArgs;
+  Design *design;
+};
+
+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);
+}
+
+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);
+}
+
+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);
+}
+
+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);
+      }
+  }
+}
+
+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);
+      }
+  }
+}

tests/ice40/lp8k.cc

@@ -0,0 +1,88 @@
+#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;
+  }
+
+  ChipArgs chipArgs;
+  Design *design;
+};
+
+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);
+}
+
+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);
+}
+
+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);
+}
+
+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);
+      }
+  }
+}
+
+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);
+      }
+  }
+}

tests/ice40/main.cc

@@ -1,18 +1,7 @@
 #include "gtest/gtest.h"
-
 #include <vector>
 
 int main(int argc, char **argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
-
-TEST(example, sum_zero) {
-  auto result = 0;
-  ASSERT_EQ(result, 0);
-}
-
-TEST(example, sum_five) {
-  auto result = 15;
-  ASSERT_EQ(result, 15);
-}

tests/ice40/up5k.cc

@@ -0,0 +1,88 @@
+#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;
+  }
+
+  ChipArgs chipArgs;
+  Design *design;
+};
+
+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);
+}
+
+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);
+}
+
+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);
+}
+
+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);
+      }
+  }
+}
+
+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);
+      }
+  }
+}