Adding tests for the overall function

Author: thk123

jbmc/unit/java_bytecode/load_method_by_regex.cpp

@@ -8,6 +8,7 @@
 
 #include <java_bytecode/load_method_by_regex.h>
 #include <testing-utils/catch.hpp>
+#include <testing-utils/require_vectors_equal_unordered.h>
 
 class load_method_by_regex_testt
 {
@@ -101,3 +102,92 @@ SCENARIO(
     }
   }
 }
+
+static symbolt create_method_symbol(const std::string &method_name)
+{
+  symbolt new_symbol;
+  new_symbol.name = method_name;
+  new_symbol.type = code_typet{{}, nil_typet{}};
+  return new_symbol;
+}
+
+static void require_result_for_pattern(
+  const std::string &pattern,
+  const std::vector<irep_idt> &expected,
+  const symbol_tablet &symbol_table)
+{
+  WHEN("Constructing a load_method_by_regex")
+  {
+    load_method_by_regext matcher{pattern};
+    const auto &results = matcher.extra_methods(symbol_table);
+    if(expected.size() == 1)
+    {
+      THEN("Expect " + id2string(expected[0]))
+      {
+        require_vectors_equal_unordered(results, expected);
+      }
+    }
+    else
+    {
+      THEN("Expect " + std::to_string(expected.size()) + " symbols")
+      {
+        require_vectors_equal_unordered(results, expected);
+      }
+    }
+  }
+}
+
+SCENARIO("load_method_by_regex", "[core][java_bytecode][load_method_by_regex]")
+{
+  symbol_tablet symbol_table;
+  symbol_table.add(create_method_symbol("java::pack.Class.methodName:()V"));
+  symbol_table.add(create_method_symbol("java::pack.Class.anotherMethod:()V"));
+  symbol_table.add(create_method_symbol("java::pack.Different.methodName:()V"));
+  symbol_table.add(create_method_symbol("java::another.Class.methodName:()V"));
+
+  GIVEN("A pattern without java prefix, without descriptor, no regex")
+  {
+    const std::string pattern = "pack.Class.methodName";
+    const std::vector<irep_idt> expected = {"java::pack.Class.methodName:()V"};
+    require_result_for_pattern(pattern, expected, symbol_table);
+  }
+  GIVEN("A pattern with java prefix, without descriptor, no regex")
+  {
+    const std::string pattern = "java::pack.Class.methodName";
+    const std::vector<irep_idt> expected = {"java::pack.Class.methodName:()V"};
+    require_result_for_pattern(pattern, expected, symbol_table);
+  }
+  GIVEN("A pattern with java prefix, with descriptor, no regex")
+  {
+    const std::string pattern = R"(java::pack.Class.methodName:\(\)V)";
+    const std::vector<irep_idt> expected = {"java::pack.Class.methodName:()V"};
+    require_result_for_pattern(pattern, expected, symbol_table);
+  }
+  GIVEN("A pattern with java prefix, with wrong descriptor, no regex")
+  {
+    const std::string pattern = R"(java::pack.Class.methodName:\(I\)V)";
+    const std::vector<irep_idt> expected = {};
+    require_result_for_pattern(pattern, expected, symbol_table);
+  }
+  GIVEN("A pattern with java prefix, without descriptor, with regex")
+  {
+    const std::string pattern = "java::pack.Class..*";
+    const std::vector<irep_idt> expected = {
+      "java::pack.Class.methodName:()V", "java::pack.Class.anotherMethod:()V"};
+    require_result_for_pattern(pattern, expected, symbol_table);
+  }
+  GIVEN("A pattern without java prefix, without descriptor, with regex")
+  {
+    const std::string pattern = "pack.Class..*";
+    const std::vector<irep_idt> expected = {
+      "java::pack.Class.methodName:()V", "java::pack.Class.anotherMethod:()V"};
+    require_result_for_pattern(pattern, expected, symbol_table);
+  }
+  GIVEN("A pattern without java prefix, with descriptor, with regex in package")
+  {
+    const std::string pattern = R"(\w+.Class.methodName:\(\)V)";
+    const std::vector<irep_idt> expected = {
+      "java::pack.Class.methodName:()V", "java::another.Class.methodName:()V"};
+    require_result_for_pattern(pattern, expected, symbol_table);
+  }
+}