Move BaseSingleMergeTest to test-utils

Will be easier to include in other projects then.
And it is where TreeAbstractTest is.

1 files changed, 0 insertions, 709 deletions

diff --git a/libs/io/src/test/java/org/the_jk/cleversync/io/BaseSingleMergeTest.kt b/libs/io/src/test/java/org/the_jk/cleversync/io/BaseSingleMergeTest.kt
deleted file mode 100644
index 65d870b..0000000
--- a/libs/io/src/test/java/org/the_jk/cleversync/io/BaseSingleMergeTest.kt
+++ /dev/null
@@ -1,709 +0,0 @@
-package org.the_jk.cleversync.io
-
-import com.google.common.truth.Correspondence
-import com.google.common.truth.Truth.assertThat
-import org.junit.Assert
-import org.junit.Assume
-import org.junit.Before
-import org.junit.Test
-import kotlin.time.Duration
-
-abstract class BaseSingleMergeTest {
-    private lateinit var src: ModifiableTree
-    private lateinit var tgt: ModifiableTree
-
-    @Before
-    fun setUp() {
-        src = source()
-        tgt = target()
-    }
-
-    @Test
-    fun empty() {
-        assertThat(SingleMerge.calculate(tgt, src)).isEmpty()
-    }
-
-    @Test
-    fun oneFile() {
-        val srcFile = src.createFile("foo")
-        srcFile.write().writer().use { it.write("Hello World") }
-
-        val actions = SingleMerge.calculate(tgt, src)
-        assertThat(actions).containsExactly(Action.Copy("foo"))
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-
-        val tgtFile = tgt.openFile("foo")
-        assertThat(tgtFile?.read()?.reader()?.use { it.readText() }).isEqualTo("Hello World")
-    }
-
-    @Test
-    fun oneFileAlreadyExistsSameContent() {
-        val srcFile = src.createFile("foo")
-        srcFile.write().writer().use { it.write("Hello World") }
-        val tgtFile = tgt.createFile("foo")
-        tgtFile.write().writer().use { it.write("Hello World") }
-
-        assertThat(SingleMerge.calculate(tgt, src)).isEmpty()
-    }
-
-    @Test
-    fun oneFileAlreadyExistsDifferentContent() {
-        val srcFile = src.createFile("foo")
-        srcFile.write().writer().use { it.write("Hello World") }
-        val tgtFile = tgt.createFile("foo")
-        tgtFile.write().writer().use { it.write("Bye bye!") }
-
-        val actions = SingleMerge.calculate(tgt, src)
-        assertThat(actions).containsExactly(Action.Copy("foo", overwrite = true))
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-
-        val newTgtFile = tgt.openFile("foo")
-        assertThat(newTgtFile?.read()?.reader()?.use { it.readText() }).isEqualTo("Hello World")
-    }
-
-    @Test
-    fun oneFileAlreadyExistsSameSizeContentOlder() {
-        val tgtFile = tgt.createFile("foo")
-        tgtFile.write().writer().use { it.write("Cruel World") }
-        Thread.sleep(minModificationTime().inWholeMilliseconds)
-        val srcFile = src.createFile("foo")
-        srcFile.write().writer().use { it.write("Hello World") }
-
-        val actions = SingleMerge.calculate(tgt, src)
-        assertThat(actions).containsExactly(Action.Copy("foo", overwrite = true))
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-
-        val newTgtFile = tgt.openFile("foo")
-        assertThat(newTgtFile?.read()?.reader()?.use { it.readText() }).isEqualTo("Hello World")
-    }
-
-    @Test
-    fun oneFileAlreadyExistsSameSizeContentNewer() {
-        val srcFile = src.createFile("foo")
-        srcFile.write().writer().use { it.write("Hello World") }
-        Thread.sleep(minModificationTime().inWholeMilliseconds)
-        val tgtFile = tgt.createFile("foo")
-        tgtFile.write().writer().use { it.write("hello world") }
-
-        assertThat(SingleMerge.calculate(tgt, src)).isEmpty()
-    }
-
-    @Test
-    fun filesInDirectories() {
-        val srcFoo = src.createFile("foo")
-        srcFoo.write().writer().use { it.write("Hello World") }
-        val srcDir = src.createDirectory("bar")
-        val srcBarFoo = srcDir.createFile("foo")
-        srcBarFoo.write().writer().use { it.write("World Hello") }
-
-        val actions = SingleMerge.calculate(tgt, src)
-        assertThat(actions).containsExactly(
-            Action.Copy("foo"),
-            Action.ChangeDir("bar", listOf(Action.Copy("foo")), create = true),
-        )
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-
-        val tgtFoo = tgt.openFile("foo")
-        assertThat(tgtFoo?.read()?.reader()?.use { it.readText() }).isEqualTo("Hello World")
-        val tgtBarFoo = tgt.openFile("bar/foo")
-        assertThat(tgtBarFoo?.read()?.reader()?.use { it.readText() }).isEqualTo("World Hello")
-    }
-
-    @Test
-    fun dirInDirInDir() {
-        val srcFoo = src.createDirectory("foo")
-        val srcFooBar = srcFoo.createDirectory("bar")
-        srcFooBar.createDirectory("fum")
-
-        val actions = SingleMerge.calculate(tgt, src)
-        assertThat(actions).containsExactly(
-            Action.ChangeDir(
-                "foo",
-                listOf(
-                    Action.ChangeDir(
-                        "bar",
-                        listOf(
-                            Action.ChangeDir(
-                                "fum",
-                                emptyList(),
-                                create = true,
-                            ),
-                        ),
-                        create = true,
-                    ),
-                ),
-                create = true,
-            ),
-        )
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-
-        val tgtFooBarFum = tgt.openDir("foo/bar/fum")
-        assertThat(tgtFooBarFum).isNotNull()
-        assertThat(tgtFooBarFum?.list()?.directories).isEmpty()
-    }
-
-    @Test
-    fun symlink() {
-        Assume.assumeTrue(sourceSupportsSymlinks() && targetSupportsSymlinks())
-
-        val srcFoo = src.createFile("foo")
-        srcFoo.write().writer().use { it.write("Hello World") }
-
-        src.createLink("link1", srcFoo)
-        src.createLink("link2", "does-not-exist")
-        src.createLink("link3", "../../escaped")
-
-        val actions = SingleMerge.calculate(tgt, src)
-        assertThat(actions).containsExactly(
-            Action.Copy("foo"),
-            Action.Link("link1", "foo"),
-            Action.Link("link2", "does-not-exist"),
-        )
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-
-        val tgtFoo = tgt.openFile("foo")
-        assertThat(tgtFoo?.read()?.reader()?.use { it.readText() }).isEqualTo("Hello World")
-        val tgtLink1 = tgt.openLink("link1")
-        when (val linkTarget = tgtLink1?.resolve()) {
-            is Link.FileTarget -> assertThat(linkTarget.file).isEqualTo(tgtFoo)
-            else -> Assert.fail()
-        }
-        val tgtLink2 = tgt.openLink("link2")
-        when (val linkTarget = tgtLink2?.resolve()) {
-            is Link.NoTarget -> assertThat(linkTarget.path).isEqualTo("does-not-exist")
-            else -> Assert.fail()
-        }
-        assertThat(tgt.openLink("link3")).isNull()
-    }
-
-    @Test
-    fun resolveSymlink() {
-        Assume.assumeTrue(sourceSupportsSymlinks())
-
-        val srcFoo = src.createFile("foo")
-        srcFoo.write().writer().use { it.write("Hello World") }
-        val srcBar = src.createDirectory("bar")
-
-        src.createLink("link1", srcFoo)
-        src.createLink("link2", srcBar)
-        src.createLink("link3", "does-not-exist")
-
-        val actions = SingleMerge.calculate(tgt, src, options = SingleMerge.Options(
-            resolveLinks = true,
-        ))
-        assertThat(actions).containsExactly(
-            Action.Copy("foo"),
-            Action.Copy("link1"),
-            Action.ChangeDir("bar", emptyList(), create = true),
-            Action.ChangeDir("link2", emptyList(), create = true),
-        )
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-
-        val tgtFoo = tgt.openFile("foo")
-        assertThat(tgtFoo?.read()?.reader()?.use { it.readText() }).isEqualTo("Hello World")
-        val tgtLink1 = tgt.openFile("link1")
-        assertThat(tgtLink1?.read()?.reader()?.use { it.readText() }).isEqualTo("Hello World")
-        assertThat(tgt.openDir("bar")).isNotNull()
-        assertThat(tgt.openDir("link2")).isNotNull()
-    }
-
-    @Test
-    fun symlinkInDir() {
-        Assume.assumeTrue(sourceSupportsSymlinks() && targetSupportsSymlinks())
-
-        val srcFoo = src.createDirectory("foo")
-        srcFoo.createLink("link", srcFoo)
-
-        val actions = SingleMerge.calculate(tgt, src)
-        assertThat(actions).containsExactly(
-            Action.ChangeDir(
-                "foo",
-                listOf(Action.Link("link", "../foo")),
-                create = true,
-            ),
-        )
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-
-        val tgtFoo = tgt.openDir("foo")
-        val tgtLink = tgtFoo?.openLink("link")
-        when (val linkTarget = tgtLink?.resolve()) {
-            is Link.DirectoryTarget -> assertThat(linkTarget.directory).isEqualTo(tgtFoo)
-            else -> Assert.fail()
-        }
-    }
-
-    @Test
-    fun symlinkUpdate() {
-        Assume.assumeTrue(sourceSupportsSymlinks() && targetSupportsSymlinks())
-
-        src.createLink("link", "does-not-exist")
-        tgt.createLink("link", "also-does-not-exist")
-
-        val actions = SingleMerge.calculate(tgt, src)
-        assertThat(actions).containsExactly(
-            Action.Link(
-                "link",
-                target = "does-not-exist",
-                overwrite = true,
-            ),
-        )
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-
-        val tgtLink = tgt.openLink("link")
-        when (val linkTarget = tgtLink?.resolve()) {
-            is Link.NoTarget -> assertThat(linkTarget.path).isEqualTo("does-not-exist")
-            else -> Assert.fail()
-        }
-    }
-
-    @Test
-    fun symlinkNoUpdate() {
-        Assume.assumeTrue(sourceSupportsSymlinks() && targetSupportsSymlinks())
-
-        src.createLink("link", "does-not-exist")
-        tgt.createLink("link", "does-not-exist")
-
-        assertThat(SingleMerge.calculate(tgt, src)).isEmpty()
-    }
-
-    @Test
-    fun deleteInTarget() {
-        val tgtFoo = tgt.createFile("foo")
-        tgtFoo.write().writer().use { it.write("aaa") }
-        val tgtBar = tgt.createDirectory("bar")
-        val tgtBarFoo = tgtBar.createFile("foo")
-        tgtBarFoo.write().writer().use { it.write("aaa") }
-
-        val actions = SingleMerge.calculate(tgt, src, options =  SingleMerge.Options(
-            deleteFilesOnlyInTarget = true,
-        ))
-        assertThat(actions).containsExactly(
-            Action.RemoveFile("foo"),
-            Action.RemoveDir("bar"),
-        )
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-
-        val content = tgt.list()
-        assertThat(content.directories).isEmpty()
-        assertThat(content.files).isEmpty()
-        assertThat(content.links).isEmpty()
-    }
-
-    @Test
-    fun deleteInTargetMixed() {
-        val srcFoo = src.createFile("foo")
-        srcFoo.write().writer().use { it.write("Hello World") }
-        val srcDir = src.createDirectory("bar")
-        val srcBarFoo = srcDir.createFile("foo")
-        srcBarFoo.write().writer().use { it.write("World Hello") }
-
-        val tgtFile = tgt.createFile("file")
-        tgtFile.write().writer().use { it.write("aaa") }
-        val tgtBar = tgt.createDirectory("bar")
-        val tgtBarFile = tgtBar.createFile("file")
-        tgtBarFile.write().writer().use { it.write("aaa") }
-
-        val actions = SingleMerge.calculate(tgt, src, options =  SingleMerge.Options(
-            deleteFilesOnlyInTarget = true,
-        ))
-        assertThat(actions).containsExactly(
-            Action.Copy("foo"),
-            Action.RemoveFile("file"),
-            Action.ChangeDir(
-                "bar",
-                listOf(
-                    Action.Copy("foo"),
-                    Action.RemoveFile("file"),
-                ),
-            ),
-        )
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-
-        val tgtFoo = tgt.openFile("foo")
-        assertThat(tgtFoo?.read()?.reader()?.use { it.readText() }).isEqualTo("Hello World")
-        assertThat(tgt.openFile("file")).isNull()
-        val tgtBarFoo = tgt.openFile("bar/foo")
-        assertThat(tgtBarFoo?.read()?.reader()?.use { it.readText() }).isEqualTo("World Hello")
-        assertThat(tgt.openFile("bar/file")).isNull()
-    }
-
-    @Test
-    fun deleteInTargetLink() {
-        Assume.assumeTrue(targetSupportsSymlinks())
-
-        tgt.createLink("foo", "does-not-exist")
-
-        val actions = SingleMerge.calculate(tgt, src, options =  SingleMerge.Options(
-            deleteFilesOnlyInTarget = true,
-        ))
-        assertThat(actions).containsExactly(Action.RemoveLink("foo"))
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-
-        assertThat(tgt.list().links).isEmpty()
-    }
-
-    @Test
-    fun mixedTypes() {
-        Assume.assumeTrue(targetSupportsSymlinks())
-
-        val srcFoo = src.createFile("foo")
-        srcFoo.write().writer().use { it.write("Hello World") }
-        src.createDirectory("bar")
-
-        val tgtBar = tgt.createFile("bar")
-        tgtBar.write().writer().use { it.write("Remove me") }
-        tgt.createLink("foo", tgtBar)
-
-        val actions = SingleMerge.calculate(tgt, src)
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-
-        val tgtBar2 = tgt.openDir("bar")
-        assertThat(tgtBar2).isNotNull()
-        val tgtFoo = tgt.openFile("foo")
-        assertThat(tgtFoo?.read()?.reader()?.use { it.readText() }).isEqualTo("Hello World")
-    }
-
-    @Test
-    fun mixedTypes2() {
-        Assume.assumeTrue(targetSupportsSymlinks())
-
-        src.createDirectory("foo")
-
-        tgt.createLink("foo", "does-not-exist")
-
-        val actions = SingleMerge.calculate(tgt, src)
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-
-        assertThat(tgt.openDir("foo")).isNotNull()
-    }
-
-    @Test
-    fun mixedTypes3() {
-        val srcFoo = src.createFile("foo")
-        srcFoo.write().writer().use { it.write("Hello World") }
-        src.createDirectory("bar")
-
-        val tgtBar = tgt.createFile("bar")
-        tgtBar.write().writer().use { it.write("Remove me") }
-        tgt.createDirectory("foo")
-
-        val actions = SingleMerge.calculate(tgt, src)
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-
-        assertThat(tgt.openFile("foo")?.read()?.reader()?.use { it.readText() }).isEqualTo("Hello World")
-        assertThat(tgt.openDir("bar")).isNotNull()
-    }
-
-    @Test
-    fun mixedTypes4() {
-        Assume.assumeTrue(sourceSupportsSymlinks() && targetSupportsSymlinks())
-
-        src.createLink("foo", "does-not-exist")
-        src.createLink("bar", "also-does-not-exist")
-
-        tgt.createDirectory("foo")
-        tgt.createFile("bar").write().writer().use { it.write("Foo") }
-
-        val actions = SingleMerge.calculate(tgt, src)
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-
-        val tgtFoo = tgt.openLink("foo")
-        when (val linkTarget = tgtFoo?.resolve()) {
-            is Link.NoTarget -> assertThat(linkTarget.path).isEqualTo("does-not-exist")
-            else -> Assert.fail()
-        }
-        val tgtBar = tgt.openLink("bar")
-        when (val linkTarget = tgtBar?.resolve()) {
-            is Link.NoTarget -> assertThat(linkTarget.path).isEqualTo("also-does-not-exist")
-            else -> Assert.fail()
-        }
-    }
-
-    @Test
-    fun errorSourceDirGone() {
-        val foo = src.createDirectory("foo")
-        foo.createFile("bar").write().use { it.write(1) }
-
-        val actions = SingleMerge.calculate(tgt, src)
-
-        assertThat(actions).containsExactly(
-            Action.ChangeDir("foo", actions = listOf(Action.Copy("bar", overwrite = false)), create = true),
-        )
-
-        assertThat(src.removeDirectory("foo")).isTrue()
-
-        assertThat(Modifier.apply(tgt, src, actions)).containsExactly("/foo: Source directory does not exist")
-        assertThat(tgt.list().directories).isEmpty()
-        assertThat(tgt.list().files).isEmpty()
-        assertThat(tgt.list().links).isEmpty()
-    }
-
-    @Test
-    fun errorTargetDirGone() {
-        val foo = src.createDirectory("foo")
-        foo.createFile("bar").write().use { it.write(1) }
-        tgt.createDirectory("foo")
-
-        val actions = SingleMerge.calculate(tgt, src)
-
-        assertThat(actions).containsExactly(
-            Action.ChangeDir("foo", actions = listOf(Action.Copy("bar", overwrite = false)), create = false),
-        )
-
-        assertThat(tgt.removeDirectory("foo")).isTrue()
-
-        assertThat(Modifier.apply(tgt, src, actions)).containsExactly("foo: Target directory does not exist")
-        assertThat(tgt.list().directories).isEmpty()
-        assertThat(tgt.list().files).isEmpty()
-        assertThat(tgt.list().links).isEmpty()
-    }
-
-    @Test
-    fun errorUnableToCreateTargetDir() {
-        val foo = src.createDirectory("foo")
-        foo.createFile("bar").write().use { it.write(1) }
-
-        val actions = SingleMerge.calculate(tgt, src)
-
-        assertThat(actions).containsExactly(
-            Action.ChangeDir("foo", actions = listOf(Action.Copy("bar", overwrite = false)), create = true),
-        )
-
-        val tgtFoo = tgt.createFile("foo")
-        tgtFoo.write().use { it.write(2) }
-
-        assertThat(Modifier.apply(tgt, src, actions)).containsExactly("foo: Unable to create directory")
-        assertThat(tgt.list().directories).isEmpty()
-        assertThat(tgt.list().files).containsExactly(tgtFoo)
-        assertThat(tgt.list().links).isEmpty()
-    }
-
-    @Test
-    fun errorSourceFileGone() {
-        src.createFile("foo").write().use { it.write(1) }
-
-        val actions = SingleMerge.calculate(tgt, src)
-
-        assertThat(actions).containsExactly(Action.Copy("foo", overwrite = false))
-
-        assertThat(src.removeFile("foo")).isTrue()
-
-        assertThat(Modifier.apply(tgt, src, actions)).containsExactly("/foo: Unable to open file")
-        assertThat(tgt.list().directories).isEmpty()
-        assertThat(tgt.list().files).isEmpty()
-        assertThat(tgt.list().links).isEmpty()
-    }
-
-    @Test
-    fun errorSourceFileIsNowADirectory() {
-        src.createFile("foo").write().use { it.write(1) }
-
-        val actions = SingleMerge.calculate(tgt, src)
-
-        assertThat(actions).containsExactly(Action.Copy("foo", overwrite = false))
-
-        assertThat(src.removeFile("foo")).isTrue()
-        src.createDirectory("foo")
-
-        assertThat(Modifier.apply(tgt, src, actions)).containsExactly("/foo: Unable to open file")
-        assertThat(tgt.list().directories).isEmpty()
-        assertThat(tgt.list().files).isEmpty()
-        assertThat(tgt.list().links).isEmpty()
-    }
-
-    @Test
-    fun errorTargetFileExists() {
-        src.createFile("foo").write().use { it.write(1) }
-
-        val actions = SingleMerge.calculate(tgt, src)
-
-        assertThat(actions).containsExactly(Action.Copy("foo", overwrite = false))
-
-        val tgtFoo = tgt.createFile("foo")
-        tgtFoo.write().use { it.write(2) }
-
-        assertThat(Modifier.apply(tgt, src, actions)).comparingElementsUsing(
-            Correspondence.from({ a: String, b: String -> a.startsWith(b) }, "startsWith"),
-        ).containsExactly("/foo: Unable to create file: ")
-        assertThat(tgt.list().directories).isEmpty()
-        assertThat(tgt.list().files).containsExactly(tgtFoo)
-        assertThat(tgtFoo.read().use { it.readAllBytes() }).asList().containsExactly(2.toByte())
-        assertThat(tgt.list().links).isEmpty()
-    }
-
-    @Test
-    fun errorTargetFileExists2() {
-        src.createFile("foo").write().use { it.write(1) }
-
-        val actions = SingleMerge.calculate(tgt, src)
-
-        assertThat(actions).containsExactly(Action.Copy("foo", overwrite = false))
-
-        val tgtFoo = tgt.createDirectory("foo")
-
-        assertThat(Modifier.apply(tgt, src, actions)).comparingElementsUsing(
-            Correspondence.from({ a: String, b: String -> a.startsWith(b) }, "startsWith"),
-        ).containsExactly("/foo: Unable to create file: ")
-        assertThat(tgt.list().directories).containsExactly(tgtFoo)
-        assertThat(tgt.list().files).isEmpty()
-        assertThat(tgt.list().links).isEmpty()
-    }
-
-    @Test
-    fun errorTargetLinkExists() {
-        Assume.assumeTrue(sourceSupportsSymlinks() && targetSupportsSymlinks())
-
-        src.createLink("foo", "bar")
-
-        val actions = SingleMerge.calculate(tgt, src)
-
-        assertThat(actions).containsExactly(Action.Link("foo", "bar", overwrite = false))
-
-        val tgtFoo = tgt.createFile("foo")
-        tgtFoo.write().use { it.write(2) }
-
-        assertThat(Modifier.apply(tgt, src, actions)).comparingElementsUsing(
-            Correspondence.from({ a: String, b: String -> a.startsWith(b) }, "startsWith"),
-        ).containsExactly("/foo: Unable to create link: ")
-        assertThat(tgt.list().directories).isEmpty()
-        assertThat(tgt.list().files).containsExactly(tgtFoo)
-        assertThat(tgtFoo.read().use { it.readAllBytes() }).asList().containsExactly(2.toByte())
-        assertThat(tgt.list().links).isEmpty()
-    }
-
-    @Test
-    fun errorTargetLinkExists2() {
-        Assume.assumeTrue(sourceSupportsSymlinks() && targetSupportsSymlinks())
-
-        src.createLink("foo", "bar")
-
-        val actions = SingleMerge.calculate(tgt, src)
-
-        assertThat(actions).containsExactly(Action.Link("foo", "bar", overwrite = false))
-
-        val tgtFoo = tgt.createDirectory("foo")
-
-        assertThat(Modifier.apply(tgt, src, actions)).comparingElementsUsing(
-            Correspondence.from({ a: String, b: String -> a.startsWith(b) }, "startsWith"),
-        ).containsExactly("/foo: Unable to create link: ")
-        assertThat(tgt.list().directories).containsExactly(tgtFoo)
-        assertThat(tgt.list().files).isEmpty()
-        assertThat(tgt.list().links).isEmpty()
-    }
-
-    @Test
-    fun targetDirAlreadyGone() {
-        tgt.createDirectory("foo")
-
-        val actions = SingleMerge.calculate(tgt, src, options = SingleMerge.Options(deleteFilesOnlyInTarget = true))
-
-        assertThat(actions).containsExactly(Action.RemoveDir("foo"))
-
-        assertThat(tgt.removeDirectory("foo")).isTrue()
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-    }
-
-    @Test
-    fun errorTargetDirIsNowAFile() {
-        tgt.createDirectory("foo")
-
-        val actions = SingleMerge.calculate(tgt, src, options = SingleMerge.Options(deleteFilesOnlyInTarget = true))
-
-        assertThat(actions).containsExactly(Action.RemoveDir("foo"))
-
-        assertThat(tgt.removeDirectory("foo")).isTrue()
-        val foo = tgt.createFile("foo")
-        foo.write().use { it.write(1) }
-
-        assertThat(Modifier.apply(tgt, src, actions)).containsExactly("/foo: Unable to remove dir")
-        assertThat(tgt.list().directories).isEmpty()
-        assertThat(tgt.list().files).containsExactly(foo)
-        assertThat(tgt.list().links).isEmpty()
-    }
-
-    @Test
-    fun targetFileAlreadyGone() {
-        tgt.createFile("foo").write().use { it.write(1) }
-
-        val actions = SingleMerge.calculate(tgt, src, options = SingleMerge.Options(deleteFilesOnlyInTarget = true))
-
-        assertThat(actions).containsExactly(Action.RemoveFile("foo"))
-
-        assertThat(tgt.removeFile("foo")).isTrue()
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-    }
-
-    @Test
-    fun errorTargetFileIsNowADir() {
-        tgt.createFile("foo").write().use { it.write(1) }
-
-        val actions = SingleMerge.calculate(tgt, src, options = SingleMerge.Options(deleteFilesOnlyInTarget = true))
-
-        assertThat(actions).containsExactly(Action.RemoveFile("foo"))
-
-        assertThat(tgt.removeFile("foo")).isTrue()
-        val foo = tgt.createDirectory("foo")
-
-        assertThat(Modifier.apply(tgt, src, actions)).containsExactly("/foo: Unable to remove file")
-        assertThat(tgt.list().directories).containsExactly(foo)
-        assertThat(tgt.list().files).isEmpty()
-        assertThat(tgt.list().links).isEmpty()
-    }
-
-    @Test
-    fun targetLinkAlreadyGone() {
-        Assume.assumeTrue(targetSupportsSymlinks())
-        tgt.createLink("foo", "bar")
-
-        val actions = SingleMerge.calculate(tgt, src, options = SingleMerge.Options(deleteFilesOnlyInTarget = true))
-
-        assertThat(actions).containsExactly(Action.RemoveLink("foo"))
-
-        assertThat(tgt.removeLink("foo")).isTrue()
-
-        assertThat(Modifier.apply(tgt, src, actions)).isEmpty()
-    }
-
-    @Test
-    fun errorTargetLinkIsNowADir() {
-        Assume.assumeTrue(targetSupportsSymlinks())
-        tgt.createLink("foo", "bar")
-
-        val actions = SingleMerge.calculate(tgt, src, options = SingleMerge.Options(deleteFilesOnlyInTarget = true))
-
-        assertThat(actions).containsExactly(Action.RemoveLink("foo"))
-
-        assertThat(tgt.removeLink("foo")).isTrue()
-        val foo = tgt.createDirectory("foo")
-
-        assertThat(Modifier.apply(tgt, src, actions)).containsExactly("/foo: Unable to remove link")
-        assertThat(tgt.list().directories).containsExactly(foo)
-        assertThat(tgt.list().files).isEmpty()
-        assertThat(tgt.list().links).isEmpty()
-    }
-
-    abstract fun source(): ModifiableTree
-    abstract fun sourceSupportsSymlinks(): Boolean
-    abstract fun target(): ModifiableTree
-    abstract fun targetSupportsSymlinks(): Boolean
-
-    abstract fun minModificationTime(): Duration
-}