test build on MacOs

k2-fsa · Apr 25, 2020 · 1036d7b · 1036d7b
1 parent 49759d2
commit 1036d7b
Show file tree

Hide file tree

Showing 3 changed files with 158 additions and 40 deletions.
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -45,4 +45,4 @@ jobs:
       - name: Test
         shell: bash
         working-directory: ${{runner.workspace}}/build
-        run: ctest --build-config $BUILD_TYPE
+        run: CTEST_OUTPUT_ON_FAILURE=1 ctest --build-config $BUILD_TYPE 
diff --git a/k2/csrc/properties.cc b/k2/csrc/properties.cc
@@ -7,9 +7,10 @@
 
 #include "k2/csrc/properties.h"
 
-#include <vector>
-#include <unordered_set>
 #include <algorithm>
+#include <iostream>
+#include <unordered_set>
+#include <vector>
 
 #include "k2/csrc/fsa.h"
 
@@ -98,15 +99,18 @@ bool IsConnected(const Fsa &fsa) {
       accessible.end())
     return false;
 
+  std::cout << "accessible done........." << std::endl;
   // reuse `accessible` to process co-accessible situation.
-  std::fill(accessible.begin(), accessible.end(), false);
-  accessible[num_states - 1] = true;  // the final state
+  std::vector<bool> co_accessible(num_states, false);
+  co_accessible[num_states - 1] = true;  // the final state
   for (int32_t i = num_states - 1; i >= 0; --i) {
     const auto &arc = fsa.arcs[i];
-    if (!accessible[arc.dest_state]) return false;
-    accessible[arc.src_state] = true;
+    if (!co_accessible[arc.dest_state]) return false;
+    co_accessible[arc.src_state] = true;
   }
-  return std::find(accessible.begin(), accessible.end(), false) ==
-         accessible.end();
+  std::cout << "co-accessible done........." << std::endl;
+  // reuse `accessible` to process co-accessible situation.
+  return std::find(co_accessible.begin(), co_accessible.end(), false) ==
+         co_accessible.end();
 }
 }  // namespace k2
