Mute Painless lambda tests on JDK 9

This commit mutes a ton of Painless lambda tests on JDK 9. This commit
did not attempt to discover exactly which tests are failing, but instead
just blanket muted all tests in LambdaTests, FunctionRefTests, and
AugmentationTests.

Relates #23473

modules/lang-painless/src/test/java/org/elasticsearch/painless/AugmentationTests.java

@@ -19,6 +19,8 @@
 
 package org.elasticsearch.painless;
 
+import org.apache.lucene.util.Constants;
+
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
@@ -27,21 +29,25 @@ import java.util.Map;
 public class AugmentationTests extends ScriptTestCase {
     
     public void testStatic() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(1, exec("ArrayList l = new ArrayList(); l.add(1); return l.getLength();"));
         assertEquals(1, exec("ArrayList l = new ArrayList(); l.add(1); return l.length;"));
     }
     
     public void testSubclass() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(1, exec("List l = new ArrayList(); l.add(1); return l.getLength();"));
         assertEquals(1, exec("List l = new ArrayList(); l.add(1); return l.length;"));
     }
     
     public void testDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(1, exec("def l = new ArrayList(); l.add(1); return l.getLength();"));
         assertEquals(1, exec("def l = new ArrayList(); l.add(1); return l.length;"));
     }
     
     public void testCapturingReference() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(1, exec("int foo(Supplier t) { return t.get() }" +
                              "ArrayList l = new ArrayList(); l.add(1);" +
                              "return foo(l::getLength);"));
@@ -54,16 +60,19 @@ public class AugmentationTests extends ScriptTestCase {
     }
     
     public void testIterable_Any() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(true, 
                 exec("List l = new ArrayList(); l.add(1); l.any(x -> x == 1)"));
     }
     
     public void testIterable_AsCollection() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(true, 
                 exec("List l = new ArrayList(); return l.asCollection() === l"));
     }
     
     public void testIterable_AsList() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(true, 
                 exec("List l = new ArrayList(); return l.asList() === l"));
         assertEquals(5, 
@@ -71,41 +80,49 @@ public class AugmentationTests extends ScriptTestCase {
     }
     
     public void testIterable_Each() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(1, 
                 exec("List l = new ArrayList(); l.add(1); List l2 = new ArrayList(); l.each(l2::add); return l2.size()"));
     }
     
     public void testIterable_EachWithIndex() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(0, 
                 exec("List l = new ArrayList(); l.add(2); Map m = new HashMap(); l.eachWithIndex(m::put); return m.get(2)"));
     }
     
     public void testIterable_Every() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(false, exec("List l = new ArrayList(); l.add(1); l.add(2); l.every(x -> x == 1)"));
     }
     
     public void testIterable_FindResults() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(1, 
                 exec("List l = new ArrayList(); l.add(1); l.add(2); l.findResults(x -> x == 1 ? x : null).size()"));
     }
     
     public void testIterable_GroupBy() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(2, 
                 exec("List l = new ArrayList(); l.add(1); l.add(-1); l.groupBy(x -> x < 0 ? 'negative' : 'positive').size()"));
     }
     
     public void testIterable_Join() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("test,ing", 
                 exec("List l = new ArrayList(); l.add('test'); l.add('ing'); l.join(',')"));
     }
     
     public void testIterable_Sum() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(3.0D, exec("def l = [1,2]; return l.sum()"));
         assertEquals(5.0D, 
                 exec("List l = new ArrayList(); l.add(1); l.add(2); l.sum(x -> x + 1)"));
     }
     
     public void testCollection_Collect() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(Arrays.asList(2, 3), 
                 exec("List l = new ArrayList(); l.add(1); l.add(2); l.collect(x -> x + 1)"));
         assertEquals(asSet(2, 3), 
@@ -113,16 +130,19 @@ public class AugmentationTests extends ScriptTestCase {
     }
     
     public void testCollection_Find() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(2, 
                 exec("List l = new ArrayList(); l.add(1); l.add(2); return l.find(x -> x == 2)"));
     }
     
     public void testCollection_FindAll() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(Arrays.asList(2), 
                 exec("List l = new ArrayList(); l.add(1); l.add(2); return l.findAll(x -> x == 2)"));
     }
     
     public void testCollection_FindResult() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("found", 
                 exec("List l = new ArrayList(); l.add(1); l.add(2); return l.findResult(x -> x > 1 ? 'found' : null)"));
         assertEquals("notfound", 
@@ -130,11 +150,13 @@ public class AugmentationTests extends ScriptTestCase {
     }
     
     public void testCollection_Split() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(Arrays.asList(Arrays.asList(2), Arrays.asList(1)), 
                 exec("List l = new ArrayList(); l.add(1); l.add(2); return l.split(x -> x == 2)"));
     }
     
     public void testMap_Collect() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(Arrays.asList("one1", "two2"), 
                 exec("Map m = new TreeMap(); m.one = 1; m.two = 2; m.collect((key,value) -> key + value)"));
         assertEquals(asSet("one1", "two2"), 
@@ -142,31 +164,37 @@ public class AugmentationTests extends ScriptTestCase {
     }
     
     public void testMap_Count() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(1, 
                 exec("Map m = new TreeMap(); m.one = 1; m.two = 2; m.count((key,value) -> value == 2)"));
     }
     
     public void testMap_Each() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(2, 
                 exec("Map m = new TreeMap(); m.one = 1; m.two = 2; Map m2 = new TreeMap(); m.each(m2::put); return m2.size()"));
     }
     
     public void testMap_Every() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(false, 
                 exec("Map m = new TreeMap(); m.one = 1; m.two = 2; m.every((key,value) -> value == 2)"));
     }
     
     public void testMap_Find() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("two", 
                 exec("Map m = new TreeMap(); m.one = 1; m.two = 2; return m.find((key,value) -> value == 2).key"));
     }
     
     public void testMap_FindAll() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(Collections.singletonMap("two", 2), 
                 exec("Map m = new TreeMap(); m.one = 1; m.two = 2; return m.findAll((key,value) -> value == 2)"));
     }
     
     public void testMap_FindResult() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("found", 
                 exec("Map m = new TreeMap(); m.one = 1; m.two = 2; return m.findResult((key,value) -> value == 2 ? 'found' : null)"));
         assertEquals("notfound", 
@@ -175,12 +203,14 @@ public class AugmentationTests extends ScriptTestCase {
     }
     
     public void testMap_FindResults() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(Arrays.asList("negative", "positive"),
                 exec("Map m = new TreeMap(); m.a = -1; m.b = 1; " + 
                      "return m.findResults((key,value) -> value < 0 ? 'negative' : 'positive')"));
     }
     
     public void testMap_GroupBy() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         Map<String,Map<String,Integer>> expected = new HashMap<>();
         expected.put("negative", Collections.singletonMap("a", -1));
         expected.put("positive", Collections.singletonMap("b", 1));

