Add MtpStorageManager for monitoring filesystem events

MtpStorageManager keeps track of file information and
send notifications for new files. MtpDatabase now uses
this instead of MediaProvider for getting object information,
although some operations are still reflected into MP.

Since MtpStorageManager handles storage ids, remove
that field from StorageVolume and VolumeInfo.

Clean up a lot of the jni code for MtpDatabase.

Bug: 63143623
Test: Test every MtpOperation in a variety of situations on Linux and
Windows. Also use the shell to manipulate files. Verify that the cache
is consistent throughout, and the operations behave as expected. Verify
files created by the shell appear.
Test: adb shell am instrument -w android.mtp /android.support.test.runner.AndroidJUnitRunner
Change-Id: Id4ea810047b0c323399cd833047733e5daafb30a

4 files changed, 1715 insertions, 0 deletions

diff --git a/media/tests/MtpTests/Android.mk b/media/tests/MtpTests/Android.mk
new file mode 100644
index 000000000000..616e600ad6e7
--- /dev/null
+++ b/media/tests/MtpTests/Android.mk
@@ -0,0 +1,12 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SRC_FILES := $(call all-subdir-java-files)
+
+LOCAL_STATIC_JAVA_LIBRARIES := android-support-test
+
+LOCAL_PACKAGE_NAME := MtpTests
+
+include $(BUILD_PACKAGE)
diff --git a/media/tests/MtpTests/AndroidManifest.xml b/media/tests/MtpTests/AndroidManifest.xml
new file mode 100644
index 000000000000..21e2b0115878
--- /dev/null
+++ b/media/tests/MtpTests/AndroidManifest.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2008 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="android.mtp" >
+
+    <uses-sdk android:minSdkVersion="21" android:targetSdkVersion="21" />
+
+    <uses-permission  android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+
+    <application>
+        <uses-library android:name="android.test.runner" />
+    </application>
+
+    <instrumentation android:name="android.support.test.runner.AndroidJUnitRunner"
+                     android:targetPackage="android.mtp"
+                     android:label="MtpTests"/>
+</manifest>
diff --git a/media/tests/MtpTests/AndroidTest.xml b/media/tests/MtpTests/AndroidTest.xml
new file mode 100644
index 000000000000..a61a3b49c8f7
--- /dev/null
+++ b/media/tests/MtpTests/AndroidTest.xml
@@ -0,0 +1,15 @@
+<configuration description="Runs sample instrumentation test.">
+    <target_preparer class="com.android.tradefed.targetprep.TestFilePushSetup"/>
+    <target_preparer class="com.android.tradefed.targetprep.TestAppInstallSetup">
+        <option name="test-file-name" value="MtpTests.apk"/>
+    </target_preparer>
+    <target_preparer class="com.android.tradefed.targetprep.PushFilePreparer"/>
+    <target_preparer class="com.android.tradefed.targetprep.RunCommandTargetPreparer"/>
+    <option name="test-suite-tag" value="apct"/>
+    <option name="test-tag" value="MtpTests"/>
+
+    <test class="com.android.tradefed.testtype.AndroidJUnitTest">
+        <option name="package" value="android.mtp"/>
+        <option name="runner" value="android.support.test.runner.AndroidJUnitRunner"/>
+    </test>
+</configuration>
\ No newline at end of file
diff --git a/media/tests/MtpTests/src/android/mtp/MtpStorageManagerTest.java b/media/tests/MtpTests/src/android/mtp/MtpStorageManagerTest.java
new file mode 100644
index 000000000000..0d7f3feaaae6
--- /dev/null
+++ b/media/tests/MtpTests/src/android/mtp/MtpStorageManagerTest.java
@@ -0,0 +1,1657 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package android.mtp;
+
+import android.os.FileUtils;
+import android.os.UserHandle;
+import android.os.storage.StorageVolume;
+import android.support.test.filters.SmallTest;
+import android.support.test.InstrumentationRegistry;
+import android.util.Log;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.UUID;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+/**
+ * Tests for MtpStorageManager functionality.
+ */
+@RunWith(JUnit4.class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class MtpStorageManagerTest {
+    private static final String TAG = MtpStorageManagerTest.class.getSimpleName();
+
+    private static final String TEMP_DIR = InstrumentationRegistry.getContext().getFilesDir()
+            + "/" + TAG + "/";
+    private static final File TEMP_DIR_FILE = new File(TEMP_DIR);
+
+    private MtpStorageManager manager;
+
+    private ArrayList<Integer> objectsAdded;
+    private ArrayList<Integer> objectsRemoved;
+
+    private File mainStorageDir;
+    private File secondaryStorageDir;
+
+    private MtpStorage mainMtpStorage;
+    private MtpStorage secondaryMtpStorage;
+
+    static {
+        MtpStorageManager.sDebug = true;
+    }
+
+    private static void logMethodName() {
+        Log.d(TAG, Thread.currentThread().getStackTrace()[3].getMethodName());
+    }
+
+    private static File createNewFile(File parent) {
+        return createNewFile(parent, UUID.randomUUID().toString());
+    }
+
+    private static File createNewFile(File parent, String name) {
+        try {
+            File ret = new File(parent, name);
+            if (!ret.createNewFile())
+                throw new AssertionError("Failed to create file");
+            return ret;
+        } catch (IOException e) {
+            throw new AssertionError(e.getMessage());
+        }
+    }
+
+    private static File createNewDir(File parent, String name) {
+        File ret = new File(parent, name);
+        if (!ret.mkdir())
+            throw new AssertionError("Failed to create file");
+        return ret;
+    }
+
+    private static File createNewDir(File parent) {
+        return createNewDir(parent, UUID.randomUUID().toString());
+    }
+
+    @Before
+    public void before() {
+        Assert.assertTrue(TEMP_DIR_FILE.mkdir());
+        mainStorageDir = createNewDir(TEMP_DIR_FILE);
+        secondaryStorageDir = createNewDir(TEMP_DIR_FILE);
+
+        StorageVolume mainStorage = new StorageVolume("1", mainStorageDir, "", true, false, true,
+                false, -1, UserHandle.CURRENT, "", "");
+        StorageVolume secondaryStorage = new StorageVolume("2", secondaryStorageDir, "", false,
+                false, true, false, -1, UserHandle.CURRENT, "", "");
+
+        objectsAdded = new ArrayList<>();
+        objectsRemoved = new ArrayList<>();
+
+        manager = new MtpStorageManager(new MtpStorageManager.MtpNotifier() {
+            @Override
+            public void sendObjectAdded(int id) {
+                objectsAdded.add(id);
+            }
+
+            @Override
+            public void sendObjectRemoved(int id) {
+                objectsRemoved.add(id);
+            }
+        }, null);
+
+        mainMtpStorage = manager.addMtpStorage(mainStorage);
+        secondaryMtpStorage = manager.addMtpStorage(secondaryStorage);
+    }
+
+    @After
+    public void after() {
+        manager.close();
+        FileUtils.deleteContentsAndDir(TEMP_DIR_FILE);
+    }
+
+    /** MtpObject getter tests. **/
+
+    @Test
+    @SmallTest
+    public void testMtpObjectGetNameRoot() {
+        logMethodName();
+        MtpStorageManager.MtpObject obj = manager.getStorageRoot(mainMtpStorage.getStorageId());
+        Assert.assertEquals(obj.getName(), mainStorageDir.getPath());
+    }
+
+    @Test
+    @SmallTest
+    public void testMtpObjectGetNameNonRoot() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.findFirst().get().getName(), newFile.getName());
+    }
+
+    @Test
+    @SmallTest
+    public void testMtpObjectGetIdRoot() {
+        logMethodName();
+        MtpStorageManager.MtpObject obj = manager.getStorageRoot(mainMtpStorage.getStorageId());
+        Assert.assertEquals(obj.getId(), mainMtpStorage.getStorageId());
+    }
+
+    @Test
+    @SmallTest
+    public void testMtpObjectGetIdNonRoot() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.findFirst().get().getId(), 1);
+    }
+
+    @Test
+    @SmallTest
+    public void testMtpObjectIsDirTrue() {
+        logMethodName();
+        MtpStorageManager.MtpObject obj = manager.getStorageRoot(mainMtpStorage.getStorageId());
+        Assert.assertTrue(obj.isDir());
+    }
+
+    @Test
+    @SmallTest
+    public void testMtpObjectIsDirFalse() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir, "TEST123.mp3");
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertFalse(stream.findFirst().get().isDir());
+    }
+
+    @Test
+    @SmallTest
+    public void testMtpObjectGetFormatDir() {
+        logMethodName();
+        File newFile = createNewDir(mainStorageDir);
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.findFirst().get().getFormat(), MtpConstants.FORMAT_ASSOCIATION);
+    }
+
+    @Test
+    @SmallTest
+    public void testMtpObjectGetFormatNonDir() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir, "TEST123.mp3");
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.findFirst().get().getFormat(), MtpConstants.FORMAT_MP3);
+    }
+
+    @Test
+    @SmallTest
+    public void testMtpObjectGetStorageId() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.findFirst().get().getStorageId(), mainMtpStorage.getStorageId());
+    }
+
+    @Test
+    @SmallTest
+    public void testMtpObjectGetLastModified() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.findFirst().get().getModifiedTime(),
+                newFile.lastModified() / 1000);
+    }
+
+    @Test
+    @SmallTest
+    public void testMtpObjectGetParent() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.findFirst().get().getParent(),
+                manager.getStorageRoot(mainMtpStorage.getStorageId()));
+    }
+
+    @Test
+    @SmallTest
+    public void testMtpObjectGetRoot() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.findFirst().get().getRoot(),
+                manager.getStorageRoot(mainMtpStorage.getStorageId()));
+    }
+
+    @Test
+    @SmallTest
+    public void testMtpObjectGetPath() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.findFirst().get().getPath().toString(), newFile.getPath());
+    }
+
+    @Test
+    @SmallTest
+    public void testMtpObjectGetSize() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        try {
+            new FileOutputStream(newFile).write(new byte[] {0, 0, 0, 0, 0, 0, 0, 0});
+        } catch (IOException e) {
+            Assert.fail();
+        }
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.findFirst().get().getSize(), 8);
+    }
+
+    @Test
+    @SmallTest
+    public void testMtpObjectGetSizeDir() {
+        logMethodName();
+        File newDir = createNewDir(mainStorageDir);
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.findFirst().get().getSize(), 0);
+    }
+
+    /** MtpStorageManager cache access tests. **/
+
+    @Test
+    @SmallTest
+    public void testAddMtpStorage() {
+        logMethodName();
+        Assert.assertEquals(mainMtpStorage.getPath(), mainStorageDir.getPath());
+        Assert.assertNotNull(manager.getStorageRoot(mainMtpStorage.getStorageId()));
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRemoveMtpStorage() {
+        logMethodName();
+        File newFile = createNewFile(secondaryStorageDir);
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                secondaryMtpStorage.getStorageId());
+        Assert.assertEquals(stream.count(), 1);
+
+        manager.removeMtpStorage(secondaryMtpStorage);
+        Assert.assertNull(manager.getStorageRoot(secondaryMtpStorage.getStorageId()));
+        Assert.assertNull(manager.getObject(1));
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testGetByPath() {
+        logMethodName();
+        File newFile = createNewFile(createNewDir(createNewDir(mainStorageDir)));
+
+        MtpStorageManager.MtpObject obj = manager.getByPath(newFile.getPath());
+        Assert.assertNotNull(obj);
+        Assert.assertEquals(obj.getPath().toString(), newFile.getPath());
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testGetByPathError() {
+        logMethodName();
+        File newFile = createNewFile(createNewDir(createNewDir(mainStorageDir)));
+
+        MtpStorageManager.MtpObject obj = manager.getByPath(newFile.getPath() + "q");
+        Assert.assertNull(obj);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testGetObject() {
+        logMethodName();
+        File newFile = createNewFile(createNewDir(createNewDir(mainStorageDir)));
+        MtpStorageManager.MtpObject obj = manager.getByPath(newFile.getPath());
+        Assert.assertNotNull(obj);
+
+        Assert.assertEquals(manager.getObject(obj.getId()), obj);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testGetObjectError() {
+        logMethodName();
+        File newFile = createNewFile(createNewDir(createNewDir(mainStorageDir)));
+
+        Assert.assertNull(manager.getObject(42));
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testGetStorageRoot() {
+        logMethodName();
+        MtpStorageManager.MtpObject obj = manager.getStorageRoot(mainMtpStorage.getStorageId());
+        Assert.assertEquals(obj.getPath().toString(), mainStorageDir.getPath());
+    }
+
+    @Test
+    @SmallTest
+    public void testGetObjectsParent() {
+        logMethodName();
+        File newDir = createNewDir(createNewDir(mainStorageDir));
+        File newFile = createNewFile(newDir);
+        File newMP3File = createNewFile(newDir, "lalala.mp3");
+        MtpStorageManager.MtpObject parent = manager.getByPath(newDir.getPath());
+        Assert.assertNotNull(parent);
+
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(parent.getId(), 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.count(), 2);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testGetObjectsFormat() {
+        logMethodName();
+        File newDir = createNewDir(createNewDir(mainStorageDir));
+        File newFile = createNewFile(newDir);
+        File newMP3File = createNewFile(newDir, "lalala.mp3");
+        MtpStorageManager.MtpObject parent = manager.getByPath(newDir.getPath());
+        Assert.assertNotNull(parent);
+
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(parent.getId(),
+                MtpConstants.FORMAT_MP3, mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.findFirst().get().getPath().toString(), newMP3File.toString());
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testGetObjectsRoot() {
+        logMethodName();
+        File newDir = createNewDir(mainStorageDir);
+        File newFile = createNewFile(mainStorageDir);
+        File newMP3File = createNewFile(newDir, "lalala.mp3");
+
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.count(), 2);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testGetObjectsAll() {
+        logMethodName();
+        File newDir = createNewDir(mainStorageDir);
+        File newFile = createNewFile(mainStorageDir);
+        File newMP3File = createNewFile(newDir, "lalala.mp3");
+
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.count(), 3);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testGetObjectsAllStorages() {
+        logMethodName();
+        File newDir = createNewDir(mainStorageDir);
+        createNewFile(mainStorageDir);
+        createNewFile(newDir, "lalala.mp3");
+        File newDir2 = createNewDir(secondaryStorageDir);
+        createNewFile(secondaryStorageDir);
+        createNewFile(newDir2, "lalala.mp3");
+
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0, 0, 0xFFFFFFFF);
+        Assert.assertEquals(stream.count(), 6);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testGetObjectsAllStoragesRoot() {
+        logMethodName();
+        File newDir = createNewDir(mainStorageDir);
+        createNewFile(mainStorageDir);
+        createNewFile(newDir, "lalala.mp3");
+        File newDir2 = createNewDir(secondaryStorageDir);
+        createNewFile(secondaryStorageDir);
+        createNewFile(newDir2, "lalala.mp3");
+
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0, 0xFFFFFFFF);
+        Assert.assertEquals(stream.count(), 4);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    /** MtpStorageManager event handling tests. **/
+
+    @Test
+    @SmallTest
+    public void testObjectAdded() {
+        logMethodName();
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.count(), 0);
+
+        File newFile = createNewFile(mainStorageDir);
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertEquals(manager.getObject(objectsAdded.get(0)).getPath().toString(),
+                newFile.getPath());
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testObjectAddedDir() {
+        logMethodName();
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.count(), 0);
+
+        File newDir = createNewDir(mainStorageDir);
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertEquals(manager.getObject(objectsAdded.get(0)).getPath().toString(),
+                newDir.getPath());
+        Assert.assertTrue(manager.getObject(objectsAdded.get(0)).isDir());
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testObjectAddedRecursiveDir() {
+        logMethodName();
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.count(), 0);
+
+        File newDir = createNewDir(createNewDir(createNewDir(mainStorageDir)));
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 3);
+        Assert.assertEquals(manager.getObject(objectsAdded.get(2)).getPath().toString(),
+                newDir.getPath());
+        Assert.assertTrue(manager.getObject(objectsAdded.get(2)).isDir());
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testObjectRemoved() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.count(), 1);
+
+        Assert.assertTrue(newFile.delete());
+        manager.flushEvents();
+        Assert.assertEquals(objectsRemoved.size(), 1);
+        Assert.assertNull(manager.getObject(objectsRemoved.get(0)));
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testObjectMoved() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        Assert.assertEquals(stream.count(), 1);
+        File toFile = new File(mainStorageDir, "to" + newFile.getName());
+
+        Assert.assertTrue(newFile.renameTo(toFile));
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertEquals(objectsRemoved.size(), 1);
+        Assert.assertEquals(manager.getObject(objectsAdded.get(0)).getPath().toString(),
+                toFile.getPath());
+        Assert.assertNull(manager.getObject(objectsRemoved.get(0)));
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    /** MtpStorageManager operation tests. Ensure that events are not sent for the main operation,
+        and also test all possible cases of other processes accessing the file at the same time, as
+        well as cases of both failure and success. **/
+
+    @Test
+    @SmallTest
+    public void testSendObjectSuccess() {
+        logMethodName();
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        int id = manager.beginSendObject(manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                "newFile", MtpConstants.FORMAT_UNDEFINED);
+        Assert.assertEquals(id, 1);
+
+        File newFile = createNewFile(mainStorageDir, "newFile");
+        manager.flushEvents();
+        MtpStorageManager.MtpObject obj = manager.getObject(id);
+        Assert.assertTrue(manager.endSendObject(obj, true));
+        Assert.assertEquals(obj.getPath().toString(), newFile.getPath());
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testSendObjectSuccessDir() {
+        logMethodName();
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        int id = manager.beginSendObject(manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                "newDir", MtpConstants.FORMAT_ASSOCIATION);
+        Assert.assertEquals(id, 1);
+
+        File newFile = createNewDir(mainStorageDir, "newDir");
+        manager.flushEvents();
+        MtpStorageManager.MtpObject obj = manager.getObject(id);
+        Assert.assertTrue(manager.endSendObject(obj, true));
+        Assert.assertEquals(obj.getPath().toString(), newFile.getPath());
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(obj.getFormat(), MtpConstants.FORMAT_ASSOCIATION);
+        Assert.assertTrue(manager.checkConsistency());
+
+        // Check that new dir receives events
+        File newerFile = createNewFile(newFile);
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertEquals(manager.getObject(objectsAdded.get(0)).getPath().toString(),
+                newerFile.getPath());
+    }
+
+    @Test
+    @SmallTest
+    public void testSendObjectSuccessDelayed() {
+        logMethodName();
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        int id = manager.beginSendObject(manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                "newFile", MtpConstants.FORMAT_UNDEFINED);
+        Assert.assertEquals(id, 1);
+        MtpStorageManager.MtpObject obj = manager.getObject(id);
+        Assert.assertTrue(manager.endSendObject(obj, true));
+
+        File newFile = createNewFile(mainStorageDir, "newFile");
+        manager.flushEvents();
+        Assert.assertEquals(obj.getPath().toString(), newFile.getPath());
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testSendObjectSuccessDirDelayed() {
+        logMethodName();
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        int id = manager.beginSendObject(manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                "newDir", MtpConstants.FORMAT_ASSOCIATION);
+        Assert.assertEquals(id, 1);
+
+        MtpStorageManager.MtpObject obj = manager.getObject(id);
+        Assert.assertTrue(manager.endSendObject(obj, true));
+        File newFile = createNewDir(mainStorageDir, "newDir");
+        manager.flushEvents();
+        Assert.assertEquals(obj.getPath().toString(), newFile.getPath());
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(obj.getFormat(), MtpConstants.FORMAT_ASSOCIATION);
+        Assert.assertTrue(manager.checkConsistency());
+
+        // Check that new dir receives events
+        File newerFile = createNewFile(newFile);
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertEquals(manager.getObject(objectsAdded.get(0)).getPath().toString(),
+                newerFile.getPath());
+    }
+
+    @Test
+    @SmallTest
+    public void testSendObjectSuccessDeleted() {
+        logMethodName();
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        int id = manager.beginSendObject(manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                "newFile", MtpConstants.FORMAT_UNDEFINED);
+        Assert.assertEquals(id, 1);
+
+        File newFile = createNewFile(mainStorageDir, "newFile");
+        Assert.assertTrue(newFile.delete());
+        manager.flushEvents();
+        MtpStorageManager.MtpObject obj = manager.getObject(id);
+        Assert.assertTrue(manager.endSendObject(obj, true));
+        Assert.assertNull(manager.getObject(obj.getId()));
+        Assert.assertEquals(objectsRemoved.get(0).intValue(), obj.getId());
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testSendObjectFailed() {
+        logMethodName();
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        int id = manager.beginSendObject(manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                "newFile", MtpConstants.FORMAT_UNDEFINED);
+        Assert.assertEquals(id, 1);
+
+        MtpStorageManager.MtpObject obj = manager.getObject(id);
+        Assert.assertTrue(manager.endSendObject(obj, false));
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testSendObjectFailedDeleted() {
+        logMethodName();
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        int id = manager.beginSendObject(manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                "newFile", MtpConstants.FORMAT_UNDEFINED);
+        Assert.assertEquals(id, 1);
+        MtpStorageManager.MtpObject obj = manager.getObject(id);
+
+        File newFile = createNewFile(mainStorageDir, "newFile");
+        Assert.assertTrue(newFile.delete());
+        manager.flushEvents();
+        Assert.assertTrue(manager.endSendObject(obj, false));
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testSendObjectFailedAdded() {
+        logMethodName();
+        Stream<MtpStorageManager.MtpObject> stream = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId());
+        int id = manager.beginSendObject(manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                "newFile", MtpConstants.FORMAT_UNDEFINED);
+        Assert.assertEquals(id, 1);
+        MtpStorageManager.MtpObject obj = manager.getObject(id);
+
+        File newDir = createNewDir(mainStorageDir, "newFile");
+        manager.flushEvents();
+        Assert.assertTrue(manager.endSendObject(obj, false));
+        Assert.assertNotEquals(objectsAdded.get(0).intValue(), id);
+        Assert.assertNull(manager.getObject(id));
+        Assert.assertEquals(manager.getObject(objectsAdded.get(0)).getPath().toString(),
+                newDir.getPath());
+        Assert.assertTrue(manager.checkConsistency());
+
+        // Expect events in new dir
+        createNewFile(newDir);
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 2);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRemoveObjectSuccess() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginRemoveObject(obj));
+
+        Assert.assertTrue(newFile.delete());
+        manager.flushEvents();
+        Assert.assertTrue(manager.endRemoveObject(obj, true));
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertNull(manager.getObject(obj.getId()));
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRemoveObjectDelayed() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginRemoveObject(obj));
+
+        Assert.assertTrue(manager.endRemoveObject(obj, true));
+        Assert.assertTrue(newFile.delete());
+        manager.flushEvents();
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertNull(manager.getObject(obj.getId()));
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRemoveObjectDir() {
+        logMethodName();
+        File newDir = createNewDir(mainStorageDir);
+        createNewFile(createNewDir(newDir));
+        MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        manager.getObjects(obj.getId(), 0, mainMtpStorage.getStorageId());
+        Assert.assertTrue(manager.beginRemoveObject(obj));
+
+        createNewFile(newDir);
+        Assert.assertTrue(FileUtils.deleteContentsAndDir(newDir));
+        manager.flushEvents();
+        Assert.assertTrue(manager.endRemoveObject(obj, true));
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertEquals(objectsRemoved.size(), 1);
+        Assert.assertEquals(manager.getObjects(0, 0, mainMtpStorage.getStorageId()).count(), 0);
+        Assert.assertNull(manager.getObject(obj.getId()));
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRemoveObjectDirDelayed() {
+        logMethodName();
+        File newDir = createNewDir(mainStorageDir);
+        createNewFile(createNewDir(newDir));
+        MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginRemoveObject(obj));
+
+        Assert.assertTrue(manager.endRemoveObject(obj, true));
+        Assert.assertTrue(FileUtils.deleteContentsAndDir(newDir));
+        manager.flushEvents();
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(manager.getObjects(0, 0, mainMtpStorage.getStorageId()).count(), 0);
+        Assert.assertNull(manager.getObject(obj.getId()));
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRemoveObjectSuccessAdded() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        int id = obj.getId();
+        Assert.assertTrue(manager.beginRemoveObject(obj));
+
+        Assert.assertTrue(newFile.delete());
+        createNewFile(mainStorageDir, newFile.getName());
+        manager.flushEvents();
+        Assert.assertTrue(manager.endRemoveObject(obj, true));
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertNull(manager.getObject(id));
+        Assert.assertNotEquals(objectsAdded.get(0).intValue(), id);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRemoveObjectFailed() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginRemoveObject(obj));
+
+        Assert.assertTrue(manager.endRemoveObject(obj, false));
+        Assert.assertEquals(manager.getObject(obj.getId()), obj);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRemoveObjectFailedDir() {
+        logMethodName();
+        File newDir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        manager.getObjects(obj.getId(), 0, mainMtpStorage.getStorageId());
+        Assert.assertTrue(manager.beginRemoveObject(obj));
+
+        createNewFile(newDir);
+        manager.flushEvents();
+        Assert.assertTrue(manager.endRemoveObject(obj, false));
+        Assert.assertEquals(manager.getObject(obj.getId()), obj);
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRemoveObjectFailedRemoved() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginRemoveObject(obj));
+
+        Assert.assertTrue(newFile.delete());
+        manager.flushEvents();
+        Assert.assertTrue(manager.endRemoveObject(obj, false));
+        Assert.assertEquals(objectsRemoved.size(), 1);
+        Assert.assertEquals(objectsRemoved.get(0).intValue(), obj.getId());
+        Assert.assertNull(manager.getObject(obj.getId()));
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testCopyObjectSuccess() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        File newDir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
+        MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> !o.isDir()).findFirst().get();
+
+        int id = manager.beginCopyObject(fileObj, dirObj);
+        Assert.assertNotEquals(id, -1);
+        createNewFile(newDir, newFile.getName());
+        manager.flushEvents();
+        MtpStorageManager.MtpObject obj = manager.getObject(id);
+        Assert.assertTrue(manager.endCopyObject(obj, true));
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testCopyObjectSuccessRecursive() {
+        logMethodName();
+        File newDirFrom = createNewDir(mainStorageDir);
+        File newDirFrom1 = createNewDir(newDirFrom);
+        File newDirFrom2 = createNewFile(newDirFrom1);
+        File delayedFile = createNewFile(newDirFrom);
+        File deletedFile = createNewFile(newDirFrom);
+        File newDirTo = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject toObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> o.getName().equals(newDirTo.getName())).findFirst().get();
+        MtpStorageManager.MtpObject fromObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> o.getName().equals(newDirFrom.getName())).findFirst().get();
+
+        manager.getObjects(fromObj.getId(), 0, mainMtpStorage.getStorageId());
+        int id = manager.beginCopyObject(fromObj, toObj);
+        Assert.assertNotEquals(id, -1);
+        File copiedDir = createNewDir(newDirTo, newDirFrom.getName());
+        File copiedDir1 = createNewDir(copiedDir, newDirFrom1.getName());
+        createNewFile(copiedDir1, newDirFrom2.getName());
+        createNewFile(copiedDir, "extraFile");
+        File toDelete = createNewFile(copiedDir, deletedFile.getName());
+        manager.flushEvents();
+        Assert.assertTrue(toDelete.delete());
+        manager.flushEvents();
+        MtpStorageManager.MtpObject obj = manager.getObject(id);
+        Assert.assertTrue(manager.endCopyObject(obj, true));
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertEquals(objectsRemoved.size(), 1);
+
+        createNewFile(copiedDir, delayedFile.getName());
+        manager.flushEvents();
+        Assert.assertTrue(manager.checkConsistency());
+
+        // Expect events in the visited dir, but not the unvisited dir.
+        createNewFile(copiedDir);
+        createNewFile(copiedDir1);
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 2);
+        Assert.assertEquals(objectsAdded.size(), 2);
+
+        // Number of files/dirs created, minus the one that was deleted.
+        Assert.assertEquals(manager.getObjects(0, 0, mainMtpStorage.getStorageId()).count(), 13);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testCopyObjectFailed() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        File newDir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
+        MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> !o.isDir()).findFirst().get();
+
+        int id = manager.beginCopyObject(fileObj, dirObj);
+        Assert.assertNotEquals(id, -1);
+        manager.flushEvents();
+        MtpStorageManager.MtpObject obj = manager.getObject(id);
+        Assert.assertTrue(manager.endCopyObject(obj, false));
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testCopyObjectFailedAdded() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        File newDir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
+        MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> !o.isDir()).findFirst().get();
+
+        int id = manager.beginCopyObject(fileObj, dirObj);
+        Assert.assertNotEquals(id, -1);
+        File addedDir = createNewDir(newDir, newFile.getName());
+        manager.flushEvents();
+        MtpStorageManager.MtpObject obj = manager.getObject(id);
+        Assert.assertTrue(manager.endCopyObject(obj, false));
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertNotEquals(objectsAdded.get(0).intValue(), id);
+        Assert.assertTrue(manager.checkConsistency());
+
+        // Expect events in new dir
+        createNewFile(addedDir);
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 2);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testCopyObjectFailedDeleted() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        File newDir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
+        MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> !o.isDir()).findFirst().get();
+
+        int id = manager.beginCopyObject(fileObj, dirObj);
+        Assert.assertNotEquals(id, -1);
+        Assert.assertTrue(createNewFile(newDir, newFile.getName()).delete());
+        manager.flushEvents();
+        MtpStorageManager.MtpObject obj = manager.getObject(id);
+        Assert.assertTrue(manager.endCopyObject(obj, false));
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRenameObjectSuccess() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginRenameObject(obj, "renamed"));
+
+        File renamed = new File(mainStorageDir, "renamed");
+        Assert.assertTrue(newFile.renameTo(renamed));
+        manager.flushEvents();
+        Assert.assertTrue(manager.endRenameObject(obj, newFile.getName(), true));
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(obj.getPath().toString(), renamed.getPath());
+
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRenameObjectDirSuccess() {
+        logMethodName();
+        File newDir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginRenameObject(obj, "renamed"));
+
+        File renamed = new File(mainStorageDir, "renamed");
+        Assert.assertTrue(newDir.renameTo(renamed));
+        manager.flushEvents();
+        Assert.assertTrue(manager.endRenameObject(obj, newDir.getName(), true));
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(obj.getPath().toString(), renamed.getPath());
+
+        Assert.assertTrue(manager.checkConsistency());
+
+        // Don't expect events
+        createNewFile(renamed);
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRenameObjectDirVisitedSuccess() {
+        logMethodName();
+        File newDir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        manager.getObjects(obj.getId(), 0, mainMtpStorage.getStorageId());
+        Assert.assertTrue(manager.beginRenameObject(obj, "renamed"));
+
+        File renamed = new File(mainStorageDir, "renamed");
+        Assert.assertTrue(newDir.renameTo(renamed));
+        manager.flushEvents();
+        Assert.assertTrue(manager.endRenameObject(obj, newDir.getName(), true));
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(obj.getPath().toString(), renamed.getPath());
+
+        Assert.assertTrue(manager.checkConsistency());
+
+        // Expect events since the dir was visited
+        createNewFile(renamed);
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRenameObjectDelayed() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginRenameObject(obj, "renamed"));
+
+        Assert.assertTrue(manager.endRenameObject(obj, newFile.getName(), true));
+        File renamed = new File(mainStorageDir, "renamed");
+        Assert.assertTrue(newFile.renameTo(renamed));
+        manager.flushEvents();
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(obj.getPath().toString(), renamed.getPath());
+
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRenameObjectDirVisitedDelayed() {
+        logMethodName();
+        File newDir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        manager.getObjects(obj.getId(), 0, mainMtpStorage.getStorageId());
+        Assert.assertTrue(manager.beginRenameObject(obj, "renamed"));
+
+        Assert.assertTrue(manager.endRenameObject(obj, newDir.getName(), true));
+        File renamed = new File(mainStorageDir, "renamed");
+        Assert.assertTrue(newDir.renameTo(renamed));
+        manager.flushEvents();
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(obj.getPath().toString(), renamed.getPath());
+
+        Assert.assertTrue(manager.checkConsistency());
+
+        // Expect events since the dir was visited
+        createNewFile(renamed);
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRenameObjectFailed() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginRenameObject(obj, "renamed"));
+
+        Assert.assertTrue(manager.endRenameObject(obj, newFile.getName(), false));
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRenameObjectFailedOldRemoved() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginRenameObject(obj, "renamed"));
+
+        Assert.assertTrue(newFile.delete());
+        manager.flushEvents();
+        Assert.assertTrue(manager.endRenameObject(obj, newFile.getName(), false));
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 1);
+
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testRenameObjectFailedNewAdded() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        MtpStorageManager.MtpObject obj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginRenameObject(obj, "renamed"));
+
+        createNewFile(mainStorageDir, "renamed");
+        manager.flushEvents();
+        Assert.assertTrue(manager.endRenameObject(obj, newFile.getName(), false));
+
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testMoveObjectSuccess() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        File dir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
+        MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> !o.isDir()).findFirst().get();
+        Assert.assertTrue(manager.beginMoveObject(fileObj, dirObj));
+
+        File moved = new File(dir, newFile.getName());
+        Assert.assertTrue(newFile.renameTo(moved));
+        manager.flushEvents();
+        Assert.assertTrue(manager.endMoveObject(
+                manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                dirObj, newFile.getName(), true));
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(fileObj.getPath().toString(), moved.getPath());
+
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testMoveObjectDirSuccess() {
+        logMethodName();
+        File newDir = createNewDir(mainStorageDir);
+        File movedDir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> o.getName().equals(newDir.getName())).findFirst().get();
+        MtpStorageManager.MtpObject movedObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> o.getName().equals(movedDir.getName())).findFirst().get();
+        Assert.assertTrue(manager.beginMoveObject(movedObj, dirObj));
+
+        File renamed = new File(newDir, movedDir.getName());
+        Assert.assertTrue(movedDir.renameTo(renamed));
+        manager.flushEvents();
+        Assert.assertTrue(manager.endMoveObject(
+                manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                dirObj, movedDir.getName(), true));
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(movedObj.getPath().toString(), renamed.getPath());
+
+        Assert.assertTrue(manager.checkConsistency());
+
+        // Don't expect events
+        createNewFile(renamed);
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testMoveObjectDirVisitedSuccess() {
+        logMethodName();
+        File newDir = createNewDir(mainStorageDir);
+        File movedDir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> o.getName().equals(newDir.getName())).findFirst().get();
+        MtpStorageManager.MtpObject movedObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> o.getName().equals(movedDir.getName())).findFirst().get();
+        manager.getObjects(movedObj.getId(), 0, mainMtpStorage.getStorageId());
+        Assert.assertTrue(manager.beginMoveObject(movedObj, dirObj));
+
+        File renamed = new File(newDir, movedDir.getName());
+        Assert.assertTrue(movedDir.renameTo(renamed));
+        manager.flushEvents();
+        Assert.assertTrue(manager.endMoveObject(
+                manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                dirObj, movedDir.getName(), true));
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(movedObj.getPath().toString(), renamed.getPath());
+
+        Assert.assertTrue(manager.checkConsistency());
+
+        // Expect events since the dir was visited
+        createNewFile(renamed);
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testMoveObjectDelayed() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        File dir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
+        MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> !o.isDir()).findFirst().get();
+        Assert.assertTrue(manager.beginMoveObject(fileObj, dirObj));
+
+        Assert.assertTrue(manager.endMoveObject(
+                manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                dirObj, newFile.getName(), true));
+
+        File moved = new File(dir, newFile.getName());
+        Assert.assertTrue(newFile.renameTo(moved));
+        manager.flushEvents();
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(fileObj.getPath().toString(), moved.getPath());
+
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testMoveObjectDirVisitedDelayed() {
+        logMethodName();
+        File newDir = createNewDir(mainStorageDir);
+        File movedDir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> o.getName().equals(newDir.getName())).findFirst().get();
+        MtpStorageManager.MtpObject movedObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> o.getName().equals(movedDir.getName())).findFirst().get();
+        manager.getObjects(movedObj.getId(), 0, mainMtpStorage.getStorageId());
+        Assert.assertTrue(manager.beginMoveObject(movedObj, dirObj));
+
+        Assert.assertTrue(manager.endMoveObject(
+                manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                dirObj, movedDir.getName(), true));
+
+        File renamed = new File(newDir, movedDir.getName());
+        Assert.assertTrue(movedDir.renameTo(renamed));
+        manager.flushEvents();
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(movedObj.getPath().toString(), renamed.getPath());
+
+        Assert.assertTrue(manager.checkConsistency());
+
+        // Expect events since the dir was visited
+        createNewFile(renamed);
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testMoveObjectFailed() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        File dir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
+        MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> !o.isDir()).findFirst().get();
+        Assert.assertTrue(manager.beginMoveObject(fileObj, dirObj));
+
+        Assert.assertTrue(manager.endMoveObject(
+                manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                dirObj, newFile.getName(), false));
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testMoveObjectFailedOldRemoved() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        File dir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
+        MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> !o.isDir()).findFirst().get();
+        Assert.assertTrue(manager.beginMoveObject(fileObj, dirObj));
+
+        Assert.assertTrue(newFile.delete());
+        manager.flushEvents();
+        Assert.assertTrue(manager.endMoveObject(
+                manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                dirObj, newFile.getName(), false));
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 1);
+
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testMoveObjectFailedNewAdded() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        File dir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject dirObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(MtpStorageManager.MtpObject::isDir).findFirst().get();
+        MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId())
+                .filter(o -> !o.isDir()).findFirst().get();
+        Assert.assertTrue(manager.beginMoveObject(fileObj, dirObj));
+
+        createNewFile(dir, newFile.getName());
+        manager.flushEvents();
+        Assert.assertTrue(manager.endMoveObject(
+                manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                dirObj, newFile.getName(), false));
+
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testMoveObjectXStorageSuccess() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginMoveObject(fileObj,
+                manager.getStorageRoot(secondaryMtpStorage.getStorageId())));
+
+        Assert.assertTrue(newFile.delete());
+        File moved = createNewFile(secondaryStorageDir, newFile.getName());
+        manager.flushEvents();
+        Assert.assertTrue(manager.endMoveObject(
+                manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                manager.getStorageRoot(secondaryMtpStorage.getStorageId()),
+                newFile.getName(), true));
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(manager.getObject(fileObj.getId()).getPath().toString(),
+                moved.getPath());
+
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testMoveObjectXStorageDirSuccess() {
+        logMethodName();
+        File movedDir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject movedObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginMoveObject(movedObj,
+                manager.getStorageRoot(secondaryMtpStorage.getStorageId())));
+
+        Assert.assertTrue(movedDir.delete());
+        File moved = createNewDir(secondaryStorageDir, movedDir.getName());
+        manager.flushEvents();
+        Assert.assertTrue(manager.endMoveObject(
+                manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                manager.getStorageRoot(secondaryMtpStorage.getStorageId()),
+                movedDir.getName(), true));
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(manager.getObject(movedObj.getId()).getPath().toString(),
+                moved.getPath());
+
+        Assert.assertTrue(manager.checkConsistency());
+
+        // Don't expect events
+        createNewFile(moved);
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testMoveObjectXStorageDirVisitedSuccess() {
+        logMethodName();
+        File movedDir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject movedObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        manager.getObjects(movedObj.getId(), 0, mainMtpStorage.getStorageId());
+        Assert.assertTrue(manager.beginMoveObject(movedObj,
+                manager.getStorageRoot(secondaryMtpStorage.getStorageId())));
+
+        Assert.assertTrue(movedDir.delete());
+        File moved = createNewDir(secondaryStorageDir, movedDir.getName());
+        manager.flushEvents();
+        Assert.assertTrue(manager.endMoveObject(
+                manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                manager.getStorageRoot(secondaryMtpStorage.getStorageId()),
+                movedDir.getName(), true));
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(manager.getObject(movedObj.getId()).getPath().toString(),
+                moved.getPath());
+
+        Assert.assertTrue(manager.checkConsistency());
+
+        // Expect events since the dir was visited
+        createNewFile(moved);
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testMoveObjectXStorageDelayed() {
+        logMethodName();
+        File movedFile = createNewFile(mainStorageDir);
+        MtpStorageManager.MtpObject movedObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginMoveObject(movedObj,
+                manager.getStorageRoot(secondaryMtpStorage.getStorageId())));
+
+        Assert.assertTrue(manager.endMoveObject(
+                manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                manager.getStorageRoot(secondaryMtpStorage.getStorageId()),
+                movedFile.getName(), true));
+
+        Assert.assertTrue(movedFile.delete());
+        File moved = createNewFile(secondaryStorageDir, movedFile.getName());
+        manager.flushEvents();
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(manager.getObject(movedObj.getId()).getPath().toString(),
+                moved.getPath());
+
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testMoveObjectXStorageDirVisitedDelayed() {
+        logMethodName();
+        File movedDir = createNewDir(mainStorageDir);
+        MtpStorageManager.MtpObject movedObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        manager.getObjects(movedObj.getId(), 0, mainMtpStorage.getStorageId());
+        Assert.assertTrue(manager.beginMoveObject(movedObj,
+                manager.getStorageRoot(secondaryMtpStorage.getStorageId())));
+
+        Assert.assertTrue(manager.endMoveObject(
+                manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                manager.getStorageRoot(secondaryMtpStorage.getStorageId()),
+                movedDir.getName(), true));
+
+        Assert.assertTrue(movedDir.delete());
+        File moved = createNewDir(secondaryStorageDir, movedDir.getName());
+        manager.flushEvents();
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+        Assert.assertEquals(manager.getObject(movedObj.getId()).getPath().toString(),
+                moved.getPath());
+
+        Assert.assertTrue(manager.checkConsistency());
+
+        // Expect events since the dir was visited
+        createNewFile(moved);
+        manager.flushEvents();
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testMoveObjectXStorageFailed() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginMoveObject(fileObj,
+                manager.getStorageRoot(secondaryMtpStorage.getStorageId())));
+
+        Assert.assertTrue(manager.endMoveObject(
+                manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                manager.getStorageRoot(secondaryMtpStorage.getStorageId()),
+                newFile.getName(), false));
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testMoveObjectXStorageFailedOldRemoved() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginMoveObject(fileObj,
+                manager.getStorageRoot(secondaryMtpStorage.getStorageId())));
+
+        Assert.assertTrue(newFile.delete());
+        manager.flushEvents();
+        Assert.assertTrue(manager.endMoveObject(
+                manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                manager.getStorageRoot(secondaryMtpStorage.getStorageId()),
+                newFile.getName(), false));
+
+        Assert.assertEquals(objectsAdded.size(), 0);
+        Assert.assertEquals(objectsRemoved.size(), 1);
+
+        Assert.assertTrue(manager.checkConsistency());
+    }
+
+    @Test
+    @SmallTest
+    public void testMoveObjectXStorageFailedNewAdded() {
+        logMethodName();
+        File newFile = createNewFile(mainStorageDir);
+        MtpStorageManager.MtpObject fileObj = manager.getObjects(0xFFFFFFFF, 0,
+                mainMtpStorage.getStorageId()).findFirst().get();
+        Assert.assertTrue(manager.beginMoveObject(fileObj,
+                manager.getStorageRoot(secondaryMtpStorage.getStorageId())));
+
+        createNewFile(secondaryStorageDir, newFile.getName());
+        manager.flushEvents();
+        Assert.assertTrue(manager.endMoveObject(
+                manager.getStorageRoot(mainMtpStorage.getStorageId()),
+                manager.getStorageRoot(secondaryMtpStorage.getStorageId()),
+                newFile.getName(), false));
+
+        Assert.assertEquals(objectsAdded.size(), 1);
+        Assert.assertEquals(objectsRemoved.size(), 0);
+
+        Assert.assertTrue(manager.checkConsistency());
+    }
+}
\ No newline at end of file