1 files changed, 3 insertions, 306 deletions
diff --git a/libs/local/src/test/java/org/the_jk/cleversync/local/LocalTreeTest.kt b/libs/local/src/test/java/org/the_jk/cleversync/local/LocalTreeTest.kt
index a7d0afa..e2d4264 100644
--- a/libs/local/src/test/java/org/the_jk/cleversync/local/LocalTreeTest.kt
+++ b/libs/local/src/test/java/org/the_jk/cleversync/local/LocalTreeTest.kt
@@ -1,326 +1,23 @@
 package org.the_jk.cleversync.local
 
-import com.google.common.truth.Truth.assertThat
-import org.junit.Assert
 import org.junit.Before
 import org.junit.Rule
-import org.junit.Test
 import org.junit.rules.TemporaryFolder
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
 import org.robolectric.annotation.Config
-import org.robolectric.shadows.ShadowLooper
-import org.the_jk.cleversync.io.Directory
-import org.the_jk.cleversync.io.Link
-import org.the_jk.cleversync.io.ModifiableLink
-import org.the_jk.cleversync.io.ModifiableTree
-import org.the_jk.cleversync.safeValue
+import org.the_jk.cleversync.TreeAbstractTest
 
 @Config(manifest=Config.NONE)
 @RunWith(RobolectricTestRunner::class)
