Adding tests for local lambdas

Author: thk123

unit/java_bytecode/java_bytecode_parser/java_bytecode_parse_lambda_method_table.cpp

@@ -276,3 +276,252 @@ SCENARIO(
     }
   }
 }
+SCENARIO(
+  "lambda_method_handle_map with local lambdas",
+  "[core][java_bytecode][java_bytecode_parse_lambda_method_handle]")
+{
+  null_message_handlert message_handler;
+  GIVEN("A method with local lambdas")
+  {
+    java_bytecode_parse_treet parse_tree;
+    java_bytecode_parse(
+      "./java_bytecode/java_bytecode_parser/lambda_examples/"
+      "LocalLambdas.class",
+      parse_tree,
+      message_handler);
+    WHEN("Parsing that class")
+    {
+      REQUIRE(parse_tree.loading_successful);
+      const java_bytecode_parse_treet::classt parsed_class =
+        parse_tree.parsed_class;
+      REQUIRE(parsed_class.attribute_bootstrapmethods_read);
+      REQUIRE(parsed_class.lambda_method_handle_map.size() == 12);
+
+      // Simple lambdas
+      THEN(
+        "There should be an entry for the lambda that has no parameters or "
+        "returns and the method it references should have an appropriate "
+        "descriptor")
+      {
+        const lambda_method_handlet &lambda_entry =
+          require_parse_tree::require_lambda_entry_for_descriptor(
+            parsed_class, "()V");
+
+        const irep_idt &lambda_impl_name = lambda_entry.lambda_method_name;
+
+        const auto lambda_method =
+          require_parse_tree::require_method(parsed_class, lambda_impl_name);
+        REQUIRE(id2string(lambda_method.descriptor) == "()V");
+      }
+
+      // Parameter lambdas
+      THEN(
+        "There should be an entry for the lambda that takes parameters and the "
+        "method it references should have an appropriate descriptor")
+      {
+        std::string descriptor = "(ILjava/lang/Object;LDummyGeneric;)V";
+        const lambda_method_handlet &lambda_entry =
+          require_parse_tree::require_lambda_entry_for_descriptor(
+            parsed_class, descriptor);
+
+        const irep_idt &lambda_impl_name = lambda_entry.lambda_method_name;
+
+        const auto lambda_method =
+          require_parse_tree::require_method(parsed_class, lambda_impl_name);
+        REQUIRE(id2string(lambda_method.descriptor) == descriptor);
+      }
+      THEN(
+        "There should be an entry for the lambda that takes array parameters "
+        "and the method it references should have an appropriate descriptor")
+      {
+        std::string descriptor = "([I[Ljava/lang/Object;[LDummyGeneric;)V";
+        const lambda_method_handlet &lambda_entry =
+          require_parse_tree::require_lambda_entry_for_descriptor(
+            parsed_class, descriptor);
+
+        const irep_idt &lambda_impl_name = lambda_entry.lambda_method_name;
+
+        const auto lambda_method =
+          require_parse_tree::require_method(parsed_class, lambda_impl_name);
+        REQUIRE(id2string(lambda_method.descriptor) == descriptor);
+      }
+
+      // Return lambdas
+      THEN(
+        "There should be an entry for the lambda that returns a primitive and "
+        "the method it references should have an appropriate descriptor")
+      {
+        std::string descriptor = "()I";
+        const lambda_method_handlet &lambda_entry =
+          require_parse_tree::require_lambda_entry_for_descriptor(
+            parsed_class, descriptor);
+
+        const irep_idt &lambda_impl_name = lambda_entry.lambda_method_name;
+
+        const auto lambda_method =
+          require_parse_tree::require_method(parsed_class, lambda_impl_name);
+        REQUIRE(id2string(lambda_method.descriptor) == descriptor);
+      }
+      THEN(
+        "There should be an entry for the lambda that returns a reference type "
+        "and the method it references should have an appropriate descriptor")
+      {
+        std::string descriptor = "()Ljava/lang/Object;";
+        const lambda_method_handlet &lambda_entry =
+          require_parse_tree::require_lambda_entry_for_descriptor(
+            parsed_class, descriptor);
+
+        const irep_idt &lambda_impl_name = lambda_entry.lambda_method_name;
+
+        const auto lambda_method =
+          require_parse_tree::require_method(parsed_class, lambda_impl_name);
+        REQUIRE(id2string(lambda_method.descriptor) == descriptor);
+      }
+      THEN(
+        "There should be an entry for the lambda that returns a specialised "
+        "generic type and the method it references should have an appropriate "
+        "descriptor")
+      {
+        std::string descriptor = "()LDummyGeneric;";
+        const lambda_method_handlet &lambda_entry =
+          require_parse_tree::require_lambda_entry_for_descriptor(
+            parsed_class, descriptor);
+
+        const irep_idt &lambda_impl_name = lambda_entry.lambda_method_name;
+
+        const auto lambda_method =
+          require_parse_tree::require_method(parsed_class, lambda_impl_name);
+        REQUIRE(id2string(lambda_method.descriptor) == descriptor);
+      }
+
+      // Array returning lambdas
+      THEN(
+        "There should be an entry for the lambda that returns an array of "
+        "primitives and the method it references should have an appropriate "
+        "descriptor")
+      {
+        std::string descriptor = "()[I";
+        const lambda_method_handlet &lambda_entry =
+          require_parse_tree::require_lambda_entry_for_descriptor(
+            parsed_class, descriptor);
+
+        const irep_idt &lambda_impl_name = lambda_entry.lambda_method_name;
+
+        const auto lambda_method =
+          require_parse_tree::require_method(parsed_class, lambda_impl_name);
+        REQUIRE(id2string(lambda_method.descriptor) == descriptor);
+      }
+      THEN(
+        "There should be an entry for the lambda that returns an array of "
+        "reference types and the method it references should have an "
+        "appropriate descriptor")
+      {
+        std::string descriptor = "()[Ljava/lang/Object;";
+        const lambda_method_handlet &lambda_entry =
+          require_parse_tree::require_lambda_entry_for_descriptor(
+            parsed_class, descriptor);
+
+        const irep_idt &lambda_impl_name = lambda_entry.lambda_method_name;
+
+        const auto lambda_method =
+          require_parse_tree::require_method(parsed_class, lambda_impl_name);
+        REQUIRE(id2string(lambda_method.descriptor) == descriptor);
+      }
+      THEN(
+        "There should be an entry for the lambda that returns an array of "
+        "specialised generic types and the method it references should have an "
+        "appropriate descriptor")
+      {
+        std::string descriptor = "()[LDummyGeneric;";
+        const lambda_method_handlet &lambda_entry =
+          require_parse_tree::require_lambda_entry_for_descriptor(
+            parsed_class, descriptor);
+
+        const irep_idt &lambda_impl_name = lambda_entry.lambda_method_name;
+
+        const auto lambda_method =
+          require_parse_tree::require_method(parsed_class, lambda_impl_name);
+        REQUIRE(id2string(lambda_method.descriptor) == descriptor);
+      }
+
+      // Capturing lamdbas
+      THEN(
+        "There should be an entry for the lambda that returns a primitive "
+        "local variable and the method it references should have an "
+        "appropriate descriptor")
+      {
+        std::string descriptor = "()I";
+        const lambda_method_handlet &lambda_entry =
+          require_parse_tree::require_lambda_entry_for_descriptor(
+            parsed_class, descriptor, 1);
+
+        const irep_idt &lambda_impl_name = lambda_entry.lambda_method_name;
+
+        const auto lambda_method =
+          require_parse_tree::require_method(parsed_class, lambda_impl_name);
+        // Note here the descriptor of the implementation is different - the
+        // implementation requries the input to be passed in
+        REQUIRE(id2string(lambda_method.descriptor) == "(I)I");
+
+        std::vector<require_parse_tree::expected_instructiont>
+          expected_instructions{{"iload_0", {}}, {"ireturn", {}}};
+
+        require_parse_tree::require_instructions_match_expectation(
+          expected_instructions, lambda_method.instructions);
+      }
+      THEN(
+        "There should be an entry for the lambda that returns a reference type "
+        "local variable  and the method it references should have an "
+        "appropriate descriptor")
+      {
+        // Since it is a local variable, the corresponding method takes the
+        // captured variable as an input
+        std::string descriptor = "()Ljava/lang/Object;";
+        const lambda_method_handlet &lambda_entry =
+          require_parse_tree::require_lambda_entry_for_descriptor(
+            parsed_class, descriptor, 1);
+
+        const irep_idt &lambda_impl_name = lambda_entry.lambda_method_name;
+
+        const auto lambda_method =
+          require_parse_tree::require_method(parsed_class, lambda_impl_name);
+        REQUIRE(
+          id2string(lambda_method.descriptor) ==
+          "(Ljava/lang/Object;)Ljava/lang/Object;");
+
+        std::vector<require_parse_tree::expected_instructiont>
+          expected_instructions{{"aload_0", {}}, {"areturn", {}}};
+
+        require_parse_tree::require_instructions_match_expectation(
+          expected_instructions, lambda_method.instructions);
+      }
+      THEN(
+        "There should be an entry for the lambda that returns a specialised "
+        "generic type local variable  and the method it references should have "
+        "an appropriate descriptor")
+      {
+        // Since it is a local variable, the corresponding method takes the
+        // captured variable as an input
+        std::string descriptor = "()LDummyGeneric;";
+        const lambda_method_handlet &lambda_entry =
+          require_parse_tree::require_lambda_entry_for_descriptor(
+            parsed_class, descriptor, 1);
+
+        const irep_idt &lambda_impl_name = lambda_entry.lambda_method_name;
+
+        const java_bytecode_parse_treet::methodt &lambda_method =
+          require_parse_tree::require_method(parsed_class, lambda_impl_name);
+        REQUIRE(
+          id2string(lambda_method.descriptor) ==
+          "(LDummyGeneric;)LDummyGeneric;");
+
+        // since just returning the parameter, nothing to put on the stack
+        std::vector<require_parse_tree::expected_instructiont>
+          expected_instructions{{"aload_0", {}}, {"areturn", {}}};
+
+        require_parse_tree::require_instructions_match_expectation(
+          expected_instructions, lambda_method.instructions);
+      }
+    }
+  }
+}

