Merge "Add tests, refactor min/targetSdkVersion checks in PackageParser" (ccec35c4) · Commits · e / os / android_frameworks_base

core/java/android/content/pm/PackageParser.java

+145 −54

Original line number	Diff line number	Diff line
		@@ -24,7 +24,10 @@ import com.android.internal.util.XmlUtils;
		import org.xmlpull.v1.XmlPullParser;
		import org.xmlpull.v1.XmlPullParserException;

		import android.annotation.IntRange;
		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.annotation.TestApi;
		import android.app.ActivityManager;
		import android.content.ComponentName;
		import android.content.Intent;
		@@ -58,7 +61,6 @@ import android.util.jar.StrictJarFile;
		import android.view.Gravity;

		import java.io.File;
		import java.io.FileNotFoundException;
		import java.io.FileOutputStream;
		import java.io.IOException;
		import java.io.InputStream;
		@@ -85,7 +87,6 @@ import java.util.zip.ZipEntry;
		import libcore.io.IoUtils;

		import static android.content.pm.ActivityInfo.FLAG_ALWAYS_FOCUSABLE;
		import static android.content.pm.ActivityInfo.FLAG_IMMERSIVE;
		import static android.content.pm.ActivityInfo.FLAG_ON_TOP_LAUNCHER;
		import static android.content.pm.ActivityInfo.RESIZE_MODE_FORCE_RESIZEABLE;
		import static android.content.pm.ActivityInfo.RESIZE_MODE_FORCE_RESIZABLE_LANDSCAPE_ONLY;
		@@ -2103,63 +2104,22 @@ public class PackageParser {

		sa.recycle();

		if (minCode != null) {
		boolean allowedCodename = false;
		for (String codename : SDK_CODENAMES) {
		if (minCode.equals(codename)) {
		allowedCodename = true;
		break;
		}
		}
		if (!allowedCodename) {
		if (SDK_CODENAMES.length > 0) {
		outError[0] = "Requires development platform " + minCode
		+ " (current platform is any of "
		+ Arrays.toString(SDK_CODENAMES) + ")";
		} else {
		outError[0] = "Requires development platform " + minCode
		+ " but this is a release platform.";
		}
		final int minSdkVersion = PackageParser.computeMinSdkVersion(minVers, minCode,
		SDK_VERSION, SDK_CODENAMES, outError);
		if (minSdkVersion < 0) {
		mParseError = PackageManager.INSTALL_FAILED_OLDER_SDK;
		return null;
		}
		pkg.applicationInfo.minSdkVersion =
		android.os.Build.VERSION_CODES.CUR_DEVELOPMENT;
		} else if (minVers > SDK_VERSION) {
		outError[0] = "Requires newer sdk version #" + minVers
		+ " (current version is #" + SDK_VERSION + ")";
		mParseError = PackageManager.INSTALL_FAILED_OLDER_SDK;
		return null;
		} else {
		pkg.applicationInfo.minSdkVersion = minVers;
		}

		if (targetCode != null) {
		boolean allowedCodename = false;
		for (String codename : SDK_CODENAMES) {
		if (targetCode.equals(codename)) {
		allowedCodename = true;
		break;
		}
		}
		if (!allowedCodename) {
		if (SDK_CODENAMES.length > 0) {
		outError[0] = "Requires development platform " + targetCode
		+ " (current platform is any of "
		+ Arrays.toString(SDK_CODENAMES) + ")";
		} else {
		outError[0] = "Requires development platform " + targetCode
		+ " but this is a release platform.";
		}
		final int targetSdkVersion = PackageParser.computeTargetSdkVersion(targetVers,
		targetCode, SDK_VERSION, SDK_CODENAMES, outError);
		if (targetSdkVersion < 0) {
		mParseError = PackageManager.INSTALL_FAILED_OLDER_SDK;
		return null;
		}
		// If the code matches, it definitely targets this SDK.
		pkg.applicationInfo.targetSdkVersion
		= android.os.Build.VERSION_CODES.CUR_DEVELOPMENT;
		} else {
		pkg.applicationInfo.targetSdkVersion = targetVers;
		}

		pkg.applicationInfo.minSdkVersion = minSdkVersion;
		pkg.applicationInfo.targetSdkVersion = targetSdkVersion;
		}

		XmlUtils.skipCurrentTag(parser);
		@@ -2407,6 +2367,137 @@ public class PackageParser {
		return pkg;
		}

		/**
		* Computes the targetSdkVersion to use at runtime. If the package is not
		* compatible with this platform, populates {@code outError[0]} with an
		* error message.
		* <p>
		* If {@code targetCode} is not specified, e.g. the value is {@code null},
		* then the {@code targetVers} will be returned unmodified.
		* <p>
		* Otherwise, the behavior varies based on whether the current platform
		* is a pre-release version, e.g. the {@code platformSdkCodenames} array
		* has length > 0:
		* <ul>
		* <li>If this is a pre-release platform and the value specified by
		* {@code targetCode} is contained within the array of allowed pre-release
		* codenames, this method will return {@link Build.VERSION_CODES#CUR_DEVELOPMENT}.
		* <li>If this is a released platform, this method will return -1 to
		* indicate that the package is not compatible with this platform.
		* </ul>
		*
		* @param targetVers targetSdkVersion number, if specified in the
		* application manifest, or 0 otherwise
		* @param targetCode targetSdkVersion code, if specified in the application
		* manifest, or {@code null} otherwise
		* @param platformSdkVersion platform SDK version number, typically
		* Build.VERSION.SDK_INT
		* @param platformSdkCodenames array of allowed pre-release SDK codenames
		* for this platform
		* @param outError output array to populate with error, if applicable
		* @return the targetSdkVersion to use at runtime, or -1 if the package is
		* not compatible with this platform
		* @hide Exposed for unit testing only.
		*/
		@TestApi
		public static int computeTargetSdkVersion(@IntRange(from = 0) int targetVers,
		@Nullable String targetCode, @IntRange(from = 1) int platformSdkVersion,
		@NonNull String[] platformSdkCodenames, @NonNull String[] outError) {
		// If it's a release SDK, return the version number unmodified.
		if (targetCode == null) {
		return targetVers;
		}

		// If it's a pre-release SDK and the codename matches this platform, it
		// definitely targets this SDK.
		if (ArrayUtils.contains(platformSdkCodenames, targetCode)) {
		return Build.VERSION_CODES.CUR_DEVELOPMENT;
		}

		// Otherwise, we're looking at an incompatible pre-release SDK.
		if (platformSdkCodenames.length > 0) {
		outError[0] = "Requires development platform " + targetCode
		+ " (current platform is any of "
		+ Arrays.toString(platformSdkCodenames) + ")";
		} else {
		outError[0] = "Requires development platform " + targetCode
		+ " but this is a release platform.";
		}
		return -1;
		}

		/**
		* Computes the minSdkVersion to use at runtime. If the package is not
		* compatible with this platform, populates {@code outError[0]} with an
		* error message.
		* <p>
		* If {@code minCode} is not specified, e.g. the value is {@code null},
		* then behavior varies based on the {@code platformSdkVersion}:
		* <ul>
		* <li>If the platform SDK version is greater than or equal to the
		* {@code minVers}, returns the {@code mniVers} unmodified.
		* <li>Otherwise, returns -1 to indicate that the package is not
		* compatible with this platform.
		* </ul>
		* <p>
		* Otherwise, the behavior varies based on whether the current platform
		* is a pre-release version, e.g. the {@code platformSdkCodenames} array
		* has length > 0:
		* <ul>
		* <li>If this is a pre-release platform and the value specified by
		* {@code targetCode} is contained within the array of allowed pre-release
		* codenames, this method will return {@link Build.VERSION_CODES#CUR_DEVELOPMENT}.
		* <li>If this is a released platform, this method will return -1 to
		* indicate that the package is not compatible with this platform.
		* </ul>
		*
		* @param minVers minSdkVersion number, if specified in the application
		* manifest, or 1 otherwise
		* @param minCode minSdkVersion code, if specified in the application
		* manifest, or {@code null} otherwise
		* @param platformSdkVersion platform SDK version number, typically
		* Build.VERSION.SDK_INT
		* @param platformSdkCodenames array of allowed prerelease SDK codenames
		* for this platform
		* @param outError output array to populate with error, if applicable
		* @return the minSdkVersion to use at runtime, or -1 if the package is not
		* compatible with this platform
		* @hide Exposed for unit testing only.
		*/
		@TestApi
		public static int computeMinSdkVersion(@IntRange(from = 1) int minVers,
		@Nullable String minCode, @IntRange(from = 1) int platformSdkVersion,
		@NonNull String[] platformSdkCodenames, @NonNull String[] outError) {
		// If it's a release SDK, make sure we meet the minimum SDK requirement.
		if (minCode == null) {
		if (minVers <= platformSdkVersion) {
		return minVers;
		}

		// We don't meet the minimum SDK requirement.
		outError[0] = "Requires newer sdk version #" + minVers
		+ " (current version is #" + platformSdkVersion + ")";
		return -1;
		}

		// If it's a pre-release SDK and the codename matches this platform, we
		// definitely meet the minimum SDK requirement.
		if (ArrayUtils.contains(platformSdkCodenames, minCode)) {
		return Build.VERSION_CODES.CUR_DEVELOPMENT;
		}

		// Otherwise, we're looking at an incompatible pre-release SDK.
		if (platformSdkCodenames.length > 0) {
		outError[0] = "Requires development platform " + minCode
		+ " (current platform is any of "
		+ Arrays.toString(platformSdkCodenames) + ")";
		} else {
		outError[0] = "Requires development platform " + minCode
		+ " but this is a release platform.";
		}
		return -1;
		}

		private FeatureInfo parseUsesFeature(Resources res, AttributeSet attrs) {
		FeatureInfo fi = new FeatureInfo();
		TypedArray sa = res.obtainAttributes(attrs,

core/tests/coretests/README

0 → 100644

+50 −0

Original line number	Diff line number	Diff line
		* 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.


		INTRODUCTION

		The Android platform core tests (APCT) consist of unit tests for core platform
		functionality. These differ from CTS in that they are not necessarily testing
		public APIs and are not guaranteed to work outside of AOSP builds.


		INSTRUCTIONS

		To run a test or set of tests, first build the FrameworksCoreTests package:

		make FrameworksCoreTests

		Next, install the resulting APK and run tests as you would normal JUnit tests:

		adb install out/target/product/.../data/app/FrameworksCoreTests/FrameworksCoreTests.apk
		adb shell am instrument -w \
		com.android.frameworks.coretests/android.support.test.runner.AndroidJUnitRunner

		To run a tests within a specific package, add the following argument AFTER -w:

		-e package android.content.pm

		To run a specific test or method within a test:

		-e class android.content.pm.PackageParserTest
		-e class android.content.pm.PackageParserTest#testComputeMinSdkVersion

		To run tests in debug mode:

		-e debug true

		For more arguments, see the guide to command=line testing:

		https://developer.android.com/studio/test/command-line.html

core/tests/coretests/src/android/content/pm/PackageParserTest.java

0 → 100644

+218 −0

Original line number	Diff line number	Diff line
		/*
		* 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.content.pm;

		import static org.junit.Assert.assertEquals;
		import static org.junit.Assert.assertNotNull;
		import static org.junit.Assert.assertNull;

		import android.os.Build;
		import android.support.test.runner.AndroidJUnit4;
		import android.test.suitebuilder.annotation.SmallTest;

		import org.junit.Test;
		import org.junit.runner.RunWith;

		@SmallTest
		@RunWith(AndroidJUnit4.class)
		public class PackageParserTest {
		private static final String RELEASED = null;
		private static final String OLDER_PRE_RELEASE = "A";
		private static final String PRE_RELEASE = "B";
		private static final String NEWER_PRE_RELEASE = "C";

		private static final String[] CODENAMES_RELEASED = { /* empty */ };
		private static final String[] CODENAMES_PRE_RELEASE = { PRE_RELEASE };

		private static final int OLDER_VERSION = 10;
		private static final int PLATFORM_VERSION = 20;
		private static final int NEWER_VERSION = 30;

		private void verifyComputeMinSdkVersion(int minSdkVersion, String minSdkCodename,
		boolean isPlatformReleased, int expectedMinSdk) {
		final String[] outError = new String[1];
		final int result = PackageParser.computeMinSdkVersion(
		minSdkVersion,
		minSdkCodename,
		PLATFORM_VERSION,
		isPlatformReleased ? CODENAMES_RELEASED : CODENAMES_PRE_RELEASE,
		outError);

		assertEquals(result, expectedMinSdk);

		if (expectedMinSdk == -1) {
		assertNotNull(outError[0]);
		} else {
		assertNull(outError[0]);
		}
		}

		@Test
		public void testComputeMinSdkVersion_preReleasePlatform() {
		// Do allow older release minSdkVersion on pre-release platform.
		// APP: Released API 10
		// DEV: Pre-release API 20
		verifyComputeMinSdkVersion(OLDER_VERSION, RELEASED, false, OLDER_VERSION);

		// Do allow same release minSdkVersion on pre-release platform.
		// APP: Released API 20
		// DEV: Pre-release API 20
		verifyComputeMinSdkVersion(PLATFORM_VERSION, RELEASED, false, PLATFORM_VERSION);

		// Don't allow newer release minSdkVersion on pre-release platform.
		// APP: Released API 30
		// DEV: Pre-release API 20
		verifyComputeMinSdkVersion(NEWER_VERSION, RELEASED, false, -1);

		// Don't allow older pre-release minSdkVersion on pre-release platform.
		// APP: Pre-release API 10
		// DEV: Pre-release API 20
		verifyComputeMinSdkVersion(OLDER_VERSION, OLDER_PRE_RELEASE, false, -1);

		// Do allow same pre-release minSdkVersion on pre-release platform,
		// but overwrite the specified version with CUR_DEVELOPMENT.
		// APP: Pre-release API 20
		// DEV: Pre-release API 20
		verifyComputeMinSdkVersion(PLATFORM_VERSION, PRE_RELEASE, false,
		Build.VERSION_CODES.CUR_DEVELOPMENT);

		// Don't allow newer pre-release minSdkVersion on pre-release platform.
		// APP: Pre-release API 30
		// DEV: Pre-release API 20
		verifyComputeMinSdkVersion(NEWER_VERSION, NEWER_PRE_RELEASE, false, -1);
		}

		@Test
		public void testComputeMinSdkVersion_releasedPlatform() {
		// Do allow older release minSdkVersion on released platform.
		// APP: Released API 10
		// DEV: Released API 20
		verifyComputeMinSdkVersion(OLDER_VERSION, RELEASED, true, OLDER_VERSION);

		// Do allow same release minSdkVersion on released platform.
		// APP: Released API 20
		// DEV: Released API 20
		verifyComputeMinSdkVersion(PLATFORM_VERSION, RELEASED, true, PLATFORM_VERSION);

		// Don't allow newer release minSdkVersion on released platform.
		// APP: Released API 30
		// DEV: Released API 20
		verifyComputeMinSdkVersion(NEWER_VERSION, RELEASED, true, -1);

		// Don't allow older pre-release minSdkVersion on released platform.
		// APP: Pre-release API 10
		// DEV: Released API 20
		verifyComputeMinSdkVersion(OLDER_VERSION, OLDER_PRE_RELEASE, true, -1);

		// Don't allow same pre-release minSdkVersion on released platform.
		// APP: Pre-release API 20
		// DEV: Released API 20
		verifyComputeMinSdkVersion(PLATFORM_VERSION, PRE_RELEASE, true, -1);

		// Don't allow newer pre-release minSdkVersion on released platform.
		// APP: Pre-release API 30
		// DEV: Released API 20
		verifyComputeMinSdkVersion(NEWER_VERSION, NEWER_PRE_RELEASE, true, -1);
		}

		private void verifyComputeTargetSdkVersion(int targetSdkVersion, String targetSdkCodename,
		boolean isPlatformReleased, int expectedTargetSdk) {
		final String[] outError = new String[1];
		final int result = PackageParser.computeTargetSdkVersion(
		targetSdkVersion,
		targetSdkCodename,
		PLATFORM_VERSION,
		isPlatformReleased ? CODENAMES_RELEASED : CODENAMES_PRE_RELEASE,
		outError);

		assertEquals(result, expectedTargetSdk);

		if (expectedTargetSdk == -1) {
		assertNotNull(outError[0]);
		} else {
		assertNull(outError[0]);
		}
		}

		@Test
		public void testComputeTargetSdkVersion_preReleasePlatform() {
		// Do allow older release targetSdkVersion on pre-release platform.
		// APP: Released API 10
		// DEV: Pre-release API 20
		verifyComputeTargetSdkVersion(OLDER_VERSION, RELEASED, false, OLDER_VERSION);

		// Do allow same release targetSdkVersion on pre-release platform.
		// APP: Released API 20
		// DEV: Pre-release API 20
		verifyComputeTargetSdkVersion(PLATFORM_VERSION, RELEASED, false, PLATFORM_VERSION);

		// Do allow newer release targetSdkVersion on pre-release platform.
		// APP: Released API 30
		// DEV: Pre-release API 20
		verifyComputeTargetSdkVersion(NEWER_VERSION, RELEASED, false, NEWER_VERSION);

		// Don't allow older pre-release targetSdkVersion on pre-release platform.
		// APP: Pre-release API 10
		// DEV: Pre-release API 20
		verifyComputeTargetSdkVersion(OLDER_VERSION, OLDER_PRE_RELEASE, false, -1);

		// Do allow same pre-release targetSdkVersion on pre-release platform,
		// but overwrite the specified version with CUR_DEVELOPMENT.
		// APP: Pre-release API 20
		// DEV: Pre-release API 20
		verifyComputeTargetSdkVersion(PLATFORM_VERSION, PRE_RELEASE, false,
		Build.VERSION_CODES.CUR_DEVELOPMENT);

		// Don't allow newer pre-release targetSdkVersion on pre-release platform.
		// APP: Pre-release API 30
		// DEV: Pre-release API 20
		verifyComputeTargetSdkVersion(NEWER_VERSION, NEWER_PRE_RELEASE, false, -1);
		}

		@Test
		public void testComputeTargetSdkVersion_releasedPlatform() {
		// Do allow older release targetSdkVersion on released platform.
		// APP: Released API 10
		// DEV: Released API 20
		verifyComputeTargetSdkVersion(OLDER_VERSION, RELEASED, true, OLDER_VERSION);

		// Do allow same release targetSdkVersion on released platform.
		// APP: Released API 20
		// DEV: Released API 20
		verifyComputeTargetSdkVersion(PLATFORM_VERSION, RELEASED, true, PLATFORM_VERSION);

		// Do allow newer release targetSdkVersion on released platform.
		// APP: Released API 30
		// DEV: Released API 20
		verifyComputeTargetSdkVersion(NEWER_VERSION, RELEASED, true, NEWER_VERSION);

		// Don't allow older pre-release targetSdkVersion on released platform.
		// APP: Pre-release API 10
		// DEV: Released API 20
		verifyComputeTargetSdkVersion(OLDER_VERSION, OLDER_PRE_RELEASE, true, -1);

		// Don't allow same pre-release targetSdkVersion on released platform.
		// APP: Pre-release API 20
		// DEV: Released API 20
		verifyComputeTargetSdkVersion(PLATFORM_VERSION, PRE_RELEASE, true, -1);

		// Don't allow newer pre-release targetSdkVersion on released platform.
		// APP: Pre-release API 30
		// DEV: Released API 20
		verifyComputeTargetSdkVersion(NEWER_VERSION, NEWER_PRE_RELEASE, true, -1);
		}
		}