-class LocalTreeTest {
+class LocalTreeTest : TreeAbstractTest() {
     @get:Rule
     val folder = TemporaryFolder()
 
-    private lateinit var tree: ModifiableTree
-
     @Before
     fun setUp() {
         tree = LocalTreeFactory.modifiableTree(folder.root.toPath())
     }
 
-    @Test
-    fun empty() {
-        val content = tree.list()
-        assertThat(content.directories).isEmpty()
-        assertThat(content.files).isEmpty()
-        assertThat(content.links).isEmpty()
-    }
-
-    @Test
-    fun emptyLive() {
-        val content = tree.liveList().safeValue()
-        assertThat(content?.directories).isEmpty()
-        assertThat(content?.files).isEmpty()
-        assertThat(content?.links).isEmpty()
-    }
-
-    @Test
-    fun createDirectory() {
-        val foo = tree.createDirectory("foo")
-        assertThat(foo.name).isEqualTo("foo")
-        val fooContent = foo.list()
-        assertThat(fooContent.directories).isEmpty()
-        assertThat(fooContent.files).isEmpty()
-        assertThat(fooContent.links).isEmpty()
-        val content = tree.list()
-        assertThat(content.directories).contains(foo)
-        assertThat(content.files).isEmpty()
-        assertThat(content.links).isEmpty()
-    }
-
-    @Test
-    fun observeCreateDirectory() {
-        val content = tree.liveList()
-        var dir: Directory? = null
-        content.observeForever {
-            if (it.directories.size == 1) dir = it.directories[0]
-        }
-        tree.createDirectory("foo")
-        while (dir == null) {
-            ShadowLooper.idleMainLooper()
-        }
-        assertThat(dir?.name).isEqualTo("foo")
-    }
-
-    @Test
-    fun createFile() {
-        val foo = tree.createFile("foo")
-        // Files are not created until you write to them.
-        assertThat(tree.list().files).isEmpty()
-        foo.write().use { os ->
-            os.write(byteArrayOf(1, 2, 3, 4))
-        }
-        assertThat(tree.list().files).contains(foo)
-        assertThat(foo.size).isEqualTo(4.toULong())
-        foo.read().use {
-            assertThat(it.readBytes()).isEqualTo(byteArrayOf(1, 2, 3, 4))
-        }
-    }
-
-    @Test
-    fun overwriteFile() {
-        val foo = tree.createFile("foo")
-        foo.write().use { os ->
-            os.write(byteArrayOf(1, 2, 3, 4))
-        }
-        foo.write().use { os ->
-            os.write(127)
-            os.write(byteArrayOf(1))
-            os.write(byteArrayOf(2), 0, 0)
-        }
-        assertThat(foo.size).isEqualTo(2.toULong())
-        assertThat(tree.list().files).hasSize(1)
-        foo.read().use {
-            assertThat(it.readBytes()).isEqualTo(byteArrayOf(127, 1))
-        }
-    }
-
-    @Test
-    fun removeDir() {
-        tree.createDirectory("foo")
-        tree.removeDirectory("foo")
-        assertThat(tree.list().directories).isEmpty()
-    }
-
-    @Test
-    fun removeDirLive() {
-        tree.createDirectory("foo")
-        val content = tree.liveList()
-        var done = false
-        content.observeForever {
-            if (it.directories.isEmpty()) done = true
-        }
-        tree.removeDirectory("foo")
-        while (!done) {
-            ShadowLooper.idleMainLooper()
-        }
-    }
-
-    @Test
-    fun createLink() {
-        val dir = tree.createDirectory("dir")
-        val file = tree.createFile("file")
-        val link = tree.createLink("link", dir.name)
-        var target = link.resolve()
-        when (target) {
-            is Link.DirectoryTarget -> assertThat(target.directory).isEqualTo(
-                dir
-            )
-            is Link.FileTarget -> Assert.fail()
-            is Link.NoTarget -> Assert.fail()
-        }
-        assertThat(tree.openDir("link")).isEqualTo(dir)
-
-        link.target(file)
-        target = link.resolve()
-        when (target) {
-            is Link.DirectoryTarget -> Assert.fail()
-            is Link.FileTarget -> Assert.fail()
-            is Link.NoTarget -> Unit
-        }
-        file.write().use { it.write(1) }
-        target = link.resolve()
-        when (target) {
-            is Link.DirectoryTarget -> Assert.fail()
-            is Link.FileTarget -> assertThat(target.file).isEqualTo(file)
-            is Link.NoTarget -> Assert.fail()
-        }
-
-        assertThat(tree.openFile("link")).isEqualTo(file)
-    }
-
-    @Test
-    fun createLinkSubdir() {
-        val foo = tree.createDirectory("foo")
-        val bar = foo.createDirectory("bar")
-        val link1 = tree.createLink("link1", "foo/bar")
-        val link2 = tree.createLink("link2", bar)
-        assertThat(link1.resolve()).isEqualTo(link2.resolve())
-        assertThat((link1.resolve() as Link.DirectoryTarget).directory).isEqualTo(bar)
-        val link3 = foo.createLink("link3", "../link1")
-        assertThat((link3.resolve() as Link.DirectoryTarget).directory).isEqualTo(bar)
-    }
-
-    @Test
-    fun createLiveLink() {
-        val content = tree.liveList()
-        var link: Link? = null
-        content.observeForever {
-            if (it.links.size == 1) link = it.links[0]
-        }
-        val dir = tree.createDirectory("dir")
-        tree.createLink("link", "dir")
-        while (link == null) {
-            ShadowLooper.idleMainLooper()
-        }
-        assertThat((link?.resolve() as Link.DirectoryTarget).directory).isEqualTo(dir)
-    }
-
-    @Test
-    fun sameDir() {
-        val dir1 = tree.createDirectory("dir")
-        val dir2 = tree.openDir("dir")
-        assertThat(dir1).isEqualTo(dir2)
-        assertThat(dir1.hashCode()).isEqualTo(dir2.hashCode())
-        assertThat(dir1.toString()).isEqualTo(dir2.toString())
-    }
-
-    @Test
-    fun sameFile() {
-        val file1 = tree.createFile("file")
-        file1.write().use { it.write(127) }
-        val file2 = tree.openFile("file")
-        assertThat(file1).isEqualTo(file2)
-        assertThat(file1.hashCode()).isEqualTo(file2.hashCode())
-        assertThat(file1.toString()).isEqualTo(file2.toString())
-    }
-
-    @Test
-    fun sameLink() {
-        val link1 = tree.createLink("link", "foo")
-        val link2 = tree.openLink("link")
-        assertThat(link1).isEqualTo(link2)
-        assertThat(link1.hashCode()).isEqualTo(link2.hashCode())
-        assertThat(link1.toString()).isEqualTo(link2.toString())
-    }
-
-    @Test
-    fun removeDirWithContent() {
-        val foo = tree.createDirectory("foo")
-        foo.createDirectory("dir")
-        foo.createFile("file").write().use { it.write(byteArrayOf(1, 2, 3, 4)) }
-        foo.createLink("link", "file")
-        assertThat(tree.list().directories).hasSize(1)
-        assertThat(tree.removeDirectory("foo")).isTrue()
-        assertThat(tree.list().directories).isEmpty()
-    }
-
-    @Test
-    fun removeWrongType() {
-        tree.createDirectory("dir")
-        assertThat(tree.removeFile("dir")).isFalse()
-        assertThat(tree.removeLink("dir")).isFalse()
-        tree.createFile("file").write().use { it.write(byteArrayOf(1, 2, 3, 4)) }
-        assertThat(tree.removeDirectory("file")).isFalse()
-        assertThat(tree.removeLink("file")).isFalse()
-        tree.createLink("link", "doesn't exist")
-        assertThat(tree.removeDirectory("link")).isFalse()
-        assertThat(tree.removeFile("link")).isFalse()
-        val content = tree.list()
-        assertThat(content.directories).hasSize(1)
-        assertThat(content.files).hasSize(1)
-        assertThat(content.links).hasSize(1)
-    }
-
-    @Test
-    fun removeFile() {
-        tree.createFile("file").write().use { it.write(byteArrayOf(1, 2, 3, 4)) }
-        assertThat(tree.list().files).hasSize(1)
-        tree.removeFile("file")
-        assertThat(tree.list().files).isEmpty()
-    }
-
-    @Test
-    fun removeLink() {
-        val dir = tree.createDirectory("dir")
-        val file = tree.createFile("file")
-        file.write().use { it.write(127) }
-        tree.createLink("link1", dir)
-        tree.createLink("link2", file)
-        assertThat(tree.list().links).hasSize(2)
-        tree.removeLink("link1")
-        tree.removeLink("link2")
-        assertThat(tree.list().links).isEmpty()
-    }
-
-    @Test
-    fun changeLink() {
-        val dir = tree.createDirectory("dir")
-        val file = tree.createFile("file")
-        file.write().use { it.write(127) }
-        val link = tree.createLink("link", "doesn't exist")
-        assertThat(link.resolve() is Link.NoTarget).isTrue()
-        link.target(file)
-        assertThat((link.resolve() as Link.FileTarget).file).isEqualTo(file)
-        link.target(dir)
-        assertThat((link.resolve() as Link.DirectoryTarget).directory).isEqualTo(dir)
-        link.target("bad")
-        assertThat(link.resolve() is Link.NoTarget).isTrue()
-    }
-
-    @Test
-    fun changeModifiableLink() {
-        val dir = tree.createDirectory("dir")
-        val file = tree.createFile("file")
-        file.write().use { it.write(127) }
-        val link = tree.createLink("link", "doesn't exist")
-        assertThat(link.modifiableResolve() is ModifiableLink.NoTarget).isTrue()
-        link.target(file)
-        assertThat((link.modifiableResolve() as ModifiableLink.ModifiableFileTarget).file).isEqualTo(file)
-        link.target(dir)
-        assertThat((link.modifiableResolve() as ModifiableLink.ModifiableDirectoryTarget).directory).isEqualTo(dir)
-        link.target("bad")
-        assertThat(link.modifiableResolve() is ModifiableLink.NoTarget).isTrue()
-    }
-
-    @Test
-    fun recursiveLink() {
-        val link = tree.createLink("link", "link")
-        assertThat(link.resolve() is Link.NoTarget).isTrue()
-    }
-
-    @Test
-    fun names() {
-        assertThat(tree.createDirectory("dir").name).isEqualTo("dir")
-        assertThat(tree.createFile("file").name).isEqualTo("file")
-        assertThat(tree.createLink("link", "file").name).isEqualTo("link")
-    }
-
-    @Test
-    fun openNonExistent() {
-        assertThat(tree.openDir("dir")).isNull()
-        assertThat(tree.openFile("file")).isNull()
-        assertThat(tree.openLink("link")).isNull()
-    }
-
-    @Test
-    fun lastModified() {
-        val file = tree.createFile("foo")
-        file.write().use { it.write(1) }
-        val old = file.lastModified
-        file.write().use { it.write(2); it.flush() }
-        val new = file.lastModified
-        assertThat(old.isBefore(new) || old == new).isTrue()
-    }
+    override fun supportSymlinks() = true
 }