luni/src/test/java/libcore/java/lang/LambdaImplementationTest.java - platform/libcore - Git at Google

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package libcore.java.lang;

 import junit.framework.TestCase;

 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.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.Callable;

 public class LambdaImplementationTest extends TestCase {

     private static final String MSG = "Hello World";

     public void testNonCapturingLambda() throws Exception {
         Callable<String> r1 = () -> MSG;
         assertGeneralLambdaClassCharacteristics(r1);
         assertLambdaImplementsInterfaces(r1, Callable.class);
         assertLambdaMethodCharacteristics(r1, Callable.class);
         assertNonSerializableLambdaCharacteristics(r1);
         assertCallableBehavior(r1, MSG);

         Callable<String> r2 = () -> MSG;
         assertMultipleInstanceCharacteristics(r1, r2);
     }

     interface Condition<T> {
         boolean check(T arg);
     }

     public void testInstanceMethodReferenceLambda() throws Exception {
         Condition<String> c = String::isEmpty;
         Class<?> lambdaClass = c.getClass();
         assertGeneralLambdaClassCharacteristics(c);
         assertLambdaImplementsInterfaces(c, Condition.class);
         assertLambdaMethodCharacteristics(c, Condition.class);
         assertNonSerializableLambdaCharacteristics(c);

         // Check the behavior of the lambda's method.
         assertTrue(c.check(""));
         assertFalse(c.check("notEmpty"));

         Method implCallMethod = lambdaClass.getMethod(
                 "check", Object.class /* type erasure => not String.class */);
         assertTrue((Boolean) implCallMethod.invoke(c, ""));
         assertFalse((Boolean) implCallMethod.invoke(c, "notEmpty"));

         Method interfaceCallMethod = Condition.class.getDeclaredMethod(
                 "check", Object.class /* type erasure => not String.class */);
         assertTrue((Boolean) interfaceCallMethod.invoke(c, ""));
         assertFalse((Boolean) interfaceCallMethod.invoke(c, "notEmpty"));
     }

     public void testStaticMethodReferenceLambda() throws Exception {
         Callable<String> r1 = LambdaImplementationTest::staticMethod;
         assertGeneralLambdaClassCharacteristics(r1);
         assertLambdaImplementsInterfaces(r1, Callable.class);
         assertLambdaMethodCharacteristics(r1, Callable.class);
         assertNonSerializableLambdaCharacteristics(r1);

         assertCallableBehavior(r1, MSG);

         Callable<String> r2 = LambdaImplementationTest::staticMethod;
         assertMultipleInstanceCharacteristics(r1, r2);
     }

     public void testObjectMethodReferenceLambda() throws Exception {
         StringBuilder o = new StringBuilder(MSG);
         Callable<String> r1 = o::toString;
         assertGeneralLambdaClassCharacteristics(r1);
         assertLambdaImplementsInterfaces(r1, Callable.class);
         assertLambdaMethodCharacteristics(r1, Callable.class);
         assertNonSerializableLambdaCharacteristics(r1);

         assertCallableBehavior(r1, MSG);

         Callable<String> r2 = o::toString;
         assertMultipleInstanceCharacteristics(r1, r2);
     }

     public void testArgumentCapturingLambda() throws Exception {
         String msg = MSG;
         Callable<String> r1 = () -> msg;
         assertGeneralLambdaClassCharacteristics(r1);
         assertLambdaImplementsInterfaces(r1, Callable.class);
         assertLambdaMethodCharacteristics(r1, Callable.class);
         assertNonSerializableLambdaCharacteristics(r1);

         assertCallableBehavior(r1, MSG);

         Callable<String> r2 = () -> msg;
         assertMultipleInstanceCharacteristics(r1, r2);
     }

     public void testSerializableLambda_withoutState() throws Exception {
         Callable<String> r1 = (Callable<String> & Serializable) () -> MSG;
         assertGeneralLambdaClassCharacteristics(r1);
         assertLambdaImplementsInterfaces(r1, Callable.class, Serializable.class);
         assertLambdaMethodCharacteristics(r1, Callable.class);
         assertSerializableLambdaCharacteristics(r1);

         assertCallableBehavior(r1, MSG);

         Callable<String> r2 = (Callable<String> & Serializable) () -> MSG;
         assertMultipleInstanceCharacteristics(r1, r2);
     }

     public void testSerializableLambda_withState() throws Exception {
         final int state = 123;
         Callable<String> r1 = (Callable<String> & Serializable) () -> MSG + state;
         assertGeneralLambdaClassCharacteristics(r1);
         assertLambdaImplementsInterfaces(r1, Callable.class, Serializable.class);
         assertLambdaMethodCharacteristics(r1, Callable.class);
         assertSerializableLambdaCharacteristics(r1);

         assertCallableBehavior(r1, MSG + state);

         Callable<String> deserializedR1 = roundtripSerialization(r1);
         assertEquals(r1.call(), deserializedR1.call());
     }

     public void testBadSerializableLambda() throws Exception {
         final Object state = new Object(); // Not Serializable
         Callable<String> r1 = (Callable<String> & Serializable) () -> "Hello world: " + state;
         assertGeneralLambdaClassCharacteristics(r1);
         assertLambdaMethodCharacteristics(r1, Callable.class);
         assertLambdaImplementsInterfaces(r1, Callable.class, Serializable.class);

         try {
             serializeObject(r1);
             fail();
         } catch (NotSerializableException expected) {
         }
     }

     public void testMultipleInterfaceLambda() throws Exception {
         Callable<String> r1 = (Callable<String> & MarkerInterface) () -> MSG;
         assertTrue(r1 instanceof MarkerInterface);
         assertGeneralLambdaClassCharacteristics(r1);
         assertLambdaMethodCharacteristics(r1, Callable.class);
         assertLambdaImplementsInterfaces(r1, Callable.class, MarkerInterface.class);
         assertNonSerializableLambdaCharacteristics(r1);

         assertCallableBehavior(r1, MSG);
     }

     private static void assertSerializableLambdaCharacteristics(Object r1) throws Exception {
         assertTrue(r1 instanceof Serializable);

         Object deserializedR1 = roundtripSerialization(r1);
         assertFalse(deserializedR1.equals(r1));
         assertNotSame(deserializedR1, r1);
     }

     @SuppressWarnings("unchecked")
     private static <T> T roundtripSerialization(T r1) throws Exception {
         byte[] bytes = serializeObject(r1);
         ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
         try (ObjectInputStream is = new ObjectInputStream(bais)) {
             return (T) is.readObject();
         }
     }

     private static <T> byte[] serializeObject(T r1) throws IOException {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         try (ObjectOutputStream os = new ObjectOutputStream(baos)) {
             os.writeObject(r1);
             os.flush();
         }
         return baos.toByteArray();
     }

     private static <T> void assertLambdaImplementsInterfaces(T r1, Class<?>... expectedInterfaces)
             throws Exception {
         Class<?> lambdaClass = r1.getClass();

         // Check directly implemented interfaces. Ordering is well-defined.
         Class<?>[] actualInterfaces = lambdaClass.getInterfaces();
         assertEquals(expectedInterfaces.length, actualInterfaces.length);
         List<Class<?>> actual = Arrays.asList(actualInterfaces);
         List<Class<?>> expected = Arrays.asList(expectedInterfaces);
         assertEquals(expected, actual);

         // Confirm that the only method declared on the lambda's class are those defined by
         // interfaces it implements. i.e. there's no additional public contract.
         Set<Method> declaredMethods = new HashSet<>();
         addNonStaticPublicMethods(lambdaClass, declaredMethods);
         Set<Method> expectedMethods = new HashSet<>();
         for (Class<?> interfaceClass : expectedInterfaces) {
             // Obtain methods declared by super-interfaces too.
             while (interfaceClass != null) {
                 addNonStaticPublicMethods(interfaceClass, expectedMethods);
                 interfaceClass = interfaceClass.getSuperclass();
             }
         }
         assertEquals(expectedMethods.size(), declaredMethods.size());

         // Check the method signatures are compatible.
         for (Method expectedMethod : expectedMethods) {
             Method actualMethod =
                     lambdaClass.getMethod(expectedMethod.getName(),
                             expectedMethod.getParameterTypes());
             assertEquals(expectedMethod.getReturnType(), actualMethod.getReturnType());
         }
     }

     private static void addNonStaticPublicMethods(Class<?> clazz, Set<Method> methodSet) {
         for (Method interfaceMethod : clazz.getDeclaredMethods()) {
             int modifiers = interfaceMethod.getModifiers();
             if ((!Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {
                 methodSet.add(interfaceMethod);
             }
         }
     }

     private static void assertNonSerializableLambdaCharacteristics(Object r1) throws Exception {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         try (ObjectOutputStream os = new ObjectOutputStream(baos)) {
             os.writeObject(r1);
             os.flush();
             fail();
         } catch (NotSerializableException expected) {
         }
     }

     private static void assertMultipleInstanceCharacteristics(Object r1, Object r2)
             throws Exception {

         // Unclear if any of this is *guaranteed* to be true.

         // Check the objects are not the same and do not equal. This could influence collection
         // behavior.
         assertNotSame(r1, r2);
         assertTrue(!r1.equals(r2));

         // Confirm the classes differ.
         Class<?> lambda1Class = r1.getClass();
         Class<?> lambda2Class = r2.getClass();
         assertNotSame(lambda1Class, lambda2Class);
     }

     private static void assertGeneralLambdaClassCharacteristics(Object r1) throws Exception {
         Class<?> lambdaClass = r1.getClass();

         // Lambda objects have classes that have names.
         assertNotNull(lambdaClass.getName());
         assertNotNull(lambdaClass.getSimpleName());
         assertNotNull(lambdaClass.getCanonicalName());

         // Lambda classes are "synthetic classes" that are not arrays.
         assertFalse(lambdaClass.isAnnotation());
         assertFalse(lambdaClass.isInterface());
         assertFalse(lambdaClass.isArray());
         assertFalse(lambdaClass.isEnum());
         assertFalse(lambdaClass.isPrimitive());
         assertTrue(lambdaClass.isSynthetic());
         assertNull(lambdaClass.getComponentType());

         // Expected modifiers
         int classModifiers = lambdaClass.getModifiers();
         assertTrue(Modifier.isFinal(classModifiers));

         // Unexpected modifiers
         assertFalse(Modifier.isPrivate(classModifiers));
         assertFalse(Modifier.isPublic(classModifiers));
         assertFalse(Modifier.isProtected(classModifiers));
         assertFalse(Modifier.isStatic(classModifiers));
         assertFalse(Modifier.isSynchronized(classModifiers));
         assertFalse(Modifier.isVolatile(classModifiers));
         assertFalse(Modifier.isTransient(classModifiers));
         assertFalse(Modifier.isNative(classModifiers));
         assertFalse(Modifier.isInterface(classModifiers));
         assertFalse(Modifier.isAbstract(classModifiers));
         assertFalse(Modifier.isStrict(classModifiers));

         // Check the classloader, inheritance hierarchy and package.
         assertSame(LambdaImplementationTest.class.getClassLoader(), lambdaClass.getClassLoader());
         assertSame(Object.class, lambdaClass.getSuperclass());
         assertSame(Object.class, lambdaClass.getGenericSuperclass());
         assertEquals(LambdaImplementationTest.class.getPackage(), lambdaClass.getPackage());

         // Check the implementation of the non-final public methods that all Objects possess.
         assertNotNull(r1.toString());
         assertTrue(r1.equals(r1));
         assertEquals(System.identityHashCode(r1), r1.hashCode());
     }

     private static <T> void assertLambdaMethodCharacteristics(T r1, Class<?> samInterfaceClass)
             throws Exception {
         // Find the single abstract method on the interface.
         Method singleAbstractMethod = null;
         for (Method method : samInterfaceClass.getDeclaredMethods()) {
             if (Modifier.isAbstract(method.getModifiers())) {
                 singleAbstractMethod = method;
                 break;
             }
         }
         assertNotNull(singleAbstractMethod);

         // Confirm the lambda implements the method as expected.
         Method implementationMethod = r1.getClass().getMethod(
                 singleAbstractMethod.getName(), singleAbstractMethod.getParameterTypes());
         assertSame(singleAbstractMethod.getReturnType(), implementationMethod.getReturnType());
         assertSame(r1.getClass(), implementationMethod.getDeclaringClass());
         assertFalse(implementationMethod.isSynthetic());
         assertFalse(implementationMethod.isBridge());
         assertFalse(implementationMethod.isDefault());
     }

     private static String staticMethod() {
         return MSG;
     }

     private interface MarkerInterface {
     }

     private static <T> void assertCallableBehavior(Callable<T> r1, T expectedResult)
             throws Exception {
         assertEquals(expectedResult, r1.call());

         Method implCallMethod = r1.getClass().getDeclaredMethod("call");
         assertEquals(expectedResult, implCallMethod.invoke(r1));

         Method interfaceCallMethod = Callable.class.getDeclaredMethod("call");
         assertEquals(expectedResult, interfaceCallMethod.invoke(r1));
     }
 }
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package libcore.java.lang;

	import junit.framework.TestCase;

	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.reflect.Method;
	import java.lang.reflect.Modifier;
	import java.util.Arrays;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Set;
	import java.util.concurrent.Callable;

	public class LambdaImplementationTest extends TestCase {

	private static final String MSG = "Hello World";

	public void testNonCapturingLambda() throws Exception {
	Callable<String> r1 = () -> MSG;
	assertGeneralLambdaClassCharacteristics(r1);
	assertLambdaImplementsInterfaces(r1, Callable.class);
	assertLambdaMethodCharacteristics(r1, Callable.class);
	assertNonSerializableLambdaCharacteristics(r1);
	assertCallableBehavior(r1, MSG);

	Callable<String> r2 = () -> MSG;
	assertMultipleInstanceCharacteristics(r1, r2);
	}

	interface Condition<T> {
	boolean check(T arg);
	}

	public void testInstanceMethodReferenceLambda() throws Exception {
	Condition<String> c = String::isEmpty;
	Class<?> lambdaClass = c.getClass();
	assertGeneralLambdaClassCharacteristics(c);
	assertLambdaImplementsInterfaces(c, Condition.class);
	assertLambdaMethodCharacteristics(c, Condition.class);
	assertNonSerializableLambdaCharacteristics(c);

	// Check the behavior of the lambda's method.
	assertTrue(c.check(""));
	assertFalse(c.check("notEmpty"));

	Method implCallMethod = lambdaClass.getMethod(
	"check", Object.class /* type erasure => not String.class */);
	assertTrue((Boolean) implCallMethod.invoke(c, ""));
	assertFalse((Boolean) implCallMethod.invoke(c, "notEmpty"));

	Method interfaceCallMethod = Condition.class.getDeclaredMethod(
	"check", Object.class /* type erasure => not String.class */);
	assertTrue((Boolean) interfaceCallMethod.invoke(c, ""));
	assertFalse((Boolean) interfaceCallMethod.invoke(c, "notEmpty"));
	}

	public void testStaticMethodReferenceLambda() throws Exception {
	Callable<String> r1 = LambdaImplementationTest::staticMethod;
	assertGeneralLambdaClassCharacteristics(r1);
	assertLambdaImplementsInterfaces(r1, Callable.class);
	assertLambdaMethodCharacteristics(r1, Callable.class);
	assertNonSerializableLambdaCharacteristics(r1);

	assertCallableBehavior(r1, MSG);

	Callable<String> r2 = LambdaImplementationTest::staticMethod;
	assertMultipleInstanceCharacteristics(r1, r2);
	}

	public void testObjectMethodReferenceLambda() throws Exception {
	StringBuilder o = new StringBuilder(MSG);
	Callable<String> r1 = o::toString;
	assertGeneralLambdaClassCharacteristics(r1);
	assertLambdaImplementsInterfaces(r1, Callable.class);
	assertLambdaMethodCharacteristics(r1, Callable.class);
	assertNonSerializableLambdaCharacteristics(r1);

	assertCallableBehavior(r1, MSG);

	Callable<String> r2 = o::toString;
	assertMultipleInstanceCharacteristics(r1, r2);
	}

	public void testArgumentCapturingLambda() throws Exception {
	String msg = MSG;
	Callable<String> r1 = () -> msg;
	assertGeneralLambdaClassCharacteristics(r1);
	assertLambdaImplementsInterfaces(r1, Callable.class);
	assertLambdaMethodCharacteristics(r1, Callable.class);
	assertNonSerializableLambdaCharacteristics(r1);

	assertCallableBehavior(r1, MSG);

	Callable<String> r2 = () -> msg;
	assertMultipleInstanceCharacteristics(r1, r2);
	}

	public void testSerializableLambda_withoutState() throws Exception {
	Callable<String> r1 = (Callable<String> & Serializable) () -> MSG;
	assertGeneralLambdaClassCharacteristics(r1);
	assertLambdaImplementsInterfaces(r1, Callable.class, Serializable.class);
	assertLambdaMethodCharacteristics(r1, Callable.class);
	assertSerializableLambdaCharacteristics(r1);

	assertCallableBehavior(r1, MSG);

	Callable<String> r2 = (Callable<String> & Serializable) () -> MSG;
	assertMultipleInstanceCharacteristics(r1, r2);
	}

	public void testSerializableLambda_withState() throws Exception {
	final int state = 123;
	Callable<String> r1 = (Callable<String> & Serializable) () -> MSG + state;
	assertGeneralLambdaClassCharacteristics(r1);
	assertLambdaImplementsInterfaces(r1, Callable.class, Serializable.class);
	assertLambdaMethodCharacteristics(r1, Callable.class);
	assertSerializableLambdaCharacteristics(r1);

	assertCallableBehavior(r1, MSG + state);

	Callable<String> deserializedR1 = roundtripSerialization(r1);
	assertEquals(r1.call(), deserializedR1.call());
	}

	public void testBadSerializableLambda() throws Exception {
	final Object state = new Object(); // Not Serializable
	Callable<String> r1 = (Callable<String> & Serializable) () -> "Hello world: " + state;
	assertGeneralLambdaClassCharacteristics(r1);
	assertLambdaMethodCharacteristics(r1, Callable.class);
	assertLambdaImplementsInterfaces(r1, Callable.class, Serializable.class);

	try {
	serializeObject(r1);
	fail();
	} catch (NotSerializableException expected) {
	}
	}

	public void testMultipleInterfaceLambda() throws Exception {
	Callable<String> r1 = (Callable<String> & MarkerInterface) () -> MSG;
	assertTrue(r1 instanceof MarkerInterface);
	assertGeneralLambdaClassCharacteristics(r1);
	assertLambdaMethodCharacteristics(r1, Callable.class);
	assertLambdaImplementsInterfaces(r1, Callable.class, MarkerInterface.class);
	assertNonSerializableLambdaCharacteristics(r1);

	assertCallableBehavior(r1, MSG);
	}

	private static void assertSerializableLambdaCharacteristics(Object r1) throws Exception {
	assertTrue(r1 instanceof Serializable);

	Object deserializedR1 = roundtripSerialization(r1);
	assertFalse(deserializedR1.equals(r1));
	assertNotSame(deserializedR1, r1);
	}

	@SuppressWarnings("unchecked")
	private static <T> T roundtripSerialization(T r1) throws Exception {
	byte[] bytes = serializeObject(r1);
	ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
	try (ObjectInputStream is = new ObjectInputStream(bais)) {
	return (T) is.readObject();
	}
	}

	private static <T> byte[] serializeObject(T r1) throws IOException {
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	try (ObjectOutputStream os = new ObjectOutputStream(baos)) {
	os.writeObject(r1);
	os.flush();
	}
	return baos.toByteArray();
	}

	private static <T> void assertLambdaImplementsInterfaces(T r1, Class<?>... expectedInterfaces)
	throws Exception {
	Class<?> lambdaClass = r1.getClass();

	// Check directly implemented interfaces. Ordering is well-defined.
	Class<?>[] actualInterfaces = lambdaClass.getInterfaces();
	assertEquals(expectedInterfaces.length, actualInterfaces.length);
	List<Class<?>> actual = Arrays.asList(actualInterfaces);
	List<Class<?>> expected = Arrays.asList(expectedInterfaces);
	assertEquals(expected, actual);

	// Confirm that the only method declared on the lambda's class are those defined by
	// interfaces it implements. i.e. there's no additional public contract.
	Set<Method> declaredMethods = new HashSet<>();
	addNonStaticPublicMethods(lambdaClass, declaredMethods);
	Set<Method> expectedMethods = new HashSet<>();
	for (Class<?> interfaceClass : expectedInterfaces) {
	// Obtain methods declared by super-interfaces too.
	while (interfaceClass != null) {
	addNonStaticPublicMethods(interfaceClass, expectedMethods);
	interfaceClass = interfaceClass.getSuperclass();
	}
	}
	assertEquals(expectedMethods.size(), declaredMethods.size());

	// Check the method signatures are compatible.
	for (Method expectedMethod : expectedMethods) {
	Method actualMethod =
	lambdaClass.getMethod(expectedMethod.getName(),
	expectedMethod.getParameterTypes());
	assertEquals(expectedMethod.getReturnType(), actualMethod.getReturnType());
	}
	}

	private static void addNonStaticPublicMethods(Class<?> clazz, Set<Method> methodSet) {
	for (Method interfaceMethod : clazz.getDeclaredMethods()) {
	int modifiers = interfaceMethod.getModifiers();
	if ((!Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {
	methodSet.add(interfaceMethod);
	}
	}
	}

	private static void assertNonSerializableLambdaCharacteristics(Object r1) throws Exception {
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	try (ObjectOutputStream os = new ObjectOutputStream(baos)) {
	os.writeObject(r1);
	os.flush();
	fail();
	} catch (NotSerializableException expected) {
	}
	}

	private static void assertMultipleInstanceCharacteristics(Object r1, Object r2)
	throws Exception {

	// Unclear if any of this is guaranteed to be true.

	// Check the objects are not the same and do not equal. This could influence collection
	// behavior.
	assertNotSame(r1, r2);
	assertTrue(!r1.equals(r2));

	// Confirm the classes differ.
	Class<?> lambda1Class = r1.getClass();
	Class<?> lambda2Class = r2.getClass();
	assertNotSame(lambda1Class, lambda2Class);
	}

	private static void assertGeneralLambdaClassCharacteristics(Object r1) throws Exception {
	Class<?> lambdaClass = r1.getClass();

	// Lambda objects have classes that have names.
	assertNotNull(lambdaClass.getName());
	assertNotNull(lambdaClass.getSimpleName());
	assertNotNull(lambdaClass.getCanonicalName());

	// Lambda classes are "synthetic classes" that are not arrays.
	assertFalse(lambdaClass.isAnnotation());
	assertFalse(lambdaClass.isInterface());
	assertFalse(lambdaClass.isArray());
	assertFalse(lambdaClass.isEnum());
	assertFalse(lambdaClass.isPrimitive());
	assertTrue(lambdaClass.isSynthetic());
	assertNull(lambdaClass.getComponentType());

	// Expected modifiers
	int classModifiers = lambdaClass.getModifiers();
	assertTrue(Modifier.isFinal(classModifiers));

	// Unexpected modifiers
	assertFalse(Modifier.isPrivate(classModifiers));
	assertFalse(Modifier.isPublic(classModifiers));
	assertFalse(Modifier.isProtected(classModifiers));
	assertFalse(Modifier.isStatic(classModifiers));
	assertFalse(Modifier.isSynchronized(classModifiers));
	assertFalse(Modifier.isVolatile(classModifiers));
	assertFalse(Modifier.isTransient(classModifiers));
	assertFalse(Modifier.isNative(classModifiers));
	assertFalse(Modifier.isInterface(classModifiers));
	assertFalse(Modifier.isAbstract(classModifiers));
	assertFalse(Modifier.isStrict(classModifiers));

	// Check the classloader, inheritance hierarchy and package.
	assertSame(LambdaImplementationTest.class.getClassLoader(), lambdaClass.getClassLoader());
	assertSame(Object.class, lambdaClass.getSuperclass());
	assertSame(Object.class, lambdaClass.getGenericSuperclass());
	assertEquals(LambdaImplementationTest.class.getPackage(), lambdaClass.getPackage());

	// Check the implementation of the non-final public methods that all Objects possess.
	assertNotNull(r1.toString());
	assertTrue(r1.equals(r1));
	assertEquals(System.identityHashCode(r1), r1.hashCode());
	}

	private static <T> void assertLambdaMethodCharacteristics(T r1, Class<?> samInterfaceClass)
	throws Exception {
	// Find the single abstract method on the interface.
	Method singleAbstractMethod = null;
	for (Method method : samInterfaceClass.getDeclaredMethods()) {
	if (Modifier.isAbstract(method.getModifiers())) {
	singleAbstractMethod = method;
	break;
	}
	}
	assertNotNull(singleAbstractMethod);

	// Confirm the lambda implements the method as expected.
	Method implementationMethod = r1.getClass().getMethod(
	singleAbstractMethod.getName(), singleAbstractMethod.getParameterTypes());
	assertSame(singleAbstractMethod.getReturnType(), implementationMethod.getReturnType());
	assertSame(r1.getClass(), implementationMethod.getDeclaringClass());
	assertFalse(implementationMethod.isSynthetic());
	assertFalse(implementationMethod.isBridge());
	assertFalse(implementationMethod.isDefault());
	}

	private static String staticMethod() {
	return MSG;
	}

	private interface MarkerInterface {
	}

	private static <T> void assertCallableBehavior(Callable<T> r1, T expectedResult)
	throws Exception {
	assertEquals(expectedResult, r1.call());

	Method implCallMethod = r1.getClass().getDeclaredMethod("call");
	assertEquals(expectedResult, implCallMethod.invoke(r1));

	Method interfaceCallMethod = Callable.class.getDeclaredMethod("call");
	assertEquals(expectedResult, interfaceCallMethod.invoke(r1));
	}
	}