summaryrefslogtreecommitdiff
path: root/app/src/test/java/org
diff options
context:
space:
mode:
Diffstat (limited to 'app/src/test/java/org')
-rw-r--r--app/src/test/java/org/the_jk/cleversync/StringUtilsTest.kt40
-rw-r--r--app/src/test/java/org/the_jk/cleversync/io/LocalTreeTest.kt323
2 files changed, 0 insertions, 363 deletions
diff --git a/app/src/test/java/org/the_jk/cleversync/StringUtilsTest.kt b/app/src/test/java/org/the_jk/cleversync/StringUtilsTest.kt
deleted file mode 100644
index 6a36156..0000000
--- a/app/src/test/java/org/the_jk/cleversync/StringUtilsTest.kt
+++ /dev/null
@@ -1,40 +0,0 @@
-package org.the_jk.cleversync
-
-import com.google.common.truth.Truth.assertThat
-import org.junit.Test
-
-class StringUtilsTest {
- @Test
- fun splitEmpty() {
- assertThat(StringUtils.split("", '.', keepEmpty = true)).containsExactly("")
- assertThat(StringUtils.split("", '.', keepEmpty = false)).isEmpty()
- }
-
- @Test
- fun splitSanity() {
- assertThat(StringUtils.split("a.bb.a", '.')).containsExactly("a", "bb", "a").inOrder()
- assertThat(StringUtils.split(".a.bb.a", '.', keepEmpty = true)).containsExactly("", "a", "bb", "a").inOrder()
- assertThat(StringUtils.split(".a.bb.a", '.', keepEmpty = false)).containsExactly("a", "bb", "a").inOrder()
- assertThat(StringUtils.split(".a.bb.a.", '.', keepEmpty = true))
- .containsExactly("", "a", "bb", "a", "").inOrder()
- assertThat(StringUtils.split(".a.bb.a.", '.', keepEmpty = false)).containsExactly("a", "bb", "a").inOrder()
- }
-
- @Test
- fun splitDouble() {
- assertThat(StringUtils.split("foo..bar", '.', keepEmpty = true)).containsExactly("foo", "", "bar").inOrder()
- assertThat(StringUtils.split("foo..bar", '.', keepEmpty = false)).containsExactly("foo", "bar").inOrder()
- }
-
- @Test
- fun splitLimit() {
- assertThat(StringUtils.split("a.bb.a", '.', limit = 1)).containsExactly("a.bb.a")
- assertThat(StringUtils.split("a.bb.a", '.', limit = 2)).containsExactly("a", "bb.a").inOrder()
- assertThat(StringUtils.split("a.bb.a", '.', limit = 3)).containsExactly("a", "bb", "a").inOrder()
- assertThat(StringUtils.split("a.bb.a.", '.', limit = 3, keepEmpty = true))
- .containsExactly("a", "bb", "a.").inOrder()
- assertThat(StringUtils.split("a.bb.a.", '.', limit = 3, keepEmpty = false))
- .containsExactly("a", "bb", "a").inOrder()
- assertThat(StringUtils.split("a.bb.a", '.', limit = 1000)).containsExactly("a", "bb", "a").inOrder()
- }
-}
diff --git a/app/src/test/java/org/the_jk/cleversync/io/LocalTreeTest.kt b/app/src/test/java/org/the_jk/cleversync/io/LocalTreeTest.kt
deleted file mode 100644
index 7b83c98..0000000
--- a/app/src/test/java/org/the_jk/cleversync/io/LocalTreeTest.kt
+++ /dev/null
@@ -1,323 +0,0 @@
-package org.the_jk.cleversync.io
-
-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.safeValue
-
-@Config(manifest=Config.NONE)
-@RunWith(RobolectricTestRunner::class)
-class LocalTreeTest {
- @get:Rule
- val folder = TemporaryFolder()
-
- private lateinit var tree: ModifiableTree
-
- @Before
- fun setUp() {
- tree = TreeFactory.localModifiableTree(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(4.toULong())
- }
- 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()
- }
-}
generated by cgit v1.2.3-70-g09d2 (git 2.52.0) at 2025-12-07 12:34:28 +0000