MtpDatabaseTest.java revision 18d70d5b7c46d2a35f66a6a76ba319eacf62e6c6 
1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.mtp;
18
19import android.database.Cursor;
20import android.mtp.MtpConstants;
21import android.mtp.MtpObjectInfo;
22import android.provider.DocumentsContract;
23import android.provider.DocumentsContract.Root;
24import android.test.AndroidTestCase;
25import android.test.suitebuilder.annotation.SmallTest;
26
27@SmallTest
28public class MtpDatabaseTest extends AndroidTestCase {
29    private final String[] COLUMN_NAMES = new String[] {
30        DocumentsContract.Document.COLUMN_DOCUMENT_ID,
31        MtpDatabaseConstants.COLUMN_DEVICE_ID,
32        MtpDatabaseConstants.COLUMN_STORAGE_ID,
33        MtpDatabaseConstants.COLUMN_OBJECT_HANDLE,
34        DocumentsContract.Document.COLUMN_MIME_TYPE,
35        DocumentsContract.Document.COLUMN_DISPLAY_NAME,
36        DocumentsContract.Document.COLUMN_SUMMARY,
37        DocumentsContract.Document.COLUMN_LAST_MODIFIED,
38        DocumentsContract.Document.COLUMN_ICON,
39        DocumentsContract.Document.COLUMN_FLAGS,
40        DocumentsContract.Document.COLUMN_SIZE
41    };
42
43    private final TestResources resources = new TestResources();
44
45    public void testPutRootDocuments() throws Exception {
46        final MtpDatabase database = new MtpDatabase(getContext());
47        database.startAddingRootDocuments(0);
48        database.putRootDocuments(0, resources, new MtpRoot[] {
49                new MtpRoot(0, 1, "Device", "Storage", 1000, 2000, ""),
50                new MtpRoot(0, 2, "Device", "Storage", 2000, 4000, ""),
51                new MtpRoot(0, 3, "Device", "/@#%&<>Storage", 3000, 6000,"")
52        });
53
54        {
55            final Cursor cursor = database.queryRootDocuments(COLUMN_NAMES);
56            assertEquals(3, cursor.getCount());
57
58            cursor.moveToNext();
59            assertEquals("documentId", 1, cursor.getInt(0));
60            assertEquals("deviceId", 0, cursor.getInt(1));
61            assertEquals("storageId", 1, cursor.getInt(2));
62            assertTrue("objectHandle", cursor.isNull(3));
63            assertEquals("mimeType", DocumentsContract.Document.MIME_TYPE_DIR, cursor.getString(4));
64            assertEquals("displayName", "Device Storage", cursor.getString(5));
65            assertTrue("summary", cursor.isNull(6));
66            assertTrue("lastModified", cursor.isNull(7));
67            assertTrue("icon", cursor.isNull(8));
68            assertEquals("flag", 0, cursor.getInt(9));
69            assertEquals("size", 1000, cursor.getInt(10));
70
71            cursor.moveToNext();
72            assertEquals("documentId", 2, cursor.getInt(0));
73            assertEquals("displayName", "Device Storage", cursor.getString(5));
74
75            cursor.moveToNext();
76            assertEquals("documentId", 3, cursor.getInt(0));
77            assertEquals("displayName", "Device /@#%&<>Storage", cursor.getString(5));
78
79            cursor.close();
80        }
81
82        {
83            final Cursor cursor = database.queryRoots(new String [] {
84                    Root.COLUMN_ROOT_ID,
85                    Root.COLUMN_FLAGS,
86                    Root.COLUMN_ICON,
87                    Root.COLUMN_TITLE,
88                    Root.COLUMN_SUMMARY,
89                    Root.COLUMN_DOCUMENT_ID,
90                    Root.COLUMN_AVAILABLE_BYTES,
91                    Root.COLUMN_CAPACITY_BYTES
92            });
93            assertEquals(3, cursor.getCount());
94
95            cursor.moveToNext();
96            assertEquals(1, cursor.getInt(0));
97            assertEquals(Root.FLAG_SUPPORTS_IS_CHILD | Root.FLAG_SUPPORTS_CREATE, cursor.getInt(1));
98            assertTrue(cursor.isNull(2));
99            assertEquals("Device Storage", cursor.getString(3));
100            assertTrue(cursor.isNull(4));
101            assertEquals(1, cursor.getInt(5));
102            assertEquals(1000, cursor.getInt(6));
103            assertEquals(2000, cursor.getInt(7));
104
105            cursor.moveToNext();
106            assertEquals(2, cursor.getInt(0));
107            assertEquals(Root.FLAG_SUPPORTS_IS_CHILD | Root.FLAG_SUPPORTS_CREATE, cursor.getInt(1));
108            assertTrue(cursor.isNull(2));
109            assertEquals("Device Storage", cursor.getString(3));
110            assertTrue(cursor.isNull(4));
111            assertEquals(2, cursor.getInt(5));
112            assertEquals(2000, cursor.getInt(6));
113            assertEquals(4000, cursor.getInt(7));
114
115            cursor.moveToNext();
116            assertEquals(3, cursor.getInt(0));
117            assertEquals(Root.FLAG_SUPPORTS_IS_CHILD | Root.FLAG_SUPPORTS_CREATE, cursor.getInt(1));
118            assertTrue(cursor.isNull(2));
119            assertEquals("Device /@#%&<>Storage", cursor.getString(3));
120            assertTrue(cursor.isNull(4));
121            assertEquals(3, cursor.getInt(5));
122            assertEquals(3000, cursor.getInt(6));
123            assertEquals(6000, cursor.getInt(7));
124
125            cursor.close();
126        }
127    }
128
129    private MtpObjectInfo createDocument(int objectHandle, String name, int format, int size) {
130        final MtpObjectInfo.Builder builder = new MtpObjectInfo.Builder();
131        builder.setObjectHandle(objectHandle);
132        builder.setName(name);
133        builder.setFormat(format);
134        builder.setCompressedSize(size);
135        return builder.build();
136    }
137
138    public void testPutChildDocuments() throws Exception {
139        final MtpDatabase database = new MtpDatabase(getContext());
140        database.startAddingChildDocuments("parentId");
141        database.putChildDocuments(0, "parentId", new MtpObjectInfo[] {
142                createDocument(100, "note.txt", MtpConstants.FORMAT_TEXT, 1024),
143                createDocument(101, "image.jpg", MtpConstants.FORMAT_EXIF_JPEG, 2 * 1024 * 1024),
144                createDocument(102, "music.mp3", MtpConstants.FORMAT_MP3, 3 * 1024 * 1024)
145        });
146
147        final Cursor cursor = database.queryChildDocuments(COLUMN_NAMES, "parentId");
148        assertEquals(3, cursor.getCount());
149
150        cursor.moveToNext();
151        assertEquals("documentId", 1, cursor.getInt(0));
152        assertEquals("deviceId", 0, cursor.getInt(1));
153        assertEquals("storageId", 0, cursor.getInt(2));
154        assertEquals("objectHandle", 100, cursor.getInt(3));
155        assertEquals("mimeType", "text/plain", cursor.getString(4));
156        assertEquals("displayName", "note.txt", cursor.getString(5));
157        assertTrue("summary", cursor.isNull(6));
158        assertTrue("lastModified", cursor.isNull(7));
159        assertTrue("icon", cursor.isNull(8));
160        assertEquals(
161                "flag",
162                DocumentsContract.Document.FLAG_SUPPORTS_DELETE |
163                DocumentsContract.Document.FLAG_SUPPORTS_WRITE,
164                cursor.getInt(9));
165        assertEquals("size", 1024, cursor.getInt(10));
166
167        cursor.moveToNext();
168        assertEquals("documentId", 2, cursor.getInt(0));
169        assertEquals("deviceId", 0, cursor.getInt(1));
170        assertEquals("storageId", 0, cursor.getInt(2));
171        assertEquals("objectHandle", 101, cursor.getInt(3));
172        assertEquals("mimeType", "image/jpeg", cursor.getString(4));
173        assertEquals("displayName", "image.jpg", cursor.getString(5));
174        assertTrue("summary", cursor.isNull(6));
175        assertTrue("lastModified", cursor.isNull(7));
176        assertTrue("icon", cursor.isNull(8));
177        assertEquals(
178                "flag",
179                DocumentsContract.Document.FLAG_SUPPORTS_DELETE |
180                DocumentsContract.Document.FLAG_SUPPORTS_WRITE,
181                cursor.getInt(9));
182        assertEquals("size", 2 * 1024 * 1024, cursor.getInt(10));
183
184        cursor.moveToNext();
185        assertEquals("documentId", 3, cursor.getInt(0));
186        assertEquals("deviceId", 0, cursor.getInt(1));
187        assertEquals("storageId", 0, cursor.getInt(2));
188        assertEquals("objectHandle", 102, cursor.getInt(3));
189        assertEquals("mimeType", "audio/mpeg", cursor.getString(4));
190        assertEquals("displayName", "music.mp3", cursor.getString(5));
191        assertTrue("summary", cursor.isNull(6));
192        assertTrue("lastModified", cursor.isNull(7));
193        assertTrue("icon", cursor.isNull(8));
194        assertEquals(
195                "flag",
196                DocumentsContract.Document.FLAG_SUPPORTS_DELETE |
197                DocumentsContract.Document.FLAG_SUPPORTS_WRITE,
198                cursor.getInt(9));
199        assertEquals("size", 3 * 1024 * 1024, cursor.getInt(10));
200
201        cursor.close();
202    }
203
204    public void testRestoreIdForRootDocuments() throws Exception {
205        final MtpDatabase database = new MtpDatabase(getContext());
206        final String[] columns = new String[] {
207                DocumentsContract.Document.COLUMN_DOCUMENT_ID,
208                MtpDatabaseConstants.COLUMN_STORAGE_ID,
209                DocumentsContract.Document.COLUMN_DISPLAY_NAME
210        };
211        final String[] rootColumns = new String[] {
212                Root.COLUMN_ROOT_ID,
213                Root.COLUMN_AVAILABLE_BYTES
214        };
215        database.startAddingRootDocuments(0);
216        database.putRootDocuments(0, resources, new MtpRoot[] {
217                new MtpRoot(0, 100, "Device", "Storage A", 1000, 0, ""),
218                new MtpRoot(0, 101, "Device", "Storage B", 1001, 0, "")
219        });
220
221        {
222            final Cursor cursor = database.queryRootDocuments(columns);
223            assertEquals(2, cursor.getCount());
224            cursor.moveToNext();
225            assertEquals("documentId", 1, cursor.getInt(0));
226            assertEquals("storageId", 100, cursor.getInt(1));
227            assertEquals("name", "Device Storage A", cursor.getString(2));
228            cursor.moveToNext();
229            assertEquals("documentId", 2, cursor.getInt(0));
230            assertEquals("storageId", 101, cursor.getInt(1));
231            assertEquals("name", "Device Storage B", cursor.getString(2));
232            cursor.close();
233        }
234
235        {
236            final Cursor cursor = database.queryRoots(rootColumns);
237            assertEquals(2, cursor.getCount());
238            cursor.moveToNext();
239            assertEquals("rootId", 1, cursor.getInt(0));
240            assertEquals("availableBytes", 1000, cursor.getInt(1));
241            cursor.moveToNext();
242            assertEquals("rootId", 2, cursor.getInt(0));
243            assertEquals("availableBytes", 1001, cursor.getInt(1));
244            cursor.close();
245        }
246
247        database.clearMapping();
248
249        {
250            final Cursor cursor = database.queryRootDocuments(columns);
251            assertEquals(2, cursor.getCount());
252            cursor.moveToNext();
253            assertEquals("documentId", 1, cursor.getInt(0));
254            assertTrue("storageId", cursor.isNull(1));
255            assertEquals("name", "Device Storage A", cursor.getString(2));
256            cursor.moveToNext();
257            assertEquals("documentId", 2, cursor.getInt(0));
258            assertTrue("storageId", cursor.isNull(1));
259            assertEquals("name", "Device Storage B", cursor.getString(2));
260            cursor.close();
261        }
262
263        {
264            final Cursor cursor = database.queryRoots(rootColumns);
265            assertEquals(2, cursor.getCount());
266            cursor.moveToNext();
267            assertEquals("rootId", 1, cursor.getInt(0));
268            assertEquals("availableBytes", 1000, cursor.getInt(1));
269            cursor.moveToNext();
270            assertEquals("rootId", 2, cursor.getInt(0));
271            assertEquals("availableBytes", 1001, cursor.getInt(1));
272            cursor.close();
273        }
274
275        database.startAddingRootDocuments(0);
276        database.putRootDocuments(0, resources, new MtpRoot[] {
277                new MtpRoot(0, 200, "Device", "Storage A", 2000, 0, ""),
278                new MtpRoot(0, 202, "Device", "Storage C", 2002, 0, "")
279        });
280
281        {
282            final Cursor cursor = database.queryRootDocuments(columns);
283            assertEquals(3, cursor.getCount());
284            cursor.moveToNext();
285            assertEquals("documentId", 1, cursor.getInt(0));
286            assertTrue("storageId", cursor.isNull(1));
287            assertEquals("name", "Device Storage A", cursor.getString(2));
288            cursor.moveToNext();
289            assertEquals("documentId", 2, cursor.getInt(0));
290            assertTrue("storageId", cursor.isNull(1));
291            assertEquals("name", "Device Storage B", cursor.getString(2));
292            cursor.moveToNext();
293            assertEquals("documentId", 4, cursor.getInt(0));
294            assertEquals("storageId", 202, cursor.getInt(1));
295            assertEquals("name", "Device Storage C", cursor.getString(2));
296            cursor.close();
297        }
298
299        {
300            final Cursor cursor = database.queryRoots(rootColumns);
301            assertEquals(3, cursor.getCount());
302            cursor.moveToNext();
303            assertEquals("rootId", 1, cursor.getInt(0));
304            assertEquals("availableBytes", 1000, cursor.getInt(1));
305            cursor.moveToNext();
306            assertEquals("rootId", 2, cursor.getInt(0));
307            assertEquals("availableBytes", 1001, cursor.getInt(1));
308            cursor.moveToNext();
309            assertEquals("rootId", 4, cursor.getInt(0));
310            assertEquals("availableBytes", 2002, cursor.getInt(1));
311            cursor.close();
312        }
313
314        database.stopAddingRootDocuments(0);
315
316        {
317            final Cursor cursor = database.queryRootDocuments(columns);
318            assertEquals(2, cursor.getCount());
319            cursor.moveToNext();
320            assertEquals("documentId", 1, cursor.getInt(0));
321            assertEquals("storageId", 200, cursor.getInt(1));
322            assertEquals("name", "Device Storage A", cursor.getString(2));
323            cursor.moveToNext();
324            assertEquals("documentId", 4, cursor.getInt(0));
325            assertEquals("storageId", 202, cursor.getInt(1));
326            assertEquals("name", "Device Storage C", cursor.getString(2));
327            cursor.close();
328        }
329
330        {
331            final Cursor cursor = database.queryRoots(rootColumns);
332            assertEquals(2, cursor.getCount());
333            cursor.moveToNext();
334            assertEquals("rootId", 1, cursor.getInt(0));
335            assertEquals("availableBytes", 2000, cursor.getInt(1));
336            cursor.moveToNext();
337            assertEquals("rootId", 4, cursor.getInt(0));
338            assertEquals("availableBytes", 2002, cursor.getInt(1));
339            cursor.close();
340        }
341    }
342
343    public void testRestoreIdForChildDocuments() throws Exception {
344        final MtpDatabase database = new MtpDatabase(getContext());
345        final String[] columns = new String[] {
346                DocumentsContract.Document.COLUMN_DOCUMENT_ID,
347                MtpDatabaseConstants.COLUMN_OBJECT_HANDLE,
348                DocumentsContract.Document.COLUMN_DISPLAY_NAME
349        };
350        database.startAddingChildDocuments("parentId");
351        database.putChildDocuments(0, "parentId", new MtpObjectInfo[] {
352                createDocument(100, "note.txt", MtpConstants.FORMAT_TEXT, 1024),
353                createDocument(101, "image.jpg", MtpConstants.FORMAT_EXIF_JPEG, 2 * 1024 * 1024),
354                createDocument(102, "music.mp3", MtpConstants.FORMAT_MP3, 3 * 1024 * 1024)
355        });
356        database.clearMapping();
357
358        {
359            final Cursor cursor = database.queryChildDocuments(columns, "parentId");
360            assertEquals(3, cursor.getCount());
361
362            cursor.moveToNext();
363            assertEquals("documentId", 1, cursor.getInt(0));
364            assertTrue("objectHandle", cursor.isNull(1));
365            assertEquals("name", "note.txt", cursor.getString(2));
366
367            cursor.moveToNext();
368            assertEquals("documentId", 2, cursor.getInt(0));
369            assertTrue("objectHandle", cursor.isNull(1));
370            assertEquals("name", "image.jpg", cursor.getString(2));
371
372            cursor.moveToNext();
373            assertEquals("documentId", 3, cursor.getInt(0));
374            assertTrue("objectHandle", cursor.isNull(1));
375            assertEquals("name", "music.mp3", cursor.getString(2));
376
377            cursor.close();
378        }
379
380        database.startAddingChildDocuments("parentId");
381        database.putChildDocuments(0, "parentId", new MtpObjectInfo[] {
382                createDocument(200, "note.txt", MtpConstants.FORMAT_TEXT, 1024),
383                createDocument(203, "video.mp4", MtpConstants.FORMAT_MP4_CONTAINER, 1024),
384        });
385
386        {
387            final Cursor cursor = database.queryChildDocuments(columns, "parentId");
388            assertEquals(4, cursor.getCount());
389
390            cursor.moveToPosition(3);
391            assertEquals("documentId", 5, cursor.getInt(0));
392            assertEquals("objectHandle", 203, cursor.getInt(1));
393            assertEquals("name", "video.mp4", cursor.getString(2));
394
395            cursor.close();
396        }
397
398        database.stopAddingChildDocuments("parentId");
399
400        {
401            final Cursor cursor = database.queryChildDocuments(columns, "parentId");
402            assertEquals(2, cursor.getCount());
403
404            cursor.moveToNext();
405            assertEquals("documentId", 1, cursor.getInt(0));
406            assertEquals("objectHandle", 200, cursor.getInt(1));
407            assertEquals("name", "note.txt", cursor.getString(2));
408
409            cursor.moveToNext();
410            assertEquals("documentId", 5, cursor.getInt(0));
411            assertEquals("objectHandle", 203, cursor.getInt(1));
412            assertEquals("name", "video.mp4", cursor.getString(2));
413            cursor.close();
414        }
415    }
416
417    public void testRestoreIdForDifferentDevices() throws Exception {
418        final MtpDatabase database = new MtpDatabase(getContext());
419        final String[] columns = new String[] {
420                DocumentsContract.Document.COLUMN_DOCUMENT_ID,
421                MtpDatabaseConstants.COLUMN_STORAGE_ID,
422                DocumentsContract.Document.COLUMN_DISPLAY_NAME
423        };
424        final String[] rootColumns = new String[] {
425                Root.COLUMN_ROOT_ID,
426                Root.COLUMN_AVAILABLE_BYTES
427        };
428        database.startAddingRootDocuments(0);
429        database.startAddingRootDocuments(1);
430        database.putRootDocuments(0, resources, new MtpRoot[] {
431                new MtpRoot(0, 100, "Device", "Storage", 0, 0, "")
432        });
433        database.putRootDocuments(1, resources, new MtpRoot[] {
434                new MtpRoot(1, 100, "Device", "Storage", 0, 0, "")
435        });
436
437        {
438            final Cursor cursor = database.queryRootDocuments(columns);
439            assertEquals(2, cursor.getCount());
440            cursor.moveToNext();
441            assertEquals("documentId", 1, cursor.getInt(0));
442            assertEquals("storageId", 100, cursor.getInt(1));
443            assertEquals("name", "Device Storage", cursor.getString(2));
444            cursor.moveToNext();
445            assertEquals("documentId", 2, cursor.getInt(0));
446            assertEquals("storageId", 100, cursor.getInt(1));
447            assertEquals("name", "Device Storage", cursor.getString(2));
448            cursor.close();
449        }
450
451        {
452            final Cursor cursor = database.queryRoots(rootColumns);
453            assertEquals(2, cursor.getCount());
454            cursor.moveToNext();
455            assertEquals("rootId", 1, cursor.getInt(0));
456            assertEquals("availableBytes", 0, cursor.getInt(1));
457            cursor.moveToNext();
458            assertEquals("rootId", 2, cursor.getInt(0));
459            assertEquals("availableBytes", 0, cursor.getInt(1));
460            cursor.close();
461        }
462
463        database.clearMapping();
464
465        database.startAddingRootDocuments(0);
466        database.startAddingRootDocuments(1);
467        database.putRootDocuments(0, resources, new MtpRoot[] {
468                new MtpRoot(0, 200, "Device", "Storage", 2000, 0, "")
469        });
470        database.putRootDocuments(1, resources, new MtpRoot[] {
471                new MtpRoot(1, 300, "Device", "Storage", 3000, 0, "")
472        });
473        database.stopAddingRootDocuments(0);
474        database.stopAddingRootDocuments(1);
475
476        {
477            final Cursor cursor = database.queryRootDocuments(columns);
478            assertEquals(2, cursor.getCount());
479            cursor.moveToNext();
480            assertEquals("documentId", 1, cursor.getInt(0));
481            assertEquals("storageId", 200, cursor.getInt(1));
482            assertEquals("name", "Device Storage", cursor.getString(2));
483            cursor.moveToNext();
484            assertEquals("documentId", 2, cursor.getInt(0));
485            assertEquals("storageId", 300, cursor.getInt(1));
486            assertEquals("name", "Device Storage", cursor.getString(2));
487            cursor.close();
488        }
489
490        {
491            final Cursor cursor = database.queryRoots(rootColumns);
492            assertEquals(2, cursor.getCount());
493            cursor.moveToNext();
494            assertEquals("rootId", 1, cursor.getInt(0));
495            assertEquals("availableBytes", 2000, cursor.getInt(1));
496            cursor.moveToNext();
497            assertEquals("rootId", 2, cursor.getInt(0));
498            assertEquals("availableBytes", 3000, cursor.getInt(1));
499            cursor.close();
500        }
501    }
502
503    public void testRestoreIdForDifferentParents() throws Exception {
504        final MtpDatabase database = new MtpDatabase(getContext());
505        final String[] columns = new String[] {
506                DocumentsContract.Document.COLUMN_DOCUMENT_ID,
507                MtpDatabaseConstants.COLUMN_OBJECT_HANDLE
508        };
509
510        database.startAddingChildDocuments("parentId1");
511        database.startAddingChildDocuments("parentId2");
512        database.putChildDocuments(0, "parentId1", new MtpObjectInfo[] {
513                createDocument(100, "note.txt", MtpConstants.FORMAT_TEXT, 1024),
514        });
515        database.putChildDocuments(0, "parentId2", new MtpObjectInfo[] {
516                createDocument(101, "note.txt", MtpConstants.FORMAT_TEXT, 1024),
517        });
518        database.clearMapping();
519
520        database.startAddingChildDocuments("parentId1");
521        database.startAddingChildDocuments("parentId2");
522        database.putChildDocuments(0, "parentId1", new MtpObjectInfo[] {
523                createDocument(200, "note.txt", MtpConstants.FORMAT_TEXT, 1024),
524        });
525        database.putChildDocuments(0, "parentId2", new MtpObjectInfo[] {
526                createDocument(201, "note.txt", MtpConstants.FORMAT_TEXT, 1024),
527        });
528        database.stopAddingChildDocuments("parentId1");
529
530        {
531            final Cursor cursor = database.queryChildDocuments(columns, "parentId1");
532            assertEquals(1, cursor.getCount());
533            cursor.moveToNext();
534            assertEquals("documentId", 1, cursor.getInt(0));
535            assertEquals("objectHandle", 200, cursor.getInt(1));
536            cursor.close();
537        }
538        {
539            final Cursor cursor = database.queryChildDocuments(columns, "parentId2");
540            assertEquals(1, cursor.getCount());
541            cursor.moveToNext();
542            assertEquals("documentId", 2, cursor.getInt(0));
543            assertTrue("objectHandle", cursor.isNull(1));
544            cursor.close();
545        }
546    }
547
548    public void testClearMtpIdentifierBeforeResolveRootDocuments() {
549        final MtpDatabase database = new MtpDatabase(getContext());
550        final String[] columns = new String[] {
551                DocumentsContract.Document.COLUMN_DOCUMENT_ID,
552                MtpDatabaseConstants.COLUMN_STORAGE_ID,
553                DocumentsContract.Document.COLUMN_DISPLAY_NAME
554        };
555        final String[] rootColumns = new String[] {
556                Root.COLUMN_ROOT_ID,
557                Root.COLUMN_AVAILABLE_BYTES
558        };
559
560        database.startAddingRootDocuments(0);
561        database.putRootDocuments(0, resources, new MtpRoot[] {
562                new MtpRoot(0, 100, "Device", "Storage", 0, 0, ""),
563        });
564        database.clearMapping();
565
566        database.startAddingRootDocuments(0);
567        database.putRootDocuments(0, resources, new MtpRoot[] {
568                new MtpRoot(0, 200, "Device", "Storage", 2000, 0, ""),
569        });
570        database.clearMapping();
571
572        database.startAddingRootDocuments(0);
573        database.putRootDocuments(0, resources, new MtpRoot[] {
574                new MtpRoot(0, 300, "Device", "Storage", 3000, 0, ""),
575        });
576        database.stopAddingRootDocuments(0);
577
578        {
579            final Cursor cursor = database.queryRootDocuments(columns);
580            assertEquals(1, cursor.getCount());
581            cursor.moveToNext();
582            assertEquals("documentId", 1, cursor.getInt(0));
583            assertEquals("storageId", 300, cursor.getInt(1));
584            assertEquals("name", "Device Storage", cursor.getString(2));
585            cursor.close();
586        }
587        {
588            final Cursor cursor = database.queryRoots(rootColumns);
589            assertEquals(1, cursor.getCount());
590            cursor.moveToNext();
591            assertEquals("rootId", 1, cursor.getInt(0));
592            assertEquals("availableBytes", 3000, cursor.getInt(1));
593            cursor.close();
594        }
595    }
596
597    public void testPutSameNameRootsAfterClearing() throws Exception {
598        final MtpDatabase database = new MtpDatabase(getContext());
599        final String[] columns = new String[] {
600                DocumentsContract.Document.COLUMN_DOCUMENT_ID,
601                MtpDatabaseConstants.COLUMN_STORAGE_ID,
602                DocumentsContract.Document.COLUMN_DISPLAY_NAME
603        };
604        final String[] rootColumns = new String[] {
605                Root.COLUMN_ROOT_ID,
606                Root.COLUMN_AVAILABLE_BYTES
607        };
608
609        database.startAddingRootDocuments(0);
610        database.putRootDocuments(0, resources, new MtpRoot[] {
611                new MtpRoot(0, 100, "Device", "Storage", 0, 0, ""),
612        });
613        database.clearMapping();
614
615        database.startAddingRootDocuments(0);
616        database.putRootDocuments(0, resources, new MtpRoot[] {
617                new MtpRoot(0, 200, "Device", "Storage", 2000, 0, ""),
618                new MtpRoot(0, 201, "Device", "Storage", 2001, 0, ""),
619        });
620        database.stopAddingRootDocuments(0);
621
622        {
623            final Cursor cursor = database.queryRootDocuments(columns);
624            assertEquals(2, cursor.getCount());
625            cursor.moveToNext();
626            assertEquals("documentId", 2, cursor.getInt(0));
627            assertEquals("storageId", 200, cursor.getInt(1));
628            assertEquals("name", "Device Storage", cursor.getString(2));
629            cursor.moveToNext();
630            assertEquals("documentId", 3, cursor.getInt(0));
631            assertEquals("storageId", 201, cursor.getInt(1));
632            assertEquals("name", "Device Storage", cursor.getString(2));
633            cursor.close();
634        }
635        {
636            final Cursor cursor = database.queryRoots(rootColumns);
637            assertEquals(2, cursor.getCount());
638            cursor.moveToNext();
639            assertEquals("rootId", 2, cursor.getInt(0));
640            assertEquals("availableBytes", 2000, cursor.getInt(1));
641            cursor.moveToNext();
642            assertEquals("rootId", 3, cursor.getInt(0));
643            assertEquals("availableBytes", 2001, cursor.getInt(1));
644            cursor.close();
645        }
646    }
647
648    public void testReplaceExistingRoots() {
649        // The client code should be able to replace exisitng rows with new information.
650        final MtpDatabase database = new MtpDatabase(getContext());
651        // Add one.
652        database.startAddingRootDocuments(0);
653        database.putRootDocuments(0, resources, new MtpRoot[] {
654                new MtpRoot(0, 100, "Device", "Storage A", 0, 0, ""),
655        });
656        database.stopAddingRootDocuments(0);
657        // Replace it.
658        database.startAddingRootDocuments(0);
659        database.putRootDocuments(0, resources, new MtpRoot[] {
660                new MtpRoot(0, 100, "Device", "Storage B", 1000, 1000, ""),
661        });
662        database.stopAddingRootDocuments(0);
663        {
664            final String[] columns = new String[] {
665                    DocumentsContract.Document.COLUMN_DOCUMENT_ID,
666                    MtpDatabaseConstants.COLUMN_STORAGE_ID,
667                    DocumentsContract.Document.COLUMN_DISPLAY_NAME
668            };
669            final Cursor cursor = database.queryRootDocuments(columns);
670            assertEquals(1, cursor.getCount());
671            cursor.moveToNext();
672            assertEquals("documentId", 1, cursor.getInt(0));
673            assertEquals("storageId", 100, cursor.getInt(1));
674            assertEquals("name", "Device Storage B", cursor.getString(2));
675            cursor.close();
676        }
677        {
678            final String[] columns = new String[] {
679                    Root.COLUMN_ROOT_ID,
680                    Root.COLUMN_AVAILABLE_BYTES
681            };
682            final Cursor cursor = database.queryRoots(columns);
683            assertEquals(1, cursor.getCount());
684            cursor.moveToNext();
685            assertEquals("rootId", 1, cursor.getInt(0));
686            assertEquals("availableBytes", 1000, cursor.getInt(1));
687            cursor.close();
688        }
689    }
690
691    public void _testFailToReplaceExisitingUnmappedRoots() {
692        // The client code should not be able to replace rows before resolving 'unmapped' rows.
693        final MtpDatabase database = new MtpDatabase(getContext());
694        // Add one.
695        database.startAddingRootDocuments(0);
696        database.putRootDocuments(0, resources, new MtpRoot[] {
697                new MtpRoot(0, 100, "Device", "Storage A", 0, 0, ""),
698        });
699        database.clearMapping();
700        // Add one.
701        database.putRootDocuments(0, resources, new MtpRoot[] {
702                new MtpRoot(0, 100, "Device", "Storage B", 1000, 1000, ""),
703        });
704        // Add one more before resolving unmapped documents.
705        try {
706            database.putRootDocuments(0, resources, new MtpRoot[] {
707                    new MtpRoot(0, 100, "Device", "Storage B", 1000, 1000, ""),
708            });
709            fail();
710        } catch (Throwable e) {
711            assertTrue(e instanceof Error);
712        }
713    }
714}
715