Move sharing map unit tests to catch

Author: danpoe

unit/Makefile

@@ -28,6 +28,7 @@ SRC += unit_tests.cpp \
        java_bytecode/inherited_static_fields/inherited_static_fields.cpp \
        pointer-analysis/custom_value_set_analysis.cpp \
        sharing_node.cpp \
+       sharing_map.cpp \
        solvers/refinement/string_constraint_generator_valueof/calculate_max_string_length.cpp \
        solvers/refinement/string_constraint_generator_valueof/get_numeric_value_from_character.cpp \
        solvers/refinement/string_constraint_generator_valueof/is_digit_with_radix.cpp \

unit/sharing_map.cpp

@@ -1,7 +1,13 @@
-#include <iostream>
-#include <cassert>
+/*******************************************************************\
+
+Module: Unit tests for sharing map
+
+Author: Daniel Poetzl
+
+\*******************************************************************/
 
 #include <util/sharing_map.h>
+#include <testing-utils/catch.hpp>
 
 typedef sharing_mapt<irep_idt, std::string, irep_id_hash> smt;
 
@@ -24,50 +30,48 @@ void fill2(smt &sm)
 
 void sharing_map_interface_test()
 {
-  std::cout << "Running interface test" << std::endl;
-
-  // empty map
+  SECTION("Empty map")
   {
     smt sm;
 
-    assert(sm.empty());
-    assert(sm.size()==0);
-    assert(!sm.has_key("i"));
+    REQUIRE(sm.empty());
+    REQUIRE(sm.size() == 0);
+    REQUIRE(!sm.has_key("i"));
   }
 
-  // insert elements
+  SECTION("Insert elements")
   {
     smt sm;
 
     smt::const_find_type r1=sm.insert(std::make_pair("i", "0"));
-    assert(r1.second);
+    REQUIRE(r1.second);
 
     smt::const_find_type r2=sm.insert("j", "1");
-    assert(r2.second);
+    REQUIRE(r2.second);
 
     smt::const_find_type r3=sm.insert(std::make_pair("i", "0"));
-    assert(!r3.second);
+    REQUIRE(!r3.second);
 
-    assert(sm.size()==2);
-    assert(!sm.empty());
+    REQUIRE(sm.size() == 2);
+    REQUIRE(!sm.empty());
   }
 
-  // place elements
+  SECTION("Place elements")
   {
     smt sm1;
     smt sm2(sm1);
 
     smt::find_type r1=sm1.place("i", "0");
-    assert(r1.second);
-    assert(!sm2.has_key("i"));    
+    REQUIRE(r1.second);
+    REQUIRE(!sm2.has_key("i"));
 
     std::string &s1=r1.first;
     s1="1";
 
-    assert(sm1.at("i")=="1");
+    REQUIRE(sm1.at("i") == "1");
   }
 
-  // retrieve elements
+  SECTION("Retrieve elements")
   {
     smt sm;
     sm.insert("i", "0");
@@ -77,109 +81,107 @@ void sharing_map_interface_test()
 
     std::string s;
     s=sm2.at("i");
-    assert(s=="0");
+    REQUIRE(s == "0");
 
     try {
       sm2.at("k");
-      assert(false);
+      REQUIRE(false);
     } catch (...) {}
 
     s=sm2.at("j");
-    assert(s=="1");
+    REQUIRE(s == "1");
 
-    assert(sm.has_key("i"));
-    assert(sm.has_key("j"));
-    assert(!sm.has_key("k"));
+    REQUIRE(sm.has_key("i"));
+    REQUIRE(sm.has_key("j"));
+    REQUIRE(!sm.has_key("k"));
 
     std::string &s2=sm.at("i");
     s2="3";
-    assert(sm2.at("i")=="3");
+    REQUIRE(sm2.at("i") == "3");
 
-    assert(sm.size()==2);
+    REQUIRE(sm.size() == 2);
 
     smt::find_type r=sm.find("i");
-    assert(r.second);
+    REQUIRE(r.second);
     r.first="4";
-    assert(sm2.at("i")=="4");
+    REQUIRE(sm2.at("i") == "4");
 
     smt::const_find_type rc=sm2.find("k");
-    assert(!rc.second);
+    REQUIRE(!rc.second);
   }
 
-  // remove elements
+  SECTION("Remove elements")
   {
     smt sm;
     sm.insert("i", "0");
     sm.insert("j", "1");
 
-    assert(sm.erase("k")==0);
-    assert(sm.size()==2);
+    REQUIRE(sm.erase("k") == 0);
+    REQUIRE(sm.size() == 2);
 
-    assert(sm.erase("i")==1);
-    assert(!sm.has_key("i"));
+    REQUIRE(sm.erase("i") == 1);
+    REQUIRE(!sm.has_key("i"));
 
-    assert(sm.erase("j")==1);
-    assert(!sm.has_key("j"));
+    REQUIRE(sm.erase("j") == 1);
+    REQUIRE(!sm.has_key("j"));
 
     sm.insert("i", "0");
     sm.insert("j", "1");
 
     smt sm3(sm);
-  
-    assert(sm.has_key("i"));
-    assert(sm.has_key("j"));
-    assert(sm3.has_key("i"));
-    assert(sm3.has_key("j"));
+
+    REQUIRE(sm.has_key("i"));
+    REQUIRE(sm.has_key("j"));
+    REQUIRE(sm3.has_key("i"));
+    REQUIRE(sm3.has_key("j"));
 
     sm.erase("i");
 
-    assert(!sm.has_key("i"));
-    assert(sm.has_key("j"));
+    REQUIRE(!sm.has_key("i"));
+    REQUIRE(sm.has_key("j"));
 
-    assert(sm3.has_key("i"));
-    assert(sm3.has_key("j"));
+    REQUIRE(sm3.has_key("i"));
+    REQUIRE(sm3.has_key("j"));
 
     sm3.erase("i");
-    assert(!sm3.has_key("i"));
+    REQUIRE(!sm3.has_key("i"));
   }
 
-  // operator[]
+  SECTION("Subscript operator")
   {
     smt sm;
 
     sm["i"];
-    assert(sm.has_key("i"));
+    REQUIRE(sm.has_key("i"));
 
     sm["i"]="0";
-    assert(sm.at("i")=="0");
+    REQUIRE(sm.at("i") == "0");
 
     sm["j"]="1";
-    assert(sm.at("j")=="1");
+    REQUIRE(sm.at("j") == "1");
   }
 }
 
 void sharing_map_copy_test()
 {
-  std::cout << "Running copy test" << std::endl;
-
   smt sm1;
   const smt &sm2=sm1;
 
   fill(sm1);
 
-  assert(sm2.find("i").first=="0");
-  assert(sm2.find("j").first=="1");
-  assert(sm2.find("k").first=="2");
+  REQUIRE(sm2.find("i").first == "0");
+  REQUIRE(sm2.find("j").first == "1");
+  REQUIRE(sm2.find("k").first == "2");
 
   smt sm3=sm1;
   const smt &sm4=sm3;
 
-  assert(sm3.erase("l")==0);
-  assert(sm3.erase("i")==1);
+  REQUIRE(sm3.erase("l") == 0);
+  REQUIRE(sm3.erase("i") == 1);
 
-  assert(!sm4.has_key("i"));
+  REQUIRE(!sm4.has_key("i"));
   sm3.place("i", "3");
-  assert(sm4.find("i").first=="3");
+  REQUIRE(sm4.find("i").first == "3");
 }
 
 class some_keyt
