Add API to query build variants.

Also add some tests for it.

Change-Id: Ibaad3dd385004c9c514aa71215526a775cbc9aaf

3 files changed, 345 insertions, 29 deletions

diff --git a/gradle/src/test/groovy/com/android/build/gradle/AppPluginDslTest.groovy b/gradle/src/test/groovy/com/android/build/gradle/AppPluginDslTest.groovy
new file mode 100644
index 0000000..593166b
--- /dev/null
+++ b/gradle/src/test/groovy/com/android/build/gradle/AppPluginDslTest.groovy
@@ -0,0 +1,221 @@
+/*
+ * Copyright (C) 2012 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 com.android.build.gradle.internal.BaseTest
+import org.gradle.api.Project
+import org.gradle.testfixtures.ProjectBuilder
+
+/**
+ * Tests for the public DSL of the App plugin ("android")
+ */
+public class AppPluginDslTest extends BaseTest {
+
+    @Override
+    protected void setUp() throws Exception {
+        BasePlugin.TEST_SDK_DIR = new File("foo")
+    }
+
+    public void testBasic() {
+        Project project = ProjectBuilder.builder().withProjectDir(
+                new File(testDir, "basic")).build()
+
+        project.apply plugin: 'android'
+
+        project.android {
+            target "android-15"
+        }
+
+        Set<BuildVariant> variants = project.android.buildVariants
+        assertEquals(2, variants.size())
+
+        Set<BuildVariant> testVariants = project.android.testBuildVariants
+        assertEquals(1, testVariants.size())
+
+        checkTestedVariant("Debug", "Test", variants, testVariants)
+        checkNonTestedVariant("Release", variants)
+    }
+
+    public void testBuildTypes() {
+        Project project = ProjectBuilder.builder().withProjectDir(
+                new File(testDir, "basic")).build()
+
+        project.apply plugin: 'android'
+
+        project.android {
+            target "android-15"
+            testBuildType "staging"
+
+            buildTypes {
+                staging {
+                    debugSigned true
+                }
+            }
+        }
+
+        // does not include tests
+        Set<BuildVariant> variants = project.android.buildVariants
+        assertEquals(3, variants.size())
+
+        Set<BuildVariant> testVariants = project.android.testBuildVariants
+        assertEquals(1, testVariants.size())
+
+        checkTestedVariant("Staging", "Test", variants, testVariants)
+
+        checkNonTestedVariant("Debug", variants)
+        checkNonTestedVariant("Release", variants)
+    }
+
+    public void testFlavors() {
+        Project project = ProjectBuilder.builder().withProjectDir(
+                new File(testDir, "basic")).build()
+
+        project.apply plugin: 'android'
+
+        project.android {
+            target "android-15"
+
+            productFlavors {
+                flavor1 {
+
+                }
+                flavor2 {
+
+                }
+            }
+        }
+
+        // does not include tests
+        Set<BuildVariant> variants = project.android.buildVariants
+        assertEquals(4, variants.size())
+
+        Set<BuildVariant> testVariants = project.android.testBuildVariants
+        assertEquals(2, testVariants.size())
+
+        checkTestedVariant("Flavor1Debug", "Flavor1Test", variants, testVariants)
+        checkTestedVariant("Flavor2Debug", "Flavor2Test", variants, testVariants)
+
+        checkNonTestedVariant("Flavor1Release", variants)
+        checkNonTestedVariant("Flavor2Release", variants)
+    }
+
+    public void testMultiFlavors() {
+        Project project = ProjectBuilder.builder().withProjectDir(
+                new File(testDir, "basic")).build()
+
+        project.apply plugin: 'android'
+
+        project.android {
+            target "android-15"
+
+            flavorGroups   "group1", "group2"
+
+            productFlavors {
+                f1 {
+                    flavorGroup   "group1"
+                }
+                f2 {
+                    flavorGroup   "group1"
+                }
+
+                fa {
+                    flavorGroup   "group2"
+                }
+                fb {
+                    flavorGroup   "group2"
+                }
+                fc {
+                    flavorGroup   "group2"
+                }
+            }
+        }
+
+        // does not include tests
+        Set<BuildVariant> variants = project.android.buildVariants
+        assertEquals(12, variants.size())
+
+        Set<BuildVariant> testVariants = project.android.testBuildVariants
+        assertEquals(6, testVariants.size())
+
+        checkTestedVariant("F1FaDebug", "F1FaTest", variants, testVariants)
+        checkTestedVariant("F1FbDebug", "F1FbTest", variants, testVariants)
+        checkTestedVariant("F1FcDebug", "F1FcTest", variants, testVariants)
+        checkTestedVariant("F2FaDebug", "F2FaTest", variants, testVariants)
+        checkTestedVariant("F2FbDebug", "F2FbTest", variants, testVariants)
+        checkTestedVariant("F2FcDebug", "F2FcTest", variants, testVariants)
+
+        checkNonTestedVariant("F1FaRelease", variants)
+        checkNonTestedVariant("F1FbRelease", variants)
+        checkNonTestedVariant("F1FcRelease", variants)
+        checkNonTestedVariant("F2FaRelease", variants)
+        checkNonTestedVariant("F2FbRelease", variants)
+        checkNonTestedVariant("F2FcRelease", variants)
+    }
+
+    private void checkTestedVariant(String variantName, String testedVariantName,
+                                    Set<BuildVariant> variants, Set<BuildVariant> testVariants) {
+        BuildVariant variant = findVariant(variants, variantName)
+        assertNotNull(variant)
+        assertNotNull(variant.testVariant)
+        assertEquals(testedVariantName, variant.testVariant.name)
+        assertEquals(variant.testVariant, findVariant(testVariants, testedVariantName))
+        checkTasks(variant, false)
+        checkTasks(variant.testVariant, true)
+    }
+
+    private void checkNonTestedVariant(String variantName, Set<BuildVariant> variants) {
+        BuildVariant variant = findVariant(variants, variantName)
+        assertNotNull(variant)
+        assertNull(variant.testVariant)
+        checkTasks(variant, false)
+    }
+
+    private void checkTasks(BuildVariant variant, boolean testVariant) {
+        assertNotNull(variant.processManifestTask)
+        assertNotNull(variant.compileAidlTask)
+        assertNotNull(variant.crunchResourcesTask)
+        assertNotNull(variant.processResourcesTask)
+        assertNotNull(variant.generateBuildConfigTask)
+        assertNotNull(variant.compileTask)
+        assertNotNull(variant.processJavaResources)
+        assertNotNull(variant.dexTask)
+        assertNotNull(variant.packageApplicationTask)
+        assertNotNull(variant.assembleTask)
+        assertNotNull(variant.uninstallTask)
+
+        if (variant.buildType.debugSigned || variant.mergedConfig.isSigningReady()) {
+            assertNotNull(variant.installTask)
+        } else {
+            assertNull(variant.installTask)
+        }
+
+        if (testVariant) {
+            assertNotNull(variant.runTestsTask)
+        } else {
+            assertNull(variant.runTestsTask)
+        }
+    }
+
+    private BuildVariant findVariant(Collection<BuildVariant> variants, String name) {
+        for (BuildVariant variant : variants) {
+            if (name.equals(variant.name)) {
+                return variant
+            }
+        }
+
+        return null
+    }
+}
\ No newline at end of file
diff --git a/gradle/src/test/groovy/com/android/build/gradle/BasicConfigTest.groovy b/gradle/src/test/groovy/com/android/build/gradle/AppPluginInternalTest.groovy
index 417a240..2641416 100644
--- a/gradle/src/test/groovy/com/android/build/gradle/BasicConfigTest.groovy
+++ b/gradle/src/test/groovy/com/android/build/gradle/AppPluginInternalTest.groovy
@@ -15,15 +15,17 @@
  */
 package com.android.build.gradle
 
