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