Adding tests for lambdas as member variables

Author: thk123

unit/java_bytecode/java_bytecode_parser/java_bytecode_parse_lambda_method_table.cpp

@@ -525,3 +525,275 @@ SCENARIO(
     }
   }
 }
+SCENARIO(
+  "lambda_method_handle_map with member lambdas",
+  "[core][java_bytecode][java_bytecode_parse_lambda_method_handle]")
+{
+  null_message_handlert message_handler;
+  GIVEN("A class that has lambdas as member variables")
+  {
+    java_bytecode_parse_treet parse_tree;
+    java_bytecode_parse(
+      "./java_bytecode/java_bytecode_parser/lambda_examples/"
+      "MemberLambdas.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");
+        REQUIRE_FALSE(lambda_method.is_static);
+
+        const fieldref_exprt primitive_fieldref{
+          java_int_type(), "memberPrimitive", "java::MemberLambdas"};
+
+        std::vector<require_parse_tree::expected_instructiont>
+          expected_instructions{{"aload_0", {}}, // load this of stack
+                                {"getfield", {primitive_fieldref}},
+                                {"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;");
+        REQUIRE_FALSE(lambda_method.is_static);
+
+        const reference_typet dummy_generic_reference_type =
+          java_reference_type(symbol_typet{"java::java.lang.Object"});
+
+        const fieldref_exprt reference_fieldref{dummy_generic_reference_type,
+                                                "memberReference",
+                                                "java::MemberLambdas"};
+
+        std::vector<require_parse_tree::expected_instructiont>
+          expected_instructions{{"aload_0", {}}, // load this of stack
+                                {"getfield", {reference_fieldref}},
+                                {"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;");
+        REQUIRE_FALSE(lambda_method.is_static);
+
+        const reference_typet dummy_generic_reference_type =
+          java_reference_type(symbol_typet{"java::DummyGeneric"});
+
+        const fieldref_exprt generic_reference_fieldref{
+          dummy_generic_reference_type,
+          "memberSpecalisedGeneric",
+          "java::MemberLambdas"};
+
+        // since just returning the parameter, nothing to put on the stack
+        std::vector<require_parse_tree::expected_instructiont>
+          expected_instructions{{"aload_0", {}}, // load this of stack
+                                {"getfield", {generic_reference_fieldref}},
+                                {"areturn", {}}};
+
+        require_parse_tree::require_instructions_match_expectation(
+          expected_instructions, lambda_method.instructions);
+      }
+    }
+  }
+}

unit/java_bytecode/java_bytecode_parser/lambda_examples/MemberLambdas.class

@@ -0,0 +1,38 @@
+public class MemberLambdas {
+
+  int memberPrimitive;
+  Object memberReference;
+  DummyGeneric<Integer> memberSpecalisedGeneric;
+
+  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 memberPrimitive; };
+  ReturningLambdaReference returnReferenceLambdaCapture = () -> { return memberReference; };
+  ReturningLambdaSpecalisedGeneric returningSpecalisedGenericLambdaCapture = () -> { return memberSpecalisedGeneric; };
+
+
+  public void testMethod() {
+    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();
+  }
+}
+