clangformat cleanup

8 files changed, 399 insertions, 403 deletions

diff --git a/tests/dummy/main.cc b/tests/dummy/main.cc
index 13f071ce..1270ccdf 100644
--- a/tests/dummy/main.cc
+++ b/tests/dummy/main.cc
@@ -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();
 }
diff --git a/tests/ice40/hx1k.cc b/tests/ice40/hx1k.cc
index deea1d34..ceae4c45 100644
--- a/tests/ice40/hx1k.cc
+++ b/tests/ice40/hx1k.cc
@@ -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);
+    }
+
+    virtual void TearDown() { delete design; }
 
-  ChipArgs chipArgs;
-  Design *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);
+        }
+    }
 }
diff --git a/tests/ice40/hx8k.cc b/tests/ice40/hx8k.cc
index 7c0ae167..060e34dd 100644
--- a/tests/ice40/hx8k.cc
+++ b/tests/ice40/hx8k.cc
@@ -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);
+    }
+
+    virtual void TearDown() { delete design; }
 
-  ChipArgs chipArgs;
-  Design *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);
+        }
+    }
 }
diff --git a/tests/ice40/lp1k.cc b/tests/ice40/lp1k.cc
index 700b593d..85b35652 100644
--- a/tests/ice40/lp1k.cc
+++ b/tests/ice40/lp1k.cc
@@ -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);
+    }
+
+    virtual void TearDown() { delete design; }
 
-  ChipArgs chipArgs;
-  Design *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);
+        }
+    }
 }
diff --git a/tests/ice40/lp384.cc b/tests/ice40/lp384.cc
index 481142b9..c29938f1 100644
--- a/tests/ice40/lp384.cc
+++ b/tests/ice40/lp384.cc
@@ -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);
+    }
+
+    virtual void TearDown() { delete design; }
 
-  ChipArgs chipArgs;
-  Design *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);
+        }
+    }
 }
diff --git a/tests/ice40/lp8k.cc b/tests/ice40/lp8k.cc
index 5dbb7674..ca2fc424 100644
--- a/tests/ice40/lp8k.cc
+++ b/tests/ice40/lp8k.cc
@@ -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);
+    }
+
+    virtual void TearDown() { delete design; }
 
-  ChipArgs chipArgs;
-  Design *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);
+        }
+    }
 }
diff --git a/tests/ice40/main.cc b/tests/ice40/main.cc
index 465bcd41..e85c836a 100644
--- a/tests/ice40/main.cc
+++ b/tests/ice40/main.cc
@@ -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();
 }
diff --git a/tests/ice40/up5k.cc b/tests/ice40/up5k.cc
index eb6dd732..38bb30fd 100644
--- a/tests/ice40/up5k.cc
+++ b/tests/ice40/up5k.cc
@@ -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);
+    }
+
+    virtual void TearDown() { delete design; }
 
-  ChipArgs chipArgs;
-  Design *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);
+        }
+    }
 }