Merge "Ravenwood support for feature flags." into main

        "androidx.test.ext.junit",

        "mockito_ravenwood",

        "platform-test-annotations",

        "flag-junit",

    ],

    srcs: [

        "src/android/os/BuildTest.java",

        "src/android/os/FileUtilsTest.java",

        "src/android/util/**/*.java",

        "src/com/android/internal/util/**/*.java",

package android.os;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertTrue;

import android.platform.test.annotations.IgnoreUnderRavenwood;

import android.platform.test.flag.junit.SetFlagsRule;

import android.platform.test.ravenwood.RavenwoodRule;

import androidx.test.filters.SmallTest;

import androidx.test.runner.AndroidJUnit4;

import junit.framework.Assert;

import junit.framework.TestCase;

import org.junit.Rule;

import org.junit.Test;

import org.junit.runner.RunWith;

/**

 * Provides test cases for android.os.Build and, in turn, many of the

 * system properties set by the build system.

 */

public class BuildTest extends TestCase {

@RunWith(AndroidJUnit4.class)

public class BuildTest {

    private static final String TAG = "BuildTest";

    @Rule

    public final RavenwoodRule mRavenwood = new RavenwoodRule();

    @Rule

    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();

    /**

     * Asserts that a String is non-null and non-empty.  If it is not,

     * an AssertionFailedError is thrown with the given message.

    /**

     * Asserts that all android.os.Build fields are non-empty and/or in a valid range.

     */

    @Test

    @SmallTest

    @IgnoreUnderRavenwood(blockedBy = Build.class)

    public void testBuildFields() throws Exception {

        assertNotEmpty("ID", Build.ID);

        assertNotEmpty("DISPLAY", Build.DISPLAY);

        // (e.g., must be a C identifier, must be a valid filename, must not contain any spaces)

        // add tests for them.

    }

    @Test

    public void testFlagEnabled() throws Exception {

        mSetFlagsRule.enableFlags(Flags.FLAG_ANDROID_OS_BUILD_VANILLA_ICE_CREAM);

        assertTrue(Flags.androidOsBuildVanillaIceCream());

    }

    @Test

    public void testFlagDisabled() throws Exception {

        mSetFlagsRule.disableFlags(Flags.FLAG_ANDROID_OS_BUILD_VANILLA_ICE_CREAM);

        assertFalse(Flags.androidOsBuildVanillaIceCream());

    }

}

# Keep all AIDL interfaces

class :aidl stubclass

# Keep all feature flag implementations

class :feature_flags stubclass

# Collections

class android.util.ArrayMap stubclass

class android.util.ArraySet stubclass

Once you’ve defined your test, you can use typical commands to execute it locally:

```

$ atest MyTestsRavenwood

$ atest --host MyTestsRavenwood

```

> **Note:** There's a known bug where `atest` currently requires a connected device to run Ravenwood tests, but that device isn't used for testing.

> **Note:** There's a known bug where `atest` currently requires a connected device to run Ravenwood tests, but that device isn't used for testing. Using the `--host` argument above is a way to bypass this requirement until bug #312525698 is fixed.

You can also run your new tests automatically via `TEST_MAPPING` rules like this:

}

```

## Strategies for feature flags

Ravenwood supports writing tests against logic that uses feature flags through the existing `SetFlagsRule` infrastructure maintained by the feature flagging team:

```

import android.platform.test.flag.junit.SetFlagsRule;

@RunWith(AndroidJUnit4.class)

public class MyCodeTest {

    @Rule

    public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();

    @Test

    public void testEnabled() {

        mSetFlagsRule.enableFlags(Flags.FLAG_MY_FLAG);

        // verify test logic that depends on flag being enabled

    }

```

This naturally composes together well with any `RavenwoodRule` that your test may need.

## Strategies for migration/bivalent tests

Ravenwood aims to support tests that are written in a “bivalent” way, where the same test code can run on both a real Android device and under a Ravenwood environment.

class AndroidHeuristicsFilter(

        private val classes: ClassNodes,

        val aidlPolicy: FilterPolicyWithReason?,

        val featureFlagsPolicy: FilterPolicyWithReason?,

        fallback: OutputFilter

) : DelegatingFilter(fallback) {

    override fun getPolicyForClass(className: String): FilterPolicyWithReason {

        if (aidlPolicy != null && classes.isAidlClass(className)) {

            return aidlPolicy

        }

        if (featureFlagsPolicy != null && classes.isFeatureFlagsClass(className)) {

            return featureFlagsPolicy

        }

        return super.getPolicyForClass(className)

    }

}

            hasClass("$className\$Stub") &&

            hasClass("$className\$Stub\$Proxy")

}

/**

 * @return if a given class "seems like" an feature flags class.

 */

private fun ClassNodes.isFeatureFlagsClass(className: String): Boolean {

    // Matches template classes defined here:

    // https://cs.android.com/android/platform/superproject/+/master:build/make/tools/aconfig/templates/

    return className.endsWith("/Flags")

            || className.endsWith("/FeatureFlags")

            || className.endsWith("/FeatureFlagsImpl")

            || className.endsWith("/FakeFeatureFlagsImpl");

}