unit/java_bytecode/java_bytecode_parser/lambda_examples/LocalLambdas.class

@@ -0,0 +1,59 @@
+public class LocalLambdas {
+  public static void test() {
+    int localPrimitive = 5;
+    Object localReference = null;
+    DummyGeneric<Integer> localSpecalisedGeneric = null;
+
+    // Declare some local lambdas
+    SimpleLambda simpleLambda = () -> { /*NOP*/ };
+
+    ParameterLambda paramLambda =
+      (int primitive, Object reference, DummyGeneric<Integer> specalisedGeneric) -> {};
+    ArrayParameterLambda arrayParamLambda =
+      (int[] primitive, Object[] reference, DummyGeneric<Integer>[] specalisedGeneric) -> {};
+
+    ReturningLambdaPrimitive returnPrimitiveLambda = () -> {
+      return 1;
+    };
+    ReturningLambdaReference returnReferenceLambda = () -> {
+      return null;
+    };
+    ReturningLambdaSpecalisedGeneric returningSpecalisedGenericLambda = () -> {
+      return null;
+    };
+
+    ReturningLambdaPrimitiveArray returnPrimitiveArrayLambda = () -> {
+      return null;
+    };
+    ReturningLambdaReferenceArray returnReferenceArrayLambda = () -> {
+      return null;
+    };
+    ReturningLambdaSpecalisedGenericArray returningSpecalisedGenericArrayLambda = () -> {
+      return null;
+    };
+
+    ReturningLambdaPrimitive returnPrimitiveLambdaCapture = () -> {
+      return localPrimitive;
+    };
+    ReturningLambdaReference returnReferenceLambdaCapture = () -> {
+      return localReference;
+    };
+    ReturningLambdaSpecalisedGeneric returningSpecalisedGenericLambdaCapture = () -> {
+      return localSpecalisedGeneric;
+    };
+
+    simpleLambda.Execute();
+    paramLambda.Execute(4, null, null);
+    arrayParamLambda.Execute(null, null, null);
+    returnPrimitiveLambda.Execute();
+    returnReferenceLambda.Execute();
+    returningSpecalisedGenericLambda.Execute();
+    returnPrimitiveArrayLambda.Execute();
+    returnReferenceArrayLambda.Execute();
+    returningSpecalisedGenericArrayLambda.Execute();
+
+    returnPrimitiveLambdaCapture.Execute();
+    returnReferenceLambdaCapture.Execute();
+    returningSpecalisedGenericLambdaCapture.Execute();
+  }
+}