/*
 * 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 android.os.cts;

import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;

import android.platform.test.annotations.AppModeFull;
import android.platform.test.annotations.AppModeInstant;
import android.platform.test.annotations.LargeTest;
import android.platform.test.annotations.Presubmit;

import com.android.compatibility.common.tradefed.build.CompatibilityBuildHelper;
import com.android.compatibility.common.util.PollingCheck;
import com.android.ddmlib.Log;
import com.android.ddmlib.testrunner.RemoteAndroidTestRunner;
import com.android.ddmlib.testrunner.TestResult.TestStatus;
import com.android.tradefed.build.IBuildInfo;
import com.android.tradefed.device.DeviceNotAvailableException;
import com.android.tradefed.log.LogUtil;
import com.android.tradefed.result.CollectingTestListener;
import com.android.tradefed.result.TestDescription;
import com.android.tradefed.result.TestResult;
import com.android.tradefed.result.TestRunResult;
import com.android.tradefed.testtype.DeviceTestCase;
import com.android.tradefed.testtype.IBuildReceiver;
import com.android.tradefed.util.CommandResult;
import com.android.tradefed.util.CommandStatus;
import com.android.tradefed.util.RunUtil;

import java.io.FileNotFoundException;
import java.util.Arrays;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Presubmit
public class StaticSharedLibsHostTests extends DeviceTestCase implements IBuildReceiver {
    private static final String ANDROID_JUNIT_RUNNER_CLASS =
            "androidx.test.runner.AndroidJUnitRunner";

    private static final String STATIC_LIB_PROVIDER_RECURSIVE_APK =
            "CtsStaticSharedLibProviderRecursive.apk";
    private static final String STATIC_LIB_PROVIDER_RECURSIVE_PKG =
            "android.os.lib.provider.recursive";

    private static final String STATIC_LIB_PROVIDER_RECURSIVE_NAME = "foo.bar.lib.recursive";
    private static final String STATIC_LIB_PROVIDER_NAME = "foo.bar.lib";

    private static final String STATIC_LIB_PROVIDER1_APK = "CtsStaticSharedLibProviderApp1.apk";
    private static final String STATIC_LIB_PROVIDER1_PKG = "android.os.lib.provider";

    private static final String STATIC_LIB_PROVIDER2_APK = "CtsStaticSharedLibProviderApp2.apk";
    private static final String STATIC_LIB_PROVIDER2_PKG = "android.os.lib.provider";

    private static final String STATIC_LIB_PROVIDER3_APK = "CtsStaticSharedLibProviderApp3.apk";
    private static final String STATIC_LIB_PROVIDER3_PKG = "android.os.lib.provider";

    private static final String STATIC_LIB_PROVIDER4_APK = "CtsStaticSharedLibProviderApp4.apk";
    private static final String STATIC_LIB_PROVIDER4_PKG = "android.os.lib.provider";

    private static final String STATIC_LIB_PROVIDER5_APK = "CtsStaticSharedLibProviderApp5.apk";
    private static final String STATIC_LIB_PROVIDER5_PKG = "android.os.lib.provider";

    private static final String STATIC_LIB_PROVIDER6_APK = "CtsStaticSharedLibProviderApp6.apk";
    private static final String STATIC_LIB_PROVIDER6_PKG = "android.os.lib.provider";

    private static final String STATIC_LIB_PROVIDER7_APK = "CtsStaticSharedLibProviderApp7.apk";
    private static final String STATIC_LIB_PROVIDER7_PKG = "android.os.lib.provider";

    private static final String STATIC_LIB_NATIVE_PROVIDER_APK =
            "CtsStaticSharedNativeLibProvider.apk";
    private static final String STATIC_LIB_NATIVE_PROVIDER_PKG =
            "android.os.lib.provider";

    private static final String STATIC_LIB_NATIVE_PROVIDER_APK1 =
            "CtsStaticSharedNativeLibProvider1.apk";
    private static final String STATIC_LIB_NATIVE_PROVIDER_PKG1 =
            "android.os.lib.provider";

    private static final String STATIC_LIB_CONSUMER1_APK = "CtsStaticSharedLibConsumerApp1.apk";
    private static final String STATIC_LIB_CONSUMER1_BAD_CERT_DIGEST_APK =
            "CtsStaticSharedLibConsumerApp1BadCertDigest.apk";
    private static final String STATIC_LIB_CONSUMER1_PKG = "android.os.lib.consumer1";

    private static final String STATIC_LIB_CONSUMER2_APK = "CtsStaticSharedLibConsumerApp2.apk";
    private static final String STATIC_LIB_CONSUMER2_PKG = "android.os.lib.consumer2";

    private static final String STATIC_LIB_CONSUMER3_APK = "CtsStaticSharedLibConsumerApp3.apk";
    private static final String STATIC_LIB_CONSUMER3_PKG = "android.os.lib.consumer3";

    private static final String STATIC_LIB_NATIVE_CONSUMER_APK
            = "CtsStaticSharedNativeLibConsumer.apk";
    private static final String STATIC_LIB_NATIVE_CONSUMER_PKG
            = "android.os.lib.consumer";

    private static final String STATIC_LIB_TEST_APP_PKG = "android.os.lib.app";
    private static final String STATIC_LIB_TEST_APP_CLASS_NAME = STATIC_LIB_TEST_APP_PKG
            + ".StaticSharedLibsTests";
    private static final String STATIC_LIB_MULTI_USER_TEST_APP_CLASS_NAME = STATIC_LIB_TEST_APP_PKG
            + ".StaticSharedLibsMultiUserTests";

    private static final String SETTING_UNUSED_STATIC_SHARED_LIB_MIN_CACHE_PERIOD =
            "unused_static_shared_lib_min_cache_period";

    private static final long DEFAULT_TIMEOUT_MILLIS = TimeUnit.SECONDS.toMillis(15);

    private CompatibilityBuildHelper mBuildHelper;
    private boolean mInstantMode = false;

    private void cleanUp() throws Exception {
        getDevice().uninstallPackage(STATIC_LIB_CONSUMER3_PKG);
        getDevice().uninstallPackage(STATIC_LIB_CONSUMER2_PKG);
        getDevice().uninstallPackage(STATIC_LIB_CONSUMER1_PKG);
        getDevice().uninstallPackage(STATIC_LIB_NATIVE_CONSUMER_PKG);
        getDevice().uninstallPackage(STATIC_LIB_PROVIDER7_PKG);
        getDevice().uninstallPackage(STATIC_LIB_PROVIDER6_PKG);
        getDevice().uninstallPackage(STATIC_LIB_PROVIDER5_PKG);
        getDevice().uninstallPackage(STATIC_LIB_PROVIDER4_PKG);
        getDevice().uninstallPackage(STATIC_LIB_PROVIDER3_PKG);
        getDevice().uninstallPackage(STATIC_LIB_PROVIDER2_PKG);
        getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
        getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
    }

    @Override
    protected void setUp() throws Exception {
        cleanUp();
    }

    @Override
    public void setBuild(IBuildInfo buildInfo) {
        mBuildHelper = new CompatibilityBuildHelper(buildInfo);
    }

    @AppModeInstant
    public void testInstallSharedLibraryInstantMode() throws Exception {
        mInstantMode = true;
        doTestInstallSharedLibrary();
    }

    @AppModeFull
    public void testInstallSharedLibraryFullMode() throws Exception {
        doTestInstallSharedLibrary();
    }

    private void doTestInstallSharedLibrary() throws Exception {
        try {
            // Install library dependency
            assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
            // Install version 1
            assertNull(install(STATIC_LIB_PROVIDER1_APK));
            // Install version 2
            assertNull(install(STATIC_LIB_PROVIDER2_APK));
            // Uninstall version 1
            assertNull(getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG));
            // Uninstall version 2
            assertNull(getDevice().uninstallPackage(STATIC_LIB_PROVIDER2_PKG));
            // Uninstall dependency
            assertNull(getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG));
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER2_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
        }
    }

    @AppModeInstant
    public void testCannotInstallSharedLibraryWithMissingDependencyInstantMode() throws Exception {
        mInstantMode = true;
        doTestCannotInstallSharedLibraryWithMissingDependency();
    }

    @AppModeFull
    public void testCannotInstallSharedLibraryWithMissingDependencyFullMode() throws Exception {
        doTestCannotInstallSharedLibraryWithMissingDependency();
    }

    private void doTestCannotInstallSharedLibraryWithMissingDependency() throws Exception {
        try {
            // Install version 1 - should fail - no dependency
            assertNotNull(install(STATIC_LIB_PROVIDER1_APK));
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER2_PKG);
        }
    }

    public void testLoadCodeAndResourcesFromSharedLibraryRecursively() throws Exception {
        try {
            // Install library dependency
            assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
            // Install the library
            assertNull(install(STATIC_LIB_PROVIDER1_APK));
            // Install the client
            assertNull(install(STATIC_LIB_CONSUMER1_APK));
            // Try to load code and resources
            runDeviceTests(STATIC_LIB_CONSUMER1_PKG,
                    "android.os.lib.consumer1.UseSharedLibraryTest",
                    "testLoadCodeAndResources");
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_CONSUMER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
        }
    }

    public void testLoadCodeAndResourcesFromSharedLibraryRecursivelyUpdate() throws Exception {
        try {
            // Install library dependency
            assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
            // Install the library
            assertNull(install(STATIC_LIB_PROVIDER1_APK));
            // Install the client
            assertNull(install(STATIC_LIB_CONSUMER1_APK));
            // Try to load code and resources
            runDeviceTests(STATIC_LIB_CONSUMER1_PKG,
                    "android.os.lib.consumer1.UseSharedLibraryTest",
                    "testLoadCodeAndResources");
            // Install library dependency
            assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK, true));
            // Try to load code and resources
            runDeviceTests(STATIC_LIB_CONSUMER1_PKG,
                    "android.os.lib.consumer1.UseSharedLibraryTest",
                    "testLoadCodeAndResources");
            // Install the library
            assertNull(install(STATIC_LIB_PROVIDER1_APK, true));
            // Try to load code and resources
            runDeviceTests(STATIC_LIB_CONSUMER1_PKG,
                    "android.os.lib.consumer1.UseSharedLibraryTest",
                    "testLoadCodeAndResources");
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_CONSUMER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
        }
    }

    @AppModeInstant
    public void testCannotUninstallUsedSharedLibrary1InstantMode() throws Exception {
        mInstantMode = true;
        doTestCannotUninstallUsedSharedLibrary1();
    }

    @AppModeFull
    public void testCannotUninstallUsedSharedLibrary1FullMode() throws Exception {
        doTestCannotUninstallUsedSharedLibrary1();
    }

    private void doTestCannotUninstallUsedSharedLibrary1() throws Exception {
        try {
            // Install library dependency
            assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
            // Install the library
            assertNull(install(STATIC_LIB_PROVIDER1_APK));
            // The library dependency cannot be uninstalled
            assertNotNull(getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG));
            // Now the library dependency can be uninstalled
            assertNull(getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG));
            // Uninstall dependency
            assertNull(getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG));
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
        }
    }

    @AppModeInstant
    public void testCannotUninstallUsedSharedLibrary2InstantMode() throws Exception {
        mInstantMode = true;
        doTestCannotUninstallUsedSharedLibrary2();
    }

    @AppModeFull
    public void testCannotUninstallUsedSharedLibrary2FullMode() throws Exception {
        doTestCannotUninstallUsedSharedLibrary2();
    }

    private void doTestCannotUninstallUsedSharedLibrary2() throws Exception {
        try {
            // Install library dependency
            assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
            // Install the library
            assertNull(install(STATIC_LIB_PROVIDER1_APK));
            // Install the client
            assertNull(install(STATIC_LIB_CONSUMER1_APK));
            // The library cannot be uninstalled
            assertNotNull(getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG));
            // Uninstall the client
            assertNull(getDevice().uninstallPackage(STATIC_LIB_CONSUMER1_PKG));
            // Now the library can be uninstalled
            assertNull(getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG));
            // Uninstall dependency
            assertNull(getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG));
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_CONSUMER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
        }
    }

    @AppModeInstant
    public void testLibraryVersionsAndVersionCodesSameOrderInstantMode() throws Exception {
        mInstantMode = true;
        doTestLibraryVersionsAndVersionCodesSameOrder();
    }

    @AppModeFull
    public void testLibraryVersionsAndVersionCodesSameOrderFullMode() throws Exception {
        doTestLibraryVersionsAndVersionCodesSameOrder();
    }

    private void doTestLibraryVersionsAndVersionCodesSameOrder() throws Exception {
        try {
            // Install library dependency
            assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
            // Install library version 1 with version code 1
            assertNull(install(STATIC_LIB_PROVIDER1_APK));
            // Install library version 2 with version code 4
            assertNull(install(STATIC_LIB_PROVIDER2_APK));
            // Shouldn't be able to install library version 3 with version code 3
            assertNotNull(install(STATIC_LIB_PROVIDER3_APK));
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER2_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER3_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
        }
    }

    @AppModeInstant
    public void testCannotInstallAppWithMissingLibraryInstantMode() throws Exception {
        mInstantMode = true;
        doTestCannotInstallAppWithMissingLibrary();
    }

    @AppModeFull
    public void testCannotInstallAppWithMissingLibraryFullMode() throws Exception {
        doTestCannotInstallAppWithMissingLibrary();
    }

    private void doTestCannotInstallAppWithMissingLibrary() throws Exception {
        try {
            // Shouldn't be able to install an app if a dependency lib is missing
            assertNotNull(install(STATIC_LIB_CONSUMER1_APK));
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_CONSUMER1_PKG);
        }
    }

    @AppModeFull
    public void testCanReplaceLibraryIfVersionAndVersionCodeSame() throws Exception {
        try {
            // Install library dependency
            assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
            // Install a library
            assertNull(install(STATIC_LIB_PROVIDER1_APK));
            // Can reinstall the library if version and version code same
            assertNull(install(STATIC_LIB_PROVIDER1_APK));
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
        }
    }

    @AppModeInstant
    public void testUninstallSpecificLibraryVersionInstantMode() throws Exception {
        mInstantMode = true;
        doTestUninstallSpecificLibraryVersion();
    }

    @AppModeFull
    public void testUninstallSpecificLibraryVersionFullMode() throws Exception {
        doTestUninstallSpecificLibraryVersion();
    }

    private void doTestUninstallSpecificLibraryVersion() throws Exception {
        try {
            // Install library dependency
            assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
            // Install library version 1 with version code 1
            assertNull(install(STATIC_LIB_PROVIDER1_APK));
            // Install library version 2 with version code 4
            assertNull(install(STATIC_LIB_PROVIDER2_APK));
            // Uninstall the library package with version code 4 (version 2)
            assertTrue(getDevice().executeShellCommand("pm uninstall --versionCode 4 "
                    + STATIC_LIB_PROVIDER1_PKG).startsWith("Success"));
            // Uninstall the library package with version code 1 (version 1)
            assertTrue(getDevice().executeShellCommand("pm uninstall "
                    + STATIC_LIB_PROVIDER1_PKG).startsWith("Success"));
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
        }
    }

    @AppModeInstant
    public void testKeyRotationInstantMode() throws Exception {
        mInstantMode = true;
        doTestKeyRotation();
    }

    @AppModeFull
    public void testKeyRotationFullMode() throws Exception {
        doTestKeyRotation();
    }

    private void doTestKeyRotation() throws Exception {
        try {
            // Install a library version specifying an upgrade key set
            assertNull(install(STATIC_LIB_PROVIDER2_APK));
            // Install a newer library signed with the upgrade key set
            assertNull(install(STATIC_LIB_PROVIDER4_APK));
            // Install a client that depends on the upgraded key set
            assertNull(install(STATIC_LIB_CONSUMER2_APK));
            // Ensure code and resources can be loaded
            runDeviceTests(STATIC_LIB_CONSUMER2_PKG,
                    "android.os.lib.consumer2.UseSharedLibraryTest",
                    "testLoadCodeAndResources");
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_CONSUMER2_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER2_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER4_PKG);
        }
    }

    @AppModeInstant
    public void testCannotInstallIncorrectlySignedLibraryInstantMode() throws Exception {
        mInstantMode = true;
        doTestCannotInstallIncorrectlySignedLibrary();
    }

    @AppModeFull
    public void testCannotInstallIncorrectlySignedLibraryFullMode() throws Exception {
        doTestCannotInstallIncorrectlySignedLibrary();
    }

    private void doTestCannotInstallIncorrectlySignedLibrary() throws Exception {
        try {
            // Install library dependency
            assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
            // Install a library version not specifying an upgrade key set
            assertNull(install(STATIC_LIB_PROVIDER1_APK));
            // Shouldn't be able to install a newer version signed differently
            assertNotNull(install(STATIC_LIB_PROVIDER4_APK));
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER4_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
        }
    }

    @AppModeInstant
    public void testLibraryAndPackageNameCanMatchInstantMode() throws Exception {
        mInstantMode = true;
        doTestLibraryAndPackageNameCanMatch();
    }

    @AppModeFull
    public void testLibraryAndPackageNameCanMatchFullMode() throws Exception {
        doTestLibraryAndPackageNameCanMatch();
    }

    private void doTestLibraryAndPackageNameCanMatch() throws Exception {
        try {
            // Install a library with same name as package should work.
            assertNull(install(STATIC_LIB_PROVIDER5_APK));
            // Install a library with same name as package should work.
            assertNull(install(STATIC_LIB_PROVIDER6_APK));
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER5_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER6_PKG);
        }
    }

    @AppModeInstant
    public void testGetSharedLibrariesInstantMode() throws Exception {
        mInstantMode = true;
        doTestGetSharedLibraries();
    }

    @AppModeFull
    public void testGetSharedLibrariesFullMode() throws Exception {
        doTestGetSharedLibraries();
    }

    private void doTestGetSharedLibraries() throws Exception {
        try {
            // Install library dependency
            assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
            // Install the first library
            assertNull(install(STATIC_LIB_PROVIDER1_APK));
            // Install the second library
            assertNull(install(STATIC_LIB_PROVIDER2_APK));
            // Install the third library
            assertNull(install(STATIC_LIB_PROVIDER4_APK));
            // Install the first client
            assertNull(install(STATIC_LIB_CONSUMER1_APK));
            // Install the second client
            assertNull(install(STATIC_LIB_CONSUMER2_APK));
            // Ensure the first library has the REQUEST_INSTALL_PACKAGES app op
            getDevice().executeShellV2Command("appops set "
                    + STATIC_LIB_CONSUMER1_PKG
                    + " REQUEST_INSTALL_PACKAGES allow");
            // Ensure libraries are properly reported
            runDeviceTests(STATIC_LIB_CONSUMER1_PKG,
                    "android.os.lib.consumer1.UseSharedLibraryTest",
                    "testSharedLibrariesProperlyReported");
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_CONSUMER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_CONSUMER2_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER2_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER4_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
        }
    }

    @AppModeFull(
            reason = "getDeclaredSharedLibraries() requires ACCESS_SHARED_LIBRARIES permission")
    public void testGetDeclaredSharedLibraries() throws Exception {
        try {
            // Install library dependency
            assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
            // Install the first library
            assertNull(install(STATIC_LIB_PROVIDER1_APK));
            // Install the second library
            assertNull(install(STATIC_LIB_PROVIDER2_APK));
            // Install the third library
            assertNull(install(STATIC_LIB_PROVIDER4_APK));
            // Install the first client
            assertNull(install(STATIC_LIB_CONSUMER1_APK));
            // Install the second client
            assertNull(install(STATIC_LIB_CONSUMER2_APK));
            // Ensure declared libraries are properly reported
            runDeviceTests(STATIC_LIB_CONSUMER1_PKG,
                    "android.os.lib.consumer1.UseSharedLibraryTest",
                    "testDeclaredSharedLibrariesProperlyReported");
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_CONSUMER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_CONSUMER2_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER2_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER4_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
        }
    }

    @AppModeInstant
    public void testAppCanSeeOnlyLibrariesItDependOnInstantMode() throws Exception {
        mInstantMode = true;
        doTestAppCanSeeOnlyLibrariesItDependOn();
    }

    @AppModeFull
    public void testAppCanSeeOnlyLibrariesItDependOnFullMode() throws Exception {
        doTestAppCanSeeOnlyLibrariesItDependOn();
    }

    private void doTestAppCanSeeOnlyLibrariesItDependOn() throws Exception {
        try {
            // Install library dependency
            assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
            // Install the first library
            assertNull(install(STATIC_LIB_PROVIDER1_APK));
            // Install the second library
            assertNull(install(STATIC_LIB_PROVIDER2_APK));
            // Install the client
            assertNull(install(STATIC_LIB_CONSUMER1_APK));
            // Ensure the client can see only the lib it depends on
            runDeviceTests(STATIC_LIB_CONSUMER1_PKG,
                    "android.os.lib.consumer1.UseSharedLibraryTest",
                    "testAppCanSeeOnlyLibrariesItDependOn");
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_CONSUMER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER2_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
        }
    }

    @AppModeInstant
    public void testLoadCodeFromNativeLibInstantMode() throws Exception {
        mInstantMode = true;
        doTestLoadCodeFromNativeLib();
    }

    @AppModeFull
    public void testLoadCodeFromNativeLibFullMode() throws Exception {
        doTestLoadCodeFromNativeLib();
    }

    private void doTestLoadCodeFromNativeLib() throws Exception {
        try {
            // Install library
            assertNull(install(STATIC_LIB_NATIVE_PROVIDER_APK));
            // Install the library client
            assertNull(install(STATIC_LIB_NATIVE_CONSUMER_APK));
            // Ensure the client can load native code from the library
            runDeviceTests(STATIC_LIB_NATIVE_CONSUMER_PKG,
                    "android.os.lib.consumer.UseSharedLibraryTest",
                    "testLoadNativeCode");
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_NATIVE_CONSUMER_PKG);
            getDevice().uninstallPackage(STATIC_LIB_NATIVE_PROVIDER_PKG);
        }
    }

    @AppModeInstant
    public void testLoadCodeFromNativeLibMultiArchViolationInstantMode() throws Exception {
        mInstantMode = true;
        doTestLoadCodeFromNativeLibMultiArchViolation();
    }

    @AppModeFull
    public void testLoadCodeFromNativeLibMultiArchViolationFullMode() throws Exception {
        doTestLoadCodeFromNativeLibMultiArchViolation();
    }

    private void doTestLoadCodeFromNativeLibMultiArchViolation() throws Exception {
        try {
            // Cannot install the library with native code if not multi-arch
            assertNotNull(install(STATIC_LIB_NATIVE_PROVIDER_APK1));
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_NATIVE_PROVIDER_PKG1);
        }
    }

    @AppModeInstant
    public void testLoadCodeAndResourcesFromSharedLibrarySignedWithTwoCertsInstantMode() throws Exception {
        mInstantMode = true;
        doTestLoadCodeAndResourcesFromSharedLibrarySignedWithTwoCerts();
    }

    @AppModeFull
    public void testLoadCodeAndResourcesFromSharedLibrarySignedWithTwoCertsFullMode() throws Exception {
        doTestLoadCodeAndResourcesFromSharedLibrarySignedWithTwoCerts();
    }

    private void doTestLoadCodeAndResourcesFromSharedLibrarySignedWithTwoCerts()
            throws Exception {
        try {
            // Install the library
            assertNull(install(STATIC_LIB_PROVIDER7_APK));
            // Install the client
            assertNull(install(STATIC_LIB_CONSUMER3_APK));
            // Try to load code and resources
            runDeviceTests(STATIC_LIB_CONSUMER3_PKG,
                    "android.os.lib.consumer3.UseSharedLibraryTest",
                    "testLoadCodeAndResources");
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_CONSUMER3_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER7_PKG);
        }
    }

    public void testSamegradeStaticSharedLibByAdb() throws Exception {
        try {
            assertNull(install(STATIC_LIB_PROVIDER5_APK));
            assertNull(install(STATIC_LIB_PROVIDER5_APK, true /*reinstall*/));
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER5_PKG);
        }
    }

    @AppModeFull(reason = "Instant app cannot get package installer service")
    public void testCannotSamegradeStaticSharedLibByInstaller() throws Exception {
        runDeviceTests(STATIC_LIB_TEST_APP_PKG, STATIC_LIB_TEST_APP_CLASS_NAME,
                "testSamegradeStaticSharedLibFail");
    }

    private void runDeviceTests(String packageName, String testClassName,
            String testMethodName) throws DeviceNotAvailableException {
        RemoteAndroidTestRunner testRunner = new RemoteAndroidTestRunner(packageName,
                ANDROID_JUNIT_RUNNER_CLASS, getDevice().getIDevice());
        testRunner.setMethodName(testClassName, testMethodName);
        CollectingTestListener listener = new CollectingTestListener();

        getDevice().runInstrumentationTests(testRunner, listener);

        final TestRunResult result = listener.getCurrentRunResults();
        if (result.isRunFailure()) {
            throw new AssertionError("Failed to successfully run device tests for "
                    + result.getName() + ": " + result.getRunFailureMessage());
        }
        if (result.getNumTests() == 0) {
            throw new AssertionError("No tests were run on the device");
        }
        if (result.hasFailedTests()) {
            // build a meaningful error message
            StringBuilder errorBuilder = new StringBuilder("on-device tests failed:\n");
            for (Map.Entry<TestDescription, TestResult> resultEntry :
                    result.getTestResults().entrySet()) {
                if (!resultEntry.getValue().getStatus().equals(TestStatus.PASSED)) {
                    errorBuilder.append(resultEntry.getKey().toString());
                    errorBuilder.append(":\n");
                    errorBuilder.append(resultEntry.getValue().getStackTrace());
                }
            }
            throw new AssertionError(errorBuilder.toString());
        }
    }

    @LargeTest
    @AppModeFull
    public void testPruneUnusedStaticSharedLibrariesWithMultiUser_reboot_fullMode()
            throws Exception {
        // This really should be a assumeTrue(getDevice().getMaxNumberOfUsersSupported() > 1), but
        // JUnit3 doesn't support assumptions framework.
        // TODO: change to assumeTrue after migrating tests to JUnit4.
        final int maxUserCount = getDevice().getMaxNumberOfUsersSupported();
        if (!(maxUserCount > 1)) {
            LogUtil.CLog.logAndDisplay(Log.LogLevel.INFO, "The device does not support multi-user");
            return;
        }

        boolean shouldCreateSecondUser = true;
        // Check whether the current user count on the device is not less than the max user count or
        // not. If yes, don't create the other user.
        final int currentUserCount = getDevice().listUsers().size();
        if (currentUserCount >= maxUserCount) {
            String message = String.format("Current user count %s is not less than the max user"
                    + " count %s, don't create the other user.", currentUserCount, maxUserCount);
            LogUtil.CLog.logAndDisplay(Log.LogLevel.INFO, message);
            shouldCreateSecondUser = false;
        }


        doTestPruneUnusedStaticSharedLibrariesWithMultiUser_reboot(shouldCreateSecondUser);
    }

    @LargeTest
    @AppModeInstant
    public void testPruneUnusedStaticSharedLibrariesWithMultiUser_reboot_instantMode()
            throws Exception {
        // This really should be a assumeTrue(getDevice().getMaxNumberOfUsersSupported() > 1), but
        // JUnit3 doesn't support assumptions framework.
        // TODO: change to assumeTrue after migrating tests to JUnit4.
        final int maxUserCount = getDevice().getMaxNumberOfUsersSupported();
        if (!(maxUserCount > 1)) {
            LogUtil.CLog.logAndDisplay(Log.LogLevel.INFO, "The device does not support multi-user");
            return;
        }

        boolean shouldCreateSecondUser = true;
        // Check whether the current user count on the device is not less than the max user count or
        // not. If yes, don't create the other user.
        final int currentUserCount = getDevice().listUsers().size();
        if (currentUserCount >= maxUserCount) {
            String message = String.format("Current user count %s is not less than the max user"
                    + " count %s, don't create the other user.", currentUserCount, maxUserCount);
            LogUtil.CLog.logAndDisplay(Log.LogLevel.INFO, message);
            shouldCreateSecondUser = false;
        }

        mInstantMode = true;
        doTestPruneUnusedStaticSharedLibrariesWithMultiUser_reboot(shouldCreateSecondUser);
    }

    private void doTestPruneUnusedStaticSharedLibrariesWithMultiUser_reboot(
            boolean shouldCreateSecondUser) throws Exception {
        int userId = -1;
        try {
            if (shouldCreateSecondUser) {
                userId = createAndStartSecondUser();
                assertThat(userId).isNotEqualTo(-1);
            }
            doTestPruneUnusedStaticSharedLibraries_reboot();
        } finally {
            if (shouldCreateSecondUser) {
                stopAndRemoveUser(userId);
            }
        }
    }

    @LargeTest
    @AppModeFull
    public void testPruneUnusedStaticSharedLibraries_reboot_fullMode()
            throws Exception {
        doTestPruneUnusedStaticSharedLibraries_reboot();
    }

    @LargeTest
    @AppModeInstant
    public void testPruneUnusedStaticSharedLibraries_reboot_instantMode()
            throws Exception {
        mInstantMode = true;
        doTestPruneUnusedStaticSharedLibraries_reboot();
    }

    private void doTestPruneUnusedStaticSharedLibraries_reboot()
            throws Exception {
        try {
            // Install an unused library
            assertThat(install(STATIC_LIB_PROVIDER_RECURSIVE_APK)).isNull();
            assertThat(checkLibrary(STATIC_LIB_PROVIDER_RECURSIVE_NAME)).isTrue();

            // Install the client and the corresponding library
            assertThat(install(STATIC_LIB_PROVIDER7_APK)).isNull();
            assertThat(install(STATIC_LIB_CONSUMER3_APK)).isNull();
            assertThat(checkLibrary(STATIC_LIB_PROVIDER_NAME)).isTrue();

            // Disallow to cache static shared library
            setGlobalSetting(SETTING_UNUSED_STATIC_SHARED_LIB_MIN_CACHE_PERIOD,
                    Integer.toString(0));

            // TODO(205779832): There's a maximum two-seconds-delay before SettingsProvider persists
            //  the settings. Waits for 3 seconds before reboot the device to ensure the setting is
            //  persisted.
            RunUtil.getDefault().sleep(3_000);
            getDevice().reboot();

            // Waits for the uninstallation of the unused library to ensure the job has be executed
            // correctly.
            PollingCheck.check("Library " + STATIC_LIB_PROVIDER_RECURSIVE_NAME
                            + " should be uninstalled", DEFAULT_TIMEOUT_MILLIS,
                    () -> !checkLibrary(STATIC_LIB_PROVIDER_RECURSIVE_NAME));
            assertWithMessage(
                    "Library " + STATIC_LIB_PROVIDER_NAME + " should not be uninstalled")
                    .that(checkLibrary(STATIC_LIB_PROVIDER_NAME)).isTrue();
        } finally {
            setGlobalSetting(SETTING_UNUSED_STATIC_SHARED_LIB_MIN_CACHE_PERIOD, null);
            getDevice().uninstallPackage(STATIC_LIB_CONSUMER3_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER7_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
        }
    }

    @LargeTest
    @AppModeFull
    public void testInstallStaticSharedLib_notKillDependentApp() throws Exception {
        try {
            // Install library dependency
            assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
            // Install the first library
            assertNull(install(STATIC_LIB_PROVIDER1_APK));
            // Install the client
            assertNull(install(STATIC_LIB_CONSUMER1_APK));

            // Bind the service in consumer1 app to verify that the app should not be killed when
            // a new version static shared library installed.
            runDeviceTests(STATIC_LIB_TEST_APP_PKG, STATIC_LIB_TEST_APP_CLASS_NAME,
                    "testInstallStaticSharedLib_notKillDependentApp");
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_CONSUMER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
        }
    }

    @AppModeFull
    public void testSamegradeStaticSharedLib_killDependentApp() throws Exception {
        try {
            // Install library dependency
            assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
            // Install the first library
            assertNull(install(STATIC_LIB_PROVIDER1_APK));
            // Install the client
            assertNull(install(STATIC_LIB_CONSUMER1_APK));

            // Bind the service in consumer1 app to verify that the app should be killed when
            // the static shared library is re-installed.
            runDeviceTests(STATIC_LIB_TEST_APP_PKG, STATIC_LIB_TEST_APP_CLASS_NAME,
                    "testSamegradeStaticSharedLib_killDependentApp");
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_CONSUMER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
        }
    }

    @AppModeFull
    public void testStaticSharedLibInstall_broadcastReceived() throws Exception {
        // Install library dependency
        assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
        runDeviceTests(STATIC_LIB_TEST_APP_PKG, STATIC_LIB_TEST_APP_CLASS_NAME,
                    "testStaticSharedLibInstall_broadcastReceived");
    }

    @AppModeFull
    public void testStaticSharedLibInstall_incorrectInstallerPkgName_broadcastNotReceived()
            throws Exception {
        // Install library dependency
        assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
        runDeviceTests(STATIC_LIB_TEST_APP_PKG, STATIC_LIB_TEST_APP_CLASS_NAME,
                "testStaticSharedLibInstall_incorrectInstallerPkgName_broadcastNotReceived");
    }

    @AppModeFull
    public void testStaticSharedLibUninstall_broadcastReceived()
            throws Exception {
        // Install library dependency
        assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
        runDeviceTests(STATIC_LIB_TEST_APP_PKG, STATIC_LIB_TEST_APP_CLASS_NAME,
                "testStaticSharedLibUninstall_broadcastReceived");
    }

    @AppModeFull
    public void testStaticSharedLibUninstall_incorrectInstallerPkgName_broadcastNotReceived()
            throws Exception {
        // Install library dependency
        assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
        runDeviceTests(STATIC_LIB_TEST_APP_PKG, STATIC_LIB_TEST_APP_CLASS_NAME,
                "testStaticSharedLibUninstall_incorrectInstallerPkgName_broadcastNotReceived");
    }

    @AppModeFull
    public void testStaticSharedLibInstallOnSecondaryUser_broadcastReceivedByAllUsers()
            throws Exception {

        runDeviceTests(STATIC_LIB_TEST_APP_PKG, STATIC_LIB_MULTI_USER_TEST_APP_CLASS_NAME,
                "testStaticSharedLibInstallOnSecondaryUser_broadcastReceivedByAllUsers");
    }

    @AppModeFull
    public void testStaticSharedLibUninstallOnAllUsers_broadcastReceivedByAllUsers()
            throws Exception {

        runDeviceTests(STATIC_LIB_TEST_APP_PKG, STATIC_LIB_MULTI_USER_TEST_APP_CLASS_NAME,
                "testStaticSharedLibUninstallOnAllUsers_broadcastReceivedByAllUsers");
    }

    @AppModeFull
    public void testCannotInstallAppWithBadCertDigestDeclared() throws Exception {
        try {
            // Install library dependency
            assertNull(install(STATIC_LIB_PROVIDER_RECURSIVE_APK));
            // Install the first library
            assertNull(install(STATIC_LIB_PROVIDER1_APK));
            // Failed to install app with bad certificate digest
            assertThat(install(STATIC_LIB_CONSUMER1_BAD_CERT_DIGEST_APK))
                    .contains("INSTALL_FAILED_SHARED_LIBRARY_BAD_CERTIFICATE_DIGEST");
        } finally {
            getDevice().uninstallPackage(STATIC_LIB_CONSUMER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER1_PKG);
            getDevice().uninstallPackage(STATIC_LIB_PROVIDER_RECURSIVE_PKG);
        }
    }

    private String install(String apk) throws DeviceNotAvailableException, FileNotFoundException {
        return install(apk, false);
    }
    private String install(String apk, boolean reinstall)
            throws DeviceNotAvailableException, FileNotFoundException {
        return getDevice().installPackage(mBuildHelper.getTestFile(apk), reinstall, false,
                apk.contains("consumer") && mInstantMode ? "--instant" : "");
    }

    private boolean checkLibrary(String libName) throws DeviceNotAvailableException {
        final CommandResult result = getDevice().executeShellV2Command("pm list libraries");
        if (result.getStatus() != CommandStatus.SUCCESS) {
            fail("Failed to execute shell command: pm list libraries");
        }
        return Arrays.stream(result.getStdout().split("\n"))
                .map(line -> line.split(":")[1])
                .collect(Collectors.toList()).contains(libName);
    }

    private void setGlobalSetting(String key, String value) throws DeviceNotAvailableException {
        final boolean deleteKey = (value == null);
        final StringBuilder cmd = new StringBuilder("settings ");
        if (deleteKey) {
            cmd.append("delete ");
        } else {
            cmd.append("put ");
        }
        cmd.append("global ").append(key);
        if (!deleteKey) {
            cmd.append(" ").append(value);
        }
        final CommandResult res = getDevice().executeShellV2Command(cmd.toString());
        if (res.getStatus() != CommandStatus.SUCCESS) {
            fail("Failed to execute shell command: " + cmd);
        }
    }

    private int createAndStartSecondUser() throws Exception {
        String output = getDevice().executeShellCommand("pm create-user SecondUser");
        assertThat(output.startsWith("Success")).isTrue();
        int userId = Integer.parseInt(output.substring(output.lastIndexOf(" ")).trim());
        output = getDevice().executeShellCommand("am start-user -w " + userId);
        assertThat(output.startsWith("Error")).isFalse();
        output = getDevice().executeShellCommand("am get-started-user-state " + userId);
        assertThat(output.contains("RUNNING_UNLOCKED")).isTrue();
        return userId;
    }

    private void stopAndRemoveUser(int userId) throws Exception {
        getDevice().executeShellCommand("am stop-user -w -f " + userId);
        getDevice().executeShellCommand("pm remove-user " + userId);
    }
}