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