+import com.android.build.gradle.internal.ApplicationVariant
+import com.android.build.gradle.internal.BaseTest
 import com.android.build.gradle.internal.PluginHolder
 import com.android.builder.BuildType
-import junit.framework.TestCase
 import org.gradle.api.Project
 import org.gradle.testfixtures.ProjectBuilder
 
-import java.security.CodeSource
-
-public class BasicConfigTest extends TestCase {
+/**
+ * Tests for the internal workings of the app plugin ("android")
+ */
+public class AppPluginInternalTest extends BaseTest {
 
     @Override
     protected void setUp() throws Exception {
@@ -48,7 +50,19 @@ public class BasicConfigTest extends TestCase {
         assertNotNull(plugin.buildTypes.get(BuildType.DEBUG))
         assertNotNull(plugin.buildTypes.get(BuildType.RELEASE))
         assertEquals(0, plugin.productFlavors.size())
-        assertEquals(3, plugin.variants.size()) // includes the test variant(s)
+
+
+        List<ApplicationVariant> variants = plugin.variants
+        assertEquals(3, variants.size()) // includes the test variant(s)
+
+        ApplicationVariant debugVariant = findVariant(variants, "Debug")
+        assertNotNull(debugVariant)
+
+        ApplicationVariant release = findVariant(variants, "Release")
+        assertNotNull(release)
+
+        ApplicationVariant test = findVariant(variants, "Test")
+        assertNotNull(test)
     }
 
     public void testDefaultConfig() {
@@ -95,10 +109,11 @@ public class BasicConfigTest extends TestCase {
 
         project.android {
             target "android-15"
+            testBuildType "staging"
 
             buildTypes {
                 staging {
-
+                    debugSigned true
                 }
             }
         }
@@ -107,7 +122,22 @@ public class BasicConfigTest extends TestCase {
         plugin.createAndroidTasks()
 
         assertEquals(3, plugin.buildTypes.size())
-        assertEquals(4, plugin.variants.size())  // includes the test variant(s)
+
+        List<ApplicationVariant> variants = plugin.variants
+        assertEquals(4, variants.size()) // includes the test variant(s)
+
+        ApplicationVariant debugVariant = findVariant(variants, "Debug")
+        assertNotNull(debugVariant)
+
+        ApplicationVariant releaseVariant = findVariant(variants, "Release")
+        assertNotNull(releaseVariant)
+
+        ApplicationVariant stagingVariant = findVariant(variants, "Staging")
+        assertNotNull(stagingVariant)
+
+        ApplicationVariant testVariant = findVariant(variants, "Test")
+        assertNotNull(testVariant)
+        assertEquals("staging", testVariant.config.buildType.name)
     }
 
     public void testFlavors() {
@@ -133,7 +163,16 @@ public class BasicConfigTest extends TestCase {
         plugin.createAndroidTasks()
 
         assertEquals(2, plugin.productFlavors.size())
-        assertEquals(6, plugin.variants.size()) // includes the test variant(s)
+
+        List<ApplicationVariant> variants = plugin.variants
+        assertEquals(6, variants.size()) // includes the test variant(s)
+
+        assertNotNull(findVariant(variants, "Flavor1Debug"))
+        assertNotNull(findVariant(variants, "Flavor1Release"))
+        assertNotNull(findVariant(variants, "Flavor1Test"))
+        assertNotNull(findVariant(variants, "Flavor2Debug"))
+        assertNotNull(findVariant(variants, "Flavor2Release"))
+        assertNotNull(findVariant(variants, "Flavor2Test"))
     }
 
     public void testMultiFlavors() {
@@ -171,31 +210,37 @@ public class BasicConfigTest extends TestCase {
         plugin.createAndroidTasks()
 
         assertEquals(5, plugin.productFlavors.size())
-        assertEquals(18, plugin.variants.size()) // includes the test variant(s)
-    }
 
+        List<ApplicationVariant> variants = plugin.variants
+        assertEquals(18, variants.size())   // includes the test variant(s)
+
+        assertNotNull(findVariant(variants, "F1FaDebug"))
+        assertNotNull(findVariant(variants, "F1FbDebug"))
+        assertNotNull(findVariant(variants, "F1FcDebug"))
+        assertNotNull(findVariant(variants, "F2FaDebug"))
+        assertNotNull(findVariant(variants, "F2FbDebug"))
+        assertNotNull(findVariant(variants, "F2FcDebug"))
+        assertNotNull(findVariant(variants, "F1FaRelease"))
+        assertNotNull(findVariant(variants, "F1FbRelease"))
+        assertNotNull(findVariant(variants, "F1FcRelease"))
+        assertNotNull(findVariant(variants, "F2FaRelease"))
+        assertNotNull(findVariant(variants, "F2FbRelease"))
+        assertNotNull(findVariant(variants, "F2FcRelease"))
+        assertNotNull(findVariant(variants, "F1FaTest"))
+        assertNotNull(findVariant(variants, "F1FbTest"))
+        assertNotNull(findVariant(variants, "F1FcTest"))
+        assertNotNull(findVariant(variants, "F2FaTest"))
+        assertNotNull(findVariant(variants, "F2FbTest"))
+        assertNotNull(findVariant(variants, "F2FcTest"))
+    }
 
-    /**
-     * Returns the Android source tree root dir.
-     * @return the root dir or null if it couldn't be computed.
-     */
-    private File getTestDir() {
-        CodeSource source = getClass().getProtectionDomain().getCodeSource()
-        if (source != null) {
-            URL location = source.getLocation();
-            try {
-                File dir = new File(location.toURI())
-                assertTrue(dir.getPath(), dir.exists())
-                System.out.println(dir.absolutePath)
-
-                File rootDir = dir.getParentFile().getParentFile().getParentFile().getParentFile()
-
-                return new File(rootDir, "tests")
-            } catch (URISyntaxException e) {
-                fail(e.getLocalizedMessage())
+    private ApplicationVariant findVariant(Collection<ApplicationVariant> variants, String name) {
+        for (ApplicationVariant variant : variants) {
+            if (name.equals(variant.name)) {
+                return variant
             }
         }
 
-        fail("Fail to get tests folder")
+        return null
     }
 }
\ No newline at end of file
diff --git a/gradle/src/test/groovy/com/android/build/gradle/internal/BaseTest.groovy b/gradle/src/test/groovy/com/android/build/gradle/internal/BaseTest.groovy
new file mode 100644
index 0000000..2a97455
--- /dev/null
+++ b/gradle/src/test/groovy/com/android/build/gradle/internal/BaseTest.groovy
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2012 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.internal
+
+import junit.framework.TestCase
+
+import java.security.CodeSource
+
+/**
+ * Base class for tests.
+ */
+public abstract class BaseTest extends TestCase {
+    /**
+     * Returns the Android source tree root dir.
+     * @return the root dir or null if it couldn't be computed.
+     */
+    protected File getTestDir() {
+        CodeSource source = getClass().getProtectionDomain().getCodeSource()
+        if (source != null) {
+            URL location = source.getLocation();
+            try {
+                File dir = new File(location.toURI())
+                assertTrue(dir.getPath(), dir.exists())
+                System.out.println(dir.absolutePath)
+
+                File rootDir = dir.getParentFile().getParentFile().getParentFile().getParentFile()
+
+                return new File(rootDir, "tests")
+            } catch (URISyntaxException e) {
+                fail(e.getLocalizedMessage())
+            }
+        }
+
+        fail("Fail to get tests folder")
+    }
+}