ojluni/src/test/java/util/stream/test/org/openjdk/tests/java/lang/invoke/SerializedLambdaTest.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package org.openjdk.tests.java.lang.invoke;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.NotSerializableException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
 import java.lang.invoke.CallSite;
 import java.lang.invoke.LambdaMetafactory;
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.BiPredicate;
 import java.util.function.Consumer;
 import java.util.function.LongConsumer;
 import java.util.function.Predicate;
 import java.util.function.Supplier;

 import org.testng.annotations.Test;

 import static org.testng.Assert.assertFalse;
 import static org.testng.Assert.assertTrue;
 import static org.testng.Assert.fail;

 /**
  * SerializedLambdaTest
  *
  * @author Brian Goetz
  */
 @Test
 public class SerializedLambdaTest {
     public static final int REPS = 50;

     @SuppressWarnings("unchecked")
     private<T> void assertSerial(T p, Consumer<T> asserter) throws IOException, ClassNotFoundException {
         asserter.accept(p);

         for (int i=0; i<REPS; i++) {
             byte[] bytes = serialize(p);
             assertTrue(bytes.length > 0);

             asserter.accept((T) deserialize(bytes));
         }
     }

     private void assertNotSerial(Predicate<String> p, Consumer<Predicate<String>> asserter)
             throws IOException, ClassNotFoundException {
         asserter.accept(p);
         try {
             byte[] bytes = serialize(p);
             fail("Expected serialization failure");
         }
         catch (NotSerializableException e) {
             // success
         }
     }

     private byte[] serialize(Object o) throws IOException {
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         ObjectOutputStream oos = new ObjectOutputStream(bos);
         oos.writeObject(o);
         oos.close();
         return bos.toByteArray();
     }

     private Object deserialize(byte[] bytes) throws IOException, ClassNotFoundException {
         try(ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
             return ois.readObject();
         }
     }

     // Test instantiating against intersection type
     public void testSimpleSerializedInstantiation() throws IOException, ClassNotFoundException {
         @SuppressWarnings("unchecked")
         Predicate<String> pred = (Predicate<String> & Serializable) s -> true;
         assertSerial(pred,
                      p -> {
                          assertTrue(p instanceof Predicate);
                          assertTrue(p instanceof Serializable);
                          assertTrue(p.test(""));
                      });
     }

     interface SerPredicate<T> extends Predicate<T>, Serializable { }

     // Test instantiating against derived type
     public void testSimpleSerializedInstantiation2() throws IOException, ClassNotFoundException {
         SerPredicate<String> serPred = (SerPredicate<String>) s -> true;
         assertSerial(serPred,
                      p -> {
                          assertTrue(p instanceof Predicate);
                          assertTrue(p instanceof Serializable);
                          assertTrue(p instanceof SerPredicate);
                          assertTrue(p.test(""));
                      });
     }

     // Negative test: non-serializable lambdas are in fact not serializable
     public void testNonserializableInstantiation() throws IOException, ClassNotFoundException {
         @SuppressWarnings("unchecked")
         Predicate<String> pred = (Predicate<String>) s -> true;
         assertNotSerial(pred,
                         p -> {
                             assertTrue(p instanceof Predicate);
                             assertFalse(p instanceof Serializable);
                             assertTrue(p.test(""));
                         });
     }

     // Test lambda capturing int
     public void testSerializeCapturingInt() throws IOException, ClassNotFoundException {
         class Moo {
             @SuppressWarnings("unchecked")
             Predicate<String> foo(int x) {
                 return (Predicate<String> & Serializable) s -> s.length() >= x;
             }
         }
         Predicate<String> pred = new Moo().foo(3);
         assertSerial(pred, p -> {
             assertTrue(p.test("yada"));
             assertFalse(p.test("no"));
         });
     }

     // Test lambda capturing String
     public void testSerializeCapturingString() throws IOException, ClassNotFoundException {
         class Moo {
             @SuppressWarnings("unchecked")
             Predicate<String> foo(String t) {
                 return (Predicate<String> & Serializable) s -> s.equals(t);
             }
         }
         Predicate<String> pred = new Moo().foo("goo");
         assertSerial(pred, p -> {
             assertTrue(p.test("goo"));
             assertFalse(p.test("foo"));
         });
     }

     // Negative test: lambdas that capture a non-serializable var
     public void testSerializeCapturingNonSerializable() throws IOException, ClassNotFoundException {
         class Box {
             String s;

             Box(String s) { this.s = s; }
         }
         class Moo {
             @SuppressWarnings("unchecked")
             Predicate<String> foo(Box b) {
                 return (Predicate<String> & Serializable) s -> s.equals(b.s);
             }
         }
         Predicate<String> pred = new Moo().foo(new Box("goo"));
         assertNotSerial(pred, p -> {
             assertTrue(p.test("goo"));
             assertFalse(p.test("foo"));
         });
     }

     static boolean startsWithA(String s) {
         return s.startsWith("a");
     }

     // Test static method ref
     public void testStaticMR() throws IOException, ClassNotFoundException {
         @SuppressWarnings("unchecked")
         Predicate<String> mh1 = (Predicate<String> & Serializable) SerializedLambdaTest::startsWithA;
         @SuppressWarnings("unchecked")
         Predicate<String> mh2 = (SerPredicate<String>) SerializedLambdaTest::startsWithA;
         Consumer<Predicate<String>> b = p -> {
             assertTrue(p instanceof Serializable);
             assertTrue(p.test("arf"));
             assertFalse(p.test("barf"));
         };
         assertSerial(mh1, b);
         assertSerial(mh2, b);
     }

     // Test unbound method ref of nonserializable class -- should still succeed
     public void testUnboundMR() throws IOException, ClassNotFoundException {
         class Moo {
             public boolean startsWithB(String s) {
                 return s.startsWith("b");
             }
         }
         @SuppressWarnings("unchecked")
         BiPredicate<Moo, String> mh1 = (BiPredicate<Moo, String> & Serializable) Moo::startsWithB;
         Consumer<BiPredicate<Moo, String>> b = p -> {
             assertTrue(p instanceof Serializable);
             assertTrue(p.test(new Moo(), "barf"));
             assertFalse(p.test(new Moo(), "arf"));
         };
         assertSerial(mh1, b);
     }

     // Negative test: test bound MR of nonserializable class
     public void testBoundMRNotSerReceiver() throws IOException, ClassNotFoundException {
         class Moo {
             public boolean startsWithB(String s) {
                 return s.startsWith("b");
             }
         }
         Moo moo = new Moo();
         @SuppressWarnings("unchecked")
         Predicate<String> mh1 = (Predicate<String> & Serializable) moo::startsWithB;
         @SuppressWarnings("unchecked")
         Predicate<String> mh2 = (SerPredicate<String>) moo::startsWithB;
         Consumer<Predicate<String>> b = p -> {
             assertTrue(p instanceof Serializable);
             assertTrue(p.test("barf"));
             assertFalse(p.test("arf"));
         };
         assertNotSerial(mh1, b);
         assertNotSerial(mh2, b);
     }

     // Test bound MR of serializable class
     @SuppressWarnings("serial")
     static class ForBoundMRef implements Serializable {
         public boolean startsWithB(String s) {
             return s.startsWith("b");
         }
     }

     public void testBoundMR() throws IOException, ClassNotFoundException {
         ForBoundMRef moo = new ForBoundMRef();
         @SuppressWarnings("unchecked")
         Predicate<String> mh1 = (Predicate<String> & Serializable) moo::startsWithB;
         @SuppressWarnings("unchecked")
         Predicate<String> mh2 = (SerPredicate<String>) moo::startsWithB;
         Consumer<Predicate<String>> b = p -> {
             assertTrue(p instanceof Serializable);
             assertTrue(p.test("barf"));
             assertFalse(p.test("arf"));
         };
         assertSerial(mh1, b);
         assertSerial(mh2, b);
     }

     static class ForCtorRef {
         public boolean startsWithB(String s) {
             return s.startsWith("b");
         }
     }
     // Test ctor ref of nonserializable class
     public void testCtorRef() throws IOException, ClassNotFoundException {
         @SuppressWarnings("unchecked")
         Supplier<ForCtorRef> ctor = (Supplier<ForCtorRef> & Serializable) ForCtorRef::new;
         Consumer<Supplier<ForCtorRef>> b = s -> {
             assertTrue(s instanceof Serializable);
             ForCtorRef m = s.get();
             assertTrue(m.startsWithB("barf"));
             assertFalse(m.startsWithB("arf"));
         };
         assertSerial(ctor, b);
     }

     //Test throwing away return type
     public void testDiscardReturnBound() throws IOException, ClassNotFoundException {
         List<String> list = new ArrayList<>();
         Consumer<String> c = (Consumer<String> & Serializable) list::add;
         assertSerial(c, cc -> { assertTrue(cc instanceof Consumer); });

         AtomicLong a = new AtomicLong();
         LongConsumer lc = (LongConsumer & Serializable) a::addAndGet;
         assertSerial(lc, plc -> { plc.accept(3); });
     }

     // Tests of direct use of metafactories

     private static boolean foo(Object s) { return s != null && ((String) s).length() > 0; }
     private static final MethodType predicateMT = MethodType.methodType(boolean.class, Object.class);
     private static final MethodType stringPredicateMT = MethodType.methodType(boolean.class, String.class);
     private static final Consumer<Predicate<String>> fooAsserter = x -> {
         assertTrue(x.test("foo"));
         assertFalse(x.test(""));
         assertFalse(x.test(null));
     };

     // standard MF: nonserializable supertype
     public void testDirectStdNonser() throws Throwable {
         MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);

         // Standard metafactory, non-serializable target: not serializable
         CallSite cs = LambdaMetafactory.metafactory(MethodHandles.lookup(),
                                                     "test", MethodType.methodType(Predicate.class),
                                                     predicateMT, fooMH, stringPredicateMT);
         Predicate<String> p = (Predicate<String>) cs.getTarget().invokeExact();
         assertNotSerial(p, fooAsserter);
     }

     // standard MF: serializable supertype
     public void testDirectStdSer() throws Throwable {
         MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);

         // Standard metafactory, serializable target: not serializable
         CallSite cs = LambdaMetafactory.metafactory(MethodHandles.lookup(),
                                                     "test", MethodType.methodType(SerPredicate.class),
                                                     predicateMT, fooMH, stringPredicateMT);
         assertNotSerial((SerPredicate<String>) cs.getTarget().invokeExact(), fooAsserter);
     }

     // alt MF: nonserializable supertype
     public void testAltStdNonser() throws Throwable {
         MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);

         // Alt metafactory, non-serializable target: not serializable
         CallSite cs = LambdaMetafactory.altMetafactory(MethodHandles.lookup(),
                                                        "test", MethodType.methodType(Predicate.class),
                                                        predicateMT, fooMH, stringPredicateMT, 0);
         assertNotSerial((Predicate<String>) cs.getTarget().invokeExact(), fooAsserter);
     }

     // alt MF: serializable supertype
     public void testAltStdSer() throws Throwable {
         MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);

         // Alt metafactory, serializable target, no FLAG_SERIALIZABLE: not serializable
         CallSite cs = LambdaMetafactory.altMetafactory(MethodHandles.lookup(),
                                                        "test", MethodType.methodType(SerPredicate.class),
                                                        predicateMT, fooMH, stringPredicateMT, 0);
         assertNotSerial((SerPredicate<String>) cs.getTarget().invokeExact(), fooAsserter);

         // Alt metafactory, serializable marker, no FLAG_SERIALIZABLE: not serializable
         cs = LambdaMetafactory.altMetafactory(MethodHandles.lookup(),
                                               "test", MethodType.methodType(Predicate.class),
                                               predicateMT, fooMH, stringPredicateMT, LambdaMetafactory.FLAG_MARKERS, 1, Serializable.class);
         assertNotSerial((Predicate<String>) cs.getTarget().invokeExact(), fooAsserter);
     }
 }
	/*
	* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package org.openjdk.tests.java.lang.invoke;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.io.NotSerializableException;
	import java.io.ObjectInputStream;
	import java.io.ObjectOutputStream;
	import java.io.Serializable;
	import java.lang.invoke.CallSite;
	import java.lang.invoke.LambdaMetafactory;
	import java.lang.invoke.MethodHandle;
	import java.lang.invoke.MethodHandles;
	import java.lang.invoke.MethodType;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.concurrent.atomic.AtomicLong;
	import java.util.function.BiPredicate;
	import java.util.function.Consumer;
	import java.util.function.LongConsumer;
	import java.util.function.Predicate;
	import java.util.function.Supplier;

	import org.testng.annotations.Test;

	import static org.testng.Assert.assertFalse;
	import static org.testng.Assert.assertTrue;
	import static org.testng.Assert.fail;

	/**
	* SerializedLambdaTest
	*
	* @author Brian Goetz
	*/
	@Test
	public class SerializedLambdaTest {
	public static final int REPS = 50;

	@SuppressWarnings("unchecked")
	private<T> void assertSerial(T p, Consumer<T> asserter) throws IOException, ClassNotFoundException {
	asserter.accept(p);

	for (int i=0; i<REPS; i++) {
	byte[] bytes = serialize(p);
	assertTrue(bytes.length > 0);

	asserter.accept((T) deserialize(bytes));
	}
	}

	private void assertNotSerial(Predicate<String> p, Consumer<Predicate<String>> asserter)
	throws IOException, ClassNotFoundException {
	asserter.accept(p);
	try {
	byte[] bytes = serialize(p);
	fail("Expected serialization failure");
	}
	catch (NotSerializableException e) {
	// success
	}
	}

	private byte[] serialize(Object o) throws IOException {
	ByteArrayOutputStream bos = new ByteArrayOutputStream();
	ObjectOutputStream oos = new ObjectOutputStream(bos);
	oos.writeObject(o);
	oos.close();
	return bos.toByteArray();
	}

	private Object deserialize(byte[] bytes) throws IOException, ClassNotFoundException {
	try(ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
	return ois.readObject();
	}
	}

	// Test instantiating against intersection type
	public void testSimpleSerializedInstantiation() throws IOException, ClassNotFoundException {
	@SuppressWarnings("unchecked")
	Predicate<String> pred = (Predicate<String> & Serializable) s -> true;
	assertSerial(pred,
	p -> {
	assertTrue(p instanceof Predicate);
	assertTrue(p instanceof Serializable);
	assertTrue(p.test(""));
	});
	}

	interface SerPredicate<T> extends Predicate<T>, Serializable { }

	// Test instantiating against derived type
	public void testSimpleSerializedInstantiation2() throws IOException, ClassNotFoundException {
	SerPredicate<String> serPred = (SerPredicate<String>) s -> true;
	assertSerial(serPred,
	p -> {
	assertTrue(p instanceof Predicate);
	assertTrue(p instanceof Serializable);
	assertTrue(p instanceof SerPredicate);
	assertTrue(p.test(""));
	});
	}

	// Negative test: non-serializable lambdas are in fact not serializable
	public void testNonserializableInstantiation() throws IOException, ClassNotFoundException {
	@SuppressWarnings("unchecked")
	Predicate<String> pred = (Predicate<String>) s -> true;
	assertNotSerial(pred,
	p -> {
	assertTrue(p instanceof Predicate);
	assertFalse(p instanceof Serializable);
	assertTrue(p.test(""));
	});
	}

	// Test lambda capturing int
	public void testSerializeCapturingInt() throws IOException, ClassNotFoundException {
	class Moo {
	@SuppressWarnings("unchecked")
	Predicate<String> foo(int x) {
	return (Predicate<String> & Serializable) s -> s.length() >= x;
	}
	}
	Predicate<String> pred = new Moo().foo(3);
	assertSerial(pred, p -> {
	assertTrue(p.test("yada"));
	assertFalse(p.test("no"));
	});
	}

	// Test lambda capturing String
	public void testSerializeCapturingString() throws IOException, ClassNotFoundException {
	class Moo {
	@SuppressWarnings("unchecked")
	Predicate<String> foo(String t) {
	return (Predicate<String> & Serializable) s -> s.equals(t);
	}
	}
	Predicate<String> pred = new Moo().foo("goo");
	assertSerial(pred, p -> {
	assertTrue(p.test("goo"));
	assertFalse(p.test("foo"));
	});
	}

	// Negative test: lambdas that capture a non-serializable var
	public void testSerializeCapturingNonSerializable() throws IOException, ClassNotFoundException {
	class Box {
	String s;

	Box(String s) { this.s = s; }
	}
	class Moo {
	@SuppressWarnings("unchecked")
	Predicate<String> foo(Box b) {
	return (Predicate<String> & Serializable) s -> s.equals(b.s);
	}
	}
	Predicate<String> pred = new Moo().foo(new Box("goo"));
	assertNotSerial(pred, p -> {
	assertTrue(p.test("goo"));
	assertFalse(p.test("foo"));
	});
	}

	static boolean startsWithA(String s) {
	return s.startsWith("a");
	}

	// Test static method ref
	public void testStaticMR() throws IOException, ClassNotFoundException {
	@SuppressWarnings("unchecked")
	Predicate<String> mh1 = (Predicate<String> & Serializable) SerializedLambdaTest::startsWithA;
	@SuppressWarnings("unchecked")
	Predicate<String> mh2 = (SerPredicate<String>) SerializedLambdaTest::startsWithA;
	Consumer<Predicate<String>> b = p -> {
	assertTrue(p instanceof Serializable);
	assertTrue(p.test("arf"));
	assertFalse(p.test("barf"));
	};
	assertSerial(mh1, b);
	assertSerial(mh2, b);
	}

	// Test unbound method ref of nonserializable class -- should still succeed
	public void testUnboundMR() throws IOException, ClassNotFoundException {
	class Moo {
	public boolean startsWithB(String s) {
	return s.startsWith("b");
	}
	}
	@SuppressWarnings("unchecked")
	BiPredicate<Moo, String> mh1 = (BiPredicate<Moo, String> & Serializable) Moo::startsWithB;
	Consumer<BiPredicate<Moo, String>> b = p -> {
	assertTrue(p instanceof Serializable);
	assertTrue(p.test(new Moo(), "barf"));
	assertFalse(p.test(new Moo(), "arf"));
	};
	assertSerial(mh1, b);
	}

	// Negative test: test bound MR of nonserializable class
	public void testBoundMRNotSerReceiver() throws IOException, ClassNotFoundException {
	class Moo {
	public boolean startsWithB(String s) {
	return s.startsWith("b");
	}
	}
	Moo moo = new Moo();
	@SuppressWarnings("unchecked")
	Predicate<String> mh1 = (Predicate<String> & Serializable) moo::startsWithB;
	@SuppressWarnings("unchecked")
	Predicate<String> mh2 = (SerPredicate<String>) moo::startsWithB;
	Consumer<Predicate<String>> b = p -> {
	assertTrue(p instanceof Serializable);
	assertTrue(p.test("barf"));
	assertFalse(p.test("arf"));
	};
	assertNotSerial(mh1, b);
	assertNotSerial(mh2, b);
	}

	// Test bound MR of serializable class
	@SuppressWarnings("serial")
	static class ForBoundMRef implements Serializable {
	public boolean startsWithB(String s) {
	return s.startsWith("b");
	}
	}

	public void testBoundMR() throws IOException, ClassNotFoundException {
	ForBoundMRef moo = new ForBoundMRef();
	@SuppressWarnings("unchecked")
	Predicate<String> mh1 = (Predicate<String> & Serializable) moo::startsWithB;
	@SuppressWarnings("unchecked")
	Predicate<String> mh2 = (SerPredicate<String>) moo::startsWithB;
	Consumer<Predicate<String>> b = p -> {
	assertTrue(p instanceof Serializable);
	assertTrue(p.test("barf"));
	assertFalse(p.test("arf"));
	};
	assertSerial(mh1, b);
	assertSerial(mh2, b);
	}

	static class ForCtorRef {
	public boolean startsWithB(String s) {
	return s.startsWith("b");
	}
	}
	// Test ctor ref of nonserializable class
	public void testCtorRef() throws IOException, ClassNotFoundException {
	@SuppressWarnings("unchecked")
	Supplier<ForCtorRef> ctor = (Supplier<ForCtorRef> & Serializable) ForCtorRef::new;
	Consumer<Supplier<ForCtorRef>> b = s -> {
	assertTrue(s instanceof Serializable);
	ForCtorRef m = s.get();
	assertTrue(m.startsWithB("barf"));
	assertFalse(m.startsWithB("arf"));
	};
	assertSerial(ctor, b);
	}

	//Test throwing away return type
	public void testDiscardReturnBound() throws IOException, ClassNotFoundException {
	List<String> list = new ArrayList<>();
	Consumer<String> c = (Consumer<String> & Serializable) list::add;
	assertSerial(c, cc -> { assertTrue(cc instanceof Consumer); });

	AtomicLong a = new AtomicLong();
	LongConsumer lc = (LongConsumer & Serializable) a::addAndGet;
	assertSerial(lc, plc -> { plc.accept(3); });
	}

	// Tests of direct use of metafactories

	private static boolean foo(Object s) { return s != null && ((String) s).length() > 0; }
	private static final MethodType predicateMT = MethodType.methodType(boolean.class, Object.class);
	private static final MethodType stringPredicateMT = MethodType.methodType(boolean.class, String.class);
	private static final Consumer<Predicate<String>> fooAsserter = x -> {
	assertTrue(x.test("foo"));
	assertFalse(x.test(""));
	assertFalse(x.test(null));
	};

	// standard MF: nonserializable supertype
	public void testDirectStdNonser() throws Throwable {
	MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);

	// Standard metafactory, non-serializable target: not serializable
	CallSite cs = LambdaMetafactory.metafactory(MethodHandles.lookup(),
	"test", MethodType.methodType(Predicate.class),
	predicateMT, fooMH, stringPredicateMT);
	Predicate<String> p = (Predicate<String>) cs.getTarget().invokeExact();
	assertNotSerial(p, fooAsserter);
	}

	// standard MF: serializable supertype
	public void testDirectStdSer() throws Throwable {
	MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);

	// Standard metafactory, serializable target: not serializable
	CallSite cs = LambdaMetafactory.metafactory(MethodHandles.lookup(),
	"test", MethodType.methodType(SerPredicate.class),
	predicateMT, fooMH, stringPredicateMT);
	assertNotSerial((SerPredicate<String>) cs.getTarget().invokeExact(), fooAsserter);
	}

	// alt MF: nonserializable supertype
	public void testAltStdNonser() throws Throwable {
	MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);

	// Alt metafactory, non-serializable target: not serializable
	CallSite cs = LambdaMetafactory.altMetafactory(MethodHandles.lookup(),
	"test", MethodType.methodType(Predicate.class),
	predicateMT, fooMH, stringPredicateMT, 0);
	assertNotSerial((Predicate<String>) cs.getTarget().invokeExact(), fooAsserter);
	}

	// alt MF: serializable supertype
	public void testAltStdSer() throws Throwable {
	MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);

	// Alt metafactory, serializable target, no FLAG_SERIALIZABLE: not serializable
	CallSite cs = LambdaMetafactory.altMetafactory(MethodHandles.lookup(),
	"test", MethodType.methodType(SerPredicate.class),
	predicateMT, fooMH, stringPredicateMT, 0);
	assertNotSerial((SerPredicate<String>) cs.getTarget().invokeExact(), fooAsserter);

	// Alt metafactory, serializable marker, no FLAG_SERIALIZABLE: not serializable
	cs = LambdaMetafactory.altMetafactory(MethodHandles.lookup(),
	"test", MethodType.methodType(Predicate.class),
	predicateMT, fooMH, stringPredicateMT, LambdaMetafactory.FLAG_MARKERS, 1, Serializable.class);
	assertNotSerial((Predicate<String>) cs.getTarget().invokeExact(), fooAsserter);
	}
	}