| /* |
| * 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 com.android.build.gradle; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| |
| import com.android.SdkConstants; |
| import com.android.build.gradle.api.TestVariant; |
| import com.android.build.gradle.internal.core.GradleVariantConfiguration; |
| import com.android.build.gradle.internal.dsl.BuildType; |
| import com.android.build.gradle.internal.errors.SyncIssueHandler; |
| import com.android.build.gradle.internal.fixture.BaseTestedVariant; |
| import com.android.build.gradle.internal.fixture.TestConstants; |
| import com.android.build.gradle.internal.fixture.TestProjects; |
| import com.android.build.gradle.internal.fixture.VariantChecker; |
| import com.android.build.gradle.internal.fixture.VariantCheckers; |
| import com.android.build.gradle.internal.scope.VariantScope; |
| import com.android.build.gradle.options.BooleanOption; |
| import com.android.build.gradle.tasks.AndroidJavaCompile; |
| import com.android.builder.core.AndroidBuilder; |
| import com.android.builder.model.SyncIssue; |
| import com.android.builder.model.TestOptions.Execution; |
| import com.android.builder.model.Version; |
| import com.android.utils.StringHelper; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableMap; |
| import com.google.common.collect.Iterables; |
| import com.google.common.truth.Truth; |
| import groovy.util.Eval; |
| import java.io.File; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.TreeMap; |
| import java.util.stream.Collectors; |
| import org.gradle.api.JavaVersion; |
| import org.gradle.api.Project; |
| import org.junit.Assert; |
| import org.junit.Before; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.rules.TemporaryFolder; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.Parameterized; |
| |
| /** Tests for checking the "application" and "atom" DSLs. */ |
| @RunWith(Parameterized.class) |
| public class PluginDslTest { |
| |
| @Rule public TemporaryFolder projectDirectory = new TemporaryFolder(); |
| private BasePlugin plugin; |
| private BaseExtension android; |
| private Project project; |
| private VariantChecker checker; |
| private final TestProjects.Plugin pluginType; |
| |
| @Parameterized.Parameters(name = "{0}") |
| public static TestProjects.Plugin[] generateStates() { |
| return new TestProjects.Plugin[] {TestProjects.Plugin.APP}; |
| } |
| |
| public PluginDslTest(TestProjects.Plugin pluginType) { |
| this.pluginType = pluginType; |
| } |
| |
| |
| @Before |
| public void setUp() throws Exception { |
| project = |
| TestProjects.builder(projectDirectory.newFolder("project").toPath()) |
| .withPlugin(pluginType) |
| .withProperty(BooleanOption.IDE_BUILD_MODEL_ONLY_ADVANCED, true) |
| .build(); |
| |
| android = project.getExtensions().getByType(pluginType.getExtensionClass()); |
| android.setCompileSdkVersion(TestConstants.COMPILE_SDK_VERSION); |
| android.setBuildToolsVersion(TestConstants.BUILD_TOOL_VERSION); |
| |
| if (pluginType == TestProjects.Plugin.APP) { |
| plugin = (AppPlugin) project.getPlugins().getPlugin(pluginType.getPluginClass()); |
| checker = VariantCheckers.createAppChecker((AppExtension) android); |
| } else { |
| throw new AssertionError("Unsupported plugin type"); |
| } |
| } |
| |
| @Test |
| public void testBasic() { |
| plugin.createAndroidTasks(); |
| VariantCheckers.checkDefaultVariants(plugin.getVariantManager().getVariantScopes()); |
| |
| // we can now call this since the variants/tasks have been created |
| Set<BaseTestedVariant> variants = checker.getVariants(); |
| Truth.assertThat(variants).named("variant list").hasSize(2); |
| |
| Set<TestVariant> testVariants = checker.getTestVariants(); |
| Truth.assertThat(testVariants).named("test variant list").hasSize(1); |
| |
| checker.checkTestedVariant("debug", "debugAndroidTest", variants, testVariants); |
| checker.checkNonTestedVariant("release", variants); |
| } |
| |
| @Test |
| public void testBasicWithStringTarget() { |
| Eval.me( |
| "project", |
| project, |
| "\n project.android {\n compileSdkVersion 'android-" |
| + String.valueOf(TestConstants.COMPILE_SDK_VERSION) |
| + "'\n }\n"); |
| |
| plugin.createAndroidTasks(); |
| VariantCheckers.checkDefaultVariants(plugin.getVariantManager().getVariantScopes()); |
| |
| // we can now call this since the variants/tasks have been created |
| Set<BaseTestedVariant> variants = checker.getVariants(); |
| Truth.assertThat(variants).named("variant list").hasSize(2); |
| |
| Set<TestVariant> testVariants = checker.getTestVariants(); |
| Truth.assertThat(testVariants).named("test variant list").hasSize(1); |
| |
| checker.checkTestedVariant("debug", "debugAndroidTest", variants, testVariants); |
| checker.checkNonTestedVariant("release", variants); |
| } |
| |
| @Test |
| public void testMultiRes() { |
| Eval.me( |
| "project", |
| project, |
| "\n" |
| + "project.android {\n" |
| + "\n" |
| + " sourceSets.main.res.srcDirs 'src/main/res1', 'src/main/res2'\n" |
| + "}\n"); |
| |
| // nothing to be done here. If the DSL fails, it'll throw an exception |
| } |
| |
| @Test |
| public void testBuildTypes() { |
| Eval.me( |
| "project", |
| project, |
| "\n" |
| + "project.android {\n" |
| + " testBuildType 'staging'\n" |
| + "\n" |
| + " buildTypes {\n" |
| + " staging {\n" |
| + " signingConfig signingConfigs.debug\n" |
| + " }\n" |
| + " }\n" |
| + "}\n"); |
| |
| plugin.createAndroidTasks(); |
| LinkedHashMap<String, Integer> map = new LinkedHashMap<>(3); |
| map.put("appVariants", 3); |
| map.put("unitTest", 3); |
| map.put("androidTests", 1); |
| assertThat(VariantCheckers.countVariants(map)) |
| .isEqualTo(plugin.getVariantManager().getVariantScopes().size()); |
| |
| // we can now call this since the variants/tasks have been created |
| |
| // does not include tests |
| Set<BaseTestedVariant> variants = checker.getVariants(); |
| Truth.assertThat(variants).named("variant list").hasSize(3); |
| |
| Set<TestVariant> testVariants = checker.getTestVariants(); |
| Truth.assertThat(testVariants).named("test variant list").hasSize(1); |
| |
| checker.checkTestedVariant("staging", "stagingAndroidTest", variants, testVariants); |
| |
| checker.checkNonTestedVariant("debug", variants); |
| checker.checkNonTestedVariant("release", variants); |
| } |
| |
| @Test |
| public void testFlavors() { |
| Eval.me( |
| "project", |
| project, |
| "\n" |
| + "project.android {\n" |
| + " flavorDimensions 'foo'\n" |
| + " productFlavors {\n" |
| + " flavor1 {\n" |
| + "\n" |
| + " }\n" |
| + " flavor2 {\n" |
| + "\n" |
| + " }\n" |
| + " }\n" |
| + "}\n"); |
| |
| plugin.createAndroidTasks(); |
| LinkedHashMap<String, Integer> map = new LinkedHashMap<>(3); |
| map.put("appVariants", 4); |
| map.put("unitTest", 4); |
| map.put("androidTests", 2); |
| assertThat(VariantCheckers.countVariants(map)) |
| .isEqualTo(plugin.getVariantManager().getVariantScopes().size()); |
| |
| // we can now call this since the variants/tasks have been created |
| |
| // does not include tests |
| Set<BaseTestedVariant> variants = checker.getVariants(); |
| Truth.assertThat(variants).named("variant list").hasSize(4); |
| |
| Set<TestVariant> testVariants = checker.getTestVariants(); |
| Truth.assertThat(testVariants).named("test variant list").hasSize(2); |
| |
| checker.checkTestedVariant( |
| "flavor1Debug", "flavor1DebugAndroidTest", variants, testVariants); |
| checker.checkTestedVariant( |
| "flavor2Debug", "flavor2DebugAndroidTest", variants, testVariants); |
| |
| checker.checkNonTestedVariant("flavor1Release", variants); |
| checker.checkNonTestedVariant("flavor2Release", variants); |
| } |
| |
| @Test |
| public void testMultiFlavors() { |
| Eval.me( |
| "project", |
| project, |
| "\n" |
| + "project.android {\n" |
| + " flavorDimensions 'dimension1', 'dimension2'\n" |
| + "\n" |
| + " productFlavors {\n" |
| + " f1 {\n" |
| + " dimension 'dimension1'\n" |
| + " javaCompileOptions.annotationProcessorOptions.className 'f1'\n" |
| + " }\n" |
| + " f2 {\n" |
| + " dimension 'dimension1'\n" |
| + " javaCompileOptions.annotationProcessorOptions.className 'f2'\n" |
| + " }\n" |
| + "\n" |
| + " fa {\n" |
| + " dimension 'dimension2'\n" |
| + " javaCompileOptions.annotationProcessorOptions.className 'fa'\n" |
| + " }\n" |
| + " fb {\n" |
| + " dimension 'dimension2'\n" |
| + " javaCompileOptions.annotationProcessorOptions.className 'fb'\n" |
| + " }\n" |
| + " fc {\n" |
| + " dimension 'dimension2'\n" |
| + " javaCompileOptions.annotationProcessorOptions.className 'fc'\n" |
| + " }\n" |
| + " }\n" |
| + "}\n"); |
| |
| plugin.createAndroidTasks(); |
| ImmutableMap<String, Integer> map = |
| ImmutableMap.of("appVariants", 12, "unitTests", 12, "androidTests", 6); |
| assertThat(VariantCheckers.countVariants(map)) |
| .isEqualTo(plugin.getVariantManager().getVariantScopes().size()); |
| |
| // we can now call this since the variants/tasks have been created |
| |
| // does not include tests |
| Set<BaseTestedVariant> variants = checker.getVariants(); |
| Truth.assertThat(variants).named("variant list").hasSize(12); |
| |
| Set<TestVariant> testVariants = checker.getTestVariants(); |
| Truth.assertThat(testVariants).named("test variant list").hasSize(6); |
| |
| checker.checkTestedVariant("f1FaDebug", "f1FaDebugAndroidTest", variants, testVariants); |
| checker.checkTestedVariant("f1FbDebug", "f1FbDebugAndroidTest", variants, testVariants); |
| checker.checkTestedVariant("f1FcDebug", "f1FcDebugAndroidTest", variants, testVariants); |
| checker.checkTestedVariant("f2FaDebug", "f2FaDebugAndroidTest", variants, testVariants); |
| checker.checkTestedVariant("f2FbDebug", "f2FbDebugAndroidTest", variants, testVariants); |
| checker.checkTestedVariant("f2FcDebug", "f2FcDebugAndroidTest", variants, testVariants); |
| |
| Map<String, VariantScope> variantMap = getVariantMap(); |
| |
| for (String dim1 : ImmutableList.of("f1", "f2")) { |
| for (String dim2 : ImmutableList.of("fa", "fb", "fc")) { |
| String variantName = |
| StringHelper.combineAsCamelCase(ImmutableList.of(dim1, dim2, "debug")); |
| GradleVariantConfiguration variant = |
| variantMap.get(variantName).getVariantConfiguration(); |
| assertThat( |
| variant.getJavaCompileOptions() |
| .getAnnotationProcessorOptions() |
| .getClassNames()) |
| .containsExactly(dim2, dim1) |
| .inOrder(); |
| } |
| } |
| |
| checker.checkNonTestedVariant("f1FaRelease", variants); |
| checker.checkNonTestedVariant("f1FbRelease", variants); |
| checker.checkNonTestedVariant("f1FcRelease", variants); |
| checker.checkNonTestedVariant("f2FaRelease", variants); |
| checker.checkNonTestedVariant("f2FbRelease", variants); |
| checker.checkNonTestedVariant("f2FcRelease", variants); |
| } |
| |
| @Test |
| public void testSourceSetsApi() { |
| // query the sourceSets, will throw if missing |
| Eval.me( |
| "project", |
| project, |
| " println project.android.sourceSets.main.java.srcDirs\n" |
| + "println project.android.sourceSets.main.resources.srcDirs\n" |
| + "println project.android.sourceSets.main.manifest.srcFile\n" |
| + "println project.android.sourceSets.main.res.srcDirs\n" |
| + "println project.android.sourceSets.main.assets.srcDirs"); |
| } |
| |
| @Test |
| public void testObfuscationMappingFile() { |
| Eval.me( |
| "project", |
| project, |
| "\n" |
| + "project.android {\n" |
| + " buildTypes {\n" |
| + " release {\n" |
| + " minifyEnabled true\n" |
| + " proguardFile getDefaultProguardFile('proguard-android.txt')\n" |
| + " }\n" |
| + " }\n" |
| + "}\n"); |
| |
| plugin.createAndroidTasks(); |
| VariantCheckers.checkDefaultVariants(plugin.getVariantManager().getVariantScopes()); |
| |
| // we can now call this since the variants/tasks have been created |
| |
| // does not include tests |
| Set<BaseTestedVariant> variants = checker.getVariants(); |
| Truth.assertThat(variants).named("variant list").hasSize(2); |
| |
| for (BaseTestedVariant variant : variants) { |
| if ("release".equals(variant.getBuildType().getName())) { |
| assertThat(variant.getMappingFile()).named("release mapping file").isNotNull(); |
| } else { |
| Assert.assertNull(variant.getMappingFile()); |
| } |
| } |
| } |
| |
| @Test |
| public void testProguardFiles_oldDsl() throws Exception { |
| Eval.me( |
| "project", |
| project, |
| "\n" |
| + "project.android {\n" |
| + " buildTypes {\n" |
| + " release {\n" |
| + " proguardFile 'file1.1'\n" |
| + " proguardFiles 'file1.2', 'file1.3'\n" |
| + " }\n" |
| + "\n" |
| + " custom {\n" |
| + " proguardFile 'file3.1'\n" |
| + " proguardFiles 'file3.2', 'file3.3'\n" |
| + " proguardFiles = ['file3.1']\n" |
| + " }\n" |
| + " }\n" |
| + "\n" |
| + " flavorDimensions 'foo'\n" |
| + " productFlavors {\n" |
| + " f1 {\n" |
| + " proguardFile 'file2.1'\n" |
| + " proguardFiles 'file2.2', 'file2.3'\n" |
| + " }\n" |
| + "\n" |
| + " f2 {\n" |
| + "\n" |
| + " }\n" |
| + "\n" |
| + " f3 {\n" |
| + " proguardFile 'file4.1'\n" |
| + " proguardFiles 'file4.2', 'file4.3'\n" |
| + " proguardFiles = ['file4.1']\n" |
| + " }\n" |
| + " }\n" |
| + "}\n"); |
| plugin.createAndroidTasks(); |
| |
| Map<String, List<String>> expected = new TreeMap<>(); |
| expected.put( |
| "f1Release", |
| ImmutableList.of("file1.1", "file1.2", "file1.3", "file2.1", "file2.2", "file2.3")); |
| expected.put("f1Debug", ImmutableList.of("file2.1", "file2.2", "file2.3")); |
| expected.put("f2Release", ImmutableList.of("file1.1", "file1.2", "file1.3")); |
| expected.put("f2Custom", ImmutableList.of("file3.1")); |
| expected.put("f3Custom", ImmutableList.of("file3.1", "file4.1")); |
| |
| checkProguardFiles(expected); |
| } |
| |
| @Test |
| public void testProguardFiles_newDsl() throws Exception { |
| Eval.me( |
| "project", |
| project, |
| "\n" |
| + "project.android {\n" |
| + " buildTypes {\n" |
| + " release {\n" |
| + " postprocessing{\n" |
| + " proguardFile 'file1.1'\n" |
| + " proguardFiles 'file1.2', 'file1.3'\n" |
| + " }\n" |
| + " }\n" |
| + "\n" |
| + " custom {\n" |
| + " postprocessing {\n" |
| + " proguardFile 'file3.1'\n" |
| + " proguardFiles 'file3.2', 'file3.3'\n" |
| + " proguardFiles = ['file3.1']\n" |
| + " }\n" |
| + " }\n" |
| + " }\n" |
| + "\n" |
| + " flavorDimensions 'foo'\n" |
| + " productFlavors {\n" |
| + " f1 {\n" |
| + " proguardFile 'file2.1'\n" |
| + " proguardFiles 'file2.2', 'file2.3'\n" |
| + " }\n" |
| + "\n" |
| + " f2 {\n" |
| + "\n" |
| + " }\n" |
| + "\n" |
| + " f3 {\n" |
| + " proguardFile 'file4.1'\n" |
| + " proguardFiles 'file4.2', 'file4.3'\n" |
| + " proguardFiles = ['file4.1']\n" |
| + " }\n" |
| + " }\n" |
| + "}\n"); |
| plugin.createAndroidTasks(); |
| |
| String defaultFile = |
| new File( |
| project.getBuildDir(), |
| "intermediates/proguard-files/proguard-defaults.txt-" |
| + Version.ANDROID_GRADLE_PLUGIN_VERSION) |
| .getAbsolutePath(); |
| |
| Map<String, List<String>> expected = new TreeMap<>(); |
| expected.put( |
| "f1Release", |
| ImmutableList.of( |
| defaultFile, |
| "file1.1", |
| "file1.2", |
| "file1.3", |
| "file2.1", |
| "file2.2", |
| "file2.3")); |
| expected.put("f2Release", ImmutableList.of(defaultFile, "file1.1", "file1.2", "file1.3")); |
| |
| // The custom build type uses setProguardFiles, so the default file will not be there. |
| expected.put("f2Custom", ImmutableList.of("file3.1")); |
| expected.put("f3Custom", ImmutableList.of("file3.1", "file4.1")); |
| |
| checkProguardFiles(expected); |
| } |
| |
| @Test |
| public void testSettingLanguageLevelFromCompileSdk_doNotOverride() { |
| Eval.me( |
| "project", |
| project, |
| "\n" |
| + "project.android {\n" |
| + " compileOptions {\n" |
| + " sourceCompatibility '1.6'\n" |
| + " targetCompatibility '1.6'\n" |
| + " }\n" |
| + "}\n"); |
| plugin.createAndroidTasks(); |
| |
| AndroidJavaCompile compileReleaseJavaWithJavac = |
| (AndroidJavaCompile) |
| project.getTasks().getByName(checker.getReleaseJavacTaskName()); |
| |
| assertThat(compileReleaseJavaWithJavac.getTargetCompatibility()) |
| .named("target compat") |
| .isEqualTo(JavaVersion.VERSION_1_6.toString()); |
| assertThat(compileReleaseJavaWithJavac.getSourceCompatibility()) |
| .named("source compat") |
| .isEqualTo(JavaVersion.VERSION_1_6.toString()); |
| } |
| |
| @Test |
| public void testSettingLanguageLevelFromCompileSdkWithJavaVersion_doNotOverride() { |
| Eval.me( |
| "project", |
| project, |
| "\n" |
| + "import org.gradle.api.JavaVersion\n" |
| + "project.android {\n" |
| + " compileOptions {\n" |
| + " sourceCompatibility = JavaVersion.VERSION_1_8\n" |
| + " targetCompatibility = JavaVersion.VERSION_1_8\n" |
| + " }\n" |
| + "}\n"); |
| plugin.createAndroidTasks(); |
| |
| AndroidJavaCompile compileReleaseJavaWithJavac = |
| (AndroidJavaCompile) |
| project.getTasks().getByName(checker.getReleaseJavacTaskName()); |
| |
| assertThat(compileReleaseJavaWithJavac.getTargetCompatibility()) |
| .named("target compat") |
| .isEqualTo(JavaVersion.VERSION_1_8.toString()); |
| assertThat(compileReleaseJavaWithJavac.getSourceCompatibility()) |
| .named("source compat") |
| .isEqualTo(JavaVersion.VERSION_1_8.toString()); |
| } |
| |
| @Test |
| public void testMockableJarName() { |
| android.setCompileSdkVersion( |
| "Google Inc.:Google APIs:" + TestConstants.COMPILE_SDK_VERSION_WITH_GOOGLE_APIS); |
| plugin.createAndroidTasks(); |
| Map<String, VariantScope> variantMap = getVariantMap(); |
| Map.Entry<String, VariantScope> vsentry = variantMap.entrySet().iterator().next(); |
| File mockableJarFile = |
| vsentry.getValue().getGlobalScope().getMockableJarArtifact().getSingleFile(); |
| assertThat(mockableJarFile).isNotNull(); |
| |
| if (SdkConstants.CURRENT_PLATFORM != SdkConstants.PLATFORM_WINDOWS) { |
| // Windows paths contain : to identify drives. |
| assertThat(mockableJarFile.getAbsolutePath()) |
| .named("Mockable jar Path") |
| .doesNotContain(":"); |
| } |
| |
| assertThat(mockableJarFile.getName()).named("Mockable jar name").isEqualTo("android.jar"); |
| } |
| |
| @Test |
| public void testEncoding() { |
| Eval.me( |
| "project", |
| project, |
| "\n" |
| + "project.android {\n" |
| + "\n" |
| + " compileOptions {\n" |
| + " encoding 'foo'\n" |
| + " }\n" |
| + "}\n"); |
| plugin.createAndroidTasks(); |
| |
| AndroidJavaCompile compileReleaseJavaWithJavac = |
| (AndroidJavaCompile) |
| project.getTasks().getByName(checker.getReleaseJavacTaskName()); |
| |
| assertThat(compileReleaseJavaWithJavac.getOptions().getEncoding()) |
| .named("source encoding") |
| .isEqualTo("foo"); |
| } |
| |
| @Test |
| public void testInstrumentationRunnerArguments_merging() throws Exception { |
| |
| Eval.me( |
| "project", |
| project, |
| "\n" |
| + "project.android {\n" |
| + " defaultConfig {\n" |
| + " testInstrumentationRunnerArguments(value: 'default', size: 'small')\n" |
| + " }\n" |
| + "\n" |
| + " flavorDimensions 'foo'\n" |
| + " productFlavors {\n" |
| + " f1 {\n" |
| + " }\n" |
| + "\n" |
| + " f2 {\n" |
| + " testInstrumentationRunnerArgument 'value', 'f2'\n" |
| + " }\n" |
| + "\n" |
| + " f3 {\n" |
| + " testInstrumentationRunnerArguments['otherValue'] = 'f3'\n" |
| + " }\n" |
| + "\n" |
| + " f4 {\n" |
| + " testInstrumentationRunnerArguments(otherValue: 'f4.1')\n" |
| + " testInstrumentationRunnerArguments = [otherValue: 'f4.2']\n" |
| + " }\n" |
| + " }\n" |
| + "}\n"); |
| plugin.createAndroidTasks(); |
| |
| Map<String, VariantScope> variantMap = getVariantMap(); |
| |
| Map<String, Map<String, String>> expected = |
| ImmutableMap.of( |
| "f1Debug", |
| ImmutableMap.of("value", "default", "size", "small"), |
| "f2Debug", |
| ImmutableMap.of("value", "f2", "size", "small"), |
| "f3Debug", |
| ImmutableMap.of("value", "default", "size", "small", "otherValue", "f3"), |
| "f4Debug", |
| ImmutableMap.of("value", "default", "size", "small", "otherValue", "f4.2")); |
| |
| expected.forEach( |
| (variant, args) -> |
| assertThat( |
| variantMap |
| .get(variant) |
| .getVariantConfiguration() |
| .getInstrumentationRunnerArguments()) |
| .containsExactlyEntriesIn(args)); |
| } |
| |
| /** Make sure DSL objects don't need "=" everywhere. */ |
| @Test |
| public void testSetters() throws Exception { |
| |
| Eval.me( |
| "project", |
| project, |
| "\n" |
| + "project.android {\n" |
| + "\n" |
| + "\n" |
| + " buildTypes {\n" |
| + " debug {\n" |
| + " useProguard false\n" |
| + " shrinkResources true\n" |
| + " }\n" |
| + " }\n" |
| + "}\n" |
| + "\n"); |
| BuildType debug = android.getBuildTypes().getByName("debug"); |
| assertThat(debug.isUseProguard()).isFalse(); |
| assertThat(debug.isShrinkResources()).isTrue(); |
| } |
| |
| @Test |
| public void testTestOptionsExecution() throws Exception { |
| android.getTestOptions().setExecution("android_test_orchestrator"); |
| assertThat(android.getTestOptions().getExecutionEnum()) |
| .isEqualTo(Execution.ANDROID_TEST_ORCHESTRATOR); |
| } |
| |
| @SuppressWarnings("deprecation") |
| @Test |
| public void testAdbExe() throws Exception { |
| assertThat(android.getAdbExe()).named("adb exe").isNotNull(); |
| assertThat(android.getAdbExecutable()).named("adb executable").isNotNull(); |
| |
| assertThat(android.getAdbExe()).named("adb exe").isEqualTo(android.getAdbExecutable()); |
| } |
| |
| @Test |
| public void testSetOlderBuildToolsVersion() { |
| android.setBuildToolsVersion("19.0.0"); |
| plugin.createAndroidTasks(); |
| assertThat(plugin.getAndroidBuilder().getBuildToolInfo().getRevision()) |
| .isEqualTo(AndroidBuilder.DEFAULT_BUILD_TOOLS_REVISION); |
| // FIXME once we get rid of the component model, we can make this better. |
| Collection<SyncIssue> syncIssues = |
| ((SyncIssueHandler) plugin.getAndroidBuilder().getIssueReporter()).getSyncIssues(); |
| assertThat(syncIssues).hasSize(1); |
| SyncIssue issue = Iterables.getOnlyElement(syncIssues); |
| assertThat(issue.getType()).isEqualTo(SyncIssue.TYPE_BUILD_TOOLS_TOO_LOW); |
| assertThat(issue.getSeverity()).isEqualTo(SyncIssue.SEVERITY_WARNING); |
| assertThat(issue.getMessage()) |
| .isEqualTo( |
| "The specified Android SDK Build Tools version (19.0.0) is " |
| + "ignored, as it is below the minimum supported version (" |
| + AndroidBuilder.MIN_BUILD_TOOLS_REV |
| + ") for Android Gradle Plugin " |
| + Version.ANDROID_GRADLE_PLUGIN_VERSION |
| + ".\n" |
| + "Android SDK Build Tools " |
| + AndroidBuilder.DEFAULT_BUILD_TOOLS_REVISION |
| + " will be used.\n" |
| + "To suppress this warning, remove \"buildToolsVersion '19.0.0'\" from your build.gradle file, " |
| + "as each version of the Android Gradle Plugin now has a default version of the build tools."); |
| } |
| |
| public void checkProguardFiles(Map<String, List<String>> expected) { |
| Map<String, VariantScope> variantMap = getVariantMap(); |
| for (Map.Entry<String, List<String>> entry : expected.entrySet()) { |
| String variantName = entry.getKey(); |
| Set<File> proguardFiles = |
| variantMap |
| .get(variantName) |
| .getProguardFiles() |
| .stream() |
| .map(File::getAbsoluteFile) |
| .collect(Collectors.toSet()); |
| Set<File> expectedFiles = |
| entry.getValue().stream().map(project::file).collect(Collectors.toSet()); |
| assertThat(proguardFiles) |
| .named("Proguard files for " + variantName) |
| .containsExactlyElementsIn(expectedFiles); |
| } |
| } |
| |
| public Map<String, VariantScope> getVariantMap() { |
| Map<String, VariantScope> result = new HashMap<>(); |
| for (VariantScope variantScope : plugin.getVariantManager().getVariantScopes()) { |
| result.put(variantScope.getFullVariantName(), variantScope); |
| } |
| return result; |
| } |
| } |
