Adding exception and tests for missing closing delimiter

Author: svorenova

src/java_bytecode/java_bytecode_convert_class.cpp

@@ -115,7 +115,7 @@ void java_bytecode_convert_classt::convert(const classt &c)
       }
       class_type=generic_class_type;
     }
-    catch(unsupported_java_class_siganture_exceptiont)
+    catch(unsupported_java_class_signature_exceptiont)
     {
       warning() << "we currently don't support parsing for example double "
         "bounded, recursive and wild card generics" << eom;

src/java_bytecode/java_local_variable_table.cpp

@@ -775,7 +775,7 @@ void java_bytecode_convert_methodt::setup_local_variables(
       {
         t=java_type_from_string(v.var.signature.value());
       }
-      catch(unsupported_java_class_siganture_exceptiont &e)
+      catch(unsupported_java_class_signature_exceptiont &e)
       {
         t=java_type_from_string(v.var.descriptor);
       }

src/java_bytecode/java_types.cpp

@@ -209,6 +209,11 @@ typet java_type_from_string(
       // string:
       // (TT;TU;I)V
       size_t closing_generic=find_closing_delimiter(src, 0, '<', '>');
+      if(closing_generic==std::string::npos)
+      {
+        throw unsupported_java_class_signature_exceptiont(
+          "Failed to find generic signature closing delimiter");
+      }
       const typet &method_type=java_type_from_string(
         src.substr(closing_generic+1, std::string::npos), class_name_prefix);
 
@@ -332,7 +337,7 @@ typet java_type_from_string(
       {
         std::size_t e_pos=find_closing_delimiter(src, f_pos, '<', '>');
         if(e_pos==std::string::npos)
-          throw unsupported_java_class_siganture_exceptiont(
+          throw unsupported_java_class_signature_exceptiont(
             "recursive generic");
 
         // construct container type
@@ -431,7 +436,7 @@ typet java_type_from_string(
 #ifdef DEBUG
     std::cout << class_name_prefix << std::endl;
 #endif
-    throw unsupported_java_class_siganture_exceptiont("wild card generic");
+    throw unsupported_java_class_signature_exceptiont("wild card generic");
   }
   default:
     return nil_typet();
@@ -489,7 +494,7 @@ std::vector<typet> java_generic_type_from_string(
   std::string signature(src.substr(1, signature_end-1));
 
   if(signature.find(";:")!=std::string::npos)
-    throw unsupported_java_class_siganture_exceptiont("multiple bounds");
+    throw unsupported_java_class_signature_exceptiont("multiple bounds");
 
   PRECONDITION(signature[signature.size()-1]==';');
 

src/java_bytecode/java_types.h

@@ -354,10 +354,10 @@ inline const typet &java_generics_class_type_bound(
 
 /// An exception that is raised for unsupported class signature.
 /// Currently we do not parse multiple bounds.
-class unsupported_java_class_siganture_exceptiont:public std::logic_error
+class unsupported_java_class_signature_exceptiont:public std::logic_error
 {
 public:
-  explicit unsupported_java_class_siganture_exceptiont(std::string type):
+  explicit unsupported_java_class_signature_exceptiont(std::string type):
     std::logic_error(
       "Unsupported class signature: "+type)
   {
@@ -373,7 +373,7 @@ inline typet java_type_from_string_with_exception(
   {
     return java_type_from_string(signature.value(), class_name);
   }
-  catch (unsupported_java_class_siganture_exceptiont &e)
+  catch (unsupported_java_class_signature_exceptiont &e)
   {
     return java_type_from_string(descriptor, class_name);
   }

unit/java_bytecode/java_utils_test.cpp

@@ -0,0 +1,65 @@
+/*******************************************************************\
+
+ Module: Unit tests for parsing generic classes
+
+ Author: DiffBlue Limited. All rights reserved.
+
+ Note: Created by fotis on 09/10/2017.
+
+\*******************************************************************/
+
+#include <string>
+#include <vector>
+
+#include <catch.hpp>
+
+#include <java_bytecode/java_utils.h>
+
+SCENARIO("Test that the generic signature delimiter lookup works reliably",
+         "[core][java_util_test]")
+{
+  GIVEN("Given the signatures of some generic classes")
+  {
+    std::vector<std::string> generic_sigs
+      {
+        // Valid inputs
+        "List<Integer>",
+        "HashMap<String, Integer>",
+        "List<List<Int>>",
+        "List<List<List<Int>>>",
+        // Invalid inputs
+        "<",
+        "List<Integer",
+        "List<List<Integer>",
+      };
+
+    WHEN("We check if the closing tag is recognised correctly")
+    {
+      // TEST VALID CASES
+
+      // List<Integer>
+      REQUIRE(find_closing_delimiter(generic_sigs[0], 4, '<', '>')==12);
+      // HashMap<String, Integer>
+      REQUIRE(find_closing_delimiter(generic_sigs[1], 7, '<', '>')==23);
+      // List<List<Int>>
+      REQUIRE(find_closing_delimiter(generic_sigs[2], 4, '<', '>')==14);
+      REQUIRE(find_closing_delimiter(generic_sigs[2], 9, '<', '>')==13);
+      // List<List<List<Int>>>
+      REQUIRE(find_closing_delimiter(generic_sigs[3], 14, '<', '>')==18);
+
+      // TEST INVALID CASES
+
+      // <
+      REQUIRE(find_closing_delimiter(generic_sigs[4], 0, '<', '>')
+              ==std::string::npos);
+      // List<Integer
+      REQUIRE(find_closing_delimiter(generic_sigs[5], 4, '<', '>')
+              ==std::string::npos);
+      // List<List<Integer>
+      // (make sure that we still recognise the first delimiter correctly)
+      REQUIRE(find_closing_delimiter(generic_sigs[6], 4, '<', '>')
+              ==std::string::npos);
+      REQUIRE(find_closing_delimiter(generic_sigs[6], 9, '<', '>')==17);
+    }
+  }
+}