1 /*
2  * Copyright (C) 2017 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 package android.mtp;
17 
18 import android.os.FileUtils;
19 import android.os.UserHandle;
20 import android.os.storage.StorageVolume;
21 import android.util.Log;
22 
23 import androidx.test.InstrumentationRegistry;
24 import androidx.test.filters.SmallTest;
25 
26 import org.junit.After;
27 import org.junit.Assert;
28 import org.junit.Before;
29 import org.junit.FixMethodOrder;
30 import org.junit.Test;
31 import org.junit.runner.RunWith;
32 import org.junit.runners.JUnit4;
33 import org.junit.runners.MethodSorters;
34 
35 import java.io.File;
36 import java.io.FileOutputStream;
37 import java.io.IOException;
38 import java.util.ArrayList;
39 import java.util.List;
40 import java.util.UUID;
41 
42 /**
43  * Tests for MtpStorageManager functionality.
44  */
45 @RunWith(JUnit4.class)
46 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
47 public class MtpStorageManagerTest {
48     private static final String TAG = MtpStorageManagerTest.class.getSimpleName();
49 
50     private static final String TEMP_DIR = InstrumentationRegistry.getContext().getFilesDir()
51             + "/" + TAG + "/";
52     private static final File TEMP_DIR_FILE = new File(TEMP_DIR);
53 
54     private MtpStorageManager manager;
55 
56     private ArrayList<Integer> objectsAdded;
57     private ArrayList<Integer> objectsRemoved;
58     private ArrayList<Integer> objectsInfoChanged;
59 
60     private File mainStorageDir;
61     private File secondaryStorageDir;
62 
63     private MtpStorage mainMtpStorage;
64     private MtpStorage secondaryMtpStorage;
65 
66     static {
67         MtpStorageManager.sDebug = true;
68     }
69 
logMethodName()70     private static void logMethodName() {
71         Log.d(TAG, Thread.currentThread().getStackTrace()[3].getMethodName());
72     }
73 
logMethodValue(String szVar, int iValue)74     private static void logMethodValue(String szVar, int iValue)
75     {
76         Log.d(TAG, szVar + "=" + iValue + ": " + Thread.currentThread().getStackTrace()[3].getMethodName());
77     }
78 
vWriteNewFile(File newFile)79     private static void vWriteNewFile(File newFile) {
80         try {
81             new FileOutputStream(newFile).write(new byte[] {0, 0, 0});
82         } catch (IOException e) {
83             Assert.fail();
84         }
85     }
86 
createNewFile(File parent)87     private static File createNewFile(File parent) {
88         return createNewFile(parent, "file-" + UUID.randomUUID().toString());
89     }
90 
createNewFileNonZero(File parent)91     private static File createNewFileNonZero(File parent) {
92         return createNewFileNonZero(parent, "file-" + UUID.randomUUID().toString());
93     }
94 
createNewFile(File parent, String name)95     private static File createNewFile(File parent, String name) {
96         return createNewFile(parent, name, false);
97     }
98 
createNewFileNonZero(File parent, String name)99     private static File createNewFileNonZero(File parent, String name) {
100         return createNewFile(parent, name, true);
101     }
102 
createNewFile(File parent, String name, boolean fgNonZero)103     private static File createNewFile(File parent, String name, boolean fgNonZero) {
104         try {
105             File ret = new File(parent, name);
106             if (!ret.createNewFile())
107                 throw new AssertionError("Failed to create file");
108             if (fgNonZero)
109                 vWriteNewFile(ret);     // create non-zero size file
110             return ret;
111         } catch (IOException e) {
112             throw new AssertionError(e.getMessage());
113         }
114     }
115 
createNewDir(File parent, String name)116     private static File createNewDir(File parent, String name) {
117         File ret = new File(parent, name);
118         if (!ret.mkdir())
119             throw new AssertionError("Failed to create file");
120         return ret;
121     }
122 
createNewDir(File parent)123     private static File createNewDir(File parent) {
124         return createNewDir(parent, "dir-" + UUID.randomUUID().toString());
125     }
126 
127     @Before
before()128     public void before() {
129         FileUtils.deleteContentsAndDir(TEMP_DIR_FILE);
130         Assert.assertTrue(TEMP_DIR_FILE.mkdir());
131         mainStorageDir = createNewDir(TEMP_DIR_FILE);
132         secondaryStorageDir = createNewDir(TEMP_DIR_FILE);
133 
134         StorageVolume mainStorage = new StorageVolume("1", mainStorageDir, mainStorageDir,
135                 "", true, false, true, false, false, -1, UserHandle.CURRENT, null /* uuid */, "",
136                 "");
137         StorageVolume secondaryStorage = new StorageVolume("2", secondaryStorageDir,
138                 secondaryStorageDir, "", false, false, true, false, false, -1, UserHandle.CURRENT,
139                 null /* uuid */, "", "");
140 
141         objectsAdded = new ArrayList<>();
142         objectsRemoved = new ArrayList<>();
143         objectsInfoChanged = new ArrayList<>();
144 
145         manager = new MtpStorageManager(new MtpStorageManager.MtpNotifier() {
146             @Override
147             public void sendObjectAdded(int id) {
148                 Log.d(TAG, "sendObjectAdded " + id);
149                 objectsAdded.add(id);
150             }
151 
152             @Override
153             public void sendObjectRemoved(int id) {
154                 Log.d(TAG, "sendObjectRemoved " + id);
155                 objectsRemoved.add(id);
156             }
157 
158             @Override
159             public void sendObjectInfoChanged(int id) {
160                 Log.d(TAG, "sendObjectInfoChanged: " + id);
161                 objectsInfoChanged.add(id);
162             }
163         }, /* subdirectories= */ null);
164 
165         mainMtpStorage = manager.addMtpStorage(mainStorage, /* isHostWindows= */ () -> false);
166         secondaryMtpStorage = manager.addMtpStorage(secondaryStorage,
167                                                     /* isHostWindows= */ () -> false);
168     }
169 
170     @After
after()171     public void after() {
172         manager.close();
173         FileUtils.deleteContentsAndDir(TEMP_DIR_FILE);
174     }
175 
176     /** MtpObject getter tests. **/
177 
178     @Test
179     @SmallTest
testMtpObjectGetNameRoot()180     public void testMtpObjectGetNameRoot() {
181         logMethodName();
182         MtpStorageManager.MtpObject obj = manager.getStorageRoot(mainMtpStorage.getStorageId());
183         Assert.assertEquals(obj.getName(), mainStorageDir.getPath());
184     }
185 
186     @Test
187     @SmallTest
testMtpObjectGetNameNonRoot()188     public void testMtpObjectGetNameNonRoot() {
189         logMethodName();
190         File newFile = createNewFile(mainStorageDir);
191         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
192                 mainMtpStorage.getStorageId());
193         Assert.assertEquals(stream.get(0).getName(), newFile.getName());
194     }
195 
196     @Test
197     @SmallTest
testMtpObjectGetIdRoot()198     public void testMtpObjectGetIdRoot() {
199         logMethodName();
200         MtpStorageManager.MtpObject obj = manager.getStorageRoot(mainMtpStorage.getStorageId());
201         Assert.assertEquals(obj.getId(), mainMtpStorage.getStorageId());
202     }
203 
204     @Test
205     @SmallTest
testMtpObjectGetIdNonRoot()206     public void testMtpObjectGetIdNonRoot() {
207         logMethodName();
208         File newFile = createNewFile(mainStorageDir);
209         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
210                 mainMtpStorage.getStorageId());
211         Assert.assertEquals(stream.get(0).getId(), 1);
212     }
213 
214     @Test
215     @SmallTest
testMtpObjectIsDirTrue()216     public void testMtpObjectIsDirTrue() {
217         logMethodName();
218         MtpStorageManager.MtpObject obj = manager.getStorageRoot(mainMtpStorage.getStorageId());
219         Assert.assertTrue(obj.isDir());
220     }
221 
222     @Test
223     @SmallTest
testMtpObjectIsDirFalse()224     public void testMtpObjectIsDirFalse() {
225         logMethodName();
226         File newFile = createNewFile(mainStorageDir, "TEST123.mp3");
227         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
228                 mainMtpStorage.getStorageId());
229         Assert.assertFalse(stream.get(0).isDir());
230     }
231 
232     @Test
233     @SmallTest
testMtpObjectGetFormatDir()234     public void testMtpObjectGetFormatDir() {
235         logMethodName();
236         File newFile = createNewDir(mainStorageDir);
237         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
238                 mainMtpStorage.getStorageId());
239         Assert.assertEquals(stream.get(0).getFormat(), MtpConstants.FORMAT_ASSOCIATION);
240     }
241 
242     @Test
243     @SmallTest
testMtpObjectGetFormatNonDir()244     public void testMtpObjectGetFormatNonDir() {
245         logMethodName();
246         File newFile = createNewFile(mainStorageDir, "TEST123.mp3");
247         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
248                 mainMtpStorage.getStorageId());
249         Assert.assertEquals(stream.get(0).getFormat(), MtpConstants.FORMAT_MP3);
250     }
251 
252     @Test
253     @SmallTest
testMtpObjectGetStorageId()254     public void testMtpObjectGetStorageId() {
255         logMethodName();
256         File newFile = createNewFile(mainStorageDir);
257         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
258                 mainMtpStorage.getStorageId());
259         Assert.assertEquals(stream.get(0).getStorageId(), mainMtpStorage.getStorageId());
260     }
261 
262     @Test
263     @SmallTest
testMtpObjectGetLastModified()264     public void testMtpObjectGetLastModified() {
265         logMethodName();
266         File newFile = createNewFile(mainStorageDir);
267         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
268                 mainMtpStorage.getStorageId());
269         Assert.assertEquals(stream.get(0).getModifiedTime(), newFile.lastModified() / 1000);
270     }
271 
272     @Test
273     @SmallTest
testMtpObjectGetParent()274     public void testMtpObjectGetParent() {
275         logMethodName();
276         File newFile = createNewFile(mainStorageDir);
277         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
278                 mainMtpStorage.getStorageId());
279         Assert.assertEquals(stream.get(0).getParent(),
280                 manager.getStorageRoot(mainMtpStorage.getStorageId()));
281     }
282 
283     @Test
284     @SmallTest
testMtpObjectGetRoot()285     public void testMtpObjectGetRoot() {
286         logMethodName();
287         File newFile = createNewFile(mainStorageDir);
288         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
289                 mainMtpStorage.getStorageId());
290         Assert.assertEquals(stream.get(0).getRoot(),
291                 manager.getStorageRoot(mainMtpStorage.getStorageId()));
292     }
293 
294     @Test
295     @SmallTest
testMtpObjectGetPath()296     public void testMtpObjectGetPath() {
297         logMethodName();
298         File newFile = createNewFile(mainStorageDir);
299         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
300                 mainMtpStorage.getStorageId());
301         Assert.assertEquals(stream.get(0).getPath().toString(), newFile.getPath());
302     }
303 
304     @Test
305     @SmallTest
testMtpObjectGetSize()306     public void testMtpObjectGetSize() {
307         logMethodName();
308         File newFile = createNewFile(mainStorageDir);
309         try {
310             new FileOutputStream(newFile).write(new byte[] {0, 0, 0, 0, 0, 0, 0, 0});
311         } catch (IOException e) {
312             Assert.fail();
313         }
314         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
315                 mainMtpStorage.getStorageId());
316         Assert.assertEquals(stream.get(0).getSize(), 8);
317     }
318 
319     @Test
320     @SmallTest
testMtpObjectGetSizeDir()321     public void testMtpObjectGetSizeDir() {
322         logMethodName();
323         File newDir = createNewDir(mainStorageDir);
324         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
325                 mainMtpStorage.getStorageId());
326         Assert.assertEquals(stream.get(0).getSize(), 0);
327     }
328 
329     /** MtpStorageManager cache access tests. **/
330 
331     @Test
332     @SmallTest
testAddMtpStorage()333     public void testAddMtpStorage() {
334         logMethodName();
335         Assert.assertEquals(mainMtpStorage.getPath(), mainStorageDir.getPath());
336         Assert.assertNotNull(manager.getStorageRoot(mainMtpStorage.getStorageId()));
337         Assert.assertTrue(manager.checkConsistency());
338     }
339 
340     @Test
341     @SmallTest
testRemoveMtpStorage()342     public void testRemoveMtpStorage() {
343         logMethodName();
344         File newFile = createNewFile(secondaryStorageDir);
345         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
346                 secondaryMtpStorage.getStorageId());
347         Assert.assertEquals(stream.size(), 1);
348 
349         manager.removeMtpStorage(secondaryMtpStorage);
350         Assert.assertNull(manager.getStorageRoot(secondaryMtpStorage.getStorageId()));
351         Assert.assertNull(manager.getObject(1));
352         Assert.assertTrue(manager.checkConsistency());
353     }
354 
355     @Test
356     @SmallTest
testGetByPath()357     public void testGetByPath() {
358         logMethodName();
359         File newFile = createNewFile(createNewDir(createNewDir(mainStorageDir)));
360 
361         MtpStorageManager.MtpObject obj = manager.getByPath(newFile.getPath());
362         Assert.assertNotNull(obj);
363         Assert.assertEquals(obj.getPath().toString(), newFile.getPath());
364         Assert.assertTrue(manager.checkConsistency());
365     }
366 
367     @Test
368     @SmallTest
testGetByPathError()369     public void testGetByPathError() {
370         logMethodName();
371         File newFile = createNewFile(createNewDir(createNewDir(mainStorageDir)));
372 
373         MtpStorageManager.MtpObject obj = manager.getByPath(newFile.getPath() + "q");
374         Assert.assertNull(obj);
375         Assert.assertTrue(manager.checkConsistency());
376     }
377 
378     @Test
379     @SmallTest
testGetObject()380     public void testGetObject() {
381         logMethodName();
382         File newFile = createNewFile(createNewDir(createNewDir(mainStorageDir)));
383         MtpStorageManager.MtpObject obj = manager.getByPath(newFile.getPath());
384         Assert.assertNotNull(obj);
385 
386         Assert.assertEquals(manager.getObject(obj.getId()), obj);
387         Assert.assertTrue(manager.checkConsistency());
388     }
389 
390     @Test
391     @SmallTest
testGetObjectError()392     public void testGetObjectError() {
393         logMethodName();
394         File newFile = createNewFile(createNewDir(createNewDir(mainStorageDir)));
395 
396         Assert.assertNull(manager.getObject(42));
397         Assert.assertTrue(manager.checkConsistency());
398     }
399 
400     @Test
401     @SmallTest
testGetStorageRoot()402     public void testGetStorageRoot() {
403         logMethodName();
404         MtpStorageManager.MtpObject obj = manager.getStorageRoot(mainMtpStorage.getStorageId());
405         Assert.assertEquals(obj.getPath().toString(), mainStorageDir.getPath());
406     }
407 
408     @Test
409     @SmallTest
testGetObjectsParent()410     public void testGetObjectsParent() {
411         logMethodName();
412         File newDir = createNewDir(createNewDir(mainStorageDir));
413         File newFile = createNewFile(newDir);
414         File newMP3File = createNewFile(newDir, "lalala.mp3");
415         MtpStorageManager.MtpObject parent = manager.getByPath(newDir.getPath());
416         Assert.assertNotNull(parent);
417 
418         List<MtpStorageManager.MtpObject> stream = manager.getObjects(parent.getId(), 0,
419                 mainMtpStorage.getStorageId());
420         Assert.assertEquals(stream.size(), 2);
421         Assert.assertTrue(manager.checkConsistency());
422     }
423 
424     @Test
425     @SmallTest
testGetObjectsFormat()426     public void testGetObjectsFormat() {
427         logMethodName();
428         File newDir = createNewDir(createNewDir(mainStorageDir));
429         File newFile = createNewFile(newDir);
430         File newMP3File = createNewFile(newDir, "lalala.mp3");
431         MtpStorageManager.MtpObject parent = manager.getByPath(newDir.getPath());
432         Assert.assertNotNull(parent);
433 
434         List<MtpStorageManager.MtpObject> stream = manager.getObjects(parent.getId(),
435                 MtpConstants.FORMAT_MP3, mainMtpStorage.getStorageId());
436         Assert.assertEquals(stream.get(0).getPath().toString(), newMP3File.toString());
437         Assert.assertTrue(manager.checkConsistency());
438     }
439 
440     @Test
441     @SmallTest
testGetObjectsRoot()442     public void testGetObjectsRoot() {
443         logMethodName();
444         File newDir = createNewDir(mainStorageDir);
445         File newFile = createNewFile(mainStorageDir);
446         File newMP3File = createNewFile(newDir, "lalala.mp3");
447 
448         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
449                 mainMtpStorage.getStorageId());
450         Assert.assertEquals(stream.size(), 2);
451         Assert.assertTrue(manager.checkConsistency());
452     }
453 
454     @Test
455     @SmallTest
testGetObjectsAll()456     public void testGetObjectsAll() {
457         logMethodName();
458         File newDir = createNewDir(mainStorageDir);
459         File newFile = createNewFile(mainStorageDir);
460         File newMP3File = createNewFile(newDir, "lalala.mp3");
461 
462         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0, 0,
463                 mainMtpStorage.getStorageId());
464         Assert.assertEquals(stream.size(), 3);
465         Assert.assertTrue(manager.checkConsistency());
466     }
467 
468     @Test
469     @SmallTest
testGetObjectsAllStorages()470     public void testGetObjectsAllStorages() {
471         logMethodName();
472         File newDir = createNewDir(mainStorageDir);
473         createNewFile(mainStorageDir);
474         createNewFile(newDir, "lalala.mp3");
475         File newDir2 = createNewDir(secondaryStorageDir);
476         createNewFile(secondaryStorageDir);
477         createNewFile(newDir2, "lalala.mp3");
478 
479         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0, 0, 0xFFFFFFFF);
480         Assert.assertEquals(stream.size(), 6);
481         Assert.assertTrue(manager.checkConsistency());
482     }
483 
484     @Test
485     @SmallTest
testGetObjectsAllStoragesRoot()486     public void testGetObjectsAllStoragesRoot() {
487         logMethodName();
488         File newDir = createNewDir(mainStorageDir);
489         createNewFile(mainStorageDir);
490         createNewFile(newDir, "lalala.mp3");
491         File newDir2 = createNewDir(secondaryStorageDir);
492         createNewFile(secondaryStorageDir);
493         createNewFile(newDir2, "lalala.mp3");
494 
495         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0, 0xFFFFFFFF);
496         Assert.assertEquals(stream.size(), 4);
497         Assert.assertTrue(manager.checkConsistency());
498     }
499 
500     /** MtpStorageManager event handling tests. **/
501 
502     @Test
503     @SmallTest
testObjectAdded()504     public void testObjectAdded() {
505         logMethodName();
506         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
507                 mainMtpStorage.getStorageId());
508         Assert.assertEquals(stream.size(), 0);
509 
510         File newFile = createNewFileNonZero(mainStorageDir);
511         manager.flushEvents();
512         Assert.assertEquals(objectsAdded.size(), 1);
513         Assert.assertEquals(manager.getObject(objectsAdded.get(0)).getPath().toString(),
514                 newFile.getPath());
515 
516         logMethodValue("objectsInfoChanged.size", objectsInfoChanged.size());
517         if (objectsInfoChanged.size() > 0)
518             Assert.assertEquals(objectsAdded.get(0).intValue(), objectsInfoChanged.get(0).intValue());
519 
520         Assert.assertTrue(manager.checkConsistency());
521     }
522 
523     @Test
524     @SmallTest
testObjectAddedDir()525     public void testObjectAddedDir() {
526         logMethodName();
527         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
528                 mainMtpStorage.getStorageId());
529         Assert.assertEquals(stream.size(), 0);
530 
531         File newDir = createNewDir(mainStorageDir);
532         manager.flushEvents();
533         Assert.assertEquals(objectsAdded.size(), 1);
534         Assert.assertEquals(manager.getObject(objectsAdded.get(0)).getPath().toString(),
535                 newDir.getPath());
536         Assert.assertTrue(manager.getObject(objectsAdded.get(0)).isDir());
537         Assert.assertEquals(objectsInfoChanged.size(), 0);
538         Assert.assertTrue(manager.checkConsistency());
539     }
540 
541     @Test
542     @SmallTest
testObjectAddedRecursiveDir()543     public void testObjectAddedRecursiveDir() {
544         logMethodName();
545         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
546                 mainMtpStorage.getStorageId());
547         Assert.assertEquals(stream.size(), 0);
548 
549         File newDir = createNewDir(createNewDir(createNewDir(mainStorageDir)));
550         manager.flushEvents();
551         Assert.assertEquals(objectsAdded.size(), 3);
552         Assert.assertEquals(manager.getObject(objectsAdded.get(2)).getPath().toString(),
553                 newDir.getPath());
554         Assert.assertTrue(manager.getObject(objectsAdded.get(2)).isDir());
555         Assert.assertEquals(objectsInfoChanged.size(), 0);
556         Assert.assertTrue(manager.checkConsistency());
557     }
558 
559     @Test
560     @SmallTest
testObjectRemoved()561     public void testObjectRemoved() {
562         logMethodName();
563         File newFile = createNewFile(mainStorageDir);
564         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
565                 mainMtpStorage.getStorageId());
566         Assert.assertEquals(stream.size(), 1);
567 
568         Assert.assertTrue(newFile.delete());
569         manager.flushEvents();
570         Assert.assertEquals(objectsRemoved.size(), 1);
571         Assert.assertNull(manager.getObject(objectsRemoved.get(0)));
572         Assert.assertTrue(manager.checkConsistency());
573     }
574 
575     @Test
576     @SmallTest
testObjectMoved()577     public void testObjectMoved() {
578         logMethodName();
579         File newFile = createNewFileNonZero(mainStorageDir);
580         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
581                 mainMtpStorage.getStorageId());
582         Assert.assertEquals(stream.size(), 1);
583         File toFile = new File(mainStorageDir, "to" + newFile.getName());
584 
585         Assert.assertTrue(newFile.renameTo(toFile));
586         manager.flushEvents();
587         Assert.assertEquals(objectsAdded.size(), 1);
588         Assert.assertEquals(objectsRemoved.size(), 1);
589         Assert.assertEquals(manager.getObject(objectsAdded.get(0)).getPath().toString(),
590                 toFile.getPath());
591         Assert.assertNull(manager.getObject(objectsRemoved.get(0)));
592         Assert.assertEquals(objectsInfoChanged.size(), 0);
593         Assert.assertTrue(manager.checkConsistency());
594     }
595 
596     /** MtpStorageManager operation tests. Ensure that events are not sent for the main operation,
597         and also test all possible cases of other processes accessing the file at the same time, as
598         well as cases of both failure and success. **/
599 
600     @Test
601     @SmallTest
testSendObjectSuccess()602     public void testSendObjectSuccess() {
603         logMethodName();
604         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
605                 mainMtpStorage.getStorageId());
606         int id = manager.beginSendObject(manager.getStorageRoot(mainMtpStorage.getStorageId()),
607                 "newFile", MtpConstants.FORMAT_UNDEFINED);
608         Assert.assertEquals(id, 1);
609 
610         File newFile = createNewFileNonZero(mainStorageDir, "newFile");
611         manager.flushEvents();
612         MtpStorageManager.MtpObject obj = manager.getObject(id);
613         Assert.assertTrue(manager.endSendObject(obj, true));
614         Assert.assertEquals(obj.getPath().toString(), newFile.getPath());
615         Assert.assertEquals(objectsAdded.size(), 0);
616         Assert.assertTrue(manager.checkConsistency());
617     }
618 
619     @Test
620     @SmallTest
testSendObjectSuccessDir()621     public void testSendObjectSuccessDir() {
622         logMethodName();
623         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
624                 mainMtpStorage.getStorageId());
625         int id = manager.beginSendObject(manager.getStorageRoot(mainMtpStorage.getStorageId()),
626                 "newDir", MtpConstants.FORMAT_ASSOCIATION);
627         Assert.assertEquals(id, 1);
628 
629         File newFile = createNewDir(mainStorageDir, "newDir");
630         manager.flushEvents();
631         MtpStorageManager.MtpObject obj = manager.getObject(id);
632         Assert.assertTrue(manager.endSendObject(obj, true));
633         Assert.assertEquals(obj.getPath().toString(), newFile.getPath());
634         Assert.assertEquals(objectsAdded.size(), 0);
635         Assert.assertEquals(objectsInfoChanged.size(), 0);
636         Assert.assertEquals(obj.getFormat(), MtpConstants.FORMAT_ASSOCIATION);
637         Assert.assertTrue(manager.checkConsistency());
638 
639         // Check that new dir receives events
640         File newerFile = createNewFileNonZero(newFile);
641         manager.flushEvents();
642         Assert.assertEquals(objectsAdded.size(), 1);
643         Assert.assertEquals(manager.getObject(objectsAdded.get(0)).getPath().toString(),
644                 newerFile.getPath());
645     }
646 
647     @Test
648     @SmallTest
testSendObjectSuccessDelayed()649     public void testSendObjectSuccessDelayed() {
650         logMethodName();
651         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
652                 mainMtpStorage.getStorageId());
653         int id = manager.beginSendObject(manager.getStorageRoot(mainMtpStorage.getStorageId()),
654                 "newFile", MtpConstants.FORMAT_UNDEFINED);
655         Assert.assertEquals(id, 1);
656         MtpStorageManager.MtpObject obj = manager.getObject(id);
657         Assert.assertTrue(manager.endSendObject(obj, true));
658 
659         File newFile = createNewFileNonZero(mainStorageDir, "newFile");
660         manager.flushEvents();
661         Assert.assertEquals(obj.getPath().toString(), newFile.getPath());
662         Assert.assertEquals(objectsAdded.size(), 0);
663         Assert.assertTrue(manager.checkConsistency());
664     }
665 
666     @Test
667     @SmallTest
testSendObjectSuccessDirDelayed()668     public void testSendObjectSuccessDirDelayed() {
669         logMethodName();
670         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
671                 mainMtpStorage.getStorageId());
672         int id = manager.beginSendObject(manager.getStorageRoot(mainMtpStorage.getStorageId()),
673                 "newDir", MtpConstants.FORMAT_ASSOCIATION);
674         Assert.assertEquals(id, 1);
675 
676         MtpStorageManager.MtpObject obj = manager.getObject(id);
677         Assert.assertTrue(manager.endSendObject(obj, true));
678         File newFile = createNewDir(mainStorageDir, "newDir");
679         manager.flushEvents();
680         Assert.assertEquals(obj.getPath().toString(), newFile.getPath());
681         Assert.assertEquals(objectsAdded.size(), 0);
682         Assert.assertEquals(objectsInfoChanged.size(), 0);
683         Assert.assertEquals(obj.getFormat(), MtpConstants.FORMAT_ASSOCIATION);
684         Assert.assertTrue(manager.checkConsistency());
685 
686         // Check that new dir receives events
687         File newerFile = createNewFileNonZero(newFile);
688         manager.flushEvents();
689         Assert.assertEquals(objectsAdded.size(), 1);
690         Assert.assertEquals(manager.getObject(objectsAdded.get(0)).getPath().toString(),
691                 newerFile.getPath());
692     }
693 
694     @Test
695     @SmallTest
testSendObjectSuccessDeleted()696     public void testSendObjectSuccessDeleted() {
697         logMethodName();
698         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
699                 mainMtpStorage.getStorageId());
700         int id = manager.beginSendObject(manager.getStorageRoot(mainMtpStorage.getStorageId()),
701                 "newFile", MtpConstants.FORMAT_UNDEFINED);
702         Assert.assertEquals(id, 1);
703 
704         File newFile = createNewFile(mainStorageDir, "newFile");
705         Assert.assertTrue(newFile.delete());
706         manager.flushEvents();
707         MtpStorageManager.MtpObject obj = manager.getObject(id);
708         Assert.assertTrue(manager.endSendObject(obj, true));
709         Assert.assertNull(manager.getObject(obj.getId()));
710         Assert.assertEquals(objectsRemoved.get(0).intValue(), obj.getId());
711         Assert.assertTrue(manager.checkConsistency());
712     }
713 
714     @Test
715     @SmallTest
testSendObjectFailed()716     public void testSendObjectFailed() {
717         logMethodName();
718         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
719                 mainMtpStorage.getStorageId());
720         int id = manager.beginSendObject(manager.getStorageRoot(mainMtpStorage.getStorageId()),
721                 "newFile", MtpConstants.FORMAT_UNDEFINED);
722         Assert.assertEquals(id, 1);
723 
724         MtpStorageManager.MtpObject obj = manager.getObject(id);
725         Assert.assertTrue(manager.endSendObject(obj, false));
726         Assert.assertTrue(manager.checkConsistency());
727     }
728 
729     @Test
730     @SmallTest
testSendObjectFailedDeleted()731     public void testSendObjectFailedDeleted() {
732         logMethodName();
733         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
734                 mainMtpStorage.getStorageId());
735         int id = manager.beginSendObject(manager.getStorageRoot(mainMtpStorage.getStorageId()),
736                 "newFile", MtpConstants.FORMAT_UNDEFINED);
737         Assert.assertEquals(id, 1);
738         MtpStorageManager.MtpObject obj = manager.getObject(id);
739 
740         File newFile = createNewFileNonZero(mainStorageDir, "newFile");
741         Assert.assertTrue(newFile.delete());
742         manager.flushEvents();
743         Assert.assertTrue(manager.endSendObject(obj, false));
744         Assert.assertEquals(objectsRemoved.size(), 0);
745         Assert.assertEquals(objectsAdded.size(), 0);
746         Assert.assertEquals(objectsInfoChanged.size(), 0);
747         Assert.assertTrue(manager.checkConsistency());
748     }
749 
750     @Test
751     @SmallTest
testSendObjectFailedAdded()752     public void testSendObjectFailedAdded() {
753         logMethodName();
754         List<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
755                 mainMtpStorage.getStorageId());
756         int id = manager.beginSendObject(manager.getStorageRoot(mainMtpStorage.getStorageId()),
757                 "newFile", MtpConstants.FORMAT_UNDEFINED);
758         Assert.assertEquals(id, 1);
759         MtpStorageManager.MtpObject obj = manager.getObject(id);
760 
761         File newDir = createNewDir(mainStorageDir, "newFile");
762         manager.flushEvents();
763         Assert.assertTrue(manager.endSendObject(obj, false));
764         Assert.assertNotEquals(objectsAdded.get(0).intValue(), id);
765         logMethodValue("objectsInfoChanged.size", objectsInfoChanged.size());
766         if (objectsInfoChanged.size() > 0)
767             Assert.assertNotEquals(objectsInfoChanged.get(0).intValue(), id);
768         Assert.assertNull(manager.getObject(id));
769         Assert.assertEquals(manager.getObject(objectsAdded.get(0)).getPath().toString(),
770                 newDir.getPath());
771         Assert.assertTrue(manager.checkConsistency());
772 
773         // Expect events in new dir
774         createNewFileNonZero(newDir);
775         manager.flushEvents();
776         Assert.assertEquals(objectsAdded.size(), 2);
777         logMethodValue("objectsInfoChanged.size", objectsInfoChanged.size());
778         if (objectsInfoChanged.size() == 1)
779             Assert.assertEquals(objectsAdded.get(1).intValue(), objectsInfoChanged.get(0).intValue());
780         Assert.assertTrue(manager.checkConsistency());
781     }
782 
783     @Test
784     @SmallTest
testRemoveObjectSuccess()785     public void testRemoveObjectSuccess() {
786         logMethodName();
787         File newFile = createNewFile(mainStorageDir);
788         MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
789                 mainMtpStorage.getStorageId()).get(0);
790         Assert.assertTrue(manager.beginRemoveObject(obj));
791 
792         Assert.assertTrue(newFile.delete());
793         manager.flushEvents();
794         Assert.assertTrue(manager.endRemoveObject(obj, true));
795         Assert.assertEquals(objectsRemoved.size(), 0);
796         Assert.assertNull(manager.getObject(obj.getId()));
797         Assert.assertTrue(manager.checkConsistency());
798     }
799 
800     @Test
801     @SmallTest
testRemoveObjectDelayed()802     public void testRemoveObjectDelayed() {
803         logMethodName();
804         File newFile = createNewFile(mainStorageDir);
805         MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
806                 mainMtpStorage.getStorageId()).get(0);
807         Assert.assertTrue(manager.beginRemoveObject(obj));
808 
809         Assert.assertTrue(manager.endRemoveObject(obj, true));
810         Assert.assertTrue(newFile.delete());
811         manager.flushEvents();
812         Assert.assertEquals(objectsRemoved.size(), 0);
813         Assert.assertNull(manager.getObject(obj.getId()));
814         Assert.assertTrue(manager.checkConsistency());
815     }
816 
817     @Test
818     @SmallTest
testRemoveObjectDir()819     public void testRemoveObjectDir() {
820         logMethodName();
821         File newDir = createNewDir(mainStorageDir);
822         createNewFileNonZero(createNewDir(newDir));
823         MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
824                 mainMtpStorage.getStorageId()).get(0);
825         manager.getObjects(obj.getId(), 0, mainMtpStorage.getStorageId());
826         Assert.assertTrue(manager.beginRemoveObject(obj));
827 
828         createNewFileNonZero(newDir);
829         Assert.assertTrue(FileUtils.deleteContentsAndDir(newDir));
830         manager.flushEvents();
831         Assert.assertTrue(manager.endRemoveObject(obj, true));
832         Assert.assertEquals(objectsAdded.size(), 1);
833         Assert.assertEquals(objectsRemoved.size(), 1);
834         Assert.assertEquals(manager.getObjects(0, 0, mainMtpStorage.getStorageId()).size(), 0);
835         Assert.assertNull(manager.getObject(obj.getId()));
836         Assert.assertTrue(manager.checkConsistency());
837     }
838 
839     @Test
840     @SmallTest
testRemoveObjectDirDelayed()841     public void testRemoveObjectDirDelayed() {
842         logMethodName();
843         File newDir = createNewDir(mainStorageDir);
844         createNewFile(createNewDir(newDir));
845         MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
846                 mainMtpStorage.getStorageId()).get(0);
847         Assert.assertTrue(manager.beginRemoveObject(obj));
848 
849         Assert.assertTrue(manager.endRemoveObject(obj, true));
850         Assert.assertTrue(FileUtils.deleteContentsAndDir(newDir));
851         manager.flushEvents();
852         Assert.assertEquals(objectsRemoved.size(), 0);
853         Assert.assertEquals(manager.getObjects(0, 0, mainMtpStorage.getStorageId()).size(), 0);
854         Assert.assertNull(manager.getObject(obj.getId()));
855         Assert.assertTrue(manager.checkConsistency());
856     }
857 
858     @Test
859     @SmallTest
testRemoveObjectSuccessAdded()860     public void testRemoveObjectSuccessAdded() {
861         logMethodName();
862         File newFile = createNewFile(mainStorageDir);
863         MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
864                 mainMtpStorage.getStorageId()).get(0);
865         int id = obj.getId();
866         Assert.assertTrue(manager.beginRemoveObject(obj));
867 
868         Assert.assertTrue(newFile.delete());
869         createNewFileNonZero(mainStorageDir, newFile.getName());
870         manager.flushEvents();
871         Assert.assertTrue(manager.endRemoveObject(obj, true));
872         Assert.assertEquals(objectsRemoved.size(), 0);
873         Assert.assertEquals(objectsAdded.size(), 1);
874         Assert.assertNull(manager.getObject(id));
875         Assert.assertNotEquals(objectsAdded.get(0).intValue(), id);
876         logMethodValue("objectsInfoChanged.size", objectsInfoChanged.size());
877         if (objectsInfoChanged.size() > 0)
878             Assert.assertNotEquals(objectsInfoChanged.get(0).intValue(), objectsAdded.get(0).intValue());
879         Assert.assertTrue(manager.checkConsistency());
880     }
881 
882     @Test
883     @SmallTest
testRemoveObjectFailed()884     public void testRemoveObjectFailed() {
885         logMethodName();
886         File newFile = createNewFile(mainStorageDir);
887         MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
888                 mainMtpStorage.getStorageId()).get(0);
889         Assert.assertTrue(manager.beginRemoveObject(obj));
890 
891         Assert.assertTrue(manager.endRemoveObject(obj, false));
892         Assert.assertEquals(manager.getObject(obj.getId()), obj);
893         Assert.assertTrue(manager.checkConsistency());
894     }
895 
896     @Test
897     @SmallTest
testRemoveObjectFailedDir()898     public void testRemoveObjectFailedDir() {
899         logMethodName();
900         File newDir = createNewDir(mainStorageDir);
901         MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
902                 mainMtpStorage.getStorageId()).get(0);
903         manager.getObjects(obj.getId(), 0, mainMtpStorage.getStorageId());
904         Assert.assertTrue(manager.beginRemoveObject(obj));
905 
906         createNewFile(newDir);
907         manager.flushEvents();
908         Assert.assertTrue(manager.endRemoveObject(obj, false));
909         Assert.assertEquals(manager.getObject(obj.getId()), obj);
910         Assert.assertEquals(objectsAdded.size(), 1);
911         Assert.assertEquals(objectsInfoChanged.size(), 0);
912         Assert.assertTrue(manager.checkConsistency());
913     }
914 
915     @Test
916     @SmallTest
testRemoveObjectFailedRemoved()917     public void testRemoveObjectFailedRemoved() {
918         logMethodName();
919         File newFile = createNewFile(mainStorageDir);
920         MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
921                 mainMtpStorage.getStorageId()).get(0);
922         Assert.assertTrue(manager.beginRemoveObject(obj));
923 
924         Assert.assertTrue(newFile.delete());
925         manager.flushEvents();
926         Assert.assertTrue(manager.endRemoveObject(obj, false));
927         Assert.assertEquals(objectsRemoved.size(), 1);
928         Assert.assertEquals(objectsRemoved.get(0).intValue(), obj.getId());
929         Assert.assertNull(manager.getObject(obj.getId()));
930         Assert.assertTrue(manager.checkConsistency());
931     }
932 
933     @Test
934     @SmallTest
testCopyObjectSuccess()935     public void testCopyObjectSuccess() {
936         logMethodName();
937         File newFile = createNewFileNonZero(mainStorageDir);
938         File newDir = createNewDir(mainStorageDir);
939         MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
940                 mainMtpStorage.getStorageId())
941                 .stream().filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
942         MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
943                 mainMtpStorage.getStorageId()).stream()
944                 .filter(o -> !o.isDir()).findFirst().get();
945 
946         int id = manager.beginCopyObject(fileObj, dirObj);
947         Assert.assertNotEquals(id, -1);
948         createNewFileNonZero(newDir, newFile.getName());
949         manager.flushEvents();
950         MtpStorageManager.MtpObject obj = manager.getObject(id);
951         Assert.assertTrue(manager.endCopyObject(obj, true));
952         Assert.assertEquals(objectsAdded.size(), 0);
953         Assert.assertTrue(manager.checkConsistency());
954     }
955 
956     @Test
957     @SmallTest
testCopyObjectSuccessRecursive()958     public void testCopyObjectSuccessRecursive() {
959         logMethodName();
960         File newDirFrom = createNewDir(mainStorageDir);
961         File newDirFrom1 = createNewDir(newDirFrom);
962         File newDirFrom2 = createNewFileNonZero(newDirFrom1);
963         File delayedFile = createNewFileNonZero(newDirFrom);
964         File deletedFile = createNewFileNonZero(newDirFrom);
965         File newDirTo = createNewDir(mainStorageDir);
966         MtpStorageManager.MtpObject toObj = manager.getObjects(0xFFFFFFFF, 0,
967                 mainMtpStorage.getStorageId()).stream()
968                 .filter(o -> o.getName().equals(newDirTo.getName())).findFirst().get();
969         MtpStorageManager.MtpObject fromObj = manager.getObjects(0xFFFFFFFF, 0,
970                 mainMtpStorage.getStorageId()).stream()
971                 .filter(o -> o.getName().equals(newDirFrom.getName())).findFirst().get();
972 
973         manager.getObjects(fromObj.getId(), 0, mainMtpStorage.getStorageId());
974         int id = manager.beginCopyObject(fromObj, toObj);
975         Assert.assertNotEquals(id, -1);
976         File copiedDir = createNewDir(newDirTo, newDirFrom.getName());
977         File copiedDir1 = createNewDir(copiedDir, newDirFrom1.getName());
978         createNewFileNonZero(copiedDir1, newDirFrom2.getName());
979         createNewFileNonZero(copiedDir, "extraFile");
980         File toDelete = createNewFileNonZero(copiedDir, deletedFile.getName());
981         manager.flushEvents();
982         Assert.assertTrue(toDelete.delete());
983         manager.flushEvents();
984         MtpStorageManager.MtpObject obj = manager.getObject(id);
985         Assert.assertTrue(manager.endCopyObject(obj, true));
986         Assert.assertEquals(objectsAdded.size(), 1);
987         Assert.assertEquals(objectsRemoved.size(), 1);
988 
989         createNewFileNonZero(copiedDir, delayedFile.getName());
990         manager.flushEvents();
991         Assert.assertTrue(manager.checkConsistency());
992 
993         // Expect events in the visited dir, but not the unvisited dir.
994         createNewFileNonZero(copiedDir);
995         createNewFileNonZero(copiedDir1);
996         manager.flushEvents();
997         Assert.assertEquals(objectsAdded.size(), 2);
998         Assert.assertEquals(objectsAdded.size(), 2);
999 
1000         // Number of files/dirs created, minus the one that was deleted.
1001         Assert.assertEquals(manager.getObjects(0, 0, mainMtpStorage.getStorageId()).size(), 13);
1002         Assert.assertTrue(manager.checkConsistency());
1003     }
1004 
1005     @Test
1006     @SmallTest
testCopyObjectFailed()1007     public void testCopyObjectFailed() {
1008         logMethodName();
1009         File newFile = createNewFileNonZero(mainStorageDir);
1010         File newDir = createNewDir(mainStorageDir);
1011         MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
1012                 mainMtpStorage.getStorageId()).stream()
1013                 .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
1014         MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
1015                 mainMtpStorage.getStorageId()).stream()
1016                 .filter(o -> !o.isDir()).findFirst().get();
1017 
1018         int id = manager.beginCopyObject(fileObj, dirObj);
1019         Assert.assertNotEquals(id, -1);
1020         manager.flushEvents();
1021         MtpStorageManager.MtpObject obj = manager.getObject(id);
1022         Assert.assertTrue(manager.endCopyObject(obj, false));
1023         Assert.assertEquals(objectsAdded.size(), 0);
1024         Assert.assertEquals(objectsInfoChanged.size(), 0);
1025         Assert.assertTrue(manager.checkConsistency());
1026     }
1027 
1028     @Test
1029     @SmallTest
testCopyObjectFailedAdded()1030     public void testCopyObjectFailedAdded() {
1031         logMethodName();
1032         File newFile = createNewFileNonZero(mainStorageDir);
1033         File newDir = createNewDir(mainStorageDir);
1034         MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
1035                 mainMtpStorage.getStorageId()).stream()
1036                 .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
1037         MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
1038                 mainMtpStorage.getStorageId()).stream()
1039                 .filter(o -> !o.isDir()).findFirst().get();
1040 
1041         int id = manager.beginCopyObject(fileObj, dirObj);
1042         Assert.assertNotEquals(id, -1);
1043         File addedDir = createNewDir(newDir, newFile.getName());
1044         manager.flushEvents();
1045         MtpStorageManager.MtpObject obj = manager.getObject(id);
1046         Assert.assertTrue(manager.endCopyObject(obj, false));
1047         Assert.assertEquals(objectsAdded.size(), 1);
1048         Assert.assertNotEquals(objectsAdded.get(0).intValue(), id);
1049         Assert.assertTrue(manager.checkConsistency());
1050 
1051         // Expect events in new dir
1052         createNewFileNonZero(addedDir);
1053         manager.flushEvents();
1054         Assert.assertEquals(objectsAdded.size(), 2);
1055         Assert.assertTrue(manager.checkConsistency());
1056     }
1057 
1058     @Test
1059     @SmallTest
testCopyObjectFailedDeleted()1060     public void testCopyObjectFailedDeleted() {
1061         logMethodName();
1062         File newFile = createNewFileNonZero(mainStorageDir);
1063         File newDir = createNewDir(mainStorageDir);
1064         MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
1065                 mainMtpStorage.getStorageId()).stream()
1066                 .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
1067         MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
1068                 mainMtpStorage.getStorageId()).stream()
1069                 .filter(o -> !o.isDir()).findFirst().get();
1070 
1071         int id = manager.beginCopyObject(fileObj, dirObj);
1072         Assert.assertNotEquals(id, -1);
1073         Assert.assertTrue(createNewFileNonZero(newDir, newFile.getName()).delete());
1074         manager.flushEvents();
1075         MtpStorageManager.MtpObject obj = manager.getObject(id);
1076         Assert.assertTrue(manager.endCopyObject(obj, false));
1077         Assert.assertEquals(objectsAdded.size(), 0);
1078         Assert.assertTrue(manager.checkConsistency());
1079     }
1080 
1081     @Test
1082     @SmallTest
testRenameObjectSuccess()1083     public void testRenameObjectSuccess() {
1084         logMethodName();
1085         File newFile = createNewFileNonZero(mainStorageDir);
1086         MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
1087                 mainMtpStorage.getStorageId()).get(0);
1088         Assert.assertTrue(manager.beginRenameObject(obj, "renamed"));
1089 
1090         File renamed = new File(mainStorageDir, "renamed");
1091         Assert.assertTrue(newFile.renameTo(renamed));
1092         manager.flushEvents();
1093         Assert.assertTrue(manager.endRenameObject(obj, newFile.getName(), true));
1094 
1095         Assert.assertEquals(objectsAdded.size(), 0);
1096         Assert.assertEquals(objectsInfoChanged.size(), 0);
1097         Assert.assertEquals(objectsRemoved.size(), 0);
1098         Assert.assertEquals(obj.getPath().toString(), renamed.getPath());
1099 
1100         Assert.assertTrue(manager.checkConsistency());
1101     }
1102 
1103     @Test
1104     @SmallTest
testRenameObjectDirSuccess()1105     public void testRenameObjectDirSuccess() {
1106         logMethodName();
1107         File newDir = createNewDir(mainStorageDir);
1108         MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
1109                 mainMtpStorage.getStorageId()).get(0);
1110         Assert.assertTrue(manager.beginRenameObject(obj, "renamed"));
1111 
1112         File renamed = new File(mainStorageDir, "renamed");
1113         Assert.assertTrue(newDir.renameTo(renamed));
1114         manager.flushEvents();
1115         Assert.assertTrue(manager.endRenameObject(obj, newDir.getName(), true));
1116 
1117         Assert.assertEquals(objectsAdded.size(), 0);
1118         Assert.assertEquals(objectsInfoChanged.size(), 0);
1119         Assert.assertEquals(objectsRemoved.size(), 0);
1120         Assert.assertEquals(obj.getPath().toString(), renamed.getPath());
1121 
1122         Assert.assertTrue(manager.checkConsistency());
1123 
1124         // Don't expect events
1125         createNewFile(renamed);
1126         manager.flushEvents();
1127         Assert.assertEquals(objectsAdded.size(), 0);
1128         Assert.assertEquals(objectsInfoChanged.size(), 0);
1129         Assert.assertTrue(manager.checkConsistency());
1130     }
1131 
1132     @Test
1133     @SmallTest
testRenameObjectDirVisitedSuccess()1134     public void testRenameObjectDirVisitedSuccess() {
1135         logMethodName();
1136         File newDir = createNewDir(mainStorageDir);
1137         MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
1138                 mainMtpStorage.getStorageId()).get(0);
1139         manager.getObjects(obj.getId(), 0, mainMtpStorage.getStorageId());
1140         Assert.assertTrue(manager.beginRenameObject(obj, "renamed"));
1141 
1142         File renamed = new File(mainStorageDir, "renamed");
1143         Assert.assertTrue(newDir.renameTo(renamed));
1144         manager.flushEvents();
1145         Assert.assertTrue(manager.endRenameObject(obj, newDir.getName(), true));
1146 
1147         Assert.assertEquals(objectsAdded.size(), 0);
1148         Assert.assertEquals(objectsInfoChanged.size(), 0);
1149         Assert.assertEquals(objectsRemoved.size(), 0);
1150         Assert.assertEquals(obj.getPath().toString(), renamed.getPath());
1151 
1152         Assert.assertTrue(manager.checkConsistency());
1153 
1154         // Expect events since the dir was visited
1155         createNewFileNonZero(renamed);
1156         manager.flushEvents();
1157         Assert.assertEquals(objectsAdded.size(), 1);
1158         Assert.assertTrue(manager.checkConsistency());
1159     }
1160 
1161     @Test
1162     @SmallTest
testRenameObjectDelayed()1163     public void testRenameObjectDelayed() {
1164         logMethodName();
1165         File newFile = createNewFileNonZero(mainStorageDir);
1166         MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
1167                 mainMtpStorage.getStorageId()).get(0);
1168         Assert.assertTrue(manager.beginRenameObject(obj, "renamed"));
1169 
1170         Assert.assertTrue(manager.endRenameObject(obj, newFile.getName(), true));
1171         File renamed = new File(mainStorageDir, "renamed");
1172         Assert.assertTrue(newFile.renameTo(renamed));
1173         manager.flushEvents();
1174 
1175         Assert.assertEquals(objectsAdded.size(), 0);
1176         Assert.assertEquals(objectsInfoChanged.size(), 0);
1177         Assert.assertEquals(objectsRemoved.size(), 0);
1178         Assert.assertEquals(obj.getPath().toString(), renamed.getPath());
1179 
1180         Assert.assertTrue(manager.checkConsistency());
1181     }
1182 
1183     @Test
1184     @SmallTest
testRenameObjectDirVisitedDelayed()1185     public void testRenameObjectDirVisitedDelayed() {
1186         logMethodName();
1187         File newDir = createNewDir(mainStorageDir);
1188         MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
1189                 mainMtpStorage.getStorageId()).get(0);
1190         manager.getObjects(obj.getId(), 0, mainMtpStorage.getStorageId());
1191         Assert.assertTrue(manager.beginRenameObject(obj, "renamed"));
1192 
1193         Assert.assertTrue(manager.endRenameObject(obj, newDir.getName(), true));
1194         File renamed = new File(mainStorageDir, "renamed");
1195         Assert.assertTrue(newDir.renameTo(renamed));
1196         manager.flushEvents();
1197 
1198         Assert.assertEquals(objectsAdded.size(), 0);
1199         Assert.assertEquals(objectsInfoChanged.size(), 0);
1200         Assert.assertEquals(objectsRemoved.size(), 0);
1201         Assert.assertEquals(obj.getPath().toString(), renamed.getPath());
1202 
1203         Assert.assertTrue(manager.checkConsistency());
1204 
1205         // Expect events since the dir was visited
1206         createNewFileNonZero(renamed);
1207         manager.flushEvents();
1208         Assert.assertEquals(objectsAdded.size(), 1);
1209         Assert.assertTrue(manager.checkConsistency());
1210     }
1211 
1212     @Test
1213     @SmallTest
testRenameObjectFailed()1214     public void testRenameObjectFailed() {
1215         logMethodName();
1216         File newFile = createNewFileNonZero(mainStorageDir);
1217         MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
1218                 mainMtpStorage.getStorageId()).get(0);
1219         Assert.assertTrue(manager.beginRenameObject(obj, "renamed"));
1220 
1221         Assert.assertTrue(manager.endRenameObject(obj, newFile.getName(), false));
1222 
1223         Assert.assertEquals(objectsAdded.size(), 0);
1224         Assert.assertEquals(objectsInfoChanged.size(), 0);
1225         Assert.assertEquals(objectsRemoved.size(), 0);
1226 
1227         Assert.assertTrue(manager.checkConsistency());
1228     }
1229 
1230     @Test
1231     @SmallTest
testRenameObjectFailedOldRemoved()1232     public void testRenameObjectFailedOldRemoved() {
1233         logMethodName();
1234         File newFile = createNewFileNonZero(mainStorageDir);
1235         MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
1236                 mainMtpStorage.getStorageId()).get(0);
1237         Assert.assertTrue(manager.beginRenameObject(obj, "renamed"));
1238 
1239         Assert.assertTrue(newFile.delete());
1240         manager.flushEvents();
1241         Assert.assertTrue(manager.endRenameObject(obj, newFile.getName(), false));
1242 
1243         Assert.assertEquals(objectsAdded.size(), 0);
1244         Assert.assertEquals(objectsInfoChanged.size(), 0);
1245         Assert.assertEquals(objectsRemoved.size(), 1);
1246 
1247         Assert.assertTrue(manager.checkConsistency());
1248     }
1249 
1250     @Test
1251     @SmallTest
testRenameObjectFailedNewAdded()1252     public void testRenameObjectFailedNewAdded() {
1253         logMethodName();
1254         File newFile = createNewFileNonZero(mainStorageDir);
1255         MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
1256                 mainMtpStorage.getStorageId()).get(0);
1257         Assert.assertTrue(manager.beginRenameObject(obj, "renamed"));
1258 
1259         createNewFileNonZero(mainStorageDir, "renamed");
1260         manager.flushEvents();
1261         Assert.assertTrue(manager.endRenameObject(obj, newFile.getName(), false));
1262 
1263         Assert.assertEquals(objectsAdded.size(), 1);
1264         logMethodValue("objectsInfoChanged.size", objectsInfoChanged.size());
1265         if (objectsInfoChanged.size() > 0)
1266             Assert.assertNotEquals(objectsAdded.get(0).intValue(), objectsInfoChanged.get(0).intValue());
1267         Assert.assertEquals(objectsRemoved.size(), 0);
1268 
1269         Assert.assertTrue(manager.checkConsistency());
1270     }
1271 
1272     @Test
1273     @SmallTest
testMoveObjectSuccess()1274     public void testMoveObjectSuccess() {
1275         logMethodName();
1276         File newFile = createNewFileNonZero(mainStorageDir);
1277         File dir = createNewDir(mainStorageDir);
1278         MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
1279                 mainMtpStorage.getStorageId()).stream()
1280                 .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
1281         MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
1282                 mainMtpStorage.getStorageId()).stream()
1283                 .filter(o -> !o.isDir()).findFirst().get();
1284         Assert.assertTrue(manager.beginMoveObject(fileObj, dirObj));
1285 
1286         File moved = new File(dir, newFile.getName());
1287         Assert.assertTrue(newFile.renameTo(moved));
1288         manager.flushEvents();
1289         Assert.assertTrue(manager.endMoveObject(
1290                 manager.getStorageRoot(mainMtpStorage.getStorageId()),
1291                 dirObj, newFile.getName(), true));
1292 
1293         Assert.assertEquals(objectsAdded.size(), 0);
1294         Assert.assertEquals(objectsInfoChanged.size(), 0);
1295         Assert.assertEquals(objectsRemoved.size(), 0);
1296         Assert.assertEquals(fileObj.getPath().toString(), moved.getPath());
1297 
1298         Assert.assertTrue(manager.checkConsistency());
1299     }
1300 
1301     @Test
1302     @SmallTest
testMoveObjectDirSuccess()1303     public void testMoveObjectDirSuccess() {
1304         logMethodName();
1305         File newDir = createNewDir(mainStorageDir);
1306         File movedDir = createNewDir(mainStorageDir);
1307         MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
1308                 mainMtpStorage.getStorageId()).stream()
1309                 .filter(o -> o.getName().equals(newDir.getName())).findFirst().get();
1310         MtpStorageManager.MtpObject movedObj = manager.getObjects(0xFFFFFFFF, 0,
1311                 mainMtpStorage.getStorageId()).stream()
1312                 .filter(o -> o.getName().equals(movedDir.getName())).findFirst().get();
1313         Assert.assertTrue(manager.beginMoveObject(movedObj, dirObj));
1314 
1315         File renamed = new File(newDir, movedDir.getName());
1316         Assert.assertTrue(movedDir.renameTo(renamed));
1317         manager.flushEvents();
1318         Assert.assertTrue(manager.endMoveObject(
1319                 manager.getStorageRoot(mainMtpStorage.getStorageId()),
1320                 dirObj, movedDir.getName(), true));
1321 
1322         Assert.assertEquals(objectsAdded.size(), 0);
1323         Assert.assertEquals(objectsInfoChanged.size(), 0);
1324         Assert.assertEquals(objectsRemoved.size(), 0);
1325         Assert.assertEquals(movedObj.getPath().toString(), renamed.getPath());
1326 
1327         Assert.assertTrue(manager.checkConsistency());
1328 
1329         // Don't expect events
1330         createNewFile(renamed);
1331         manager.flushEvents();
1332         Assert.assertEquals(objectsAdded.size(), 0);
1333         Assert.assertEquals(objectsInfoChanged.size(), 0);
1334         Assert.assertTrue(manager.checkConsistency());
1335     }
1336 
1337     @Test
1338     @SmallTest
testMoveObjectDirVisitedSuccess()1339     public void testMoveObjectDirVisitedSuccess() {
1340         logMethodName();
1341         File newDir = createNewDir(mainStorageDir);
1342         File movedDir = createNewDir(mainStorageDir);
1343         MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
1344                 mainMtpStorage.getStorageId()).stream()
1345                 .filter(o -> o.getName().equals(newDir.getName())).findFirst().get();
1346         MtpStorageManager.MtpObject movedObj = manager.getObjects(0xFFFFFFFF, 0,
1347                 mainMtpStorage.getStorageId()).stream()
1348                 .filter(o -> o.getName().equals(movedDir.getName())).findFirst().get();
1349         manager.getObjects(movedObj.getId(), 0, mainMtpStorage.getStorageId());
1350         Assert.assertTrue(manager.beginMoveObject(movedObj, dirObj));
1351 
1352         File renamed = new File(newDir, movedDir.getName());
1353         Assert.assertTrue(movedDir.renameTo(renamed));
1354         manager.flushEvents();
1355         Assert.assertTrue(manager.endMoveObject(
1356                 manager.getStorageRoot(mainMtpStorage.getStorageId()),
1357                 dirObj, movedDir.getName(), true));
1358 
1359         Assert.assertEquals(objectsAdded.size(), 0);
1360         Assert.assertEquals(objectsInfoChanged.size(), 0);
1361         Assert.assertEquals(objectsRemoved.size(), 0);
1362         Assert.assertEquals(movedObj.getPath().toString(), renamed.getPath());
1363 
1364         Assert.assertTrue(manager.checkConsistency());
1365 
1366         // Expect events since the dir was visited
1367         createNewFileNonZero(renamed);
1368         manager.flushEvents();
1369         Assert.assertEquals(objectsAdded.size(), 1);
1370         Assert.assertTrue(manager.checkConsistency());
1371     }
1372 
1373     @Test
1374     @SmallTest
testMoveObjectDelayed()1375     public void testMoveObjectDelayed() {
1376         logMethodName();
1377         File newFile = createNewFileNonZero(mainStorageDir);
1378         File dir = createNewDir(mainStorageDir);
1379         MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
1380                 mainMtpStorage.getStorageId()).stream()
1381                 .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
1382         MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
1383                 mainMtpStorage.getStorageId()).stream()
1384                 .filter(o -> !o.isDir()).findFirst().get();
1385         Assert.assertTrue(manager.beginMoveObject(fileObj, dirObj));
1386 
1387         Assert.assertTrue(manager.endMoveObject(
1388                 manager.getStorageRoot(mainMtpStorage.getStorageId()),
1389                 dirObj, newFile.getName(), true));
1390 
1391         File moved = new File(dir, newFile.getName());
1392         Assert.assertTrue(newFile.renameTo(moved));
1393         manager.flushEvents();
1394 
1395         Assert.assertEquals(objectsAdded.size(), 0);
1396         Assert.assertEquals(objectsRemoved.size(), 0);
1397         Assert.assertEquals(fileObj.getPath().toString(), moved.getPath());
1398 
1399         Assert.assertTrue(manager.checkConsistency());
1400     }
1401 
1402     @Test
1403     @SmallTest
testMoveObjectDirVisitedDelayed()1404     public void testMoveObjectDirVisitedDelayed() {
1405         logMethodName();
1406         File newDir = createNewDir(mainStorageDir);
1407         File movedDir = createNewDir(mainStorageDir);
1408         MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
1409                 mainMtpStorage.getStorageId()).stream()
1410                 .filter(o -> o.getName().equals(newDir.getName())).findFirst().get();
1411         MtpStorageManager.MtpObject movedObj = manager.getObjects(0xFFFFFFFF, 0,
1412                 mainMtpStorage.getStorageId()).stream()
1413                 .filter(o -> o.getName().equals(movedDir.getName())).findFirst().get();
1414         manager.getObjects(movedObj.getId(), 0, mainMtpStorage.getStorageId());
1415         Assert.assertTrue(manager.beginMoveObject(movedObj, dirObj));
1416 
1417         Assert.assertTrue(manager.endMoveObject(
1418                 manager.getStorageRoot(mainMtpStorage.getStorageId()),
1419                 dirObj, movedDir.getName(), true));
1420 
1421         File renamed = new File(newDir, movedDir.getName());
1422         Assert.assertTrue(movedDir.renameTo(renamed));
1423         manager.flushEvents();
1424 
1425         Assert.assertEquals(objectsAdded.size(), 0);
1426         Assert.assertEquals(objectsInfoChanged.size(), 0);
1427         Assert.assertEquals(objectsRemoved.size(), 0);
1428         Assert.assertEquals(movedObj.getPath().toString(), renamed.getPath());
1429 
1430         Assert.assertTrue(manager.checkConsistency());
1431 
1432         // Expect events since the dir was visited
1433         createNewFileNonZero(renamed);
1434         manager.flushEvents();
1435         Assert.assertEquals(objectsAdded.size(), 1);
1436         Assert.assertTrue(manager.checkConsistency());
1437     }
1438 
1439     @Test
1440     @SmallTest
testMoveObjectFailed()1441     public void testMoveObjectFailed() {
1442         logMethodName();
1443         File newFile = createNewFileNonZero(mainStorageDir);
1444         File dir = createNewDir(mainStorageDir);
1445         MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
1446                 mainMtpStorage.getStorageId()).stream()
1447                 .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
1448         MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
1449                 mainMtpStorage.getStorageId()).stream()
1450                 .filter(o -> !o.isDir()).findFirst().get();
1451         Assert.assertTrue(manager.beginMoveObject(fileObj, dirObj));
1452 
1453         Assert.assertTrue(manager.endMoveObject(
1454                 manager.getStorageRoot(mainMtpStorage.getStorageId()),
1455                 dirObj, newFile.getName(), false));
1456 
1457         Assert.assertEquals(objectsAdded.size(), 0);
1458         Assert.assertEquals(objectsInfoChanged.size(), 0);
1459         Assert.assertEquals(objectsRemoved.size(), 0);
1460 
1461         Assert.assertTrue(manager.checkConsistency());
1462     }
1463 
1464     @Test
1465     @SmallTest
testMoveObjectFailedOldRemoved()1466     public void testMoveObjectFailedOldRemoved() {
1467         logMethodName();
1468         File newFile = createNewFileNonZero(mainStorageDir);
1469         File dir = createNewDir(mainStorageDir);
1470         MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
1471                 mainMtpStorage.getStorageId()).stream()
1472                 .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
1473         MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
1474                 mainMtpStorage.getStorageId()).stream()
1475                 .filter(o -> !o.isDir()).findFirst().get();
1476         Assert.assertTrue(manager.beginMoveObject(fileObj, dirObj));
1477 
1478         Assert.assertTrue(newFile.delete());
1479         manager.flushEvents();
1480         Assert.assertTrue(manager.endMoveObject(
1481                 manager.getStorageRoot(mainMtpStorage.getStorageId()),
1482                 dirObj, newFile.getName(), false));
1483 
1484         Assert.assertEquals(objectsAdded.size(), 0);
1485         Assert.assertEquals(objectsInfoChanged.size(), 0);
1486         Assert.assertEquals(objectsRemoved.size(), 1);
1487 
1488         Assert.assertTrue(manager.checkConsistency());
1489     }
1490 
1491     @Test
1492     @SmallTest
testMoveObjectFailedNewAdded()1493     public void testMoveObjectFailedNewAdded() {
1494         logMethodName();
1495         File newFile = createNewFileNonZero(mainStorageDir);
1496         File dir = createNewDir(mainStorageDir);
1497         MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
1498                 mainMtpStorage.getStorageId()).stream()
1499                 .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
1500         MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
1501                 mainMtpStorage.getStorageId()).stream()
1502                 .filter(o -> !o.isDir()).findFirst().get();
1503         Assert.assertTrue(manager.beginMoveObject(fileObj, dirObj));
1504 
1505         createNewFileNonZero(dir, newFile.getName());
1506         manager.flushEvents();
1507         Assert.assertTrue(manager.endMoveObject(
1508                 manager.getStorageRoot(mainMtpStorage.getStorageId()),
1509                 dirObj, newFile.getName(), false));
1510 
1511         Assert.assertEquals(objectsAdded.size(), 1);
1512         Assert.assertEquals(objectsRemoved.size(), 0);
1513 
1514         Assert.assertTrue(manager.checkConsistency());
1515     }
1516 
1517     @Test
1518     @SmallTest
testMoveObjectXStorageSuccess()1519     public void testMoveObjectXStorageSuccess() {
1520         logMethodName();
1521         File newFile = createNewFileNonZero(mainStorageDir);
1522         MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
1523                 mainMtpStorage.getStorageId()).get(0);
1524         Assert.assertTrue(manager.beginMoveObject(fileObj,
1525                 manager.getStorageRoot(secondaryMtpStorage.getStorageId())));
1526 
1527         Assert.assertTrue(newFile.delete());
1528         File moved = createNewFileNonZero(secondaryStorageDir, newFile.getName());
1529         manager.flushEvents();
1530         Assert.assertTrue(manager.endMoveObject(
1531                 manager.getStorageRoot(mainMtpStorage.getStorageId()),
1532                 manager.getStorageRoot(secondaryMtpStorage.getStorageId()),
1533                 newFile.getName(), true));
1534 
1535         Assert.assertEquals(objectsAdded.size(), 0);
1536         Assert.assertEquals(objectsRemoved.size(), 0);
1537         Assert.assertEquals(manager.getObject(fileObj.getId()).getPath().toString(),
1538                 moved.getPath());
1539 
1540         Assert.assertTrue(manager.checkConsistency());
1541     }
1542 
1543     @Test
1544     @SmallTest
testMoveObjectXStorageDirSuccess()1545     public void testMoveObjectXStorageDirSuccess() {
1546         logMethodName();
1547         File movedDir = createNewDir(mainStorageDir);
1548         MtpStorageManager.MtpObject movedObj = manager.getObjects(0xFFFFFFFF, 0,
1549                 mainMtpStorage.getStorageId()).get(0);
1550         Assert.assertTrue(manager.beginMoveObject(movedObj,
1551                 manager.getStorageRoot(secondaryMtpStorage.getStorageId())));
1552 
1553         Assert.assertTrue(movedDir.delete());
1554         File moved = createNewDir(secondaryStorageDir, movedDir.getName());
1555         manager.flushEvents();
1556         Assert.assertTrue(manager.endMoveObject(
1557                 manager.getStorageRoot(mainMtpStorage.getStorageId()),
1558                 manager.getStorageRoot(secondaryMtpStorage.getStorageId()),
1559                 movedDir.getName(), true));
1560 
1561         Assert.assertEquals(objectsAdded.size(), 0);
1562         Assert.assertEquals(objectsInfoChanged.size(), 0);
1563         Assert.assertEquals(objectsRemoved.size(), 0);
1564         Assert.assertEquals(manager.getObject(movedObj.getId()).getPath().toString(),
1565                 moved.getPath());
1566 
1567         Assert.assertTrue(manager.checkConsistency());
1568 
1569         // Don't expect events
1570         createNewFile(moved);
1571         manager.flushEvents();
1572         Assert.assertEquals(objectsAdded.size(), 0);
1573         Assert.assertEquals(objectsInfoChanged.size(), 0);
1574         Assert.assertTrue(manager.checkConsistency());
1575     }
1576 
1577     @Test
1578     @SmallTest
testMoveObjectXStorageDirVisitedSuccess()1579     public void testMoveObjectXStorageDirVisitedSuccess() {
1580         logMethodName();
1581         File movedDir = createNewDir(mainStorageDir);
1582         MtpStorageManager.MtpObject movedObj = manager.getObjects(0xFFFFFFFF, 0,
1583                 mainMtpStorage.getStorageId()).get(0);
1584         manager.getObjects(movedObj.getId(), 0, mainMtpStorage.getStorageId());
1585         Assert.assertTrue(manager.beginMoveObject(movedObj,
1586                 manager.getStorageRoot(secondaryMtpStorage.getStorageId())));
1587 
1588         Assert.assertTrue(movedDir.delete());
1589         File moved = createNewDir(secondaryStorageDir, movedDir.getName());
1590         manager.flushEvents();
1591         Assert.assertTrue(manager.endMoveObject(
1592                 manager.getStorageRoot(mainMtpStorage.getStorageId()),
1593                 manager.getStorageRoot(secondaryMtpStorage.getStorageId()),
1594                 movedDir.getName(), true));
1595 
1596         Assert.assertEquals(objectsAdded.size(), 0);
1597         Assert.assertEquals(objectsInfoChanged.size(), 0);
1598         Assert.assertEquals(objectsRemoved.size(), 0);
1599         Assert.assertEquals(manager.getObject(movedObj.getId()).getPath().toString(),
1600                 moved.getPath());
1601 
1602         Assert.assertTrue(manager.checkConsistency());
1603 
1604         // Expect events since the dir was visited
1605         createNewFileNonZero(moved);
1606         manager.flushEvents();
1607         Assert.assertEquals(objectsAdded.size(), 1);
1608         Assert.assertTrue(manager.checkConsistency());
1609     }
1610 
1611     @Test
1612     @SmallTest
testMoveObjectXStorageDelayed()1613     public void testMoveObjectXStorageDelayed() {
1614         logMethodName();
1615         File movedFile = createNewFileNonZero(mainStorageDir);
1616         MtpStorageManager.MtpObject movedObj = manager.getObjects(0xFFFFFFFF, 0,
1617                 mainMtpStorage.getStorageId()).get(0);
1618         Assert.assertTrue(manager.beginMoveObject(movedObj,
1619                 manager.getStorageRoot(secondaryMtpStorage.getStorageId())));
1620 
1621         Assert.assertTrue(manager.endMoveObject(
1622                 manager.getStorageRoot(mainMtpStorage.getStorageId()),
1623                 manager.getStorageRoot(secondaryMtpStorage.getStorageId()),
1624                 movedFile.getName(), true));
1625 
1626         Assert.assertTrue(movedFile.delete());
1627         File moved = createNewFileNonZero(secondaryStorageDir, movedFile.getName());
1628         manager.flushEvents();
1629 
1630         Assert.assertEquals(objectsAdded.size(), 0);
1631         Assert.assertEquals(objectsRemoved.size(), 0);
1632         Assert.assertEquals(manager.getObject(movedObj.getId()).getPath().toString(),
1633                 moved.getPath());
1634 
1635         Assert.assertTrue(manager.checkConsistency());
1636     }
1637 
1638     @Test
1639     @SmallTest
testMoveObjectXStorageDirVisitedDelayed()1640     public void testMoveObjectXStorageDirVisitedDelayed() {
1641         logMethodName();
1642         File movedDir = createNewDir(mainStorageDir);
1643         MtpStorageManager.MtpObject movedObj = manager.getObjects(0xFFFFFFFF, 0,
1644                 mainMtpStorage.getStorageId()).get(0);
1645         manager.getObjects(movedObj.getId(), 0, mainMtpStorage.getStorageId());
1646         Assert.assertTrue(manager.beginMoveObject(movedObj,
1647                 manager.getStorageRoot(secondaryMtpStorage.getStorageId())));
1648 
1649         Assert.assertTrue(manager.endMoveObject(
1650                 manager.getStorageRoot(mainMtpStorage.getStorageId()),
1651                 manager.getStorageRoot(secondaryMtpStorage.getStorageId()),
1652                 movedDir.getName(), true));
1653 
1654         Assert.assertTrue(movedDir.delete());
1655         File moved = createNewDir(secondaryStorageDir, movedDir.getName());
1656         manager.flushEvents();
1657 
1658         Assert.assertEquals(objectsAdded.size(), 0);
1659         Assert.assertEquals(objectsInfoChanged.size(), 0);
1660         Assert.assertEquals(objectsRemoved.size(), 0);
1661         Assert.assertEquals(manager.getObject(movedObj.getId()).getPath().toString(),
1662                 moved.getPath());
1663 
1664         Assert.assertTrue(manager.checkConsistency());
1665 
1666         // Expect events since the dir was visited
1667         createNewFileNonZero(moved);
1668         manager.flushEvents();
1669         Assert.assertEquals(objectsAdded.size(), 1);
1670         Assert.assertTrue(manager.checkConsistency());
1671     }
1672 
1673     @Test
1674     @SmallTest
testMoveObjectXStorageFailed()1675     public void testMoveObjectXStorageFailed() {
1676         logMethodName();
1677         File newFile = createNewFileNonZero(mainStorageDir);
1678         MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
1679                 mainMtpStorage.getStorageId()).get(0);
1680         Assert.assertTrue(manager.beginMoveObject(fileObj,
1681                 manager.getStorageRoot(secondaryMtpStorage.getStorageId())));
1682 
1683         Assert.assertTrue(manager.endMoveObject(
1684                 manager.getStorageRoot(mainMtpStorage.getStorageId()),
1685                 manager.getStorageRoot(secondaryMtpStorage.getStorageId()),
1686                 newFile.getName(), false));
1687 
1688         Assert.assertEquals(objectsAdded.size(), 0);
1689         Assert.assertEquals(objectsInfoChanged.size(), 0);
1690         Assert.assertEquals(objectsRemoved.size(), 0);
1691 
1692         Assert.assertTrue(manager.checkConsistency());
1693     }
1694 
1695     @Test
1696     @SmallTest
testMoveObjectXStorageFailedOldRemoved()1697     public void testMoveObjectXStorageFailedOldRemoved() {
1698         logMethodName();
1699         File newFile = createNewFileNonZero(mainStorageDir);
1700         MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
1701                 mainMtpStorage.getStorageId()).get(0);
1702         Assert.assertTrue(manager.beginMoveObject(fileObj,
1703                 manager.getStorageRoot(secondaryMtpStorage.getStorageId())));
1704 
1705         Assert.assertTrue(newFile.delete());
1706         manager.flushEvents();
1707         Assert.assertTrue(manager.endMoveObject(
1708                 manager.getStorageRoot(mainMtpStorage.getStorageId()),
1709                 manager.getStorageRoot(secondaryMtpStorage.getStorageId()),
1710                 newFile.getName(), false));
1711 
1712         Assert.assertEquals(objectsAdded.size(), 0);
1713         Assert.assertEquals(objectsInfoChanged.size(), 0);
1714         Assert.assertEquals(objectsRemoved.size(), 1);
1715 
1716         Assert.assertTrue(manager.checkConsistency());
1717     }
1718 
1719     @Test
1720     @SmallTest
testMoveObjectXStorageFailedNewAdded()1721     public void testMoveObjectXStorageFailedNewAdded() {
1722         logMethodName();
1723         File newFile = createNewFileNonZero(mainStorageDir);
1724         MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
1725                 mainMtpStorage.getStorageId()).get(0);
1726         Assert.assertTrue(manager.beginMoveObject(fileObj,
1727                 manager.getStorageRoot(secondaryMtpStorage.getStorageId())));
1728 
1729         createNewFileNonZero(secondaryStorageDir, newFile.getName());
1730         manager.flushEvents();
1731         Assert.assertTrue(manager.endMoveObject(
1732                 manager.getStorageRoot(mainMtpStorage.getStorageId()),
1733                 manager.getStorageRoot(secondaryMtpStorage.getStorageId()),
1734                 newFile.getName(), false));
1735 
1736         Assert.assertEquals(objectsAdded.size(), 1);
1737         Assert.assertEquals(objectsRemoved.size(), 0);
1738 
1739         Assert.assertTrue(manager.checkConsistency());
1740     }
1741 }
1742