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