diff --git a/k2/csrc/properties_test.cc b/k2/csrc/properties_test.cc
@@ -31,7 +31,11 @@ TEST(Properties, IsNotValid) {
   // only epsilon arcs enter the final state
   {
     Fsa fsa;
-    std::vector<Arc> arcs = {{0, 1, 0}, {0, 2, 1}, {1, 2, 0}, };
+    std::vector<Arc> arcs = {
+        {0, 1, 0},
+        {0, 2, 1},
+        {1, 2, 0},
+    };
     std::vector<Range> leaving_arcs = {{0, 2}, {2, 3}, {3, 3}};
     fsa.leaving_arcs = std::move(leaving_arcs);
     fsa.arcs = std::move(arcs);
@@ -42,8 +46,17 @@ TEST(Properties, IsNotValid) {
   // every state contains at least one arc except the final state
   {
     Fsa fsa;
-    std::vector<Arc> arcs = {{0, 1, 0}, {0, 2, 0}, {2, 3, 0}, };
-    std::vector<Range> leaving_arcs = {{0, 2}, {2, 2}, {2, 3}, {3, 3}, };
+    std::vector<Arc> arcs = {
+        {0, 1, 0},
+        {0, 2, 0},
+        {2, 3, 0},
+    };
+    std::vector<Range> leaving_arcs = {
+        {0, 2},
+        {2, 2},
+        {2, 3},
+        {3, 3},
+    };
     fsa.leaving_arcs = std::move(leaving_arcs);
     fsa.arcs = std::move(arcs);
     bool is_valid = IsValid(fsa);
@@ -53,8 +66,15 @@ TEST(Properties, IsNotValid) {
   // every state contains at least one arc except the final state (another case)
   {
     Fsa fsa;
-    std::vector<Arc> arcs = {{0, 1, 0}, {0, 2, 0}, };
-    std::vector<Range> leaving_arcs = {{0, 2}, {2, 2}, {2, 2}, };
+    std::vector<Arc> arcs = {
+        {0, 1, 0},
+        {0, 2, 0},
+    };
+    std::vector<Range> leaving_arcs = {
+        {0, 2},
+        {2, 2},
+        {2, 2},
+    };
     fsa.leaving_arcs = std::move(leaving_arcs);
     fsa.arcs = std::move(arcs);
     bool is_valid = IsValid(fsa);
@@ -64,8 +84,16 @@ TEST(Properties, IsNotValid) {
   // `leaving_arcs` and `arcs` in this state are not consistent
   {
     Fsa fsa;
-    std::vector<Arc> arcs = {{0, 1, 0}, {0, 2, 0}, };
-    std::vector<Range> leaving_arcs = {{0, 2}, {3, 3}, {2, 3}, {3, 3}, };
+    std::vector<Arc> arcs = {
+        {0, 1, 0},
+        {0, 2, 0},
+    };
+    std::vector<Range> leaving_arcs = {
+        {0, 2},
+        {3, 3},
+        {2, 3},
+        {3, 3},
+    };
     fsa.leaving_arcs = std::move(leaving_arcs);
     fsa.arcs = std::move(arcs);
     bool is_valid = IsValid(fsa);
@@ -75,8 +103,16 @@ TEST(Properties, IsNotValid) {
   // `leaving_arcs` and `arcs` in this state are not consistent (another case)
   {
     Fsa fsa;
-    std::vector<Arc> arcs = {{0, 1, 0}, {0, 2, 0}, {1, 2, 0}, };
-    std::vector<Range> leaving_arcs = {{0, 2}, {2, 3}, {4, 4}, };
+    std::vector<Arc> arcs = {
+        {0, 1, 0},
+        {0, 2, 0},
+        {1, 2, 0},
+    };
+    std::vector<Range> leaving_arcs = {
+        {0, 2},
+        {2, 3},
+        {4, 4},
+    };
     fsa.leaving_arcs = std::move(leaving_arcs);
     fsa.arcs = std::move(arcs);
     bool is_valid = IsValid(fsa);
@@ -93,7 +129,11 @@ TEST(Properties, IsValid) {
   }
 
   {
-    std::vector<Arc> arcs = {{0, 1, 0}, {0, 2, 0}, {1, 2, 0}, };
+    std::vector<Arc> arcs = {
+        {0, 1, 0},
+        {0, 2, 0},
+        {1, 2, 0},
+    };
     std::vector<Range> leaving_arcs = {{0, 2}, {2, 3}, {3, 3}};
     Fsa fsa;
     fsa.leaving_arcs = std::move(leaving_arcs);
@@ -104,8 +144,15 @@ TEST(Properties, IsValid) {
 }
 
 TEST(Properties, IsNotTopSorted) {
-  std::vector<Arc> arcs = {{0, 1, 0}, {0, 2, 0}, {2, 1, 0}, };
-  std::vector<Range> leaving_arcs = {{0, 2}, {2, 3}, };
+  std::vector<Arc> arcs = {
+      {0, 1, 0},
+      {0, 2, 0},
+      {2, 1, 0},
+  };
+  std::vector<Range> leaving_arcs = {
+      {0, 2},
+      {2, 3},
+  };
   Fsa fsa;
   fsa.leaving_arcs = std::move(leaving_arcs);
   fsa.arcs = std::move(arcs);
@@ -114,8 +161,15 @@ TEST(Properties, IsNotTopSorted) {
 }
 
 TEST(Properties, IsTopSorted) {
-  std::vector<Arc> arcs = {{0, 1, 0}, {0, 2, 0}, {1, 2, 0}, };
-  std::vector<Range> leaving_arcs = {{0, 2}, {2, 3}, };
+  std::vector<Arc> arcs = {
+      {0, 1, 0},
+      {0, 2, 0},
+      {1, 2, 0},
+  };
+  std::vector<Range> leaving_arcs = {
+      {0, 2},
+      {2, 3},
+  };
   Fsa fsa;
   fsa.leaving_arcs = std::move(leaving_arcs);
   fsa.arcs = std::move(arcs);
@@ -124,8 +178,15 @@ TEST(Properties, IsTopSorted) {
 }
 
 TEST(Properties, HasNoSelfLoops) {
-  std::vector<Arc> arcs = {{0, 1, 0}, {0, 2, 0}, {1, 2, 0}, };
-  std::vector<Range> leaving_arcs = {{0, 2}, {2, 3}, };
+  std::vector<Arc> arcs = {
+      {0, 1, 0},
+      {0, 2, 0},
+      {1, 2, 0},
+  };
+  std::vector<Range> leaving_arcs = {
+      {0, 2},
+      {2, 3},
+  };
   Fsa fsa;
   fsa.leaving_arcs = std::move(leaving_arcs);
   fsa.arcs = std::move(arcs);
@@ -134,8 +195,15 @@ TEST(Properties, HasNoSelfLoops) {
 }
 
 TEST(Properties, HasSelfLoops) {
-  std::vector<Arc> arcs = {{0, 1, 0}, {1, 2, 0}, {1, 1, 0}, };
-  std::vector<Range> leaving_arcs = {{0, 1}, {1, 3}, };
+  std::vector<Arc> arcs = {
+      {0, 1, 0},
+      {1, 2, 0},
+      {1, 1, 0},
+  };
+  std::vector<Range> leaving_arcs = {
+      {0, 1},
+      {1, 3},
+  };
   Fsa fsa;
   fsa.leaving_arcs = std::move(leaving_arcs);
   fsa.arcs = std::move(arcs);
@@ -144,8 +212,15 @@ TEST(Properties, HasSelfLoops) {
 }
 
 TEST(Properties, IsNotDeterministic) {
-  std::vector<Arc> arcs = {{0, 1, 2}, {1, 2, 0}, {1, 3, 0}, };
-  std::vector<Range> leaving_arcs = {{0, 1}, {1, 3}, };
+  std::vector<Arc> arcs = {
+      {0, 1, 2},
+      {1, 2, 0},
+      {1, 3, 0},
+  };
+  std::vector<Range> leaving_arcs = {
+      {0, 1},
+      {1, 3},
+  };
   Fsa fsa;
   fsa.leaving_arcs = std::move(leaving_arcs);
   fsa.arcs = std::move(arcs);
@@ -154,8 +229,15 @@ TEST(Properties, IsNotDeterministic) {
 }
 
 TEST(Properties, IsDeterministic) {
-  std::vector<Arc> arcs = {{0, 1, 2}, {1, 2, 0}, {1, 3, 2}, };
-  std::vector<Range> leaving_arcs = {{0, 1}, {1, 3}, };
+  std::vector<Arc> arcs = {
+      {0, 1, 2},
+      {1, 2, 0},
+      {1, 3, 2},
+  };
+  std::vector<Range> leaving_arcs = {
+      {0, 1},
+      {1, 3},
+  };
   Fsa fsa;
   fsa.leaving_arcs = std::move(leaving_arcs);
   fsa.arcs = std::move(arcs);
@@ -164,8 +246,15 @@ TEST(Properties, IsDeterministic) {
 }
 
 TEST(Properties, IsNotEpsilonFree) {
-  std::vector<Arc> arcs = {{0, 1, 2}, {0, 2, 0}, {1, 2, 1}, };
-  std::vector<Range> leaving_arcs = {{0, 2}, {2, 3}, };
+  std::vector<Arc> arcs = {
+      {0, 1, 2},
+      {0, 2, 0},
+      {1, 2, 1},
+  };
+  std::vector<Range> leaving_arcs = {
+      {0, 2},
+      {2, 3},
+  };
   Fsa fsa;
   fsa.leaving_arcs = std::move(leaving_arcs);
   fsa.arcs = std::move(arcs);
@@ -174,8 +263,15 @@ TEST(Properties, IsNotEpsilonFree) {
 }
 
 TEST(Properties, IsEpsilonFree) {
-  std::vector<Arc> arcs = {{0, 1, 2}, {0, 2, 1}, {1, 2, 1}, };
-  std::vector<Range> leaving_arcs = {{0, 2}, {2, 3}, };
+  std::vector<Arc> arcs = {
+      {0, 1, 2},
+      {0, 2, 1},
+      {1, 2, 1},
+  };
+  std::vector<Range> leaving_arcs = {
+      {0, 2},
+      {2, 3},
+  };
   Fsa fsa;
   fsa.leaving_arcs = std::move(leaving_arcs);
   fsa.arcs = std::move(arcs);
@@ -186,8 +282,14 @@ TEST(Properties, IsEpsilonFree) {
 TEST(Properties, IsNoConnected) {
   // state is not accessible
   {
-    std::vector<Arc> arcs = {{0, 2, 0}, };
-    std::vector<Range> leaving_arcs = {{0, 1}, {1, 1}, {1, 1}, };
+    std::vector<Arc> arcs = {
+        {0, 2, 0},
+    };
+    std::vector<Range> leaving_arcs = {
+        {0, 1},
+        {1, 1},
+        {1, 1},
+    };
     Fsa fsa;
     fsa.leaving_arcs = std::move(leaving_arcs);
     fsa.arcs = std::move(arcs);
@@ -197,8 +299,15 @@ TEST(Properties, IsNoConnected) {
 
   // state is not co-accessible
   {
-    std::vector<Arc> arcs = {{0, 1, 0}, {0, 2, 0}, };
-    std::vector<Range> leaving_arcs = {{0, 2}, {2, 2}, {2, 2}, };
+    std::vector<Arc> arcs = {
+        {0, 1, 0},
+        {0, 2, 0},
+    };
+    std::vector<Range> leaving_arcs = {
+        {0, 2},
+        {2, 2},
+        {2, 2},
+    };
     Fsa fsa;
     fsa.leaving_arcs = std::move(leaving_arcs);
     fsa.arcs = std::move(arcs);
@@ -208,7 +317,12 @@ TEST(Properties, IsNoConnected) {
 }
 
 TEST(Properties, IsConnected) {
-  std::vector<Arc> arcs = {{0, 1, 0}, {0, 3, 0}, {1, 2, 0}, {2, 3, 0}, };
+  std::vector<Arc> arcs = {
+      {0, 1, 0},
+      {0, 3, 0},
+      {1, 2, 0},
+      {2, 3, 0},
+  };
   std::vector<Range> leaving_arcs = {{0, 2}, {2, 3}, {3, 4}, {4, 4}};
   Fsa fsa;
   fsa.leaving_arcs = std::move(leaving_arcs);