| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.mtp; |
| |
| import android.database.Cursor; |
| import android.mtp.MtpConstants; |
| import android.mtp.MtpObjectInfo; |
| import android.provider.DocumentsContract; |
| import android.provider.DocumentsContract.Document; |
| import android.provider.DocumentsContract.Root; |
| import android.test.AndroidTestCase; |
| import android.test.suitebuilder.annotation.SmallTest; |
| |
| import java.io.FileNotFoundException; |
| |
| import static com.android.mtp.MtpDatabase.strings; |
| |
| @SmallTest |
| public class MtpDatabaseTest extends AndroidTestCase { |
| private final String[] COLUMN_NAMES = new String[] { |
| DocumentsContract.Document.COLUMN_DOCUMENT_ID, |
| MtpDatabaseConstants.COLUMN_DEVICE_ID, |
| MtpDatabaseConstants.COLUMN_STORAGE_ID, |
| MtpDatabaseConstants.COLUMN_OBJECT_HANDLE, |
| DocumentsContract.Document.COLUMN_MIME_TYPE, |
| DocumentsContract.Document.COLUMN_DISPLAY_NAME, |
| DocumentsContract.Document.COLUMN_SUMMARY, |
| DocumentsContract.Document.COLUMN_LAST_MODIFIED, |
| DocumentsContract.Document.COLUMN_ICON, |
| DocumentsContract.Document.COLUMN_FLAGS, |
| DocumentsContract.Document.COLUMN_SIZE |
| }; |
| |
| private final TestResources resources = new TestResources(); |
| MtpDatabase mDatabase; |
| |
| @Override |
| public void setUp() { |
| mDatabase = new MtpDatabase(getContext(), MtpDatabaseConstants.FLAG_DATABASE_IN_MEMORY); |
| } |
| |
| @Override |
| public void tearDown() { |
| mDatabase.close(); |
| mDatabase = null; |
| } |
| |
| public void testPutRootDocuments() throws Exception { |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 1, "Device", "Storage", 1000, 2000, ""), |
| new MtpRoot(0, 2, "Device", "Storage", 2000, 4000, ""), |
| new MtpRoot(0, 3, "Device", "/@#%&<>Storage", 3000, 6000,"") |
| }); |
| |
| { |
| final Cursor cursor = mDatabase.queryRootDocuments(COLUMN_NAMES); |
| assertEquals(3, cursor.getCount()); |
| |
| cursor.moveToNext(); |
| assertEquals("documentId", 1, cursor.getInt(0)); |
| assertEquals("deviceId", 0, cursor.getInt(1)); |
| assertEquals("storageId", 1, cursor.getInt(2)); |
| assertTrue("objectHandle", cursor.isNull(3)); |
| assertEquals("mimeType", DocumentsContract.Document.MIME_TYPE_DIR, cursor.getString(4)); |
| assertEquals("displayName", "Device Storage", cursor.getString(5)); |
| assertTrue("summary", cursor.isNull(6)); |
| assertTrue("lastModified", cursor.isNull(7)); |
| assertEquals("icon", R.drawable.ic_root_mtp, cursor.getInt(8)); |
| assertEquals("flag", 0, cursor.getInt(9)); |
| assertEquals("size", 1000, cursor.getInt(10)); |
| |
| cursor.moveToNext(); |
| assertEquals("documentId", 2, cursor.getInt(0)); |
| assertEquals("displayName", "Device Storage", cursor.getString(5)); |
| |
| cursor.moveToNext(); |
| assertEquals("documentId", 3, cursor.getInt(0)); |
| assertEquals("displayName", "Device /@#%&<>Storage", cursor.getString(5)); |
| |
| cursor.close(); |
| } |
| |
| { |
| final Cursor cursor = mDatabase.queryRoots(new String [] { |
| Root.COLUMN_ROOT_ID, |
| Root.COLUMN_FLAGS, |
| Root.COLUMN_ICON, |
| Root.COLUMN_TITLE, |
| Root.COLUMN_SUMMARY, |
| Root.COLUMN_DOCUMENT_ID, |
| Root.COLUMN_AVAILABLE_BYTES, |
| Root.COLUMN_CAPACITY_BYTES |
| }); |
| assertEquals(3, cursor.getCount()); |
| |
| cursor.moveToNext(); |
| assertEquals(1, cursor.getInt(0)); |
| assertEquals(Root.FLAG_SUPPORTS_IS_CHILD | Root.FLAG_SUPPORTS_CREATE, cursor.getInt(1)); |
| assertEquals(R.drawable.ic_root_mtp, cursor.getInt(2)); |
| assertEquals("Device Storage", cursor.getString(3)); |
| assertTrue(cursor.isNull(4)); |
| assertEquals(1, cursor.getInt(5)); |
| assertEquals(1000, cursor.getInt(6)); |
| assertEquals(2000, cursor.getInt(7)); |
| |
| cursor.moveToNext(); |
| assertEquals(2, cursor.getInt(0)); |
| assertEquals(Root.FLAG_SUPPORTS_IS_CHILD | Root.FLAG_SUPPORTS_CREATE, cursor.getInt(1)); |
| assertEquals(R.drawable.ic_root_mtp, cursor.getInt(2)); |
| assertEquals("Device Storage", cursor.getString(3)); |
| assertTrue(cursor.isNull(4)); |
| assertEquals(2, cursor.getInt(5)); |
| assertEquals(2000, cursor.getInt(6)); |
| assertEquals(4000, cursor.getInt(7)); |
| |
| cursor.moveToNext(); |
| assertEquals(3, cursor.getInt(0)); |
| assertEquals(Root.FLAG_SUPPORTS_IS_CHILD | Root.FLAG_SUPPORTS_CREATE, cursor.getInt(1)); |
| assertEquals(R.drawable.ic_root_mtp, cursor.getInt(2)); |
| assertEquals("Device /@#%&<>Storage", cursor.getString(3)); |
| assertTrue(cursor.isNull(4)); |
| assertEquals(3, cursor.getInt(5)); |
| assertEquals(3000, cursor.getInt(6)); |
| assertEquals(6000, cursor.getInt(7)); |
| |
| cursor.close(); |
| } |
| } |
| |
| private MtpObjectInfo createDocument(int objectHandle, String name, int format, int size) { |
| final MtpObjectInfo.Builder builder = new MtpObjectInfo.Builder(); |
| builder.setObjectHandle(objectHandle); |
| builder.setName(name); |
| builder.setFormat(format); |
| builder.setCompressedSize(size); |
| return builder.build(); |
| } |
| |
| public void testPutChildDocuments() throws Exception { |
| mDatabase.getMapper().startAddingChildDocuments("parentId"); |
| mDatabase.getMapper().putChildDocuments(0, "parentId", new MtpObjectInfo[] { |
| createDocument(100, "note.txt", MtpConstants.FORMAT_TEXT, 1024), |
| createDocument(101, "image.jpg", MtpConstants.FORMAT_EXIF_JPEG, 2 * 1024 * 1024), |
| createDocument(102, "music.mp3", MtpConstants.FORMAT_MP3, 3 * 1024 * 1024) |
| }); |
| |
| final Cursor cursor = mDatabase.queryChildDocuments(COLUMN_NAMES, "parentId"); |
| assertEquals(3, cursor.getCount()); |
| |
| cursor.moveToNext(); |
| assertEquals("documentId", 1, cursor.getInt(0)); |
| assertEquals("deviceId", 0, cursor.getInt(1)); |
| assertEquals("storageId", 0, cursor.getInt(2)); |
| assertEquals("objectHandle", 100, cursor.getInt(3)); |
| assertEquals("mimeType", "text/plain", cursor.getString(4)); |
| assertEquals("displayName", "note.txt", cursor.getString(5)); |
| assertTrue("summary", cursor.isNull(6)); |
| assertTrue("lastModified", cursor.isNull(7)); |
| assertTrue("icon", cursor.isNull(8)); |
| assertEquals( |
| "flag", |
| DocumentsContract.Document.FLAG_SUPPORTS_DELETE | |
| DocumentsContract.Document.FLAG_SUPPORTS_WRITE, |
| cursor.getInt(9)); |
| assertEquals("size", 1024, cursor.getInt(10)); |
| |
| cursor.moveToNext(); |
| assertEquals("documentId", 2, cursor.getInt(0)); |
| assertEquals("deviceId", 0, cursor.getInt(1)); |
| assertEquals("storageId", 0, cursor.getInt(2)); |
| assertEquals("objectHandle", 101, cursor.getInt(3)); |
| assertEquals("mimeType", "image/jpeg", cursor.getString(4)); |
| assertEquals("displayName", "image.jpg", cursor.getString(5)); |
| assertTrue("summary", cursor.isNull(6)); |
| assertTrue("lastModified", cursor.isNull(7)); |
| assertTrue("icon", cursor.isNull(8)); |
| assertEquals( |
| "flag", |
| DocumentsContract.Document.FLAG_SUPPORTS_DELETE | |
| DocumentsContract.Document.FLAG_SUPPORTS_WRITE, |
| cursor.getInt(9)); |
| assertEquals("size", 2 * 1024 * 1024, cursor.getInt(10)); |
| |
| cursor.moveToNext(); |
| assertEquals("documentId", 3, cursor.getInt(0)); |
| assertEquals("deviceId", 0, cursor.getInt(1)); |
| assertEquals("storageId", 0, cursor.getInt(2)); |
| assertEquals("objectHandle", 102, cursor.getInt(3)); |
| assertEquals("mimeType", "audio/mpeg", cursor.getString(4)); |
| assertEquals("displayName", "music.mp3", cursor.getString(5)); |
| assertTrue("summary", cursor.isNull(6)); |
| assertTrue("lastModified", cursor.isNull(7)); |
| assertTrue("icon", cursor.isNull(8)); |
| assertEquals( |
| "flag", |
| DocumentsContract.Document.FLAG_SUPPORTS_DELETE | |
| DocumentsContract.Document.FLAG_SUPPORTS_WRITE, |
| cursor.getInt(9)); |
| assertEquals("size", 3 * 1024 * 1024, cursor.getInt(10)); |
| |
| cursor.close(); |
| } |
| |
| public void testRestoreIdForRootDocuments() throws Exception { |
| final String[] columns = new String[] { |
| DocumentsContract.Document.COLUMN_DOCUMENT_ID, |
| MtpDatabaseConstants.COLUMN_STORAGE_ID, |
| DocumentsContract.Document.COLUMN_DISPLAY_NAME |
| }; |
| final String[] rootColumns = new String[] { |
| Root.COLUMN_ROOT_ID, |
| Root.COLUMN_AVAILABLE_BYTES |
| }; |
| |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 100, "Device", "Storage A", 1000, 0, ""), |
| new MtpRoot(0, 101, "Device", "Storage B", 1001, 0, "") |
| }); |
| |
| { |
| final Cursor cursor = mDatabase.queryRootDocuments(columns); |
| assertEquals(2, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("documentId", 1, cursor.getInt(0)); |
| assertEquals("storageId", 100, cursor.getInt(1)); |
| assertEquals("name", "Device Storage A", cursor.getString(2)); |
| cursor.moveToNext(); |
| assertEquals("documentId", 2, cursor.getInt(0)); |
| assertEquals("storageId", 101, cursor.getInt(1)); |
| assertEquals("name", "Device Storage B", cursor.getString(2)); |
| cursor.close(); |
| } |
| |
| { |
| final Cursor cursor = mDatabase.queryRoots(rootColumns); |
| assertEquals(2, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("rootId", 1, cursor.getInt(0)); |
| assertEquals("availableBytes", 1000, cursor.getInt(1)); |
| cursor.moveToNext(); |
| assertEquals("rootId", 2, cursor.getInt(0)); |
| assertEquals("availableBytes", 1001, cursor.getInt(1)); |
| cursor.close(); |
| } |
| |
| mDatabase.getMapper().clearMapping(); |
| |
| { |
| final Cursor cursor = mDatabase.queryRootDocuments(columns); |
| assertEquals(2, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("documentId", 1, cursor.getInt(0)); |
| assertTrue("storageId", cursor.isNull(1)); |
| assertEquals("name", "Device Storage A", cursor.getString(2)); |
| cursor.moveToNext(); |
| assertEquals("documentId", 2, cursor.getInt(0)); |
| assertTrue("storageId", cursor.isNull(1)); |
| assertEquals("name", "Device Storage B", cursor.getString(2)); |
| cursor.close(); |
| } |
| |
| { |
| final Cursor cursor = mDatabase.queryRoots(rootColumns); |
| assertEquals(2, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("rootId", 1, cursor.getInt(0)); |
| assertEquals("availableBytes", 1000, cursor.getInt(1)); |
| cursor.moveToNext(); |
| assertEquals("rootId", 2, cursor.getInt(0)); |
| assertEquals("availableBytes", 1001, cursor.getInt(1)); |
| cursor.close(); |
| } |
| |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 200, "Device", "Storage A", 2000, 0, ""), |
| new MtpRoot(0, 202, "Device", "Storage C", 2002, 0, "") |
| }); |
| |
| { |
| final Cursor cursor = mDatabase.queryRootDocuments(columns); |
| assertEquals(3, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("documentId", 1, cursor.getInt(0)); |
| assertTrue("storageId", cursor.isNull(1)); |
| assertEquals("name", "Device Storage A", cursor.getString(2)); |
| cursor.moveToNext(); |
| assertEquals("documentId", 2, cursor.getInt(0)); |
| assertTrue("storageId", cursor.isNull(1)); |
| assertEquals("name", "Device Storage B", cursor.getString(2)); |
| cursor.moveToNext(); |
| assertEquals("documentId", 4, cursor.getInt(0)); |
| assertEquals("storageId", 202, cursor.getInt(1)); |
| assertEquals("name", "Device Storage C", cursor.getString(2)); |
| cursor.close(); |
| } |
| |
| { |
| final Cursor cursor = mDatabase.queryRoots(rootColumns); |
| assertEquals(3, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("rootId", 1, cursor.getInt(0)); |
| assertEquals("availableBytes", 1000, cursor.getInt(1)); |
| cursor.moveToNext(); |
| assertEquals("rootId", 2, cursor.getInt(0)); |
| assertEquals("availableBytes", 1001, cursor.getInt(1)); |
| cursor.moveToNext(); |
| assertEquals("rootId", 4, cursor.getInt(0)); |
| assertEquals("availableBytes", 2002, cursor.getInt(1)); |
| cursor.close(); |
| } |
| |
| mDatabase.getMapper().stopAddingRootDocuments(0); |
| |
| { |
| final Cursor cursor = mDatabase.queryRootDocuments(columns); |
| assertEquals(2, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("documentId", 1, cursor.getInt(0)); |
| assertEquals("storageId", 200, cursor.getInt(1)); |
| assertEquals("name", "Device Storage A", cursor.getString(2)); |
| cursor.moveToNext(); |
| assertEquals("documentId", 4, cursor.getInt(0)); |
| assertEquals("storageId", 202, cursor.getInt(1)); |
| assertEquals("name", "Device Storage C", cursor.getString(2)); |
| cursor.close(); |
| } |
| |
| { |
| final Cursor cursor = mDatabase.queryRoots(rootColumns); |
| assertEquals(2, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("rootId", 1, cursor.getInt(0)); |
| assertEquals("availableBytes", 2000, cursor.getInt(1)); |
| cursor.moveToNext(); |
| assertEquals("rootId", 4, cursor.getInt(0)); |
| assertEquals("availableBytes", 2002, cursor.getInt(1)); |
| cursor.close(); |
| } |
| } |
| |
| public void testRestoreIdForChildDocuments() throws Exception { |
| final String[] columns = new String[] { |
| DocumentsContract.Document.COLUMN_DOCUMENT_ID, |
| MtpDatabaseConstants.COLUMN_OBJECT_HANDLE, |
| DocumentsContract.Document.COLUMN_DISPLAY_NAME |
| }; |
| mDatabase.getMapper().startAddingChildDocuments("parentId"); |
| mDatabase.getMapper().putChildDocuments(0, "parentId", new MtpObjectInfo[] { |
| createDocument(100, "note.txt", MtpConstants.FORMAT_TEXT, 1024), |
| createDocument(101, "image.jpg", MtpConstants.FORMAT_EXIF_JPEG, 2 * 1024 * 1024), |
| createDocument(102, "music.mp3", MtpConstants.FORMAT_MP3, 3 * 1024 * 1024) |
| }); |
| mDatabase.getMapper().clearMapping(); |
| |
| { |
| final Cursor cursor = mDatabase.queryChildDocuments(columns, "parentId"); |
| assertEquals(3, cursor.getCount()); |
| |
| cursor.moveToNext(); |
| assertEquals("documentId", 1, cursor.getInt(0)); |
| assertTrue("objectHandle", cursor.isNull(1)); |
| assertEquals("name", "note.txt", cursor.getString(2)); |
| |
| cursor.moveToNext(); |
| assertEquals("documentId", 2, cursor.getInt(0)); |
| assertTrue("objectHandle", cursor.isNull(1)); |
| assertEquals("name", "image.jpg", cursor.getString(2)); |
| |
| cursor.moveToNext(); |
| assertEquals("documentId", 3, cursor.getInt(0)); |
| assertTrue("objectHandle", cursor.isNull(1)); |
| assertEquals("name", "music.mp3", cursor.getString(2)); |
| |
| cursor.close(); |
| } |
| |
| mDatabase.getMapper().startAddingChildDocuments("parentId"); |
| mDatabase.getMapper().putChildDocuments(0, "parentId", new MtpObjectInfo[] { |
| createDocument(200, "note.txt", MtpConstants.FORMAT_TEXT, 1024), |
| createDocument(203, "video.mp4", MtpConstants.FORMAT_MP4_CONTAINER, 1024), |
| }); |
| |
| { |
| final Cursor cursor = mDatabase.queryChildDocuments(columns, "parentId"); |
| assertEquals(4, cursor.getCount()); |
| |
| cursor.moveToPosition(3); |
| assertEquals("documentId", 5, cursor.getInt(0)); |
| assertEquals("objectHandle", 203, cursor.getInt(1)); |
| assertEquals("name", "video.mp4", cursor.getString(2)); |
| |
| cursor.close(); |
| } |
| |
| mDatabase.getMapper().stopAddingChildDocuments("parentId"); |
| |
| { |
| final Cursor cursor = mDatabase.queryChildDocuments(columns, "parentId"); |
| assertEquals(2, cursor.getCount()); |
| |
| cursor.moveToNext(); |
| assertEquals("documentId", 1, cursor.getInt(0)); |
| assertEquals("objectHandle", 200, cursor.getInt(1)); |
| assertEquals("name", "note.txt", cursor.getString(2)); |
| |
| cursor.moveToNext(); |
| assertEquals("documentId", 5, cursor.getInt(0)); |
| assertEquals("objectHandle", 203, cursor.getInt(1)); |
| assertEquals("name", "video.mp4", cursor.getString(2)); |
| cursor.close(); |
| } |
| } |
| |
| public void testRestoreIdForDifferentDevices() throws Exception { |
| final String[] columns = new String[] { |
| DocumentsContract.Document.COLUMN_DOCUMENT_ID, |
| MtpDatabaseConstants.COLUMN_STORAGE_ID, |
| DocumentsContract.Document.COLUMN_DISPLAY_NAME |
| }; |
| final String[] rootColumns = new String[] { |
| Root.COLUMN_ROOT_ID, |
| Root.COLUMN_AVAILABLE_BYTES |
| }; |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().startAddingRootDocuments(1); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 100, "Device", "Storage", 0, 0, "") |
| }); |
| mDatabase.getMapper().putRootDocuments(1, resources, new MtpRoot[] { |
| new MtpRoot(1, 100, "Device", "Storage", 0, 0, "") |
| }); |
| |
| { |
| final Cursor cursor = mDatabase.queryRootDocuments(columns); |
| assertEquals(2, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("documentId", 1, cursor.getInt(0)); |
| assertEquals("storageId", 100, cursor.getInt(1)); |
| assertEquals("name", "Device Storage", cursor.getString(2)); |
| cursor.moveToNext(); |
| assertEquals("documentId", 2, cursor.getInt(0)); |
| assertEquals("storageId", 100, cursor.getInt(1)); |
| assertEquals("name", "Device Storage", cursor.getString(2)); |
| cursor.close(); |
| } |
| |
| { |
| final Cursor cursor = mDatabase.queryRoots(rootColumns); |
| assertEquals(2, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("rootId", 1, cursor.getInt(0)); |
| assertEquals("availableBytes", 0, cursor.getInt(1)); |
| cursor.moveToNext(); |
| assertEquals("rootId", 2, cursor.getInt(0)); |
| assertEquals("availableBytes", 0, cursor.getInt(1)); |
| cursor.close(); |
| } |
| |
| mDatabase.getMapper().clearMapping(); |
| |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().startAddingRootDocuments(1); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 200, "Device", "Storage", 2000, 0, "") |
| }); |
| mDatabase.getMapper().putRootDocuments(1, resources, new MtpRoot[] { |
| new MtpRoot(1, 300, "Device", "Storage", 3000, 0, "") |
| }); |
| mDatabase.getMapper().stopAddingRootDocuments(0); |
| mDatabase.getMapper().stopAddingRootDocuments(1); |
| |
| { |
| final Cursor cursor = mDatabase.queryRootDocuments(columns); |
| assertEquals(2, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("documentId", 1, cursor.getInt(0)); |
| assertEquals("storageId", 200, cursor.getInt(1)); |
| assertEquals("name", "Device Storage", cursor.getString(2)); |
| cursor.moveToNext(); |
| assertEquals("documentId", 2, cursor.getInt(0)); |
| assertEquals("storageId", 300, cursor.getInt(1)); |
| assertEquals("name", "Device Storage", cursor.getString(2)); |
| cursor.close(); |
| } |
| |
| { |
| final Cursor cursor = mDatabase.queryRoots(rootColumns); |
| assertEquals(2, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("rootId", 1, cursor.getInt(0)); |
| assertEquals("availableBytes", 2000, cursor.getInt(1)); |
| cursor.moveToNext(); |
| assertEquals("rootId", 2, cursor.getInt(0)); |
| assertEquals("availableBytes", 3000, cursor.getInt(1)); |
| cursor.close(); |
| } |
| } |
| |
| public void testRestoreIdForDifferentParents() throws Exception { |
| final String[] columns = new String[] { |
| DocumentsContract.Document.COLUMN_DOCUMENT_ID, |
| MtpDatabaseConstants.COLUMN_OBJECT_HANDLE |
| }; |
| |
| mDatabase.getMapper().startAddingChildDocuments("parentId1"); |
| mDatabase.getMapper().startAddingChildDocuments("parentId2"); |
| mDatabase.getMapper().putChildDocuments(0, "parentId1", new MtpObjectInfo[] { |
| createDocument(100, "note.txt", MtpConstants.FORMAT_TEXT, 1024), |
| }); |
| mDatabase.getMapper().putChildDocuments(0, "parentId2", new MtpObjectInfo[] { |
| createDocument(101, "note.txt", MtpConstants.FORMAT_TEXT, 1024), |
| }); |
| mDatabase.getMapper().clearMapping(); |
| |
| mDatabase.getMapper().startAddingChildDocuments("parentId1"); |
| mDatabase.getMapper().startAddingChildDocuments("parentId2"); |
| mDatabase.getMapper().putChildDocuments(0, "parentId1", new MtpObjectInfo[] { |
| createDocument(200, "note.txt", MtpConstants.FORMAT_TEXT, 1024), |
| }); |
| mDatabase.getMapper().putChildDocuments(0, "parentId2", new MtpObjectInfo[] { |
| createDocument(201, "note.txt", MtpConstants.FORMAT_TEXT, 1024), |
| }); |
| mDatabase.getMapper().stopAddingChildDocuments("parentId1"); |
| |
| { |
| final Cursor cursor = mDatabase.queryChildDocuments(columns, "parentId1"); |
| assertEquals(1, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("documentId", 1, cursor.getInt(0)); |
| assertEquals("objectHandle", 200, cursor.getInt(1)); |
| cursor.close(); |
| } |
| { |
| final Cursor cursor = mDatabase.queryChildDocuments(columns, "parentId2"); |
| assertEquals(1, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("documentId", 2, cursor.getInt(0)); |
| assertTrue("objectHandle", cursor.isNull(1)); |
| cursor.close(); |
| } |
| } |
| |
| public void testClearMtpIdentifierBeforeResolveRootDocuments() { |
| final String[] columns = new String[] { |
| DocumentsContract.Document.COLUMN_DOCUMENT_ID, |
| MtpDatabaseConstants.COLUMN_STORAGE_ID, |
| DocumentsContract.Document.COLUMN_DISPLAY_NAME |
| }; |
| final String[] rootColumns = new String[] { |
| Root.COLUMN_ROOT_ID, |
| Root.COLUMN_AVAILABLE_BYTES |
| }; |
| |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 100, "Device", "Storage", 0, 0, ""), |
| }); |
| mDatabase.getMapper().clearMapping(); |
| |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 200, "Device", "Storage", 2000, 0, ""), |
| }); |
| mDatabase.getMapper().clearMapping(); |
| |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 300, "Device", "Storage", 3000, 0, ""), |
| }); |
| mDatabase.getMapper().stopAddingRootDocuments(0); |
| |
| { |
| final Cursor cursor = mDatabase.queryRootDocuments(columns); |
| assertEquals(1, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("documentId", 1, cursor.getInt(0)); |
| assertEquals("storageId", 300, cursor.getInt(1)); |
| assertEquals("name", "Device Storage", cursor.getString(2)); |
| cursor.close(); |
| } |
| { |
| final Cursor cursor = mDatabase.queryRoots(rootColumns); |
| assertEquals(1, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("rootId", 1, cursor.getInt(0)); |
| assertEquals("availableBytes", 3000, cursor.getInt(1)); |
| cursor.close(); |
| } |
| } |
| |
| public void testPutSameNameRootsAfterClearing() throws Exception { |
| final String[] columns = new String[] { |
| DocumentsContract.Document.COLUMN_DOCUMENT_ID, |
| MtpDatabaseConstants.COLUMN_STORAGE_ID, |
| DocumentsContract.Document.COLUMN_DISPLAY_NAME |
| }; |
| final String[] rootColumns = new String[] { |
| Root.COLUMN_ROOT_ID, |
| Root.COLUMN_AVAILABLE_BYTES |
| }; |
| |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 100, "Device", "Storage", 0, 0, ""), |
| }); |
| mDatabase.getMapper().clearMapping(); |
| |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 200, "Device", "Storage", 2000, 0, ""), |
| new MtpRoot(0, 201, "Device", "Storage", 2001, 0, ""), |
| }); |
| mDatabase.getMapper().stopAddingRootDocuments(0); |
| |
| { |
| final Cursor cursor = mDatabase.queryRootDocuments(columns); |
| assertEquals(2, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("documentId", 2, cursor.getInt(0)); |
| assertEquals("storageId", 200, cursor.getInt(1)); |
| assertEquals("name", "Device Storage", cursor.getString(2)); |
| cursor.moveToNext(); |
| assertEquals("documentId", 3, cursor.getInt(0)); |
| assertEquals("storageId", 201, cursor.getInt(1)); |
| assertEquals("name", "Device Storage", cursor.getString(2)); |
| cursor.close(); |
| } |
| { |
| final Cursor cursor = mDatabase.queryRoots(rootColumns); |
| assertEquals(2, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("rootId", 2, cursor.getInt(0)); |
| assertEquals("availableBytes", 2000, cursor.getInt(1)); |
| cursor.moveToNext(); |
| assertEquals("rootId", 3, cursor.getInt(0)); |
| assertEquals("availableBytes", 2001, cursor.getInt(1)); |
| cursor.close(); |
| } |
| } |
| |
| public void testReplaceExistingRoots() { |
| // The client code should be able to replace existing rows with new information. |
| // Add one. |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 100, "Device", "Storage A", 0, 0, ""), |
| }); |
| mDatabase.getMapper().stopAddingRootDocuments(0); |
| // Replace it. |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 100, "Device", "Storage B", 1000, 1000, ""), |
| }); |
| mDatabase.getMapper().stopAddingRootDocuments(0); |
| { |
| final String[] columns = new String[] { |
| DocumentsContract.Document.COLUMN_DOCUMENT_ID, |
| MtpDatabaseConstants.COLUMN_STORAGE_ID, |
| DocumentsContract.Document.COLUMN_DISPLAY_NAME |
| }; |
| final Cursor cursor = mDatabase.queryRootDocuments(columns); |
| assertEquals(1, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("documentId", 1, cursor.getInt(0)); |
| assertEquals("storageId", 100, cursor.getInt(1)); |
| assertEquals("name", "Device Storage B", cursor.getString(2)); |
| cursor.close(); |
| } |
| { |
| final String[] columns = new String[] { |
| Root.COLUMN_ROOT_ID, |
| Root.COLUMN_AVAILABLE_BYTES |
| }; |
| final Cursor cursor = mDatabase.queryRoots(columns); |
| assertEquals(1, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("rootId", 1, cursor.getInt(0)); |
| assertEquals("availableBytes", 1000, cursor.getInt(1)); |
| cursor.close(); |
| } |
| } |
| |
| public void testFailToReplaceExisitingUnmappedRoots() { |
| // The client code should not be able to replace rows before resolving 'unmapped' rows. |
| // Add one. |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 100, "Device", "Storage A", 0, 0, ""), |
| }); |
| mDatabase.getMapper().clearMapping(); |
| final Cursor oldCursor = mDatabase.queryRoots(strings(Root.COLUMN_ROOT_ID)); |
| assertEquals(1, oldCursor.getCount()); |
| |
| // Add one. |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 101, "Device", "Storage B", 1000, 1000, ""), |
| }); |
| // Add one more before resolving unmapped documents. |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 102, "Device", "Storage B", 1000, 1000, ""), |
| }); |
| mDatabase.getMapper().stopAddingRootDocuments(0); |
| |
| // Because the roots shares the same name, the roots should have new IDs. |
| final Cursor newCursor = mDatabase.queryRoots(strings(Root.COLUMN_ROOT_ID)); |
| assertEquals(2, newCursor.getCount()); |
| oldCursor.moveToNext(); |
| newCursor.moveToNext(); |
| assertFalse(oldCursor.getString(0).equals(newCursor.getString(0))); |
| newCursor.moveToNext(); |
| assertFalse(oldCursor.getString(0).equals(newCursor.getString(0))); |
| |
| oldCursor.close(); |
| newCursor.close(); |
| } |
| |
| public void testQueryDocument() { |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 100, "Device", "Storage A", 0, 0, ""), |
| }); |
| mDatabase.getMapper().stopAddingRootDocuments(0); |
| |
| final Cursor cursor = mDatabase.queryDocument("1", strings(Document.COLUMN_DISPLAY_NAME)); |
| assertEquals(1, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("Device Storage A", cursor.getString(0)); |
| cursor.close(); |
| } |
| |
| public void testGetParentId() throws FileNotFoundException { |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 100, "Device", "Storage A", 0, 0, ""), |
| }); |
| mDatabase.getMapper().stopAddingRootDocuments(0); |
| |
| mDatabase.getMapper().startAddingChildDocuments("1"); |
| mDatabase.getMapper().putChildDocuments( |
| 0, |
| "1", |
| new MtpObjectInfo[] { |
| createDocument(200, "note.txt", MtpConstants.FORMAT_TEXT, 1024), |
| }); |
| mDatabase.getMapper().stopAddingChildDocuments("1"); |
| |
| assertEquals("1", mDatabase.getParentId("2")); |
| } |
| |
| public void testDeleteDocument() { |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 100, "Device", "Storage A", 0, 0, ""), |
| }); |
| mDatabase.getMapper().stopAddingRootDocuments(0); |
| |
| mDatabase.getMapper().startAddingChildDocuments("1"); |
| mDatabase.getMapper().putChildDocuments( |
| 0, |
| "1", |
| new MtpObjectInfo[] { |
| createDocument(200, "dir", MtpConstants.FORMAT_ASSOCIATION, 1024), |
| }); |
| mDatabase.getMapper().stopAddingChildDocuments("1"); |
| |
| mDatabase.getMapper().startAddingChildDocuments("2"); |
| mDatabase.getMapper().putChildDocuments( |
| 0, |
| "2", |
| new MtpObjectInfo[] { |
| createDocument(200, "note.txt", MtpConstants.FORMAT_TEXT, 1024), |
| }); |
| mDatabase.getMapper().stopAddingChildDocuments("2"); |
| |
| mDatabase.deleteDocument("2"); |
| |
| { |
| // Do not query deleted documents. |
| final Cursor cursor = |
| mDatabase.queryChildDocuments(strings(Document.COLUMN_DOCUMENT_ID), "1"); |
| assertEquals(0, cursor.getCount()); |
| cursor.close(); |
| } |
| |
| { |
| // Child document should be deleted also. |
| final Cursor cursor = |
| mDatabase.queryDocument("3", strings(Document.COLUMN_DOCUMENT_ID)); |
| assertEquals(0, cursor.getCount()); |
| cursor.close(); |
| } |
| } |
| |
| public void testPutNewDocument() { |
| mDatabase.getMapper().startAddingRootDocuments(0); |
| mDatabase.getMapper().putRootDocuments(0, resources, new MtpRoot[] { |
| new MtpRoot(0, 100, "Device", "Storage A", 0, 0, ""), |
| }); |
| mDatabase.getMapper().stopAddingRootDocuments(0); |
| |
| assertEquals( |
| "2", |
| mDatabase.putNewDocument( |
| 0, "1", createDocument(200, "note.txt", MtpConstants.FORMAT_TEXT, 1024))); |
| |
| { |
| final Cursor cursor = |
| mDatabase.queryChildDocuments(strings(Document.COLUMN_DOCUMENT_ID), "1"); |
| assertEquals(1, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("2", cursor.getString(0)); |
| cursor.close(); |
| } |
| |
| // The new document should not be mapped with existing invalidated document. |
| mDatabase.getMapper().clearMapping(); |
| mDatabase.getMapper().startAddingChildDocuments("1"); |
| mDatabase.putNewDocument( |
| 0, |
| "1", |
| createDocument(201, "note.txt", MtpConstants.FORMAT_TEXT, 1024)); |
| mDatabase.getMapper().stopAddingChildDocuments("1"); |
| |
| { |
| final Cursor cursor = |
| mDatabase.queryChildDocuments(strings(Document.COLUMN_DOCUMENT_ID), "1"); |
| assertEquals(1, cursor.getCount()); |
| cursor.moveToNext(); |
| assertEquals("3", cursor.getString(0)); |
| cursor.close(); |
| } |
| } |
| } |