From f1ee826e1a0a005a0cafab8adbefcfd5c3bb3192 Mon Sep 17 00:00:00 2001 From: Thomas Spriggs Date: Wed, 28 Feb 2018 10:17:45 +0000 Subject: [PATCH 1/2] Update `java_bytecode_parse_lambda_method_handle` tests to run for each java compiler. --- ...ava_bytecode_parse_lambda_method_table.cpp | 46 +++++++++++++----- .../ReturningLambdaPrimitive.class | Bin 142 -> 0 bytes .../ReturningLambdaPrimitiveArray.class | Bin 148 -> 0 bytes .../ReturningLambdaReference.class | Bin 159 -> 0 bytes .../ReturningLambdaReferenceArray.class | Bin 165 -> 0 bytes .../ReturningLambdaSpecalisedGeneric.class | Bin 223 -> 0 bytes ...eturningLambdaSpecalisedGenericArray.class | Bin 230 -> 0 bytes .../lambda_examples/SimpleLambda.class | Bin 130 -> 0 bytes .../ArrayParameterLambda.class | Bin 0 -> 260 bytes .../eclipse_classes/DummyGeneric.class | Bin 0 -> 444 bytes .../eclipse_classes/LocalLambdas.class | Bin 0 -> 4384 bytes .../eclipse_classes/MemberLambdas.class | Bin 0 -> 4526 bytes .../OuterMemberLambdas$Inner.class | Bin 0 -> 2084 bytes .../eclipse_classes/OuterMemberLambdas.class | Bin 0 -> 534 bytes .../eclipse_classes/ParameterLambda.class | Bin 0 -> 249 bytes .../ReturningLambdaPrimitive.class | Bin 0 -> 145 bytes .../ReturningLambdaPrimitiveArray.class | Bin 0 -> 151 bytes .../ReturningLambdaReference.class | Bin 0 -> 162 bytes .../ReturningLambdaReferenceArray.class | Bin 0 -> 168 bytes .../ReturningLambdaSpecalisedGeneric.class | Bin 0 -> 226 bytes ...eturningLambdaSpecalisedGenericArray.class | Bin 0 -> 233 bytes .../eclipse_classes/SimpleLambda.class | Bin 0 -> 133 bytes .../eclipse_classes/StaticLambdas.class | Bin 0 -> 4345 bytes .../ArrayParameterLambda.class | Bin 257 -> 260 bytes .../DummyGeneric.class | Bin 441 -> 444 bytes .../LocalLambdas.class | Bin 4350 -> 4347 bytes .../MemberLambdas.class | Bin .../OuterMemberLambdas$Inner.class | Bin .../OuterMemberLambdas.class | Bin .../ParameterLambda.class | Bin 246 -> 249 bytes .../ReturningLambdaPrimitive.class | Bin 0 -> 145 bytes .../ReturningLambdaPrimitiveArray.class | Bin 0 -> 151 bytes .../ReturningLambdaReference.class | Bin 0 -> 162 bytes .../ReturningLambdaReferenceArray.class | Bin 0 -> 168 bytes .../ReturningLambdaSpecalisedGeneric.class | Bin 0 -> 226 bytes ...eturningLambdaSpecalisedGenericArray.class | Bin 0 -> 233 bytes .../openjdk_8_classes/SimpleLambda.class | Bin 0 -> 133 bytes .../StaticLambdas.class | Bin .../ArrayParameterLambda.class | Bin 0 -> 260 bytes .../oracle_8_classes/DummyGeneric.class | Bin 0 -> 444 bytes .../oracle_8_classes/LocalLambdas.class | Bin 0 -> 4347 bytes .../oracle_8_classes/MemberLambdas.class | Bin 0 -> 4426 bytes .../OuterMemberLambdas$Inner.class | Bin 0 -> 2097 bytes .../oracle_8_classes/OuterMemberLambdas.class | Bin 0 -> 534 bytes .../oracle_8_classes/ParameterLambda.class | Bin 0 -> 249 bytes .../ReturningLambdaPrimitive.class | Bin 0 -> 145 bytes .../ReturningLambdaPrimitiveArray.class | Bin 0 -> 151 bytes .../ReturningLambdaReference.class | Bin 0 -> 162 bytes .../ReturningLambdaReferenceArray.class | Bin 0 -> 168 bytes .../ReturningLambdaSpecalisedGeneric.class | Bin 0 -> 226 bytes ...eturningLambdaSpecalisedGenericArray.class | Bin 0 -> 233 bytes .../oracle_8_classes/SimpleLambda.class | Bin 0 -> 133 bytes .../oracle_8_classes/StaticLambdas.class | Bin 0 -> 4245 bytes .../ArrayParameterLambda.class | Bin 0 -> 260 bytes .../oracle_9_classes/DummyGeneric.class | Bin 0 -> 444 bytes .../oracle_9_classes/LocalLambdas.class | Bin 0 -> 4347 bytes .../oracle_9_classes/MemberLambdas.class | Bin 0 -> 4426 bytes .../OuterMemberLambdas$Inner.class | Bin 0 -> 2097 bytes .../oracle_9_classes/OuterMemberLambdas.class | Bin 0 -> 534 bytes .../oracle_9_classes/ParameterLambda.class | Bin 0 -> 249 bytes .../ReturningLambdaPrimitive.class | Bin 0 -> 145 bytes .../ReturningLambdaPrimitiveArray.class | Bin 0 -> 151 bytes .../ReturningLambdaReference.class | Bin 0 -> 162 bytes .../ReturningLambdaReferenceArray.class | Bin 0 -> 168 bytes .../ReturningLambdaSpecalisedGeneric.class | Bin 0 -> 226 bytes ...eturningLambdaSpecalisedGenericArray.class | Bin 0 -> 233 bytes .../oracle_9_classes/SimpleLambda.class | Bin 0 -> 133 bytes .../oracle_9_classes/StaticLambdas.class | Bin 0 -> 4245 bytes .../lambda_examples/readme.md | 45 +++++++++++++++++ 69 files changed, 79 insertions(+), 12 deletions(-) delete mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/ReturningLambdaPrimitive.class delete mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/ReturningLambdaPrimitiveArray.class delete mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/ReturningLambdaReference.class delete mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/ReturningLambdaReferenceArray.class delete mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/ReturningLambdaSpecalisedGeneric.class delete mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/ReturningLambdaSpecalisedGenericArray.class delete mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/SimpleLambda.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ArrayParameterLambda.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/DummyGeneric.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/LocalLambdas.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/MemberLambdas.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/OuterMemberLambdas$Inner.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/OuterMemberLambdas.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ParameterLambda.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaPrimitive.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaPrimitiveArray.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaReference.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaReferenceArray.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaSpecalisedGeneric.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaSpecalisedGenericArray.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/SimpleLambda.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/StaticLambdas.class rename unit/java_bytecode/java_bytecode_parser/lambda_examples/{ => openjdk_8_classes}/ArrayParameterLambda.class (56%) rename unit/java_bytecode/java_bytecode_parser/lambda_examples/{ => openjdk_8_classes}/DummyGeneric.class (60%) rename unit/java_bytecode/java_bytecode_parser/lambda_examples/{ => openjdk_8_classes}/LocalLambdas.class (69%) rename unit/java_bytecode/java_bytecode_parser/lambda_examples/{ => openjdk_8_classes}/MemberLambdas.class (100%) rename unit/java_bytecode/java_bytecode_parser/lambda_examples/{ => openjdk_8_classes}/OuterMemberLambdas$Inner.class (100%) rename unit/java_bytecode/java_bytecode_parser/lambda_examples/{ => openjdk_8_classes}/OuterMemberLambdas.class (100%) rename unit/java_bytecode/java_bytecode_parser/lambda_examples/{ => openjdk_8_classes}/ParameterLambda.class (56%) create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/openjdk_8_classes/ReturningLambdaPrimitive.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/openjdk_8_classes/ReturningLambdaPrimitiveArray.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/openjdk_8_classes/ReturningLambdaReference.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/openjdk_8_classes/ReturningLambdaReferenceArray.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/openjdk_8_classes/ReturningLambdaSpecalisedGeneric.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/openjdk_8_classes/ReturningLambdaSpecalisedGenericArray.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/openjdk_8_classes/SimpleLambda.class rename unit/java_bytecode/java_bytecode_parser/lambda_examples/{ => openjdk_8_classes}/StaticLambdas.class (100%) create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/ArrayParameterLambda.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/DummyGeneric.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/LocalLambdas.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/MemberLambdas.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/OuterMemberLambdas$Inner.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/OuterMemberLambdas.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/ParameterLambda.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/ReturningLambdaPrimitive.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/ReturningLambdaPrimitiveArray.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/ReturningLambdaReference.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/ReturningLambdaReferenceArray.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/ReturningLambdaSpecalisedGeneric.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/ReturningLambdaSpecalisedGenericArray.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/SimpleLambda.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/StaticLambdas.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ArrayParameterLambda.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/DummyGeneric.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/LocalLambdas.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/MemberLambdas.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/OuterMemberLambdas$Inner.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/OuterMemberLambdas.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ParameterLambda.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ReturningLambdaPrimitive.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ReturningLambdaPrimitiveArray.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ReturningLambdaReference.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ReturningLambdaReferenceArray.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ReturningLambdaSpecalisedGeneric.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ReturningLambdaSpecalisedGenericArray.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/SimpleLambda.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/StaticLambdas.class create mode 100644 unit/java_bytecode/java_bytecode_parser/lambda_examples/readme.md diff --git a/unit/java_bytecode/java_bytecode_parser/java_bytecode_parse_lambda_method_table.cpp b/unit/java_bytecode/java_bytecode_parser/java_bytecode_parse_lambda_method_table.cpp index d1484f098a3..e218c624428 100644 --- a/unit/java_bytecode/java_bytecode_parser/java_bytecode_parse_lambda_method_table.cpp +++ b/unit/java_bytecode/java_bytecode_parser/java_bytecode_parse_lambda_method_table.cpp @@ -7,6 +7,7 @@ \*******************************************************************/ #include +#include #include #include @@ -21,17 +22,28 @@ typedef java_bytecode_parse_treet::classt::lambda_method_handlet lambda_method_handlet; +void run_test_with_compilers( + const std::function &test_with_compiler) +{ + test_with_compiler("openjdk_8"); + test_with_compiler("eclipse"); + test_with_compiler("oracle_8"); + test_with_compiler("oracle_9"); +} + SCENARIO( "lambda_method_handle_map with static lambdas", "[core][java_bytecode][java_bytecode_parse_lambda_method_handle]") { + run_test_with_compilers([](const std::string &compiler) + { null_message_handlert message_handler; - GIVEN("A class with a static lambda variables") + GIVEN("A class with a static lambda variables from " + compiler + " compiler.") { java_bytecode_parse_treet parse_tree; java_bytecode_parse( - "./java_bytecode/java_bytecode_parser/lambda_examples/" - "StaticLambdas.class", + "./java_bytecode/java_bytecode_parser/lambda_examples/" + + compiler + "_classes/StaticLambdas.class", parse_tree, message_handler); WHEN("Parsing that class") @@ -275,18 +287,21 @@ SCENARIO( } } } + }); } SCENARIO( "lambda_method_handle_map with local lambdas", "[core][java_bytecode][java_bytecode_parse_lambda_method_handle]") { + run_test_with_compilers([](const std::string &compiler) + { null_message_handlert message_handler; - GIVEN("A method with local lambdas") + GIVEN("A method with local lambdas from " + compiler + " compiler.") { java_bytecode_parse_treet parse_tree; java_bytecode_parse( - "./java_bytecode/java_bytecode_parser/lambda_examples/" - "LocalLambdas.class", + "./java_bytecode/java_bytecode_parser/lambda_examples/" + + compiler + "_classes/LocalLambdas.class", parse_tree, message_handler); WHEN("Parsing that class") @@ -524,18 +539,21 @@ SCENARIO( } } } + }); } SCENARIO( "lambda_method_handle_map with member lambdas", "[core][java_bytecode][java_bytecode_parse_lambda_method_handle]") { + run_test_with_compilers([](const std::string &compiler) + { null_message_handlert message_handler; - GIVEN("A class that has lambdas as member variables") + GIVEN("A class that has lambdas as member variables from " + compiler + " compiler.") { java_bytecode_parse_treet parse_tree; java_bytecode_parse( - "./java_bytecode/java_bytecode_parser/lambda_examples/" - "MemberLambdas.class", + "./java_bytecode/java_bytecode_parser/lambda_examples/" + + compiler + "_classes/MemberLambdas.class", parse_tree, message_handler); WHEN("Parsing that class") @@ -796,21 +814,24 @@ SCENARIO( } } } + }); } SCENARIO( "lambda_method_handle_map with member lambdas capturing outer class " "variables", "[core][java_bytecode][java_bytecode_parse_lambda_method_handle]") { + run_test_with_compilers([](const std::string &compiler) + { null_message_handlert message_handler; GIVEN( "An inner class with member variables as lambdas that capture outer " - "variables") + "variables from " + compiler + " compiler.") { java_bytecode_parse_treet parse_tree; java_bytecode_parse( - "./java_bytecode/java_bytecode_parser/lambda_examples/" - "OuterMemberLambdas$Inner.class", + "./java_bytecode/java_bytecode_parser/lambda_examples/" + + compiler + "_classes/OuterMemberLambdas$Inner.class", parse_tree, message_handler); WHEN("Parsing that class") @@ -932,4 +953,5 @@ SCENARIO( } } } + }); } diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/ReturningLambdaPrimitive.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/ReturningLambdaPrimitive.class deleted file mode 100644 index 81073aa0155809aabea3db26435d18144e0161b3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 142 zcmX^0Z`VEs1_l!bPId-%b_Nbc26oqq)a25VR7M774NXr*2Cm@z(xT*4x6B-%kWg?* zVo7GQPhxITN@B5IR$^HqBZEXxYDsBPUS?i8L_DA8YI0&uW^rl?)N03~qQpu@1_6Wx{z+M> j$t7$I42%p+Kpy~U7DfhU1{NTn706>^U<0z)!7L5{4Q@U2 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/SimpleLambda.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/SimpleLambda.class deleted file mode 100644 index ff1dae8ba4be47077bef82c1f7362bd259030c0e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 130 zcmX^0Z`VEs1_l!bPId-%b_Nbc26oqq)a25VR7M774b3n{2Cm@z(xT*4x6B-%kWg?* zVo7GQPhxITN@B5IR$^HqBLh!xW^O@FDnyWxK>#GGpOcuEuJ50em6}|_#=yYHzy!1f TNV5QqWnclZ7+8TM69XFnp>Z7o diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ArrayParameterLambda.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ArrayParameterLambda.class new file mode 100644 index 0000000000000000000000000000000000000000..00e4747b0aa3f98ffad80acc3261e04c33eddf1f GIT binary patch literal 260 zcmX^0Z`VEs1_l!bZgvJHMg|ebqN2pgfW)H2+|-iPBA>+Eq?AN<1{OvJfvm)`ME#t^ zymWp4q^#8B5=I7g*NW8S(vnn026c^S&uAZX71q%{E~UA-mF}r|sYRK|)|z3A44lE4 z>3NAIrA0tpHpJ+%K{D1euOu}+waD5IY!p{;erZv1s#|6b&@54iQ$Z?<(h`$Xi}gUR hVPjxmWMBsR4@d+3z{iag+9 zLVb>(MLe1DTvm8P8pV@bF?9XEE7J3$rg;7Q+c0P-UE0MXxi!toJQBCE8Z`8I8pixy z6(XPWNUY8(M+{>(xY#!5ZBsY``JxYGbXsUrHmTCEQ#0g`@-8t~lxxlD8|+sibaW|J c4Ztya6zv}Y`q(GrG?)P)4F`1`Zbpp00iP^kj{pDw literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/LocalLambdas.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/LocalLambdas.class new file mode 100644 index 0000000000000000000000000000000000000000..411cb26b993fd334a56d15ce9899aaad34ffbbfc GIT binary patch literal 4384 zcmbVP33n4!6#ibCX3}O_iq%RhNP$9A6e{~tK(TDqut*WqqBuc$4GH>nF8VX57y843AaU(qa^G|fqHJP(+sU&H+93=CtvO#Eii`rOASLC^n(Iukf0`k zu>`Hx%>g5oNNux~tTPh*2{W-v=V=val)!Oif$R0Hx}m4y5*Wl-32YW<@oVhP=nQZo ztM{$cQ@W9eQ=k&#rNAVC34Q^`1j~M+LzpPhQ_7+pJBnxplO?)Mpv|w_XG~EljHr}4 zUSM3b>#$L&!f_JWE-*bB^QKCNPt>uGj#Oj16rCwBGa6eq(BD5;42e(7XDG!Zm=VDo z%u_IzdFxIMsWlYA0(2-?$aM5vy4+qQFQ?0Iu*ZiG$;3QiO_vRwX1RZ9h0qdi?c zeq}v=ZJk)IU>Or~xI~j0S6G$R6~QW;qM*x?+DykF*`R#!6KJqReJ9G6)hypDRU!#(Mm* zUFp;^oF1H2g>A!%1t9x13NS zX9!efic^iWQ5;-M%dB@cmBiSj13fI9`ZC4J4(qGB;>oj0DrT3+IVF<4yNI1vBIlRL z1+uSnwejq#f;Thh&Xlslrc4bxLUjCC-*KiPfn-J ztZ8VO)w;Po-IuM#-MCl5JpvO;hbL0I(mVBb`z{I8wrX)RZ49co5BIYf@Rd?z2^?~J zQjoNjuhLR|Nj=*VOQ&}ZWI9}T+-({xNjGPR;0ET&|J$^WJiM%X)D({G)RM{WgsFFo z3gIr!-f9T!RdF#wWIRL$2d?BjuHq6bBJVLWI5{Qn85LJxDS1zm!PzHyFQ~W%E6CeN z1}B{4y{h6`oJ!s+WN=(b-difJ!#eWbB!eSJ^4?Lg2d9&_pA3!|$$MYL^*D>X_sFQj z7RmcW#SPd(-p6DV&izuwjkt-tFG}ZrtKw$dLf$u}bAM8CD{dq2M{91XT`4~0I+I#9 ztMk$PJ3Edq8OmL$fz`MRzX2 z4Cdra=E5wN{A}#y)AK3J!;6@YH~G{&fQ445@1^bl-o?4lXh#tHsU^4=< zT80a0;rTp0#+?f&tI~s=7^G|s{fJ{XWowDD6T!CRA_VHHWrflqmGqC~UbE z00?LC7T~85ER)fK+mV-=K(I`>W_uHtT2YW`c$pOiNnLJ5p=gcGv8`br;J&oxME*MJ z-T7SOQGX?Yw)(3mYAd_ia*Yk7plqVG!@3CWBf_n%&gC1Mix)3m_TcMXcs8C9@eM9K zo6?B*CKsL!Yef7w7oN>*M0~Rg&qn9M%h&~)yzyyq;n@Ve_^ICbw7T$YkR#%!7V*67 z+pSpNfjhbGW(q$*-h+4;k66^Bc!DJ&c~9Y4JZDkQv-n=JsFzt%uUpg`c$-lBfM&-ewu@_acTe#0O53yuE)nspQP literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/MemberLambdas.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/MemberLambdas.class new file mode 100644 index 0000000000000000000000000000000000000000..fdc38149e65f639d4b98abb6ecf1d3a18a6d32ec GIT binary patch literal 4526 zcmbVOd3;n?75?rJ@<`@FCPSeVX<0%g3EGersAUjrLzmHkQijrM#QKsv!h_j(Gl@+> z#RV5!a6zs6zSpH%t%F+kt=6q--S>Up*FXIEo%?3q%)B=t{WZT|=6>(o?>qONd(S=h z-u=HbcLCUl|5}JCEZphj#~d$X=f@`OvV{(X#36gy9?IE;$)Rh<4msl$g`T`&?e^Tf zTXCly1(go0dz=G~=M=_iO=iN{l)|~bI9qbY?VMY7Ca!i0j^~amEXwSd%I9Zl-=ubB z-N}MoneynXucdQqljn4y;!HYTY8w^0?B+{3$DhA=%rr&5oY zjD+oZ_KdODX-hMg2euaO63^k}3c)(m1JwTKipLLS z#4ht;dEmj9;~qjeH#53P_VAN*%_az zFj*7*1Fe~t+Tp|J!@MRJA0+UO{ejiPiu zE*I&Q8s}n}NUv5{9hHWXEs0KCCAvpyoQLJ2%e2)6v-EQ!2@8)B-L)DI!V1w{r!Wv5 zFEZ7-egSriey_&)xIpyW@b&$fmdcnq>-u)#dhzgRjg|iTj@};+K_FbSZahXjJWgYk zzub>kxMa>bL_(scIBpV8;~J~6j72)*7MxvEQsnpAV>wf#i!8+ZY|oYNnz5sD&@BtQ zHEMgbRUu2NjH^n|6)nCl=#%Z zzBtO5vcMbXoOa1CuBH{%^^c}Uqs~U7-fqS%7G`*wW;+|=@u)fE={TNo=?)DR*(7mu!mk-E_g@^(#Ir3tOX2*Gi`Jte`jf0l{R5+% z^>guj3(t#cf?1oD6wN8#MbxyL`wQ`63ol~94hzlsE2N<(l)?a>Oo@ zOky%zQ7l%<70)jDXRX|g_u&o;?^jsU$ThbxT|Ddz`F9nG_5pjmQuJmtK7bGMvBQ^5 z-K20&f74Fal)m$8?7~FODX+~Gi-)I5sU}*s;_=DRY-thh{pC)Lx5+Y{*P=Axd_cnSJwsM3(Y5wU$tv4j%dud4Eq}aZ#@dliv?OQY?a7t`H z(0C(G(e`~B5;!fkpK81br)m2M4YhH9rSWEtYvGrTaeuGzHjZoIca3rXqVZ0SYvIov zmvuH>;8S@dXP3(kALsw%0gWU>yDhcwZ-ooaPF3ji_n-F!D(E#DQUF5*~x zUh#J=zwYIjifv`^PFy&627_RluO}E1uz_HsfK3FK3D`ogO~7`75dk|0t`U$X*ePHa z!5#tGL82Q3-6-g>g7yot1&!U#abuX^?-mm=%PrSrAy;K7kMv5eN*(zS(qZqm# zujNfl>R}u4+r#UXY%6BrY$LucEM6QHGppWhw&Xn!_AShtJ8An6K8%kT^ig~qpD^f? z_zXU4(C2VBzG%=r_zJ#i(AV${eAA%&@Ev^Dpzq;__>nE9 literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/OuterMemberLambdas$Inner.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/OuterMemberLambdas$Inner.class new file mode 100644 index 0000000000000000000000000000000000000000..cc890bb1481b61ebf60fd3052b46859e5a645fda GIT binary patch literal 2084 zcmbVM+j84f6kW%;D7Mu`bpvTio202rZ5NU>DJ9?%pzbZ;G$l?`t_9gXNtD`>N0Kw- zpLl?oc9`^`AHeWU4C_c5+eoHNd62ZV&)#e8+u48o_3{;f8#vUE5;(Wj^`*Nh+jZ$y z&33(Mdif38mac|T0prj-GM8GWy}z_oKa>q$;DRgtu4_MXt+wS`M>2G(m>p`R!1?NS zaBkWA;YrW1-1FU*d(xG5<3D|ShV;D}@)Eb!kqxtDd9rz5GEl1#3t=H1Lc)P?uqd^IMi}`RfAHg<%H8U4hYx)0AlloY9emp1}yt>NtfdfssOSSI66!7SQhg zEE}w`z|CPuVX@1_c+CB><=Cya6wP@ZV;EPk7v2!8U&kDA-cew4Iy6iuuuB5#ZxUIu znmME}uR!xU(#Qx*RxMjT?5dgCG3zbno~t_S*{OWGBsvfA3Np>JAi$KPgp1&#m z1E-nAHN3CkJr3=^&6vt(F)05=7Ry-Ca6M_=tA?^(b+io96Q^_HkXazSaznn%HpJ=$nLL_t5v5rq!w03X_dyN+m8-0lD3gWho z3hwkwdx@y}CNk*zt|;I8Iv#+4(;-bF3xU(|@G~{1>o(*)OLcHM8Tg{&Wa76S$M<~K z?1X*tGI)qb8ny%$`cYZ-k@HM0g?E*P=APN`9rswrSJ)QFw)-l9KMMo-M4ln|1JiD{ zq?fNc&a-Z(JYZJyT`q?~%|9G>jyv-I9fp*z_Z^&|h_+(3S~bg;<;ihu8d%Kmf^aE( zgvCh>kEt-Qs&wD!_zbJmeM^ObHKqGW$6c&Z_ahYoda#izEz|QPFU(l9p!Wo>BnmvN zOd1XZW?yg0l^50&ml(hZm(D03E*!q0c17^z^#%+>?K}RD(ee~d^F7JGr(6RmehZ~* zFJP2@N3K+QiF3dU%qZ!il4g~(prp&c(KdxEeCGl#jmsmAvt+nP{CBC>iA+3PA@qju#;6KsxXDf&MfBtLCKQq*yZ6EG`FYZ5BqKKbu`yycZ5>?b)WOp#LyCi;=Cle2TfFEV- z8HrIjboF#iRd4s~$LHHSfOG8UkrJr(lbFmkg(EVa3`b)b<&hDnOyyiQ1F0v?{%A^m zEKm-e>ei@G#cEChqW8nz(E}OMKC@Ntzqch&|27Yv$d`eNXnaMQjPeE6y^ACapBFVt z3j;OLGENNlI{b6l{?)msW15g@b=Z+>E3M*=K>GM(D3IyS##BTa8zrn^ooDovrklj> zcrQnRn{mc-45d-FUXYpiQAGkZZ~0C5BgMfiF+N=?>#r|M&g|9#rJm-+x`B)$;-}md zXe?`woJb(+G7i9_^G~snMUD~3W5wkHihR4u=M+kO5_ToVGBZtAv*+{`l@}+eGUk{D a$0nn-*rqjXaZX{|VI2+5w($f<-{eK_; literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ParameterLambda.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ParameterLambda.class new file mode 100644 index 0000000000000000000000000000000000000000..e338cb6642daec2184c894cca933c8efaed7441c GIT binary patch literal 249 zcmX^0Z`VEs1_l!bZgvJHMh5Xw-UG)NTUNRW!6w8Z4pVm**c*cccX8JK~d Z0@6U&vof#&`RqU*69Wg3#R+C{0RaAfL*W1b literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaPrimitive.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaPrimitive.class new file mode 100644 index 0000000000000000000000000000000000000000..c9433aa3004653a58edcc2bf00cb08b4e5496b7d GIT binary patch literal 145 zcmX^0Z`VEs1_l!bPId++Mh1zX)RNMoyv)3GpTyjxl*E9d%-qb9%(7H=1{OvJfvm)` zME#t^ymWp4q^#8B5=I7g*NW8S(vnn024)RSPeul=;QZ2}GE literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaPrimitiveArray.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaPrimitiveArray.class new file mode 100644 index 0000000000000000000000000000000000000000..332d65646b84824f5a983978fe4afebf9492a8aa GIT binary patch literal 151 zcmX^0Z`VEs1_l!bPId++Mh4lS)RNMoyv)3GpTyjxl*E9d%-qb9%(7I+qN2n~b_Nzk z27#=^vPAuy#JqHU|D>$c1)M7o532Y1uj10^`tARAoR8|I{08oS-NHQ^S002AAC7J*L literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaReference.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaReference.class new file mode 100644 index 0000000000000000000000000000000000000000..4a2929c89161b203ab2ed8fd2535d480bddd8e3c GIT binary patch literal 162 zcmX^0Z`VEs1_l!bPId++Mh1zX)RNMoyv)3GpTyjxl*FLawA7;1yyR4N1{OvJfvm)` zME#t^ymWp4q^#8B5=I7g*NW8S(vnn01`!QSA9Q(ZMh33n{L-T2RJY6=pc+w#sh)Wy msYPjt$*IM9ARTNB42%rSKvw{1pe?KnKmni#JCI~z-~a$UnkiTS literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaReferenceArray.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaReferenceArray.class new file mode 100644 index 0000000000000000000000000000000000000000..4a01a1551483eaccc925baa5a60d995327f5bd44 GIT binary patch literal 168 zcmX^0Z`VEs1_l!bPId++Mh4lS)RNMoyv)3GpTyjxl*FLawA7;1yyR5JqN2n~b_Nzk z27#=^vPAuy#JqHU|D>$cXu r5VJk=N>Yo`5|dMl^*}n<7#J8Cn1OBq(m-oi8Gr&n5q2QS#J~XnvmPtB literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaSpecalisedGeneric.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaSpecalisedGeneric.class new file mode 100644 index 0000000000000000000000000000000000000000..d7994cd2ddbf23798010f2932299c6fa851ad85d GIT binary patch literal 226 zcmZ9GJqp4=5QS%>CMGsE_BMhxrm>4y`GXJ;%n3G|aoLcpvdM~G&B6nCC~=~KU^Q>} z_#W@^yxjp{20afP2E#qp)@Y?=%*!<6$q5B7RE60FH5w&6Xfx>N{LI6GYZ>m+97WB* zTU}7t8VQak@zR#%^=m{7{6tC3shIHS56|OY*;dym(L@V!g5+q8z_lt!8hq9?+#I;T bYT8IH0D~5-r%S6k;L`8W=RlW||4zXRwEa9| literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaSpecalisedGenericArray.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/ReturningLambdaSpecalisedGenericArray.class new file mode 100644 index 0000000000000000000000000000000000000000..ebe151d624036f3643458ff22a1b366be3be5a9e GIT binary patch literal 233 zcmZ9Hy$ZrW5QO)lCMGso_y~$Nrm<55!5@TxU`ngaWepdSQ_e*6)hv7fA4*(*K(N{w zhHsd?Kdv_b7(&AVOF(BsMQOCsNq~72V|XBmnL1LuBuz%isWEtQpemr5;tBl>b>gq1 zlw={mnV(6P1qo>N`rBYu=K1BzjRd%%N;Gmk=iUE&9Q^85x}b#2Xu^;e?n@(Sp)#i0 ipHZ*e>`>Bi@Pcdr0Tq6NFYl^>&E8>WL7kQRR^Ag3fIlAq literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/SimpleLambda.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/SimpleLambda.class new file mode 100644 index 0000000000000000000000000000000000000000..82f6ca5758f04e1023bb40fc1907f1dda8d18d4b GIT binary patch literal 133 zcmX^0Z`VEs1_l!bPId++Mh2eX%-n*URG-A$q?AN<1{OvJfvm)`ME#t^ymWp4q^#8B z5=I7g*NW8S(vnn024)S-Fh&Nh;QZ2}@ST1_q#N VphZ9$XecWKPyi^x4kVcvH~>>%9xea? literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/StaticLambdas.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/eclipse_classes/StaticLambdas.class new file mode 100644 index 0000000000000000000000000000000000000000..5181e07a228f1e7386e10ad6acdcc3d4b7bec911 GIT binary patch literal 4345 zcmbVOcYGAr5&oW#wWqrWIvp5ef-xXDlAHw5Y(s>xjckMBvkgcA$BL7zPK#JL-5q-? z#WE?RkU|RSz4u}#ww%PdOX4^^ah%?J@4fw-U%q*JWp7u4-!J+@GdKHv^JdlYdE%&(^A){d0GApZs)u#|unE zq;1c$=Zw7$TbaG4VQayj?>P*v(AbAMVRiO^`QR3&0#gIQ1!|G-A>1TB$Vv|_i!^Ke#jj#=@NpD1Uc6uv}^h*}cqQz5RG>}*-^?=qy@(EHI zwo5_L)IK)?iG1!`Je~+Lu``!<3$DLQVM+hML523=;-sVTaP%oy*WK>qW_%WDx__Xx z;xfEjmvlnmQjMipCWJ>SEGH~lc^QHpA;>|EE~EvySz#5CCf7K;4VwhMO`{tbfnTn$ zhVTQ6m0ku*aG6kcXe`GHq3}!=pft8?D1&x9S}40T&c{ljT&>U>UnO=xq@IVXggUHo z0agk1I)(LdYNW_A=)kqY+pBRQRtxVj3-TIK2DOlZg%RQ1sPQnY5#G%T1M&4@q1O2c z+$8)18W&-02A#oXJyzpltjHi4Y{V@Z>##C|RFK@b#(Jz`@5{Oc=cbwI3CA0=C-SEE z71`eo+MX-FYsQY9rihX}i6?110X-}v|A<=_2Q8hK2b1)jvVWuFA1O|z;9$zaVfMFh zKa(7LQgCt1!cn@2)QEh}%V~{-nq|VloXzdr(1X$n`C6M*h!0< zlff-*nKUUp6VJBrEQO0AE?SFI_@{Ve{R88S`nh<%h3CaNji}8|3gU|A#H1_mo-&(uKF5RG}Y}*b%$Kcw`sPN4(3$LbhGJy@6^2b ziI8=(VBe#8f0MjKqs197=UnfaE7@|zHcBP27=Z0@pZP{TvpC5I7XQ-5wMB~jkL)(vOsIB`;jklO} zf6-j`cN%Xu>;AU6?w>W@W!C)@*JYm_DezG`oVUwmhtJ@D@PfvQVWA_n@Gph6XNM|u z1n1Au!4Ak5LKhNJ+SC$K%to?&`87qo4VpH-9*muD10y-~jpQUZlH=J(&RQcmJB{Ql zG?FvTNDeb2ImL|R_@a~uHlT+q_VU+Vl=5d+(GT2wf~Oc|PX*5~ zO16UM7-fG2FEGkjopq?rx;0=mz7kOs2tw<;3hB7}n#r2X3|5Vd`unkrS&dXba?(ZH9OLkZvs178<> z#LG;b%BH`ZQOZ^;yn=_-hF4M#_Esz!ZH$I}pyvLnu>0W51NWT~_pc@}aQ~Wy`_~$0 zY#=pf8_XBhPWzq2hP@?2xv{xK@#^jfJ{7{V@thN{LwGi&bK;kV@N8J;#4iis+04#~ z?+W4B=xX?0O8IM_$6KR2)E#254aOPoi0)A)#9)(*Gu|C#H1FmTyw~jb`|y6sJ6IO; zETnt!5!`3AkK$waxY0g=2k*zM3;|J}#N4EmM9;jE)S|S+FPG3|^t&lEjkCWS_*`q?E*oD*^#=&M$tK b<|yh800W2C({&lNz$M-$=0Jy#_eR|p)6>a${(k3e3`LjXLMho6qwLbk~-nde?IVcbfRuV zHtf!A!XdlQ@q~Li@PmpK6YLqg~pQQtTi_LECdJE6qzG$zU?FD i=%P^lbu899)=2?S$jB2ia|&7H#OK9jP!Q$4Rq+Y?Mn4|_ literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/openjdk_8_classes/SimpleLambda.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/openjdk_8_classes/SimpleLambda.class new file mode 100644 index 0000000000000000000000000000000000000000..db8113dbbc6192dc1c7339bdbebd073f011a22d2 GIT binary patch literal 133 zcmX^0Z`VEs1_l!bPId-%b_Nbc26oqq)a25VR7M774b3n{2Cm@z(xT*4x6B-%kf={$ zZc<93XI@EaQCebhYO!8cVp$?115a>fZb42eM3#|303@oPlbDyT@1K;Fnq0!hz`)4B W1hfc9vj9zIU;(ihSb-!H0~-J&fgUaZ literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/StaticLambdas.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/openjdk_8_classes/StaticLambdas.class similarity index 100% rename from unit/java_bytecode/java_bytecode_parser/lambda_examples/StaticLambdas.class rename to unit/java_bytecode/java_bytecode_parser/lambda_examples/openjdk_8_classes/StaticLambdas.class diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/ArrayParameterLambda.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/ArrayParameterLambda.class new file mode 100644 index 0000000000000000000000000000000000000000..b8f263c9af8b207b3ad8e1426a2b34a49f6a80e0 GIT binary patch literal 260 zcmX^0Z`VEs1_l!bZgvJvb_Om+26oqq)a25VR7M7MjcCtkpRB~PME#t^ymWp4q^#8B z66F1rd{!WjiGdBsVh6K00M%Pa4FCWD literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/DummyGeneric.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/DummyGeneric.class new file mode 100644 index 0000000000000000000000000000000000000000..8883176162913c157d480512227573a343538eca GIT binary patch literal 444 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 literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/OuterMemberLambdas.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/OuterMemberLambdas.class new file mode 100644 index 0000000000000000000000000000000000000000..da380075695df966c7d51116df4e833865b11d0a GIT binary patch literal 534 zcmZWm%T5A85UkxIAnJ)v%4gImM0Sret;ik z>>Y_wIZQuls=B9pK0e>x0i0vMh%A~8b{yn`qxiuB=>MR1^gxER&uGn^%DHR>Qcqd~Z%TgL7HE8nhfn0oKt(jZBJQDlfwFs%gyHid zXKG=nCR)ac;aZ1(E<3*}_jODYGVLxaRysKn_Hvvk%HDyZ_{%hv+c z|H}|)F7uA;s&Rk}{{`%Eu*wloK+*a&lpwIqaRz0MctBLyZZOiaIgmeng?O=)8rv0y c!Do|gDrN%e*kYf-wzUoBfE)1A7|TO^0gN$!B>(^b literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/ParameterLambda.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/ParameterLambda.class new file mode 100644 index 0000000000000000000000000000000000000000..b07856c29dc98525305ea53a9bae73ee6609291f GIT binary patch literal 249 zcmX^0Z`VEs1_l!bZgvJvb_Om+26oqq)a25VR7M6B4Nsq}#Ii*FoW#6zegCAa)Z`Lt zAD7bH+)DSx1DnGYoL^d$ zoa&aD12jm~CowlEB@v{eC@nELwO9}25=I98fW)H2+*F__L;)j%0J;;|7#J8Cn1G%F Y(kzS&%nU3*J}Z#N#J~n*v4dG002whu;Q#;t literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/ReturningLambdaPrimitive.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/ReturningLambdaPrimitive.class new file mode 100644 index 0000000000000000000000000000000000000000..b069f3568a981671f42b3ad464941a80c36f34bb GIT binary patch literal 145 zcmX^0Z`VEs1_l!bPId-%b_Nbc26oqq)a25VR7M774NXr*2Cm@z(xT*4x6B-%kf={$ zZc<93XI@EaQCebhYO!8cVp$?1gG5kjNoi4DW?ni(K|oPvZe~el8BmJ=NQHh*VqUtw he^ORzatRv)10w?y&{81H0&M$tK b<|yh800W2C({&lNz$M-$=0Jy#_eR|p)6>a${(k3e3`LjXLMho6qwLbk~-nde?IVcbfRuV zHtf!A!XdlQ@q~Li@PmpK6YLqg~pQQtTi_LECdJE6qzG$zU?FD i=%P^lbu899)=2?S$jB2ia|&7H#OK9jP!Q$4Rq+Y?Mn4|_ literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/SimpleLambda.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/SimpleLambda.class new file mode 100644 index 0000000000000000000000000000000000000000..db8113dbbc6192dc1c7339bdbebd073f011a22d2 GIT binary patch literal 133 zcmX^0Z`VEs1_l!bPId-%b_Nbc26oqq)a25VR7M774b3n{2Cm@z(xT*4x6B-%kf={$ zZc<93XI@EaQCebhYO!8cVp$?115a>fZb42eM3#|303@oPlbDyT@1K;Fnq0!hz`)4B W1hfc9vj9zIU;(ihSb-!H0~-J&fgUaZ literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/StaticLambdas.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_8_classes/StaticLambdas.class new file mode 100644 index 0000000000000000000000000000000000000000..a5d959f57812675dfa7d5f851dfec18ef5028547 GIT binary patch literal 4245 zcmbVP340sW6+NRk9$T7NvYed|lHk;K(!@!~ibH@H0;Wm`wi{^E0AqRLOd?BSG!B@3 z-`6hC7ASky6o@H{R0un?DP?V0TK45{@Nw=NX>83n@%LeWZ|-^ToqOMXZ|=SGbnx5K z0RSuUO%yHIU5_7NPYf9h3d+WiLtfB%F*qm)a$^|6UP0%_Z~=w|T^PefxLD97FNHC;Qs)v*U{*WPPs(7OE5ZfmFISlKj3 zld0Y2Ub8)8W(V3&@7ryq-3|>iJmsFel{PbW!RkN7%36+{*3ghTX=re8xZEeTzQ-QO zn(mN8TSr$-t{-E$E9+VVmea9;8b-k$%xA2WIoQ{4ip8EWea^@7reh9PrW;dRrE9sC z;|-CKFdfGnR^t`g^wf#|SQU4gW6`;+e-0Ie*{NP-&jG z5)FpVt)jmmxM+w;JF^2GtBqAG92Kb_@(SFff~ec_>ZQDvzm=tyWQ6^G^o z_Tz1()69E8Q=ax62~4*f+MfWkcD6Zs<++B7-*gYz3Jktf9N7S_n?q#XMKkQrWRRcPszp^;-k zBP%qtv~KSjXXSv)@>=TiqZKJ4F4Q}t#i(f<8{B&#T!-QT(;=t$YMNWS!iQ0Ph~iP; z82Ps9)~7S&Sc>-KhMcsu$ySk56&y?DpbeaiO$L@>xsFE-JSLqLI7Y|g(yzH{jdJFMdJd?mCilP`OC14T% zUGTFB>>z$l@PP!niJuqzLIPWfUljaO0$Ye*7W_&AXA!?D__YMK5x*|@9|`ml|5NZm zf`75S!S-(rQ>xC6?ghh?ABM3X0uB1f7g*^bS8_P;31B{{;u0F3*?owbt|2((*Bch@ zfL5rIX*e=Ksjj-=dEdJ7lT|gKA6i23qIeT;MR@~w+p8;M&!a=e-_g*-N)p(&ntGR8 zD|4Lqk?1c8CxbJJ2ALjaNDqj`xgK>%e!lT3w zHME5-hE^X{_(+cJfAaXhj*ks|f-em0lq~I+?EINz<#x%&pGp?~M6&Np$+{m)w)IGs zoguTQ%j{-s(Xe1NZtd*e+#ajl`&KZ?%$;W1%{jxo!tlOQ>FM}NLv1RT+cT7BjCW;u zlj_Wvg@VQJ%^R&_Dpc8?m#(Lp+5U`GX!aC4#?X3Phj)yzBUOsM!+GobO?pcnUU%$g zth{WenaT9nuEhfOH6uNAKI832!`#F3FrTlih4D#>!IBrC0wEV4?nzADMmswAtbk}Rl7vZgA@vPv1}S}gK>p2A)`rA9e< z(bLfO6GU(-pS5aGLl?2(5pWuQ#9lp8zVb7?#LHiP1d$>pX&6C`u4zR~t|6?|1nL6o zim2Cc<_Mxi#1t@!n4&;K5pe|)MKmgqETTz)sTHkh6|L!>miVbDKUZT4@eCf?Of+E@ z=3+LF`3N529B%qZepBYs>!Z-i7q9~hm?}r}S5I>yD$!3Has+eK{(zbh%y`_l?43Xp znM{^2b7qj4B$K%nX3p9du-Ql^Q?bmPU0yw+1ue$OW8O~4YaowFJ|S-kd8`N%@(l7= zJ|^VF$YZSu@@j(njgrU0ROU&DPLdM|23x%fwt3zp&c-<;$!k6rCZB@(kVb^YSn4J+ zRu?cP3FjGG>>FF6jInr@jm=V=vS(g+c|o8vyas&QBgz0^mKbYz0+ABqjk2c1NTRGQ zG43eqN{l_qXo>MhX_PQeWJ8IuNSP=x9x0P0#w6v`5}HL$D`BC?>7!A;f;kBOLayU~ zf*ClIKac0}*KsSymoWp@qJdYbI5VP=?=8t#XyP&MqD}-hKBtV*=}++`K4XsD%>ISc zyoH=waT}YUJMeQhLBGVW*aY2$U$Y7NE$(I$bT59#Cg^@Vz$WM+Jj^EO_xJ;wpu6xV MU-!?x?q6{4cZk;x7ytkO literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ArrayParameterLambda.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ArrayParameterLambda.class new file mode 100644 index 0000000000000000000000000000000000000000..ffb673a5db65e30b74ed6b3a095e2275fe2af899 GIT binary patch literal 260 zcmX^0Z`VEs1_o0GZgvJvb_Om+26oqq)a25VR7M7MjcCtkpRB~PME#t^ymWp4q^#8B z66F1rd{!WjiGdBsVh6K00M=MY4gdfE literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/DummyGeneric.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/DummyGeneric.class new file mode 100644 index 0000000000000000000000000000000000000000..e1b3e6b476425993e1b510b7cd11dd0e534a085c GIT binary patch literal 444 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 literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/OuterMemberLambdas.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/OuterMemberLambdas.class new file mode 100644 index 0000000000000000000000000000000000000000..55c7bac25482d913bda5dc041c9d109b8cb74769 GIT binary patch literal 534 zcmZWm%T5A85UkxIAnJ)v%4gImM0Sret;ik z>>Y_wIZQuls=B9pK0e>x0i0vMh%A~8b{yn`qxiuB=>MR1^gxER&uGn^%DHR>Qcqd~Z%TgL7HE8nhfn0oKt(jZBJQDlfwFs%gyHid zXKG=nCR)ac;aZ1(E<3*}_jODYGVLxaRysKn_Hvvk%HDyZ_{%hv+c z|H}|)F7uA;s&Rk}{{`%Eu*wloK+*a&lpwIqaRz0MctBLyZZOiaIgmeng?O=)8rv0y c!Do|gDrN%e*kYf-wzUoBfE)1A7|TO^0gga_CIA2c literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ParameterLambda.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ParameterLambda.class new file mode 100644 index 0000000000000000000000000000000000000000..aa02bb1dea1d3fbde992ce8ab24d68f16274170f GIT binary patch literal 249 zcmX^0Z`VEs1_o0GZgvJvb_Om+26oqq)a25VR7M6B4Nsq}#Ii*FoW#6zegCAa)Z`Lt zAD7bH+)DSx1DnGYoL^d$ zoa&aD12jm~CowlEB@v{eC@nELwO9}25=I98fW)H2+*F__L;)j%0J;;|7#J8Cn1G%F Y(kzS&%nU3*J}Z#N#J~n*v4dG002(7h;s5{u literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ReturningLambdaPrimitive.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ReturningLambdaPrimitive.class new file mode 100644 index 0000000000000000000000000000000000000000..3a13a75eabe3c0a41ad3c03714d87a75d5b12d0a GIT binary patch literal 145 zcmX^0Z`VEs1_o0GPId-%b_Nbc26oqq)a25VR7M774NXr*2Cm@z(xT*4x6B-%kf={$ zZc<93XI@EaQCebhYO!8cVp$?1gG5kjNoi4DW?ni(K|oPvZe~el8BmJ=NQHh*VqUtw he^ORzatRv)10w?y&{81H09 literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ReturningLambdaPrimitiveArray.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ReturningLambdaPrimitiveArray.class new file mode 100644 index 0000000000000000000000000000000000000000..b560ac34ad8d9706cfb4a1ff6bb302e1a5186a30 GIT binary patch literal 151 zcmX^0Z`VEs1_o0GPId-%b_Nbc26oqq)a25VR7M6C4b5mzMh33n{L-T2RJY6=pqQvn zVs27OqGw)7YEfEZa%!<&R$^HqBZF*EYDsBPUS?i8L_t7NW^QIlW?8CZQBh(gBZB}) pnSM@UUb?=2QdVkm2^#|gBLfrAY9P(R$iU3N0%9?+0!bzYHUNmwC7S>M literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ReturningLambdaReference.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ReturningLambdaReference.class new file mode 100644 index 0000000000000000000000000000000000000000..afad7d8c0f60ce31d2f9cb85cf7fd3aa5dd9935a GIT binary patch literal 162 zcmX^0Z`VEs1_o0GPId-%b_Nbc26oqq)a25VR7M674Nae{#Ii*FoW#6zegCAa)Z`Lt zMh33n{L-T2RJY6=pc+x1#N4EmM9;jE)S|S+z2O%Js6Kpo)vLRVzlNG(1g$M9Z;zR|(YTo0` z`#hevI{?g}=Yj7*z`$EwP}mw7^v9EUY0L7uL5)U&M$tK b<|yh800W2C({&lNz$M-$=0Jy#_eR|p*B?A& literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ReturningLambdaSpecalisedGenericArray.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/ReturningLambdaSpecalisedGenericArray.class new file mode 100644 index 0000000000000000000000000000000000000000..b39b5f987bf96e5f035c3d2e938db7fb9d3e8129 GIT binary patch literal 233 zcmZ9Hxe5Y75JYRd)+5otPf#?`$Vd?c4}=B54UO8dT}F0C8Fxj0&A<=vqr~6>a${(k3e3`LjXLMho6qwLbk~-nde?IVcbfRuV zHtf!A!XdlQ@q~Li@PmpK6YLqg~pQQtTi_LECdJE6qzG$zU?FD i=%P^lbu899)=2?S$jB2ia|&7H#OK9jP!Q$4Rq+Y@C_f+o literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/SimpleLambda.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/SimpleLambda.class new file mode 100644 index 0000000000000000000000000000000000000000..a7af9c4cfe370fc23ea66d3a40aec771b4b82fb1 GIT binary patch literal 133 zcmX^0Z`VEs1_o0GPId-%b_Nbc26oqq)a25VR7M774b3n{2Cm@z(xT*4x6B-%kf={$ zZc<93XI@EaQCebhYO!8cVp$?115a>fZb42eM3#|303@oPlbDyT@1K;Fnq0!hz`)4B W1hfc9vj9zIU;(ihSb-!H0~-J&{~j*@ literal 0 HcmV?d00001 diff --git a/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/StaticLambdas.class b/unit/java_bytecode/java_bytecode_parser/lambda_examples/oracle_9_classes/StaticLambdas.class new file mode 100644 index 0000000000000000000000000000000000000000..73005861fc57b1430dae1c7dfc601c9be6bf3eb1 GIT binary patch literal 4245 zcmbVP340sW6+NRk9$T7NvYefe)xmZsI0ui#c|qsJ;GiJLjbR9T1)U$m1sE1|VGI}HVnLV0a49Ym zba@O{;7UP1kKrm@E$A2W_@z94C68ar<2Um7ZIV9Rkc5WcClSFdNle0RNz~wvNleC_ zNz~$=By`-DL>>N|M7_*LWj2O8bv&%&5e@NzYr1xNi(?PkuD#dNpmq79-PTUav9f87 zCR4l3y=HsH%nr1l*|*zDyB!*4c*;F_D{W@%g4KVTm9-o@t)U^cerRxTxZEeTzQ-QO zn(mN8TZ^hD*N(B=m36HF%jsB04WnQW<}+5x9PH~i#bVExKIdb3(=i7t(~YSu(zRU6 z@rKAqn2uu(tMLkLdg^3{Pd!u(Jc+kk8-(WhMWZ4yoibs5IYO zi3UUGR?%M=Tr|X_o!J48)y66o<^?VIZY$cTy6@TH)vIY#Uwr6YR9R{XIuhDS#i2QY z{dimHH1l52l&5`10@E#r_9wusU2A7;cb$ewt!-O1)O6}_)fyUG+qMVS39wc%ZiO}RIxBfPWQG@75nB5A(8zJ2 zk>wg%TDNzNvvR;?c`fz%(TWri7wVnSV$?K_4eq@Vu0!#F>5x-=HO;ME;lrptMDZwa zjC@;lYtxx>EJb^ALr&V-V5`Wf3XWstpbeag4F;BCnT|&dJSLsxI8Mjo(y1;LdL!7MR zDe3eYI0dT=bYhKx_2@A00~}*u363_DLVKv5I}r35VE ze+d3(0y~KRCHR>Hx{3cS_}K)u5I-mQ`2;o-zaaQO37k#*U%~%NU@P(e1;3a;FY!x) z4-mY}c988A4O6Plj_w7+lplt%9|8^fsTWx3Ay;xZ@Cjf(sp1kEp4okfnyw)@<<}b) z?toUPl4&?HK&h^};d$S>@{?6HpdVU7@uGMYuSIzSc-^ZjW6z^Q#^2D;#7Yv_x0-sB zTjbPu=c4A{(lCef0YChGD9+pCa{Rq0&O4GY{DDJx&7KFL}n#xy2d~aN$zwjvW zeGP44i=ov=6+Vz-`%oSq>G;^dC-}m^PRY`K$9gE8fsIy+@7I4W4tTN zn^b4UEEFt$Zw|JOsZeEmUb=2Hv;7&X(CjI8jG^_o4(}LaN2(Nihx69=oAj1Eyzbb~ zSb5n_Gn47DU5f?mYestLe8$_4hPj95VF6!R3-7^k-f>yai0Y)cDalI5%ki0p2qHyH(lCM=UDJw~Ttir^3DgDF z6;ZEY+X$jX#1t@!n4&;K5pe|)MKmgqETTz)sTHkh6|L!>miVbDKUZQ3@eCf?Of+E@ z=3+LF`3N529B%qZepBYs>v`zq3)q2$OqE6a)zh4aO7zo)9Kjs5KcHp=GamOXdneFD zCX*%1oEc;$$z*PYnX?`a*lZ+|saR&tF0UTZf)?ZCF>fd2HIT<7pO80&JXVAWc?Nkb z9~1Io3#cqb0^4rBT9skqsrrB4wh)c%)307?YG!OK283t%SuQr;kSYa^@iT3%QQ} z31;9-{yd(~U&pN+U&;(vjRsz&;>?IfzPBV}p^3-1i#ie5_?$9Ir$5D)_>4Jn4f_{T z^ICGQ!}V-}Zp81{1l@$2*#zywt!#pB#~;`P?Z+K#g6_iIY=Z8^pV$Q5j|bQU?ZaPu L-3NW$hp_)UnPmFile System" + import source. + 4. The `.java` files should now show in the src folder of the package explorer. + The IDE will have automatically compiled these, because it needs the `.class` + files for its autocomplete/syntax highlighting/tool tip functionality. + 5. The auto compiled files should be in a `bin` sub directory of the project + directory. These can be copied into the appropriate sub directory of the unit + test using your command line shell or file browser of choice. Note that the + `bin` directory and the class files are not shown in the Eclipse IDE. + +The Eclipse java compiler is distibuted as a .jar file, which can be run from +the command line. For detailed information see here [https://help.eclipse.org/neon/index.jsp?topic=%2Forg.eclipse.jdt.doc.user%2Ftasks%2Ftask-using_batch_compiler.htm] +For example the eclipse compiler version could be extracted with `java -jar +./ecj-4.7.2.jar -version`. However this is redundant as the version number is +usually in the file name of the jar file already. The java files can be compiled +with the eclipse compiler through the command line with `java -jar +./ecj-4.7.2.jar -g -1.8 ./*.java`. The additional `-1.8` is required to use java +compilance level 1.8, which is required for lambdas. From 3e298ef85d4877bf8990d00179c52081e641ac48 Mon Sep 17 00:00:00 2001 From: Thomas Spriggs Date: Thu, 1 Mar 2018 14:05:57 +0000 Subject: [PATCH 2/2] Formmatting fixes/updates for `java_bytecode_parse_lambda_method_handle` test update. --- ...ava_bytecode_parse_lambda_method_table.cpp | 1863 +++++++++-------- 1 file changed, 964 insertions(+), 899 deletions(-) diff --git a/unit/java_bytecode/java_bytecode_parser/java_bytecode_parse_lambda_method_table.cpp b/unit/java_bytecode/java_bytecode_parser/java_bytecode_parse_lambda_method_table.cpp index e218c624428..ea132076074 100644 --- a/unit/java_bytecode/java_bytecode_parser/java_bytecode_parse_lambda_method_table.cpp +++ b/unit/java_bytecode/java_bytecode_parser/java_bytecode_parse_lambda_method_table.cpp @@ -35,923 +35,988 @@ SCENARIO( "lambda_method_handle_map with static lambdas", "[core][java_bytecode][java_bytecode_parse_lambda_method_handle]") { - run_test_with_compilers([](const std::string &compiler) - { - null_message_handlert message_handler; - GIVEN("A class with a static lambda variables from " + compiler + " compiler.") - { - java_bytecode_parse_treet parse_tree; - java_bytecode_parse( - "./java_bytecode/java_bytecode_parser/lambda_examples/" + - compiler + "_classes/StaticLambdas.class", - parse_tree, - message_handler); - WHEN("Parsing that class") + // NOLINTNEXTLINE(whitespace/braces) + run_test_with_compilers([](const std::string &compiler) { + null_message_handlert message_handler; + GIVEN( + "A class with a static lambda variables from " + compiler + " compiler.") { - 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 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); - REQUIRE(id2string(lambda_method.descriptor) == descriptor); - - const typet primitive_type = java_int_type(); - - fieldref_exprt fieldref{ - primitive_type, "staticPrimitive", "java::StaticLambdas"}; - - std::vector - expected_instructions{{"getstatic", {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 " - "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, 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) == descriptor); - - const reference_typet dummy_generic_reference_type = - java_reference_type(symbol_typet{"java::java.lang.Object"}); - - fieldref_exprt fieldref{dummy_generic_reference_type, - "staticReference", - "java::StaticLambdas"}; - - std::vector - expected_instructions{{"getstatic", {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 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, 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) == descriptor); - - const reference_typet dummy_generic_reference_type = - java_reference_type(symbol_typet{"java::DummyGeneric"}); - - fieldref_exprt fieldref{dummy_generic_reference_type, - "staticSpecalisedGeneric", - "java::StaticLambdas"}; - - std::vector - expected_instructions{{"getstatic", {fieldref}}, {"areturn", {}}}; - - require_parse_tree::require_instructions_match_expectation( - expected_instructions, lambda_method.instructions); + java_bytecode_parse_treet parse_tree; + java_bytecode_parse( + "./java_bytecode/java_bytecode_parser/lambda_examples/" + compiler + + "_classes/StaticLambdas.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 " + "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); + REQUIRE(id2string(lambda_method.descriptor) == descriptor); + + const typet primitive_type = java_int_type(); + + fieldref_exprt fieldref{// NOLINT(whitespace/braces) + primitive_type, + "staticPrimitive", + "java::StaticLambdas"}; + + std::vector + expected_instructions{{"getstatic", {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 " + "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, 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) == descriptor); + + const reference_typet dummy_generic_reference_type = + java_reference_type(symbol_typet{"java::java.lang.Object"}); + + fieldref_exprt fieldref{dummy_generic_reference_type, + "staticReference", + "java::StaticLambdas"}; + + std::vector + expected_instructions{{"getstatic", {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 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, 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) == descriptor); + + const reference_typet dummy_generic_reference_type = + java_reference_type(symbol_typet{"java::DummyGeneric"}); + + fieldref_exprt fieldref{dummy_generic_reference_type, + "staticSpecalisedGeneric", + "java::StaticLambdas"}; + + std::vector + expected_instructions{{"getstatic", {fieldref}}, {"areturn", {}}}; + + require_parse_tree::require_instructions_match_expectation( + expected_instructions, lambda_method.instructions); + } } } - } }); } SCENARIO( "lambda_method_handle_map with local lambdas", "[core][java_bytecode][java_bytecode_parse_lambda_method_handle]") { - run_test_with_compilers([](const std::string &compiler) - { - null_message_handlert message_handler; - GIVEN("A method with local lambdas from " + compiler + " compiler.") - { - java_bytecode_parse_treet parse_tree; - java_bytecode_parse( - "./java_bytecode/java_bytecode_parser/lambda_examples/" + - compiler + "_classes/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 - 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 - 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 - expected_instructions{{"aload_0", {}}, {"areturn", {}}}; - - require_parse_tree::require_instructions_match_expectation( - expected_instructions, lambda_method.instructions); - } - } - } - }); + run_test_with_compilers( + [](const std::string &compiler) { // NOLINT(whitespace/braces) + null_message_handlert message_handler; + GIVEN("A method with local lambdas from " + compiler + " compiler.") + { + java_bytecode_parse_treet parse_tree; + java_bytecode_parse( + "./java_bytecode/java_bytecode_parser/lambda_examples/" + compiler + + "_classes/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 + 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 + 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 + expected_instructions{{"aload_0", {}}, {"areturn", {}}}; + + require_parse_tree::require_instructions_match_expectation( + expected_instructions, lambda_method.instructions); + } + } + } + }); } SCENARIO( "lambda_method_handle_map with member lambdas", "[core][java_bytecode][java_bytecode_parse_lambda_method_handle]") { - run_test_with_compilers([](const std::string &compiler) - { - null_message_handlert message_handler; - GIVEN("A class that has lambdas as member variables from " + compiler + " compiler.") - { - java_bytecode_parse_treet parse_tree; - java_bytecode_parse( - "./java_bytecode/java_bytecode_parser/lambda_examples/" + - compiler + "_classes/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 - 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 - 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 - 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); - } - } - } - }); + run_test_with_compilers( + [](const std::string &compiler) { // NOLINT(whitespace/braces) + null_message_handlert message_handler; + GIVEN( + "A class that has lambdas as member variables from " + compiler + + " compiler.") + { + java_bytecode_parse_treet parse_tree; + java_bytecode_parse( + "./java_bytecode/java_bytecode_parser/lambda_examples/" + compiler + + "_classes/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{// NOLINT(whitespace/braces) + java_int_type(), + "memberPrimitive", + "java::MemberLambdas"}; + + std::vector + 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"}); + + // NOLINTNEXTLINE(whitespace/braces) + const fieldref_exprt reference_fieldref{ + dummy_generic_reference_type, + "memberReference", + "java::MemberLambdas"}; + + std::vector + 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"}); + + // NOLINTNEXTLINE(whitespace/braces) + 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 + 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); + } + } + } + }); } SCENARIO( "lambda_method_handle_map with member lambdas capturing outer class " "variables", "[core][java_bytecode][java_bytecode_parse_lambda_method_handle]") { - run_test_with_compilers([](const std::string &compiler) - { - null_message_handlert message_handler; - GIVEN( - "An inner class with member variables as lambdas that capture outer " - "variables from " + compiler + " compiler.") - { - java_bytecode_parse_treet parse_tree; - java_bytecode_parse( - "./java_bytecode/java_bytecode_parser/lambda_examples/" + - compiler + "_classes/OuterMemberLambdas$Inner.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() == 3); - - // Field ref for getting the outer class - const reference_typet outer_class_reference_type = - java_reference_type(symbol_typet{"java::OuterMemberLambdas"}); - const fieldref_exprt outer_fieldref{ - outer_class_reference_type, "this$0", "java::OuterMemberLambdas$Inner"}; - - 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); - - 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::OuterMemberLambdas"}; - - std::vector - expected_instructions{{"aload_0", {}}, // load this of stack - {"getfield", {outer_fieldref}}, - {"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); - - 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::OuterMemberLambdas"}; - - std::vector - expected_instructions{{"aload_0", {}}, // load this of stack - {"getfield", {outer_fieldref}}, - {"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); - - 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::OuterMemberLambdas"}; - - // since just returning the parameter, nothing to put on the stack - std::vector - expected_instructions{{"aload_0", {}}, // load this of stack - {"getfield", {outer_fieldref}}, - {"getfield", {generic_reference_fieldref}}, - {"areturn", {}}}; - - require_parse_tree::require_instructions_match_expectation( - expected_instructions, lambda_method.instructions); - } - } - } - }); + run_test_with_compilers( + [](const std::string &compiler) { // NOLINT(whitespace/braces) + null_message_handlert message_handler; + GIVEN( + "An inner class with member variables as lambdas that capture outer " + "variables from " + + compiler + " compiler.") + { + java_bytecode_parse_treet parse_tree; + java_bytecode_parse( + "./java_bytecode/java_bytecode_parser/lambda_examples/" + compiler + + "_classes/OuterMemberLambdas$Inner.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() == 3); + + // Field ref for getting the outer class + const reference_typet outer_class_reference_type = + java_reference_type(symbol_typet{"java::OuterMemberLambdas"}); + const fieldref_exprt outer_fieldref{outer_class_reference_type, + "this$0", + "java::OuterMemberLambdas$Inner"}; + + 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); + + 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); + + // NOLINTNEXTLINE(whitespace/braces) + const fieldref_exprt primitive_fieldref{ + java_int_type(), "memberPrimitive", "java::OuterMemberLambdas"}; + + std::vector + expected_instructions{{"aload_0", {}}, // load this of stack + {"getfield", {outer_fieldref}}, + {"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); + + 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"}); + + // NOLINTNEXTLINE(whitespace/braces) + const fieldref_exprt reference_fieldref{ + dummy_generic_reference_type, + "memberReference", + "java::OuterMemberLambdas"}; + + std::vector + expected_instructions{{"aload_0", {}}, // load this of stack + {"getfield", {outer_fieldref}}, + {"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); + + 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"}); + + // NOLINTNEXTLINE(whitespace/braces) + const fieldref_exprt generic_reference_fieldref{ + dummy_generic_reference_type, + "memberSpecalisedGeneric", + "java::OuterMemberLambdas"}; + + // since just returning the parameter, nothing to put on the stack + std::vector + expected_instructions{{"aload_0", {}}, // load this of stack + {"getfield", {outer_fieldref}}, + {"getfield", {generic_reference_fieldref}}, + {"areturn", {}}}; + + require_parse_tree::require_instructions_match_expectation( + expected_instructions, lambda_method.instructions); + } + } + } + }); }