tests/tests/libcoreapievolution/src/android/apievolution/cts/ApiEvolutionTest.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2018 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 android.apievolution.cts;

 import android.telephony.CellIdentity;
 import android.telephony.CellIdentityNr;
 import android.telephony.CellInfoNr;
 import android.telephony.CellSignalStrength;
 import android.telephony.CellSignalStrengthNr;

 import org.junit.Test;

 import java.lang.annotation.Annotation;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.nio.Buffer;
 import java.nio.ByteBuffer;
 import java.nio.CharBuffer;
 import java.nio.DoubleBuffer;
 import java.nio.FloatBuffer;
 import java.nio.IntBuffer;
 import java.nio.LongBuffer;
 import java.nio.ShortBuffer;
 import java.text.ParseException;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;

 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;

 /**
  * A test to ensure that platform bytecode is as expected to enable API evolution.
  */
 public class ApiEvolutionTest {

     /**
      * Tests for the presence of a synthetic overload for a subclass method override
      * that has a more specific (sub-) return type, but doesn't carry any annotation.
      */
     @Test
     public void testCovariantReturnTypeMethods_specializingSubclass() throws Exception {
         // Exceptions are not required to be identical in this case because the synthetic method
         // mirrors the superclass version.
         assertSyntheticMethodOverloadExists(
                 Sub.class, "myMethod", new Class[] { Integer.class },
                 String.class, Object.class,
                 false /* requireIdenticalExceptions */);
     }

     /**
      * Tests for the presence of a synthetic overload for {@link ConcurrentHashMap#keySet}
      * that must be introduced by the platform build tools in response to the presence of a
      * {@link dalvik.annotation.codegen.CovariantReturnType} annotation. http://b/28099367
      */
     @Test
     public void testCovariantReturnTypeMethods_annotation_concurrentHashMap() throws Exception {
         assertSyntheticMethodOverloadExists(ConcurrentHashMap.class, "keySet", null, Set.class,
                 ConcurrentHashMap.KeySetView.class, true /* requireIdenticalExceptions */);
     }

     @Test public void testCovariantReturnTypeMethods_annotation_byteBuffer() throws Exception {
         assertSyntheticBufferMethodOverloadsExists(ByteBuffer.class);
     }

     @Test public void testCovariantReturnTypeMethods_annotation_charBuffer() throws Exception {
         assertSyntheticBufferMethodOverloadsExists(CharBuffer.class);
     }

     @Test public void testCovariantReturnTypeMethods_annotation_doubleBuffer() throws Exception {
         assertSyntheticBufferMethodOverloadsExists(DoubleBuffer.class);
     }

     @Test public void testCovariantReturnTypeMethods_annotation_floatBuffer() throws Exception {
         assertSyntheticBufferMethodOverloadsExists(FloatBuffer.class);
     }

     @Test public void testCovariantReturnTypeMethods_annotation_intBuffer() throws Exception {
         assertSyntheticBufferMethodOverloadsExists(IntBuffer.class);
     }

     @Test public void testCovariantReturnTypeMethods_annotation_longBuffer() throws Exception {
         assertSyntheticBufferMethodOverloadsExists(LongBuffer.class);
     }

     @Test public void testCovariantReturnTypeMethods_annotation_shortBuffer() throws Exception {
         assertSyntheticBufferMethodOverloadsExists(ShortBuffer.class);
     }

     /**
      * Ensures that {@link CellInfoNr#getCellIdentity()} returns a {@link CellIdentityNr}.
      * This is not a libcore/ API but testing it here avoids duplicating test support code.
      */
     @Test public void testCellIdentityNr_Override() throws Exception {
         assertSyntheticMethodOverloadExists(CellInfoNr.class, "getCellIdentity", null,
             CellIdentity.class, CellIdentityNr.class, true /* requireIdenticalExceptions */);
     }

     /**
      * Ensures that {@link CellInfoNr#getCellSignalStrength()} returns a {@link
      * CellSignalStrengthNr}. This is not a libcore/ API but testing it here avoids duplicating
      * test support code.
      */
     @Test public void testCellCellSignalStrength_Override() throws Exception {
         assertSyntheticMethodOverloadExists(CellInfoNr.class, "getCellSignalStrength", null,
             CellSignalStrength.class, CellSignalStrengthNr.class,
             true /* requireIdenticalExceptions */);
     }

     /**
      * Asserts the presence of synthetic methods overloads for methods that return {@code this} on
      * {@link Buffer} subclasses, and which are annotated with {@code @CovariantReturnType}.
      * In OpenJDK 9 the return types were changed from {@link Buffer} to be the subclass's type
      * instead. http://b/71597787
      */
     private static void assertSyntheticBufferMethodOverloadsExists(Class<? extends Buffer> c)
             throws Exception {
         assertSyntheticBufferMethodOverloadExists(c, "position", new Class[] { Integer.TYPE });
         assertSyntheticBufferMethodOverloadExists(c, "limit", new Class[] { Integer.TYPE });
         assertSyntheticBufferMethodOverloadExists(c, "mark", null);
         assertSyntheticBufferMethodOverloadExists(c, "reset", null);
         assertSyntheticBufferMethodOverloadExists(c, "clear", null);
         assertSyntheticBufferMethodOverloadExists(c, "flip", null);
         assertSyntheticBufferMethodOverloadExists(c, "rewind", null);
     }

     private static void assertSyntheticBufferMethodOverloadExists(
             Class<? extends Buffer> bufferClass, String methodName, Class[] parameterTypes)
             throws Exception {
         assertSyntheticMethodOverloadExists(bufferClass, methodName, parameterTypes,
                 Buffer.class /* originalReturnType */,
                 bufferClass /* syntheticReturnType */,
                 true  /* requireIdenticalExceptions */);
     }

     private static void assertSyntheticMethodOverloadExists(
             Class<?> clazz, String methodName, Class[] parameterTypes,
             Class<?> originalReturnType, Class<?> syntheticReturnType,
             boolean requireIdenticalExceptions) throws Exception {

         if (parameterTypes == null) {
             parameterTypes = new Class[0];
         }
         String fullMethodName = clazz + "." + methodName;

         // Assert we find the original, non-synthetic version using getDeclaredMethod().
         Method declaredMethod = clazz.getDeclaredMethod(methodName, parameterTypes);
         assertEquals(originalReturnType, declaredMethod.getReturnType());

         // Assert both versions of the method are returned from getDeclaredMethods().
         Method original = null;
         Method synthetic = null;
         for (Method method : clazz.getDeclaredMethods()) {
             if (methodMatches(methodName, parameterTypes, method)) {
                 if (method.getReturnType().equals(syntheticReturnType)) {
                     synthetic = method;
                 } else if (method.getReturnType().equals(originalReturnType)) {
                     original = method;
                 }
             }
         }
         assertNotNull("Unable to find original signature: " + fullMethodName
                 + ", returning " + originalReturnType, original);
         assertNotNull("Unable to find synthetic signature: " + fullMethodName
                 + ", returning " + syntheticReturnType, synthetic);

         // Check modifiers are as expected.
         assertFalse(original.isSynthetic());
         assertFalse(original.isBridge());
         assertTrue(synthetic.isSynthetic());
         assertTrue(synthetic.isBridge());

         int originalModifiers = original.getModifiers();
         int syntheticModifiers = synthetic.getModifiers();

         // These masks aren't in the public API but are defined in the dex spec.
         int syntheticMask = 0x00001000;
         int bridgeMask = 0x00000040;
         int mask = syntheticMask | bridgeMask;
         assertEquals("Method modifiers for " + fullMethodName
                         + " are expected to be identical except for SYNTHETIC and BRIDGE."
                         + " original=" + Modifier.toString(originalModifiers)
                         + ", synthetic=" + Modifier.toString(syntheticModifiers),
                 originalModifiers | mask,
                 syntheticModifiers | mask);

         // Exceptions are not required at method resolution time but we check they're the same in
         // most cases for completeness.
         if (requireIdenticalExceptions) {
             assertArrayEquals("Exceptions for " + fullMethodName + " must be compatible",
                     original.getExceptionTypes(), synthetic.getExceptionTypes());
         }

         // Android doesn't support runtime type annotations so nothing to do for them.

         // Type parameters are *not* copied because they're not needed at method resolution time.
         assertEquals(0, synthetic.getTypeParameters().length);

         // Check method annotations.
         Annotation[] annotations = original.getDeclaredAnnotations();
         assertArrayEquals("Annotations differ between original and synthetic versions of "
                 + fullMethodName, annotations, synthetic.getDeclaredAnnotations());
         Annotation[][] parameterAnnotations = original.getParameterAnnotations();
         // Check parameter annotations.
         assertArrayEquals("Annotations differ between original and synthetic versions of "
                 + fullMethodName, parameterAnnotations, synthetic.getParameterAnnotations());
     }

     private static boolean methodMatches(String methodName, Class[] parameterTypes, Method method) {
         return method.getName().equals(methodName)
                 && Arrays.equals(parameterTypes, method.getParameterTypes());
     }

     /** Annotation used in return type specialization tests. */
     @Retention(RetentionPolicy.RUNTIME)
     private @interface TestAnnotation {}

     /** Base class for return type specialization tests. */
     private static class Base {
         protected Object myMethod(Integer p1) throws Exception {
             return null;
         }
     }

     /** Sub class for return type specialization tests. */
     private static class Sub extends Base {
         @TestAnnotation
         @Override
         protected String myMethod(@TestAnnotation Integer p1) throws ParseException {
             return null;
         }
     }
 }
	/*
	* Copyright (C) 2018 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 android.apievolution.cts;

	import android.telephony.CellIdentity;
	import android.telephony.CellIdentityNr;
	import android.telephony.CellInfoNr;
	import android.telephony.CellSignalStrength;
	import android.telephony.CellSignalStrengthNr;

	import org.junit.Test;

	import java.lang.annotation.Annotation;
	import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;
	import java.lang.reflect.Method;
	import java.lang.reflect.Modifier;
	import java.nio.Buffer;
	import java.nio.ByteBuffer;
	import java.nio.CharBuffer;
	import java.nio.DoubleBuffer;
	import java.nio.FloatBuffer;
	import java.nio.IntBuffer;
	import java.nio.LongBuffer;
	import java.nio.ShortBuffer;
	import java.text.ParseException;
	import java.util.Arrays;
	import java.util.List;
	import java.util.Set;
	import java.util.concurrent.ConcurrentHashMap;

	import static org.junit.Assert.assertArrayEquals;
	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertFalse;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.assertTrue;

	/**
	* A test to ensure that platform bytecode is as expected to enable API evolution.
	*/
	public class ApiEvolutionTest {

	/**
	* Tests for the presence of a synthetic overload for a subclass method override
	* that has a more specific (sub-) return type, but doesn't carry any annotation.
	*/
	@Test
	public void testCovariantReturnTypeMethods_specializingSubclass() throws Exception {
	// Exceptions are not required to be identical in this case because the synthetic method
	// mirrors the superclass version.
	assertSyntheticMethodOverloadExists(
	Sub.class, "myMethod", new Class[] { Integer.class },
	String.class, Object.class,
	false /* requireIdenticalExceptions */);
	}

	/**
	* Tests for the presence of a synthetic overload for {@link ConcurrentHashMap#keySet}
	* that must be introduced by the platform build tools in response to the presence of a
	* {@link dalvik.annotation.codegen.CovariantReturnType} annotation. http://b/28099367
	*/
	@Test
	public void testCovariantReturnTypeMethods_annotation_concurrentHashMap() throws Exception {
	assertSyntheticMethodOverloadExists(ConcurrentHashMap.class, "keySet", null, Set.class,
	ConcurrentHashMap.KeySetView.class, true /* requireIdenticalExceptions */);
	}

	@Test public void testCovariantReturnTypeMethods_annotation_byteBuffer() throws Exception {
	assertSyntheticBufferMethodOverloadsExists(ByteBuffer.class);
	}

	@Test public void testCovariantReturnTypeMethods_annotation_charBuffer() throws Exception {
	assertSyntheticBufferMethodOverloadsExists(CharBuffer.class);
	}

	@Test public void testCovariantReturnTypeMethods_annotation_doubleBuffer() throws Exception {
	assertSyntheticBufferMethodOverloadsExists(DoubleBuffer.class);
	}

	@Test public void testCovariantReturnTypeMethods_annotation_floatBuffer() throws Exception {
	assertSyntheticBufferMethodOverloadsExists(FloatBuffer.class);
	}

	@Test public void testCovariantReturnTypeMethods_annotation_intBuffer() throws Exception {
	assertSyntheticBufferMethodOverloadsExists(IntBuffer.class);
	}

	@Test public void testCovariantReturnTypeMethods_annotation_longBuffer() throws Exception {
	assertSyntheticBufferMethodOverloadsExists(LongBuffer.class);
	}

	@Test public void testCovariantReturnTypeMethods_annotation_shortBuffer() throws Exception {
	assertSyntheticBufferMethodOverloadsExists(ShortBuffer.class);
	}

	/**
	* Ensures that {@link CellInfoNr#getCellIdentity()} returns a {@link CellIdentityNr}.
	* This is not a libcore/ API but testing it here avoids duplicating test support code.
	*/
	@Test public void testCellIdentityNr_Override() throws Exception {
	assertSyntheticMethodOverloadExists(CellInfoNr.class, "getCellIdentity", null,
	CellIdentity.class, CellIdentityNr.class, true /* requireIdenticalExceptions */);
	}

	/**
	* Ensures that {@link CellInfoNr#getCellSignalStrength()} returns a {@link
	* CellSignalStrengthNr}. This is not a libcore/ API but testing it here avoids duplicating
	* test support code.
	*/
	@Test public void testCellCellSignalStrength_Override() throws Exception {
	assertSyntheticMethodOverloadExists(CellInfoNr.class, "getCellSignalStrength", null,
	CellSignalStrength.class, CellSignalStrengthNr.class,
	true /* requireIdenticalExceptions */);
	}

	/**
	* Asserts the presence of synthetic methods overloads for methods that return {@code this} on
	* {@link Buffer} subclasses, and which are annotated with {@code @CovariantReturnType}.
	* In OpenJDK 9 the return types were changed from {@link Buffer} to be the subclass's type
	* instead. http://b/71597787
	*/
	private static void assertSyntheticBufferMethodOverloadsExists(Class<? extends Buffer> c)
	throws Exception {
	assertSyntheticBufferMethodOverloadExists(c, "position", new Class[] { Integer.TYPE });
	assertSyntheticBufferMethodOverloadExists(c, "limit", new Class[] { Integer.TYPE });
	assertSyntheticBufferMethodOverloadExists(c, "mark", null);
	assertSyntheticBufferMethodOverloadExists(c, "reset", null);
	assertSyntheticBufferMethodOverloadExists(c, "clear", null);
	assertSyntheticBufferMethodOverloadExists(c, "flip", null);
	assertSyntheticBufferMethodOverloadExists(c, "rewind", null);
	}

	private static void assertSyntheticBufferMethodOverloadExists(
	Class<? extends Buffer> bufferClass, String methodName, Class[] parameterTypes)
	throws Exception {
	assertSyntheticMethodOverloadExists(bufferClass, methodName, parameterTypes,
	Buffer.class /* originalReturnType */,
	bufferClass /* syntheticReturnType */,
	true /* requireIdenticalExceptions */);
	}

	private static void assertSyntheticMethodOverloadExists(
	Class<?> clazz, String methodName, Class[] parameterTypes,
	Class<?> originalReturnType, Class<?> syntheticReturnType,
	boolean requireIdenticalExceptions) throws Exception {

	if (parameterTypes == null) {
	parameterTypes = new Class[0];
	}
	String fullMethodName = clazz + "." + methodName;

	// Assert we find the original, non-synthetic version using getDeclaredMethod().
	Method declaredMethod = clazz.getDeclaredMethod(methodName, parameterTypes);
	assertEquals(originalReturnType, declaredMethod.getReturnType());

	// Assert both versions of the method are returned from getDeclaredMethods().
	Method original = null;
	Method synthetic = null;
	for (Method method : clazz.getDeclaredMethods()) {
	if (methodMatches(methodName, parameterTypes, method)) {
	if (method.getReturnType().equals(syntheticReturnType)) {
	synthetic = method;
	} else if (method.getReturnType().equals(originalReturnType)) {
	original = method;
	}
	}
	}
	assertNotNull("Unable to find original signature: " + fullMethodName
	+ ", returning " + originalReturnType, original);
	assertNotNull("Unable to find synthetic signature: " + fullMethodName
	+ ", returning " + syntheticReturnType, synthetic);

	// Check modifiers are as expected.
	assertFalse(original.isSynthetic());
	assertFalse(original.isBridge());
	assertTrue(synthetic.isSynthetic());
	assertTrue(synthetic.isBridge());

	int originalModifiers = original.getModifiers();
	int syntheticModifiers = synthetic.getModifiers();

	// These masks aren't in the public API but are defined in the dex spec.
	int syntheticMask = 0x00001000;
	int bridgeMask = 0x00000040;
	int mask = syntheticMask \| bridgeMask;
	assertEquals("Method modifiers for " + fullMethodName
	+ " are expected to be identical except for SYNTHETIC and BRIDGE."
	+ " original=" + Modifier.toString(originalModifiers)
	+ ", synthetic=" + Modifier.toString(syntheticModifiers),
	originalModifiers \| mask,
	syntheticModifiers \| mask);

	// Exceptions are not required at method resolution time but we check they're the same in
	// most cases for completeness.
	if (requireIdenticalExceptions) {
	assertArrayEquals("Exceptions for " + fullMethodName + " must be compatible",
	original.getExceptionTypes(), synthetic.getExceptionTypes());
	}

	// Android doesn't support runtime type annotations so nothing to do for them.

	// Type parameters are not copied because they're not needed at method resolution time.
	assertEquals(0, synthetic.getTypeParameters().length);

	// Check method annotations.
	Annotation[] annotations = original.getDeclaredAnnotations();
	assertArrayEquals("Annotations differ between original and synthetic versions of "
	+ fullMethodName, annotations, synthetic.getDeclaredAnnotations());
	Annotation[][] parameterAnnotations = original.getParameterAnnotations();
	// Check parameter annotations.
	assertArrayEquals("Annotations differ between original and synthetic versions of "
	+ fullMethodName, parameterAnnotations, synthetic.getParameterAnnotations());
	}

	private static boolean methodMatches(String methodName, Class[] parameterTypes, Method method) {
	return method.getName().equals(methodName)
	&& Arrays.equals(parameterTypes, method.getParameterTypes());
	}

	/** Annotation used in return type specialization tests. */
	@Retention(RetentionPolicy.RUNTIME)
	private @interface TestAnnotation {}

	/** Base class for return type specialization tests. */
	private static class Base {
	protected Object myMethod(Integer p1) throws Exception {
	return null;
	}
	}

	/** Sub class for return type specialization tests. */
	private static class Sub extends Base {
	@TestAnnotation
	@Override
	protected String myMethod(@TestAnnotation Integer p1) throws ParseException {
	return null;
	}
	}
	}