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