--- /dev/null
+/*
+ * Copyright (C) 2010 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.storage;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.content.res.Resources.NotFoundException;
+import android.os.Environment;
+import android.os.SystemClock;
+import android.test.InstrumentationTestCase;
+import android.util.Log;
+import android.os.Environment;
+import android.os.FileUtils;
+import android.os.storage.OnObbStateChangeListener;
+import android.os.storage.StorageManager;
+
+import java.io.BufferedReader;
+import java.io.DataInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.InputStream;
+import java.io.IOException;
+import java.io.StringReader;
+
+public class StorageManagerBaseTest extends InstrumentationTestCase {
+
+ protected Context mContext = null;
+ protected StorageManager mSm = null;
+ private static String LOG_TAG = "StorageManagerBaseTest";
+ protected static final long MAX_WAIT_TIME = 120*1000;
+ protected static final long WAIT_TIME_INCR = 5*1000;
+ protected static String OBB_FILE_1 = "obb_file1.obb";
+ protected static String OBB_FILE_1_CONTENTS_1 = "OneToOneThousandInts.bin";
+ protected static String OBB_FILE_2 = "obb_file2.obb";
+ protected static String OBB_FILE_3 = "obb_file3.obb";
+ protected static String OBB_FILE_1_PASSWORD = "password1";
+ protected static String OBB_FILE_1_ENCRYPTED = "obb_enc_file100_orig1.obb";
+ protected static String OBB_FILE_2_UNSIGNED = "obb_file2_nosign.obb";
+ protected static String OBB_FILE_3_PASSWORD = "password3";
+ protected static String OBB_FILE_3_ENCRYPTED = "obb_enc_file100_orig3.obb";
+ protected static String OBB_FILE_3_BAD_PACKAGENAME = "obb_file3_bad_packagename.obb";
+
+ protected static boolean FORCE = true;
+ protected static boolean DONT_FORCE = false;
+
+ private static final String SAMPLE1_TEXT = "This is sample text.\n\nTesting 1 2 3.";
+
+ private static final String SAMPLE2_TEXT =
+ "We the people of the United States, in order to form a more perfect union,\n"
+ + "establish justice, insure domestic tranquility, provide for the common\n"
+ + "defense, promote the general welfare, and secure the blessings of liberty\n"
+ + "to ourselves and our posterity, do ordain and establish this Constitution\n"
+ + "for the United States of America.\n\n";
+
+ class MountingObbThread extends Thread {
+ boolean mStop = false;
+ volatile boolean mFileOpenOnObb = false;
+ private String mObbFilePath = null;
+ private String mPathToContentsFile = null;
+ private String mOfficialObbFilePath = null;
+
+ /**
+ * Constructor
+ *
+ * @param obbFilePath path to the OBB image file
+ * @param pathToContentsFile path to a file on the mounted OBB volume to open after the OBB
+ * has been mounted
+ */
+ public MountingObbThread (String obbFilePath, String pathToContentsFile) {
+ assertTrue("obbFilePath cannot be null!", obbFilePath != null);
+ mObbFilePath = obbFilePath;
+ assertTrue("path to contents file cannot be null!", pathToContentsFile != null);
+ mPathToContentsFile = pathToContentsFile;
+ }
+
+ /**
+ * Runs the thread
+ *
+ * Mounts OBB_FILE_1, and tries to open a file on the mounted OBB (specified in the
+ * constructor). Once it's open, it waits until someone calls its doStop(), after which it
+ * closes the opened file.
+ */
+ public void run() {
+ // the official OBB file path and the mount-request file path should be the same, but
+ // let's distinguish the two as they may make for some interesting tests later
+ mOfficialObbFilePath = mountObb(mObbFilePath);
+ assertEquals("Expected and actual OBB file paths differ!", mObbFilePath,
+ mOfficialObbFilePath);
+
+ // open a file on OBB 1...
+ DataInputStream inputFile = openFileOnMountedObb(mOfficialObbFilePath,
+ mPathToContentsFile);
+ assertTrue("Failed to open file!", inputFile != null);
+
+ synchronized (this) {
+ mFileOpenOnObb = true;
+ notifyAll();
+ }
+
+ while (!mStop) {
+ try {
+ Thread.sleep(WAIT_TIME_INCR);
+ } catch (InterruptedException e) {
+ // nothing special to be done for interruptions
+ }
+ }
+ try {
+ inputFile.close();
+ } catch (IOException e) {
+ fail("Failed to close file on OBB due to error: " + e.toString());
+ }
+ }
+
+ /**
+ * Tells whether a file has yet been successfully opened on the OBB or not
+ *
+ * @return true if the specified file on the OBB was opened; false otherwise
+ */
+ public boolean isFileOpenOnObb() {
+ return mFileOpenOnObb;
+ }
+
+ /**
+ * Returns the official path of the OBB file that was mounted
+ *
+ * This is not the mount path, but the normalized path to the actual OBB file
+ *
+ * @return a {@link String} representation of the path to the OBB file that was mounted
+ */
+ public String officialObbFilePath() {
+ return mOfficialObbFilePath;
+ }
+
+ /**
+ * Requests the thread to stop running
+ *
+ * Closes the opened file and returns
+ */
+ public void doStop() {
+ mStop = true;
+ }
+ }
+
+ public class ObbListener extends OnObbStateChangeListener {
+ private String LOG_TAG = "StorageManagerBaseTest.ObbListener";
+
+ String mOfficialPath = null;
+ boolean mDone = false;
+ int mState = -1;
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void onObbStateChange(String path, int state) {
+ Log.i(LOG_TAG, "Storage state changing to: " + state);
+
+ synchronized (this) {
+ Log.i(LOG_TAG, "OfficialPath is now: " + path);
+ mState = state;
+ mOfficialPath = path;
+ mDone = true;
+ notifyAll();
+ }
+ }
+
+ /**
+ * Tells whether we are done or not (system told us the OBB has changed state)
+ *
+ * @return true if the system has told us this OBB's state has changed, false otherwise
+ */
+ public boolean isDone() {
+ return mDone;
+ }
+
+ /**
+ * The last state of the OBB, according to the system
+ *
+ * @return A {@link String} representation of the state of the OBB
+ */
+ public int state() {
+ return mState;
+ }
+
+ /**
+ * The normalized, official path to the OBB file (according to the system)
+ *
+ * @return A {@link String} representation of the official path to the OBB file
+ */
+ public String officialPath() {
+ return mOfficialPath;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void setUp() throws Exception {
+ mContext = getInstrumentation().getContext();
+ mSm = (StorageManager)mContext.getSystemService(android.content.Context.STORAGE_SERVICE);
+
+ }
+
+ /**
+ * Helper to copy a raw resource file to an actual specified file
+ *
+ * @param rawResId The raw resource ID of the OBB resource file
+ * @param outFile A File representing the file we want to copy the OBB to
+ * @throws NotFoundException If the resource file could not be found
+ */
+ private void copyRawToFile(int rawResId, File outFile) throws NotFoundException {
+ Resources res = mContext.getResources();
+ InputStream is = null;
+ try {
+ is = res.openRawResource(rawResId);
+ } catch (NotFoundException e) {
+ Log.i(LOG_TAG, "Failed to load resource with id: " + rawResId);
+ throw e;
+ }
+ FileUtils.setPermissions(outFile.getPath(), FileUtils.S_IRWXU | FileUtils.S_IRWXG
+ | FileUtils.S_IRWXO, -1, -1);
+ assertTrue(FileUtils.copyToFile(is, outFile));
+ FileUtils.setPermissions(outFile.getPath(), FileUtils.S_IRWXU | FileUtils.S_IRWXG
+ | FileUtils.S_IRWXO, -1, -1);
+ }
+
+ /**
+ * Creates an OBB file (with the given name), into the app's standard files directory
+ *
+ * @param name The name of the OBB file we want to create/write to
+ * @param rawResId The raw resource ID of the OBB file in the package
+ * @return A {@link File} representing the file to write to
+ */
+ protected File createObbFile(String name, int rawResId) {
+ File outFile = null;
+ try {
+ final File filesDir = mContext.getFilesDir();
+ outFile = new File(filesDir, name);
+ copyRawToFile(rawResId, outFile);
+ } catch (NotFoundException e) {
+ if (outFile != null) {
+ outFile.delete();
+ }
+ }
+ return outFile;
+ }
+
+ /**
+ * Mounts an OBB file and opens a file located on it
+ *
+ * @param obbPath Path to OBB image
+ * @param fileName The full name and path to the file on the OBB to open once the OBB is mounted
+ * @return The {@link DataInputStream} representing the opened file, if successful in opening
+ * the file, or null of unsuccessful.
+ */
+ protected DataInputStream openFileOnMountedObb(String obbPath, String fileName) {
+
+ // get mSm obb mount path
+ assertTrue("Cannot open file when OBB is not mounted!", mSm.isObbMounted(obbPath));
+
+ String path = mSm.getMountedObbPath(obbPath);
+ assertTrue("Path should not be null!", path != null);
+
+ File inFile = new File(path, fileName);
+ DataInputStream inStream = null;
+ try {
+ inStream = new DataInputStream(new FileInputStream(inFile));
+ Log.i(LOG_TAG, "Opened file: " + fileName + " for read at path: " + path);
+ } catch (FileNotFoundException e) {
+ Log.e(LOG_TAG, e.toString());
+ return null;
+ } catch (SecurityException e) {
+ Log.e(LOG_TAG, e.toString());
+ return null;
+ }
+ return inStream;
+ }
+
+ /**
+ * Mounts an OBB file
+ *
+ * @param obbFilePath The full path to the OBB file to mount
+ * @param key (optional) The key to use to unencrypt the OBB; pass null for no encryption
+ * @param expectedState The expected state resulting from trying to mount the OBB
+ * @return A {@link String} representing the normalized path to OBB file that was mounted
+ */
+ protected String mountObb(String obbFilePath, String key, int expectedState) {
+ return doMountObb(obbFilePath, key, expectedState);
+ }
+
+ /**
+ * Mounts an OBB file with default options (no encryption, mounting succeeds)
+ *
+ * @param obbFilePath The full path to the OBB file to mount
+ * @return A {@link String} representing the normalized path to OBB file that was mounted
+ */
+ protected String mountObb(String obbFilePath) {
+ return doMountObb(obbFilePath, null, OnObbStateChangeListener.MOUNTED);
+ }
+
+ /**
+ * Synchronously waits for an OBB listener to be signaled of a state change, but does not throw
+ *
+ * @param obbListener The listener for the OBB file
+ * @return true if the listener was signaled of a state change by the system, else returns
+ * false if we time out.
+ */
+ protected boolean doWaitForObbStateChange(ObbListener obbListener) {
+ synchronized(obbListener) {
+ long waitTimeMillis = 0;
+ while (!obbListener.isDone()) {
+ try {
+ Log.i(LOG_TAG, "Waiting for listener...");
+ obbListener.wait(WAIT_TIME_INCR);
+ Log.i(LOG_TAG, "Awoke from waiting for listener...");
+ waitTimeMillis += WAIT_TIME_INCR;
+ if (waitTimeMillis > MAX_WAIT_TIME) {
+ fail("Timed out waiting for OBB state to change!");
+ }
+ } catch (InterruptedException e) {
+ Log.i(LOG_TAG, e.toString());
+ }
+ }
+ return obbListener.isDone();
+ }
+ }
+
+ /**
+ * Synchronously waits for an OBB listener to be signaled of a state change
+ *
+ * @param obbListener The listener for the OBB file
+ * @return true if the listener was signaled of a state change by the system; else a fail()
+ * is triggered if we timed out
+ */
+ protected String doMountObb_noThrow(String obbFilePath, String key, int expectedState) {
+ Log.i(LOG_TAG, "doMountObb() on " + obbFilePath + " using key: " + key);
+ assertTrue ("Null path was passed in for OBB file!", obbFilePath != null);
+ assertTrue ("Null path was passed in for OBB file!", obbFilePath != null);
+
+ ObbListener obbListener = new ObbListener();
+ boolean success = mSm.mountObb(obbFilePath, key, obbListener);
+ success &= obbFilePath.equals(doWaitForObbStateChange(obbListener));
+ success &= (expectedState == obbListener.state());
+
+ if (OnObbStateChangeListener.MOUNTED == expectedState) {
+ success &= obbFilePath.equals(obbListener.officialPath());
+ success &= mSm.isObbMounted(obbListener.officialPath());
+ } else {
+ success &= !mSm.isObbMounted(obbListener.officialPath());
+ }
+
+ if (success) {
+ return obbListener.officialPath();
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * Mounts an OBB file without throwing and synchronously waits for it to finish mounting
+ *
+ * @param obbFilePath The full path to the OBB file to mount
+ * @param key (optional) The key to use to unencrypt the OBB; pass null for no encryption
+ * @param expectedState The expected state resulting from trying to mount the OBB
+ * @return A {@link String} representing the actual normalized path to OBB file that was
+ * mounted, or null if the mounting failed
+ */
+ protected String doMountObb(String obbFilePath, String key, int expectedState) {
+ Log.i(LOG_TAG, "doMountObb() on " + obbFilePath + " using key: " + key);
+ assertTrue ("Null path was passed in for OBB file!", obbFilePath != null);
+
+ ObbListener obbListener = new ObbListener();
+ assertTrue("mountObb call failed", mSm.mountObb(obbFilePath, key, obbListener));
+ assertTrue("Failed to get OBB mount status change for file: " + obbFilePath,
+ doWaitForObbStateChange(obbListener));
+ assertEquals("OBB mount state not what was expected!", expectedState, obbListener.state());
+
+ if (OnObbStateChangeListener.MOUNTED == expectedState) {
+ assertEquals(obbFilePath, obbListener.officialPath());
+ assertTrue("Obb should be mounted, but SM reports it is not!",
+ mSm.isObbMounted(obbListener.officialPath()));
+ } else if (OnObbStateChangeListener.UNMOUNTED == expectedState) {
+ assertFalse("Obb should not be mounted, but SM reports it is!",
+ mSm.isObbMounted(obbListener.officialPath()));
+ }
+
+ assertEquals("Mount state is not what was expected!", expectedState, obbListener.state());
+ return obbListener.officialPath();
+ }
+
+ /**
+ * Unmounts an OBB file without throwing, and synchronously waits for it to finish unmounting
+ *
+ * @param obbFilePath The full path to the OBB file to mount
+ * @param force true if we shuold force the unmount, false otherwise
+ * @return true if the unmount was successful, false otherwise
+ */
+ protected boolean unmountObb_noThrow(String obbFilePath, boolean force) {
+ Log.i(LOG_TAG, "doUnmountObb_noThrow() on " + obbFilePath);
+ assertTrue ("Null path was passed in for OBB file!", obbFilePath != null);
+ boolean success = true;
+
+ ObbListener obbListener = new ObbListener();
+ assertTrue("unmountObb call failed", mSm.unmountObb(obbFilePath, force, obbListener));
+
+ boolean stateChanged = doWaitForObbStateChange(obbListener);
+ if (force) {
+ success &= stateChanged;
+ success &= (OnObbStateChangeListener.UNMOUNTED == obbListener.state());
+ success &= !mSm.isObbMounted(obbFilePath);
+ }
+ return success;
+ }
+
+ /**
+ * Unmounts an OBB file and synchronously waits for it to finish unmounting
+ *
+ * @param obbFilePath The full path to the OBB file to mount
+ * @param force true if we shuold force the unmount, false otherwise
+ */
+ protected void unmountObb(String obbFilePath, boolean force) {
+ Log.i(LOG_TAG, "doUnmountObb() on " + obbFilePath);
+ assertTrue ("Null path was passed in for OBB file!", obbFilePath != null);
+
+ ObbListener obbListener = new ObbListener();
+ assertTrue("unmountObb call failed", mSm.unmountObb(obbFilePath, force, obbListener));
+
+ boolean stateChanged = doWaitForObbStateChange(obbListener);
+ if (force) {
+ assertTrue("Timed out waiting to unmount OBB file " + obbFilePath, stateChanged);
+ assertEquals("OBB failed to unmount", OnObbStateChangeListener.UNMOUNTED,
+ obbListener.state());
+ assertFalse("Obb should NOT be mounted, but SM reports it is!", mSm.isObbMounted(
+ obbFilePath));
+ }
+ }
+
+ /**
+ * Helper to validate the contents of an "int" file in an OBB.
+ *
+ * The format of the files are sequential int's, in the range of: [start..end)
+ *
+ * @param path The full path to the file (path to OBB)
+ * @param filename The filename containing the ints to validate
+ * @param start The first int expected to be found in the file
+ * @param end The last int + 1 expected to be found in the file
+ */
+ protected void doValidateIntContents(String path, String filename, int start, int end) {
+ File inFile = new File(path, filename);
+ DataInputStream inStream = null;
+ Log.i(LOG_TAG, "Validating file " + filename + " at " + path);
+ try {
+ inStream = new DataInputStream(new FileInputStream(inFile));
+
+ for (int i = start; i < end; ++i) {
+ if (inStream.readInt() != i) {
+ fail("Unexpected value read in OBB file");
+ }
+ }
+ if (inStream != null) {
+ inStream.close();
+ }
+ Log.i(LOG_TAG, "Successfully validated file " + filename);
+ } catch (FileNotFoundException e) {
+ fail("File " + inFile + " not found: " + e.toString());
+ } catch (IOException e) {
+ fail("IOError with file " + inFile + ":" + e.toString());
+ }
+ }
+
+ /**
+ * Helper to validate the contents of a text file in an OBB
+ *
+ * @param path The full path to the file (path to OBB)
+ * @param filename The filename containing the ints to validate
+ * @param contents A {@link String} containing the expected contents of the file
+ */
+ protected void doValidateTextContents(String path, String filename, String contents) {
+ File inFile = new File(path, filename);
+ BufferedReader fileReader = null;
+ BufferedReader textReader = null;
+ Log.i(LOG_TAG, "Validating file " + filename + " at " + path);
+ try {
+ fileReader = new BufferedReader(new FileReader(inFile));
+ textReader = new BufferedReader(new StringReader(contents));
+ String actual = null;
+ String expected = null;
+ while ((actual = fileReader.readLine()) != null) {
+ expected = textReader.readLine();
+ if (!actual.equals(expected)) {
+ fail("File " + filename + " in OBB " + path + " does not match expected value");
+ }
+ }
+ fileReader.close();
+ textReader.close();
+ Log.i(LOG_TAG, "File " + filename + " successfully verified.");
+ } catch (IOException e) {
+ fail("IOError with file " + inFile + ":" + e.toString());
+ }
+ }
+
+ /**
+ * Helper to validate the contents of a "long" file on our OBBs
+ *
+ * The format of the files are sequential 0's of type long
+ *
+ * @param path The full path to the file (path to OBB)
+ * @param filename The filename containing the ints to validate
+ * @param size The number of zero's expected in the file
+ * @param checkContents If true, the contents of the file are actually verified; if false,
+ * we simply verify that the file can be opened
+ */
+ protected void doValidateZeroLongFile(String path, String filename, long size,
+ boolean checkContents) {
+ File inFile = new File(path, filename);
+ DataInputStream inStream = null;
+ Log.i(LOG_TAG, "Validating file " + filename + " at " + path);
+ try {
+ inStream = new DataInputStream(new FileInputStream(inFile));
+
+ if (checkContents) {
+ for (long i = 0; i < size; ++i) {
+ if (inStream.readLong() != 0) {
+ fail("Unexpected value read in OBB file" + filename);
+ }
+ }
+ }
+
+ if (inStream != null) {
+ inStream.close();
+ }
+ Log.i(LOG_TAG, "File " + filename + " successfully verified for " + size + " zeros");
+ } catch (IOException e) {
+ fail("IOError with file " + inFile + ":" + e.toString());
+ }
+ }
+
+ /**
+ * Helper to synchronously wait until we can get a path for a given OBB file
+ *
+ * @param filePath The full normalized path to the OBB file
+ * @return The mounted path of the OBB, used to access contents in it
+ */
+ protected String doWaitForPath(String filePath) {
+ String path = null;
+
+ long waitTimeMillis = 0;
+ assertTrue("OBB " + filePath + " is not currently mounted!", mSm.isObbMounted(filePath));
+ while (path == null) {
+ try {
+ Thread.sleep(WAIT_TIME_INCR);
+ waitTimeMillis += WAIT_TIME_INCR;
+ if (waitTimeMillis > MAX_WAIT_TIME) {
+ fail("Timed out waiting to get path of OBB file " + filePath);
+ }
+ } catch (InterruptedException e) {
+ // do nothing
+ }
+ path = mSm.getMountedObbPath(filePath);
+ }
+ Log.i(LOG_TAG, "Got OBB path: " + path);
+ return path;
+ }
+
+ /**
+ * Verifies the pre-defined contents of our first OBB (OBB_FILE_1)
+ *
+ * The OBB contains 4 files and no subdirectories
+ *
+ * @param filePath The normalized path to the already-mounted OBB file
+ */
+ protected void verifyObb1Contents(String filePath) {
+ String path = null;
+ path = doWaitForPath(filePath);
+
+ // Validate contents of 2 files in this obb
+ doValidateIntContents(path, "OneToOneThousandInts.bin", 0, 1000);
+ doValidateIntContents(path, "SevenHundredInts.bin", 0, 700);
+ doValidateZeroLongFile(path, "FiveLongs.bin", 5, true);
+ }
+
+ /**
+ * Verifies the pre-defined contents of our second OBB (OBB_FILE_2)
+ *
+ * The OBB contains 2 files and no subdirectories
+ *
+ * @param filePath The normalized path to the already-mounted OBB file
+ */
+ protected void verifyObb2Contents(String filename) {
+ String path = null;
+ path = doWaitForPath(filename);
+
+ // Validate contents of file
+ doValidateTextContents(path, "sample.txt", SAMPLE1_TEXT);
+ doValidateTextContents(path, "sample2.txt", SAMPLE2_TEXT);
+ }
+
+ /**
+ * Verifies the pre-defined contents of our third OBB (OBB_FILE_3)
+ *
+ * The OBB contains nested files and subdirectories
+ *
+ * @param filePath The normalized path to the already-mounted OBB file
+ */
+ protected void verifyObb3Contents(String filename) {
+ String path = null;
+ path = doWaitForPath(filename);
+
+ // Validate contents of file
+ doValidateIntContents(path, "OneToOneThousandInts.bin", 0, 1000);
+ doValidateZeroLongFile(path, "TwoHundredLongs", 200, true);
+
+ // validate subdirectory 1
+ doValidateZeroLongFile(path + File.separator + "subdir1", "FiftyLongs", 50, true);
+
+ // validate subdirectory subdir2/
+ doValidateIntContents(path + File.separator + "subdir2", "OneToOneThousandInts", 0, 1000);
+
+ // validate subdirectory subdir2/subdir2a/
+ doValidateZeroLongFile(path + File.separator + "subdir2" + File.separator + "subdir2a",
+ "TwoHundredLongs", 200, true);
+
+ // validate subdirectory subdir2/subdir2a/subdir2a1/
+ doValidateIntContents(path + File.separator + "subdir2" + File.separator + "subdir2a"
+ + File.separator + "subdir2a1", "OneToOneThousandInts", 0, 1000);
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (C) 2010 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.storage;
+
+import android.content.Context;
+import android.os.Environment;
+import android.test.InstrumentationTestCase;
+import android.test.suitebuilder.annotation.LargeTest;
+import android.util.Log;
+
+import com.android.frameworks.coretests.R;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.File;
+import java.io.FileInputStream;
+
+import junit.framework.AssertionFailedError;
+
+public class StorageManagerIntegrationTest extends StorageManagerBaseTest {
+
+ private static String LOG_TAG = "StorageManagerBaseTest.StorageManagerIntegrationTest";
+ protected File mFile = null;
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void setUp() throws Exception {
+ super.setUp();
+ mContext = getInstrumentation().getContext();
+ mFile = null;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected void tearDown() throws Exception {
+ if (mFile != null) {
+ mFile.delete();
+ mFile = null;
+ }
+ super.tearDown();
+ }
+
+ /**
+ * Tests mounting a single OBB file and verifies its contents.
+ */
+ @LargeTest
+ public void testMountSingleObb() {
+ mFile = createObbFile(OBB_FILE_1, R.raw.obb_file1);
+ String filePath = mFile.getAbsolutePath();
+ mountObb(filePath);
+ verifyObb1Contents(filePath);
+ unmountObb(filePath, DONT_FORCE);
+ }
+
+ /**
+ * Tests mounting several OBB files and verifies its contents.
+ */
+ @LargeTest
+ public void testMountMultipleObb() {
+ File file1 = null;
+ File file2 = null;
+ File file3 = null;
+ try {
+ file1 = createObbFile(OBB_FILE_1, R.raw.obb_file1);
+ String filePath1 = file1.getAbsolutePath();
+ mountObb(filePath1);
+ verifyObb1Contents(filePath1);
+
+ file2 = createObbFile(OBB_FILE_2, R.raw.obb_file2);
+ String filePath2 = file2.getAbsolutePath();
+ mountObb(filePath2);
+ verifyObb2Contents(filePath2);
+
+ file3 = createObbFile(OBB_FILE_3, R.raw.obb_file3);
+ String filePath3 = file3.getAbsolutePath();
+ mountObb(filePath3);
+ verifyObb3Contents(filePath3);
+
+ unmountObb(filePath1, DONT_FORCE);
+ unmountObb(filePath2, DONT_FORCE);
+ unmountObb(filePath3, DONT_FORCE);
+ } finally {
+ if (file1 != null) {
+ file1.delete();
+ }
+ if (file2 != null) {
+ file2.delete();
+ }
+ if (file3 != null) {
+ file3.delete();
+ }
+ }
+ }
+
+ /**
+ * Tests mounting a single encrypted OBB file and verifies its contents.
+ */
+ @LargeTest
+ public void testMountSingleEncryptedObb() {
+ mFile = createObbFile(OBB_FILE_3_ENCRYPTED, R.raw.obb_enc_file100_orig3);
+ String filePath = mFile.getAbsolutePath();
+ mountObb(filePath, OBB_FILE_3_PASSWORD, OnObbStateChangeListener.MOUNTED);
+ verifyObb3Contents(filePath);
+ unmountObb(filePath, DONT_FORCE);
+ }
+
+ /**
+ * Tests mounting a single encrypted OBB file using an invalid password.
+ */
+ @LargeTest
+ public void testMountSingleEncryptedObbInvalidPassword() {
+ mFile = createObbFile("bad password@$%#@^*(!&)", R.raw.obb_enc_file100_orig3);
+ String filePath = mFile.getAbsolutePath();
+ mountObb(filePath, OBB_FILE_3_PASSWORD, OnObbStateChangeListener.ERROR_COULD_NOT_MOUNT);
+ unmountObb(filePath, DONT_FORCE);
+ }
+
+ /**
+ * Tests simultaneously mounting 2 encrypted OBBs with different keys and verifies contents.
+ */
+ @LargeTest
+ public void testMountTwoEncryptedObb() {
+ File file3 = null;
+ File file1 = null;
+ try {
+ file3 = createObbFile(OBB_FILE_3_ENCRYPTED, R.raw.obb_enc_file100_orig3);
+ String filePath3 = file3.getAbsolutePath();
+ mountObb(filePath3, OBB_FILE_3_PASSWORD, OnObbStateChangeListener.MOUNTED);
+ verifyObb3Contents(filePath3);
+
+ file1 = createObbFile(OBB_FILE_1_ENCRYPTED, R.raw.obb_enc_file100_orig1);
+ String filePath1 = file1.getAbsolutePath();
+ mountObb(filePath1, OBB_FILE_1_PASSWORD, OnObbStateChangeListener.MOUNTED);
+ verifyObb1Contents(filePath1);
+
+ unmountObb(filePath3, DONT_FORCE);
+ unmountObb(filePath1, DONT_FORCE);
+ } finally {
+ if (file3 != null) {
+ file3.delete();
+ }
+ if (file1 != null) {
+ file1.delete();
+ }
+ }
+ }
+
+ /**
+ * Tests that we can not force unmount when a file is currently open on the OBB.
+ */
+ @LargeTest
+ public void testUnmount_DontForce() {
+ mFile = createObbFile(OBB_FILE_1, R.raw.obb_file1);
+ String obbFilePath = mFile.getAbsolutePath();
+
+ MountingObbThread mountingThread = new MountingObbThread(obbFilePath,
+ OBB_FILE_1_CONTENTS_1);
+
+ try {
+ mountingThread.start();
+
+ long waitTime = 0;
+ while (!mountingThread.isFileOpenOnObb()) {
+ synchronized (mountingThread) {
+ Log.i(LOG_TAG, "Waiting for file to be opened on OBB...");
+ mountingThread.wait(WAIT_TIME_INCR);
+ waitTime += WAIT_TIME_INCR;
+ if (waitTime > MAX_WAIT_TIME) {
+ fail("Timed out waiting for file file to be opened on OBB!");
+ }
+ }
+ }
+
+ unmountObb(obbFilePath, DONT_FORCE);
+
+ // verify still mounted
+ assertTrue("mounted path should not be null!", obbFilePath != null);
+ assertTrue("mounted path should still be mounted!", mSm.isObbMounted(obbFilePath));
+
+ // close the opened file
+ mountingThread.doStop();
+
+ // try unmounting again (should succeed this time)
+ unmountObb(obbFilePath, DONT_FORCE);
+ assertFalse("mounted path should no longer be mounted!",
+ mSm.isObbMounted(obbFilePath));
+ } catch (InterruptedException e) {
+ fail("Timed out waiting for file on OBB to be opened...");
+ }
+ }
+
+ /**
+ * Tests mounting a single OBB that isn't signed.
+ */
+ @LargeTest
+ public void testMountUnsignedObb() {
+ mFile = createObbFile(OBB_FILE_2_UNSIGNED, R.raw.obb_file2_nosign);
+ String filePath = mFile.getAbsolutePath();
+ mountObb(filePath, OBB_FILE_2_UNSIGNED, OnObbStateChangeListener.ERROR_INTERNAL);
+ }
+
+ /**
+ * Tests mounting a single OBB that is signed with a different package.
+ */
+ @LargeTest
+ public void testMountBadPackageNameObb() {
+ mFile = createObbFile(OBB_FILE_3_BAD_PACKAGENAME, R.raw.obb_file3_bad_packagename);
+ String filePath = mFile.getAbsolutePath();
+ mountObb(filePath, OBB_FILE_3_BAD_PACKAGENAME,
+ OnObbStateChangeListener.ERROR_PERMISSION_DENIED);
+ }
+
+ /**
+ * Tests remounting a single OBB that has already been mounted.
+ */
+ @LargeTest
+ public void testRemountObb() {
+ mFile = createObbFile(OBB_FILE_1, R.raw.obb_file1);
+ String filePath = mFile.getAbsolutePath();
+ mountObb(filePath);
+ verifyObb1Contents(filePath);
+ mountObb(filePath, null, OnObbStateChangeListener.ERROR_ALREADY_MOUNTED);
+ verifyObb1Contents(filePath);
+ unmountObb(filePath, DONT_FORCE);
+ }
+}
\ No newline at end of file
OSDN Git Service
