| // Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| package nesthostexample; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertTrue; |
| |
| import com.android.tools.r8.D8TestCompileResult; |
| import com.android.tools.r8.JdkClassFileProvider; |
| import com.android.tools.r8.JvmTestBuilder; |
| import com.android.tools.r8.R8TestCompileResult; |
| import com.android.tools.r8.TestBase; |
| import com.android.tools.r8.TestParameters; |
| import com.android.tools.r8.TestParametersCollection; |
| import com.android.tools.r8.TestRuntime.CfVm; |
| import com.android.tools.r8.ToolHelper; |
| import com.android.tools.r8.graph.DexClass; |
| import com.android.tools.r8.graph.DexEncodedMethod; |
| import com.android.tools.r8.graph.DexType; |
| import com.android.tools.r8.ir.desugar.nest.NestBasedAccessDesugaring; |
| import com.android.tools.r8.references.Reference; |
| import com.android.tools.r8.synthesis.SyntheticItemsTestUtils; |
| import com.android.tools.r8.utils.StringUtils; |
| import com.android.tools.r8.utils.codeinspector.ClassSubject; |
| import com.android.tools.r8.utils.codeinspector.CodeInspector; |
| import com.android.tools.r8.utils.codeinspector.FoundMethodSubject; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableMap; |
| import java.io.IOException; |
| import java.util.List; |
| import java.util.stream.Collectors; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.Parameterized; |
| import org.junit.runners.Parameterized.Parameters; |
| |
| @RunWith(Parameterized.class) |
| public class FullNestOnProgramPathTest extends TestBase { |
| |
| public static final ImmutableMap<Class<?>, String> NEST_MAIN_RESULT = |
| ImmutableMap.<Class<?>, String>builder() |
| .put( |
| BasicNestHostWithInnerClassFields.class, |
| StringUtils.lines(BasicNestHostWithInnerClassFields.getExpectedResult())) |
| .put( |
| BasicNestHostWithInnerClassMethods.class, |
| StringUtils.lines(BasicNestHostWithInnerClassMethods.getExpectedResult())) |
| .put( |
| BasicNestHostWithInnerClassConstructors.class, |
| StringUtils.lines(BasicNestHostWithInnerClassConstructors.getExpectedResult())) |
| .put( |
| BasicNestHostWithAnonymousInnerClass.class, |
| StringUtils.lines(BasicNestHostWithAnonymousInnerClass.getExpectedResult())) |
| .put(NestHostExample.class, StringUtils.lines(NestHostExample.getExpectedResult())) |
| .build(); |
| |
| public FullNestOnProgramPathTest(TestParameters parameters) { |
| this.parameters = parameters; |
| } |
| |
| private final TestParameters parameters; |
| |
| @Parameters(name = "{0}") |
| public static TestParametersCollection data() { |
| return getTestParameters() |
| .withCfRuntimesStartingFromIncluding(CfVm.JDK11) |
| .withDexRuntimes() |
| .withApiLevelsStartingAtIncluding(apiLevelWithInvokeCustomSupport()) |
| .enableApiLevelsForCf() |
| .build(); |
| } |
| |
| @Test |
| public void testAllNestsReference() throws Exception { |
| parameters.assumeJvmTestParameters(); |
| JvmTestBuilder jvmTestBuilder = |
| testForJvm(parameters).addProgramClassesAndInnerClasses(NEST_MAIN_RESULT.keySet()); |
| for (Class<?> clazz : NEST_MAIN_RESULT.keySet()) { |
| jvmTestBuilder |
| .run(parameters.getRuntime(), clazz) |
| .assertSuccessWithOutput(NEST_MAIN_RESULT.get(clazz)); |
| } |
| } |
| |
| @Test |
| public void testAllNestsD8() throws Exception { |
| D8TestCompileResult compileResult = |
| testForD8(parameters.getBackend()) |
| .addProgramClassesAndInnerClasses(NEST_MAIN_RESULT.keySet()) |
| .setMinApi(parameters) |
| .compile() |
| .applyIf(parameters.isDexRuntime(), b -> b.inspect(this::assertOnlyRequiredBridges)); |
| for (Class<?> clazz : NEST_MAIN_RESULT.keySet()) { |
| compileResult |
| .run(parameters.getRuntime(), clazz) |
| .assertSuccessWithOutput(NEST_MAIN_RESULT.get(clazz)); |
| } |
| } |
| |
| @Test |
| public void testAllNestsR8() throws Exception { |
| parameters.assumeR8TestParameters(); |
| R8TestCompileResult compileResult = |
| testForR8(parameters.getBackend()) |
| .addDontShrink() |
| .addDontObfuscate() |
| .addKeepAllAttributes() |
| .addOptionsModification(options -> options.enableNestReduction = false) |
| .addProgramClassesAndInnerClasses(NEST_MAIN_RESULT.keySet()) |
| .applyIf( |
| parameters.isCfRuntime(), |
| b -> b.addLibraryProvider(JdkClassFileProvider.fromSystemJdk())) |
| .setMinApi(parameters) |
| .compile() |
| .inspect(this::assertOnlyRequiredBridges) |
| .applyIf( |
| parameters.isCfRuntime(), |
| b -> b.inspect(FullNestOnProgramPathTest::checkNestMateAttributes)); |
| for (Class<?> clazz : NEST_MAIN_RESULT.keySet()) { |
| compileResult |
| .run(parameters.getRuntime(), clazz) |
| .assertSuccessWithOutput(NEST_MAIN_RESULT.get(clazz)); |
| } |
| } |
| |
| // Single Nest test compile only the nest into dex, |
| // then run the main class from this dex. |
| @Test |
| public void testSingleNestR8() throws Exception { |
| parameters.assumeR8TestParameters(); |
| for (Class<?> clazz : NEST_MAIN_RESULT.keySet()) { |
| testForR8(parameters.getBackend()) |
| .addDontShrink() |
| .addDontObfuscate() |
| .addKeepAllAttributes() |
| .setMinApi(parameters) |
| .addProgramClassesAndInnerClasses(clazz) |
| .addOptionsModification(options -> options.enableNestReduction = false) |
| .applyIf( |
| parameters.isCfRuntime(), |
| b -> b.addLibraryProvider(JdkClassFileProvider.fromSystemJdk())) |
| .compile() |
| .run(parameters.getRuntime(), clazz) |
| .assertSuccessWithOutput(NEST_MAIN_RESULT.get(clazz)); |
| } |
| } |
| |
| @Test |
| public void testSingleNestD8() throws Exception { |
| for (Class<?> clazz : NEST_MAIN_RESULT.keySet()) { |
| testForD8(parameters.getBackend()) |
| .setMinApi(parameters) |
| .addProgramClassesAndInnerClasses(clazz) |
| .compile() |
| .run(parameters.getRuntime(), clazz) |
| .assertSuccessWithOutput(NEST_MAIN_RESULT.get(clazz)); |
| } |
| } |
| |
| private static int minNumberOfTestClasses() { |
| return NEST_MAIN_RESULT.keySet().stream() |
| .mapToInt( |
| c -> { |
| try { |
| return ToolHelper.getClassFilesForInnerClasses(c).size() + 1; |
| } catch (IOException e) { |
| throw new RuntimeException(e); |
| } |
| }) |
| .sum(); |
| } |
| |
| private static void checkNestMateAttributes(CodeInspector inspector) { |
| // Interface method desugaring may add extra classes |
| assertTrue(minNumberOfTestClasses() <= inspector.allClasses().size()); |
| List<String> outerClassNames = |
| NEST_MAIN_RESULT.keySet().stream().map(Class::getSimpleName).collect(Collectors.toList()); |
| ImmutableList<String> nonNestClasses = |
| ImmutableList.of("NeverInline", "OutsideInliningNoAccess", "OutsideInliningWithAccess"); |
| inspector.forAllClasses( |
| classSubject -> { |
| DexClass dexClass = classSubject.getDexProgramClass(); |
| if (!nonNestClasses.contains(dexClass.type.getName())) { |
| assertTrue(dexClass.isInANest()); |
| if (outerClassNames.contains(dexClass.type.getName())) { |
| assertNull(dexClass.getNestHostClassAttribute()); |
| assertFalse(dexClass.getNestMembersClassAttributes().isEmpty()); |
| } else { |
| assertTrue(dexClass.getNestMembersClassAttributes().isEmpty()); |
| assertTrue( |
| outerClassNames.contains( |
| dexClass.getNestHostClassAttribute().getNestHost().getName())); |
| } |
| } |
| }); |
| } |
| |
| private void assertOnlyRequiredBridges(CodeInspector inspector) { |
| // The following 2 classes have an extra private member which does not require a bridge. |
| |
| // Two bridges for method and staticMethod. |
| int methodNumBridges = parameters.isCfRuntime() ? 0 : 2; |
| ClassSubject methodMainClass = inspector.clazz(BasicNestHostWithInnerClassMethods.class); |
| assertEquals(methodNumBridges, methodMainClass.allMethods(this::isNestBridge).size()); |
| |
| // Two bridges for method and staticMethod. |
| int constructorNumBridges = parameters.isCfRuntime() ? 0 : 1; |
| ClassSubject constructorMainClass = |
| inspector.clazz(BasicNestHostWithInnerClassConstructors.class); |
| assertEquals(constructorNumBridges, constructorMainClass.allMethods(this::isNestBridge).size()); |
| |
| // Four bridges for field and staticField, both get & set. |
| int fieldNumBridges = parameters.isCfRuntime() ? 0 : 4; |
| ClassSubject fieldMainClass = inspector.clazz(BasicNestHostWithInnerClassFields.class); |
| assertEquals(fieldNumBridges, fieldMainClass.allMethods(this::isNestBridge).size()); |
| } |
| |
| private boolean isNestBridge(FoundMethodSubject methodSubject) { |
| DexEncodedMethod method = methodSubject.getMethod(); |
| if (method.isInstanceInitializer()) { |
| if (method.getReference().proto.parameters.isEmpty()) { |
| return false; |
| } |
| DexType[] formals = method.getReference().proto.parameters.values; |
| DexType lastFormal = formals[formals.length - 1]; |
| return lastFormal.isClassType() |
| && SyntheticItemsTestUtils.isInitializerTypeArgument( |
| Reference.classFromDescriptor(lastFormal.toDescriptorString())); |
| } |
| return method |
| .getReference() |
| .name |
| .toString() |
| .startsWith(NestBasedAccessDesugaring.NEST_ACCESS_NAME_PREFIX); |
| } |
| } |