modules/lang-painless/src/test/java/org/elasticsearch/painless/FunctionRefTests.java

@@ -19,6 +19,7 @@
 
 package org.elasticsearch.painless;
 
+import org.apache.lucene.util.Constants;
 import org.joda.time.DateTime;
 import org.joda.time.DateTimeZone;
 
@@ -32,32 +33,39 @@ import static org.hamcrest.Matchers.startsWith;
 public class FunctionRefTests extends ScriptTestCase {
 
     public void testStaticMethodReference() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(1, exec("List l = new ArrayList(); l.add(2); l.add(1); l.sort(Integer::compare); return l.get(0);"));
     }
     
     public void testStaticMethodReferenceDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(1, exec("def l = new ArrayList(); l.add(2); l.add(1); l.sort(Integer::compare); return l.get(0);"));
     }
 
     public void testVirtualMethodReference() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(2, exec("List l = new ArrayList(); l.add(1); l.add(1); return l.stream().mapToInt(Integer::intValue).sum();"));
     }
     
     public void testVirtualMethodReferenceDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(2, exec("def l = new ArrayList(); l.add(1); l.add(1); return l.stream().mapToInt(Integer::intValue).sum();"));
     }
 
     public void testQualifiedStaticMethodReference() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(true,
                 exec("List l = [true]; l.stream().map(org.elasticsearch.painless.FeatureTest::overloadedStatic).findFirst().get()"));
     }
 
     public void testQualifiedStaticMethodReferenceDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(true,
                 exec("def l = [true]; l.stream().map(org.elasticsearch.painless.FeatureTest::overloadedStatic).findFirst().get()"));
     }
 
     public void testQualifiedVirtualMethodReference() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         long instant = randomLong();
         assertEquals(instant, exec(
                 "List l = [params.d]; return l.stream().mapToLong(org.joda.time.ReadableDateTime::getMillis).sum()",
@@ -65,6 +73,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
 
     public void testQualifiedVirtualMethodReferenceDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         long instant = randomLong();
         assertEquals(instant, exec(
                 "def l = [params.d]; return l.stream().mapToLong(org.joda.time.ReadableDateTime::getMillis).sum()",
@@ -72,6 +81,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
 
     public void testCtorMethodReference() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(3.0D, 
                 exec("List l = new ArrayList(); l.add(1.0); l.add(2.0); " + 
                         "DoubleStream doubleStream = l.stream().mapToDouble(Double::doubleValue);" + 
@@ -82,6 +92,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
     
     public void testCtorMethodReferenceDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(3.0D, 
             exec("def l = new ArrayList(); l.add(1.0); l.add(2.0); " + 
                  "def doubleStream = l.stream().mapToDouble(Double::doubleValue);" + 
@@ -92,6 +103,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
 
     public void testArrayCtorMethodRef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(1.0D, 
                 exec("List l = new ArrayList(); l.add(1.0); l.add(2.0); " + 
                      "def[] array = l.stream().toArray(Double[]::new);" + 
@@ -99,6 +111,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
 
     public void testArrayCtorMethodRefDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(1.0D, 
                 exec("def l = new ArrayList(); l.add(1.0); l.add(2.0); " + 
                      "def[] array = l.stream().toArray(Double[]::new);" + 
@@ -106,26 +119,31 @@ public class FunctionRefTests extends ScriptTestCase {
     }
 
     public void testCapturingMethodReference() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("5", exec("Integer x = Integer.valueOf(5); return Optional.empty().orElseGet(x::toString);"));
         assertEquals("[]", exec("List l = new ArrayList(); return Optional.empty().orElseGet(l::toString);"));
     }
     
     public void testCapturingMethodReferenceDefImpl() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("5", exec("def x = Integer.valueOf(5); return Optional.empty().orElseGet(x::toString);"));
         assertEquals("[]", exec("def l = new ArrayList(); return Optional.empty().orElseGet(l::toString);"));
     }
     
     public void testCapturingMethodReferenceDefInterface() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("5", exec("Integer x = Integer.valueOf(5); def opt = Optional.empty(); return opt.orElseGet(x::toString);"));
         assertEquals("[]", exec("List l = new ArrayList(); def opt = Optional.empty(); return opt.orElseGet(l::toString);"));
     }
     
     public void testCapturingMethodReferenceDefEverywhere() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("5", exec("def x = Integer.valueOf(5); def opt = Optional.empty(); return opt.orElseGet(x::toString);"));
         assertEquals("[]", exec("def l = new ArrayList(); def opt = Optional.empty(); return opt.orElseGet(l::toString);"));
     }
     
     public void testCapturingMethodReferenceMultipleLambdas() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("testingcdefg", exec(
                 "String x = 'testing';" +
                 "String y = 'abcdefg';" + 
@@ -134,6 +152,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
     
     public void testCapturingMethodReferenceMultipleLambdasDefImpls() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("testingcdefg", exec(
                 "def x = 'testing';" +
                 "def y = 'abcdefg';" + 
@@ -142,6 +161,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
     
     public void testCapturingMethodReferenceMultipleLambdasDefInterface() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("testingcdefg", exec(
                 "String x = 'testing';" +
                 "String y = 'abcdefg';" + 
@@ -150,6 +170,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
     
     public void testCapturingMethodReferenceMultipleLambdasDefEverywhere() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("testingcdefg", exec(
                 "def x = 'testing';" +
                 "def y = 'abcdefg';" + 
@@ -158,26 +179,31 @@ public class FunctionRefTests extends ScriptTestCase {
     }
     
     public void testOwnStaticMethodReference() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(2, exec("int mycompare(int i, int j) { j - i } " +
                              "List l = new ArrayList(); l.add(2); l.add(1); l.sort(this::mycompare); return l.get(0);"));
     }
     
     public void testOwnStaticMethodReferenceDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(2, exec("int mycompare(int i, int j) { j - i } " +
                              "def l = new ArrayList(); l.add(2); l.add(1); l.sort(this::mycompare); return l.get(0);"));
     }
 
     public void testInterfaceDefaultMethod() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("bar", exec("String f(BiFunction function) { function.apply('foo', 'bar') }" + 
                                  "Map map = new HashMap(); f(map::getOrDefault)"));
     }
     
     public void testInterfaceDefaultMethodDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("bar", exec("String f(BiFunction function) { function.apply('foo', 'bar') }" + 
                                  "def map = new HashMap(); f(map::getOrDefault)"));
     }
 
     public void testMethodMissing() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         Exception e = expectScriptThrows(IllegalArgumentException.class, () -> {
             exec("List l = [2, 1]; l.sort(Integer::bogus); return l.get(0);");
         });
@@ -185,6 +211,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
 
     public void testQualifiedMethodMissing() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         Exception e = expectScriptThrows(IllegalArgumentException.class, () -> {
             exec("List l = [2, 1]; l.sort(org.joda.time.ReadableDateTime::bogus); return l.get(0);", false);
         });
@@ -192,6 +219,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
 
     public void testClassMissing() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         Exception e = expectScriptThrows(IllegalArgumentException.class, () -> {
             exec("List l = [2, 1]; l.sort(Bogus::bogus); return l.get(0);", false);
         });
@@ -199,6 +227,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
 
     public void testQualifiedClassMissing() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         Exception e = expectScriptThrows(IllegalArgumentException.class, () -> {
             exec("List l = [2, 1]; l.sort(org.joda.time.BogusDateTime::bogus); return l.get(0);", false);
         });
@@ -208,6 +237,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
 
     public void testNotFunctionalInterface() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         IllegalArgumentException expected = expectScriptThrows(IllegalArgumentException.class, () -> {
             exec("List l = new ArrayList(); l.add(2); l.add(1); l.add(Integer::bogus); return l.get(0);");
         });
@@ -215,12 +245,14 @@ public class FunctionRefTests extends ScriptTestCase {
     }
 
     public void testIncompatible() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         expectScriptThrows(BootstrapMethodError.class, () -> {
             exec("List l = new ArrayList(); l.add(2); l.add(1); l.sort(String::startsWith); return l.get(0);");
         });
     }
     
     public void testWrongArity() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         IllegalArgumentException expected = expectScriptThrows(IllegalArgumentException.class, () -> {
             exec("Optional.empty().orElseGet(String::startsWith);");
         });
@@ -228,6 +260,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
     
     public void testWrongArityNotEnough() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         IllegalArgumentException expected = expectScriptThrows(IllegalArgumentException.class, () -> {
             exec("List l = new ArrayList(); l.add(2); l.add(1); l.sort(String::isEmpty);");
         });
@@ -235,6 +268,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
     
     public void testWrongArityDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         IllegalArgumentException expected = expectScriptThrows(IllegalArgumentException.class, () -> {
             exec("def y = Optional.empty(); return y.orElseGet(String::startsWith);");
         });
@@ -242,6 +276,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
     
     public void testWrongArityNotEnoughDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         IllegalArgumentException expected = expectScriptThrows(IllegalArgumentException.class, () -> {
             exec("def l = new ArrayList(); l.add(2); l.add(1); l.sort(String::isEmpty);");
         });
@@ -249,6 +284,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
 
     public void testReturnVoid() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         Throwable expected = expectScriptThrows(BootstrapMethodError.class, () -> {
             exec("StringBuilder b = new StringBuilder(); List l = [1, 2]; l.stream().mapToLong(b::setLength);");
         });
@@ -257,6 +293,7 @@ public class FunctionRefTests extends ScriptTestCase {
     }
 
     public void testReturnVoidDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         Exception expected = expectScriptThrows(LambdaConversionException.class, () -> {
             exec("StringBuilder b = new StringBuilder(); def l = [1, 2]; l.stream().mapToLong(b::setLength);");
         });

modules/lang-painless/src/test/java/org/elasticsearch/painless/LambdaTests.java

@@ -19,6 +19,8 @@
 
 package org.elasticsearch.painless;
 
+import org.apache.lucene.util.Constants;
+
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
@@ -28,72 +30,87 @@ import static org.hamcrest.Matchers.containsString;
 public class LambdaTests extends ScriptTestCase {
 
     public void testNoArgLambda() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(1, exec("Optional.empty().orElseGet(() -> 1);"));
     }
 
     public void testNoArgLambdaDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(1, exec("def x = Optional.empty(); x.orElseGet(() -> 1);"));
     }
 
     public void testLambdaWithArgs() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("short", exec("List l = new ArrayList(); l.add('looooong'); l.add('short'); "
                                  + "l.sort((a, b) -> a.length() - b.length()); return l.get(0)"));
 
     }
 
     public void testLambdaWithTypedArgs() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("short", exec("List l = new ArrayList(); l.add('looooong'); l.add('short'); "
                                  + "l.sort((String a, String b) -> a.length() - b.length()); return l.get(0)"));
 
     }
 
     public void testPrimitiveLambdas() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(4, exec("List l = new ArrayList(); l.add(1); l.add(1); "
                            + "return l.stream().mapToInt(x -> x + 1).sum();"));
     }
 
     public void testPrimitiveLambdasWithTypedArgs() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(4, exec("List l = new ArrayList(); l.add(1); l.add(1); "
                            + "return l.stream().mapToInt(int x -> x + 1).sum();"));
     }
 
     public void testPrimitiveLambdasDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(4, exec("def l = new ArrayList(); l.add(1); l.add(1); "
                            + "return l.stream().mapToInt(x -> x + 1).sum();"));
     }
 
     public void testPrimitiveLambdasWithTypedArgsDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(4, exec("def l = new ArrayList(); l.add(1); l.add(1); "
                            + "return l.stream().mapToInt(int x -> x + 1).sum();"));
     }
 
     public void testPrimitiveLambdasConvertible() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(2, exec("List l = new ArrayList(); l.add(1); l.add(1); "
                            + "return l.stream().mapToInt(byte x -> x).sum();"));
     }
 
     public void testPrimitiveArgs() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(2, exec("int applyOne(IntFunction arg) { arg.apply(1) } applyOne(x -> x + 1)"));
     }
 
     public void testPrimitiveArgsTyped() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(2, exec("int applyOne(IntFunction arg) { arg.apply(1) } applyOne(int x -> x + 1)"));
     }
 
     public void testPrimitiveArgsTypedOddly() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(2L, exec("long applyOne(IntFunction arg) { arg.apply(1) } applyOne(long x -> x + 1)"));
     }
 
     public void testMultipleStatements() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(2, exec("int applyOne(IntFunction arg) { arg.apply(1) } applyOne(x -> { def y = x + 1; return y })"));
     }
 
     public void testUnneededCurlyStatements() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(2, exec("int applyOne(IntFunction arg) { arg.apply(1) } applyOne(x -> { x + 1 })"));
     }
 
     /** interface ignores return value */
     public void testVoidReturn() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(2, exec("List list = new ArrayList(); "
                            + "list.add(2); "
                            + "List list2 = new ArrayList(); "
@@ -103,6 +120,7 @@ public class LambdaTests extends ScriptTestCase {
 
     /** interface ignores return value */
     public void testVoidReturnDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(2, exec("def list = new ArrayList(); "
                            + "list.add(2); "
                            + "List list2 = new ArrayList(); "
@@ -111,16 +129,19 @@ public class LambdaTests extends ScriptTestCase {
     }
 
     public void testTwoLambdas() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("testingcdefg", exec(
                 "org.elasticsearch.painless.FeatureTest test = new org.elasticsearch.painless.FeatureTest(2,3);" +
                 "return test.twoFunctionsOfX(x -> 'testing'.concat(x), y -> 'abcdefg'.substring(y))"));
     }
 
     public void testNestedLambdas() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(1, exec("Optional.empty().orElseGet(() -> Optional.empty().orElseGet(() -> 1));"));
     }
 
     public void testLambdaInLoop() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(100, exec("int sum = 0; " +
                                "for (int i = 0; i < 100; i++) {" +
                                "  sum += Optional.empty().orElseGet(() -> 1);" +
@@ -129,14 +150,17 @@ public class LambdaTests extends ScriptTestCase {
     }
 
     public void testCapture() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(5, exec("int x = 5; return Optional.empty().orElseGet(() -> x);"));
     }
 
     public void testTwoCaptures() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals("1test", exec("int x = 1; String y = 'test'; return Optional.empty().orElseGet(() -> x + y);"));
     }
 
     public void testCapturesAreReadOnly() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         IllegalArgumentException expected = expectScriptThrows(IllegalArgumentException.class, () -> {
             exec("List l = new ArrayList(); l.add(1); l.add(1); "
                     + "return l.stream().mapToInt(x -> { l = null; return x + 1 }).sum();");
@@ -146,12 +170,14 @@ public class LambdaTests extends ScriptTestCase {
 
     @AwaitsFix(bugUrl = "def type tracking")
     public void testOnlyCapturesAreReadOnly() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(4, exec("List l = new ArrayList(); l.add(1); l.add(1); "
                            + "return l.stream().mapToInt(x -> { x += 1; return x }).sum();"));
     }
 
     /** Lambda parameters shouldn't be able to mask a variable already in scope */
     public void testNoParamMasking() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         IllegalArgumentException expected = expectScriptThrows(IllegalArgumentException.class, () -> {
             exec("int x = 0; List l = new ArrayList(); l.add(1); l.add(1); "
                     + "return l.stream().mapToInt(x -> { x += 1; return x }).sum();");
@@ -160,20 +186,24 @@ public class LambdaTests extends ScriptTestCase {
     }
 
     public void testCaptureDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(5, exec("int x = 5; def y = Optional.empty(); y.orElseGet(() -> x);"));
     }
 
     public void testNestedCapture() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(1, exec("boolean x = false; int y = 1;" +
                              "return Optional.empty().orElseGet(() -> x ? 5 : Optional.empty().orElseGet(() -> y));"));
     }
 
     public void testNestedCaptureParams() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(2, exec("int foo(Function f) { return f.apply(1) }" +
                              "return foo(x -> foo(y -> x + 1))"));
     }
 
     public void testWrongArity() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         IllegalArgumentException expected = expectScriptThrows(IllegalArgumentException.class, () -> {
             exec("Optional.empty().orElseGet(x -> x);");
         });
@@ -181,6 +211,7 @@ public class LambdaTests extends ScriptTestCase {
     }
 
     public void testWrongArityDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         IllegalArgumentException expected = expectScriptThrows(IllegalArgumentException.class, () -> {
             exec("def y = Optional.empty(); return y.orElseGet(x -> x);");
         });
@@ -188,6 +219,7 @@ public class LambdaTests extends ScriptTestCase {
     }
 
     public void testWrongArityNotEnough() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         IllegalArgumentException expected = expectScriptThrows(IllegalArgumentException.class, () -> {
             exec("List l = new ArrayList(); l.add(1); l.add(1); "
                + "return l.stream().mapToInt(() -> 5).sum();");
@@ -196,6 +228,7 @@ public class LambdaTests extends ScriptTestCase {
     }
 
     public void testWrongArityNotEnoughDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         IllegalArgumentException expected = expectScriptThrows(IllegalArgumentException.class, () -> {
             exec("def l = new ArrayList(); l.add(1); l.add(1); "
                + "return l.stream().mapToInt(() -> 5).sum();");
@@ -204,14 +237,17 @@ public class LambdaTests extends ScriptTestCase {
     }
 
     public void testLambdaInFunction() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(5, exec("def foo() { Optional.empty().orElseGet(() -> 5) } return foo();"));
     }
 
     public void testLambdaCaptureFunctionParam() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         assertEquals(5, exec("def foo(int x) { Optional.empty().orElseGet(() -> x) } return foo(5);"));
     }
 
     public void testReservedCapture() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         String compare = "boolean compare(Supplier s, def v) {s.get() == v}";
         assertEquals(true, exec(compare + "compare(() -> new ArrayList(), new ArrayList())"));
         assertEquals(true, exec(compare + "compare(() -> { new ArrayList() }, new ArrayList())"));
@@ -236,6 +272,7 @@ public class LambdaTests extends ScriptTestCase {
     }
 
     public void testReturnVoid() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         Throwable expected = expectScriptThrows(ClassCastException.class, () -> {
             exec("StringBuilder b = new StringBuilder(); List l = [1, 2]; l.stream().mapToLong(i -> b.setLength(i))");
         });
@@ -243,6 +280,7 @@ public class LambdaTests extends ScriptTestCase {
     }
 
     public void testReturnVoidDef() {
+        assumeFalse("JDK is JDK 9", Constants.JRE_IS_MINIMUM_JAVA9);
         // If we can catch the error at compile time we do
         Exception expected = expectScriptThrows(ClassCastException.class, () -> {
             exec("StringBuilder b = new StringBuilder(); def l = [1, 2]; l.stream().mapToLong(i -> b.setLength(i))");