Merge branch 'master' into add-new-system-tests-for-next-and-call

Author: tianqi77

Team20/Code20/source/PKB.cpp renamed to Team20/Code20/source/Pkb.cpp

@@ -154,9 +154,21 @@ void Pkb::deriveTables() {
       PkbTableTransformers::pseudoinvertFlattenKeys<LINE_NO, NEXT>(
           this->nextsTable);
 
-  this->closeFollowTable = PkbTableTransformers::close(this->followTable);
-  this->closeParentTable = PkbTableTransformers::close(this->parentTable);
-  this->closePrevLineTable = PkbTableTransformers::close(prevLineTable);
+  if (!followTable.map.empty()) {
+    this->closeFollowTable = PkbTableTransformers::closeWarshall(
+        PkbTableTransformers::closeOnce(this->followTable));
+  }
+
+  if (!parentTable.map.empty()) {
+    this->closeParentTable = PkbTableTransformers::closeWarshall(
+        PkbTableTransformers::closeOnce(this->parentTable));
+  }
+
+  if (!prevLineTable.map.empty()) {
+    this->closePrevLineTable = PkbTableTransformers::closeWarshall(
+        PkbTableTransformers::closeOnce(prevLineTable));
+  }
+
   this->closeChildrenTable =
       PkbTableTransformers::closeFlatten<PARENT>(childrenTable);
   this->closeCallsTable =
@@ -344,7 +356,7 @@ void Pkb::deriveAllAffectsBipRelatedTables() {
 void Pkb::deriveAllCloseAffectsBipRelatedTables() {
   deriveAllAffectsBipRelatedTables();
   this->closeAffectsBipTable =
-      PkbTableTransformers::closeFlatten<LINE_NO>(this->affectsBipTable);
+      PkbTableTransformers::closeWarshall(this->affectsBipTable);
   this->closeInvertAffectsBipTable =
       PkbTableTransformers::pseudoinvertFlattenKeys<LINE_NO, LINE_NO>(
           this->closeAffectsBipTable);

Team20/Code20/source/PkbTableTransformers.h

@@ -17,22 +17,6 @@ class PkbTableTransformers {
   static std::vector<std::vector<bool>> closeWarshallReachabilityMatrix(
       KeysTable<std::size_t, std::unordered_set<std::size_t>> keysTable);
 
-  /** @brief Composes keysTable with itself, once.
-  Where `result` is the returned value, firstly copies keysTable.map to `result`
-  by iterating through each key in keysTable.keys to get the value mapped by
-  keysTable.map, to insert the key-value pair in `result`. Then, iterating
-  through each key in keysTable.keys to get the key-values pair p1 in `result`,
-  for each p1.value in p1.values, for each key-values pair p2 in `result` with
-  p2.key equivalent to p1.value, concatenates the unordered_set of values
-  `result[p1.key]` with p2.values.
-  @param keysTable An associative container that contains key-values pairs with
-  unique keys. There is a binary relation between keys and values.
-  @return The composition of keysTable with itself.
-  */
-  template <class T>
-  static KeysTable<T, std::unordered_set<T>>
-  closeOnce(KeysTable<T, T> keysTable);
-
   /** @brief Auxiliary function of PkbTableTransformers::closeFlatten. For
   algorithm details, see PkbTableTransformers::closeFlatten.
   @param parent The parent for which all its descendants will be recursively
@@ -49,6 +33,22 @@ class PkbTableTransformers {
                   KeysTable<T, std::unordered_set<T>> &mapCloseFlattened);
 
 public:
+  /** @brief Composes keysTable with itself, once.
+  Where `result` is the returned value, firstly copies keysTable.map to `result`
+  by iterating through each key in keysTable.keys to get the value mapped by
+  keysTable.map, to insert the key-value pair in `result`. Then, iterating
+  through each key in keysTable.keys to get the key-values pair p1 in `result`,
+  for each p1.value in p1.values, for each key-values pair p2 in `result` with
+  p2.key equivalent to p1.value, concatenates the unordered_set of values
+  `result[p1.key]` with p2.values.
+  @param keysTable An associative container that contains key-values pairs with
+  unique keys. There is a binary relation between keys and values.
+  @return The composition of keysTable with itself.
+  */
+  template <class T>
+  static KeysTable<T, std::unordered_set<T>>
+  closeOnce(KeysTable<T, T> keysTable);
+
   /** @brief Composes two tables, where variantTable maps to a `std::variant`.
   @param variantTable Table that maps keys `T` to a `std::variant` of values `V`
   and intermediate values `U`.

Team20/Code20/source/SetUpTests.cpp

@@ -573,6 +573,34 @@ SetUpTests::SetUpTests(Pkb &pkb, TestNumber testNumber) {
      26	a = k + c}
      */
 
+    pkbTables->addFollow(l1, l2);
+    pkbTables->addFollow(l2, l3);
+    pkbTables->addFollow(l3, l6);
+    pkbTables->addFollow(l4, l5);
+    pkbTables->addFollow(l7, l8);
+    pkbTables->addFollow(l8, l9);
+    pkbTables->addFollow(l9, l10);
+    pkbTables->addFollow(l10, l11);
+    pkbTables->addFollow(l12, l13);
+    pkbTables->addFollow(l13, l14);
+    pkbTables->addFollow(l14, l25);
+    pkbTables->addFollow(l15, l23);
+    pkbTables->addFollow(l16, l17);
+    pkbTables->addFollow(l17, l19);
+
+    pkbTables->addParent(l4, l3);
+    pkbTables->addParent(l5, l3);
+    pkbTables->addParent(l15, l14);
+    pkbTables->addParent(l23, l14);
+    pkbTables->addParent(l16, l15);
+    pkbTables->addParent(l17, l15);
+    pkbTables->addParent(l19, l15);
+    pkbTables->addParent(l22, l15);
+    pkbTables->addParent(l18, l17);
+    pkbTables->addParent(l20, l19);
+    pkbTables->addParent(l21, l19);
+    pkbTables->addParent(l24, l23);
+
     Pkb::VAR vx = "x", vy = "y", vr = "r", vm = "m", vq = "q", vt = "t",
              vk = "k", vn = "n", vc = "c", va = "a";
     Pkb::PROC paux = "aux", pmain = "main", pcomplicate = "complicate",