@@ -208,8 +210,6 @@ class some_key_hash
 
 void sharing_map_collision_test()
 {
-  std::cout << "Running collision test" << std::endl;
-
   typedef sharing_mapt<some_keyt, std::string, some_key_hash> smt;
 
   smt sm;
@@ -223,20 +223,18 @@ void sharing_map_collision_test()
 
   sm.erase(8);
 
-  assert(sm.has_key(0));
-  assert(sm.has_key(16));
+  REQUIRE(sm.has_key(0));
+  REQUIRE(sm.has_key(16));
 
-  assert(sm.has_key(1));
-  assert(sm.has_key(2));
+  REQUIRE(sm.has_key(1));
+  REQUIRE(sm.has_key(2));
 
-  assert(!sm.has_key(8));
+  REQUIRE(!sm.has_key(8));
 }
 
 void sharing_map_view_test()
 {
-  std::cout << "Running view test" << std::endl;
-
-  // view test
+  SECTION("View")
   {
     smt sm;
 
@@ -245,10 +243,10 @@ void sharing_map_view_test()
     smt::viewt view;
     sm.get_view(view);
 
-    assert(view.size()==3);
+    REQUIRE(view.size() == 3);
   }
 
-  // delta view test (no sharing, same keys)
+  SECTION("Delta view (no sharing, same keys)")
   {
     smt sm1;
     fill(sm1);
@@ -259,14 +257,14 @@ void sharing_map_view_test()
     smt::delta_viewt delta_view;
 
     sm1.get_delta_view(sm2, delta_view);
-    assert(delta_view.size()==3);
+    REQUIRE(delta_view.size() == 3);
 
     delta_view.clear();
     sm1.get_delta_view(sm2, delta_view, false);
-    assert(delta_view.size()==3);
+    REQUIRE(delta_view.size() == 3);
   }
 
-  // delta view test (all shared, same keys)
+  SECTION("delta view (all shared, same keys)")
   {
     smt sm1;
     fill(sm1);
@@ -276,36 +274,36 @@ void sharing_map_view_test()
     smt::delta_viewt delta_view;
 
     sm1.get_delta_view(sm2, delta_view);
-    assert(delta_view.size()==0);
+    REQUIRE(delta_view.size() == 0);
 
     delta_view.clear();
     sm1.get_delta_view(sm2, delta_view, false);
-    assert(delta_view.size()==0);
+    REQUIRE(delta_view.size() == 0);
   }
 
-  // delta view test (some sharing, same keys)
+  SECTION("delta view (some sharing, same keys)")
   {
     smt sm1;
     fill(sm1);
 
     smt sm2(sm1);
     auto r=sm2.find("i");
-    assert(r.second);
+    REQUIRE(r.second);
     r.first="3";
 
     smt::delta_viewt delta_view;
 
     sm1.get_delta_view(sm2, delta_view);
-    assert(delta_view.size()>0); // not everything is shared
-    assert(delta_view.size()<3); // there is some sharing
+    REQUIRE(delta_view.size() > 0); // not everything is shared
+    REQUIRE(delta_view.size() < 3); // there is some sharing
 
     delta_view.clear();
     sm1.get_delta_view(sm2, delta_view, false);
-    assert(delta_view.size()>0); // not everything is shared
-    assert(delta_view.size()<3); // there is some sharing
+    REQUIRE(delta_view.size() > 0); // not everything is shared
+    REQUIRE(delta_view.size() < 3); // there is some sharing
   }
 
-  // delta view test (no sharing, different keys)
+  SECTION("delta view (no sharing, different keys)")
   {
     smt sm1;
     fill(sm1);
@@ -316,21 +314,30 @@ void sharing_map_view_test()
     smt::delta_viewt delta_view;
 
     sm1.get_delta_view(sm2, delta_view);
-    assert(delta_view.size()==0);
+    REQUIRE(delta_view.size() == 0);
 
     delta_view.clear();
     sm1.get_delta_view(sm2, delta_view, false);
-    assert(delta_view.size()==3);
+    REQUIRE(delta_view.size() == 3);
   }
 }
 
-int main()
+TEST_CASE("Sharing map interface")
 {
   sharing_map_interface_test();
+}
+
+TEST_CASE("Sharing map copying")
+{
   sharing_map_copy_test();
-  sharing_map_collision_test();
-  sharing_map_view_test();
+}
 
-  return 0;
+TEST_CASE("Sharing map collisions")
+{
+  sharing_map_collision_test();
 }
 
+TEST_CASE("Sharing map views")
+{
+  sharing_map_view_test();
+}