Ilya Gorbunov
937 lines
36 KiB
Kotlin
937 lines
36 KiB
Kotlin
/*
|
|
* Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
|
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
|
|
*/
|
|
|
|
package kotlin.jdk7.test
|
|
|
|
import java.io.IOException
|
|
import java.nio.file.*
|
|
import java.nio.file.attribute.*
|
|
import kotlin.io.path.*
|
|
import kotlin.random.Random
|
|
import kotlin.test.*
|
|
|
|
class PathExtensionsTest : AbstractPathTest() {
|
|
private val isCaseInsensitiveFileSystem = Path("C:/") == Path("c:/")
|
|
private val isBackslashSeparator = FileSystems.getDefault().separator == "\\"
|
|
|
|
@Test
|
|
fun filenameComponents() {
|
|
fun check(path: String, name: String, nameNoExt: String, extension: String) {
|
|
val p = Path(path)
|
|
assertEquals(name, p.name, "name")
|
|
assertEquals(nameNoExt, p.nameWithoutExtension, "nameWithoutExtension")
|
|
assertEquals(extension, p.extension, "extension")
|
|
}
|
|
|
|
check(path = "aaa.bbb", name = "aaa.bbb", nameNoExt = "aaa", extension = "bbb")
|
|
check(path = "aaa", name = "aaa", nameNoExt = "aaa", extension = "")
|
|
check(path = "aaa.", name = "aaa.", nameNoExt = "aaa", extension = "")
|
|
check(path = ".aaa", name = ".aaa", nameNoExt = "", extension = "aaa")
|
|
check(path = "/dir.ext/aaa.bbb", name = "aaa.bbb", nameNoExt = "aaa", extension = "bbb")
|
|
check(path = "/dir.ext/aaa", name = "aaa", nameNoExt = "aaa", extension = "")
|
|
check(path = "/", name = "", nameNoExt = "", extension = "")
|
|
check(path = "", name = "", nameNoExt = "", extension = "")
|
|
}
|
|
|
|
@Test
|
|
fun invariantSeparators() {
|
|
val path = Path("base") / "nested" / "leaf"
|
|
assertEquals("base/nested/leaf", path.invariantSeparatorsPathString)
|
|
|
|
val path2 = Path("base", "nested", "terminal")
|
|
assertEquals("base/nested/terminal", path2.invariantSeparatorsPathString)
|
|
}
|
|
|
|
@Test
|
|
fun createNewFile() {
|
|
val dir = createTempDirectory().cleanupRecursively()
|
|
|
|
val file = dir / "new-file"
|
|
|
|
assertTrue(file.notExists())
|
|
|
|
file.createFile()
|
|
assertTrue(file.exists())
|
|
assertTrue(file.isRegularFile())
|
|
|
|
assertFailsWith<FileAlreadyExistsException> { file.createFile() }
|
|
}
|
|
|
|
@Test
|
|
fun createParentDirectories() {
|
|
val dir = createTempDirectory().cleanupRecursively()
|
|
val file = dir / "test-dir" / "sub-dir" / "new-file"
|
|
val parent = file.parent!!
|
|
|
|
assertTrue(file.notExists())
|
|
assertTrue(parent.notExists())
|
|
|
|
val result = file.createParentDirectories()
|
|
assertTrue(file.notExists())
|
|
assertTrue(parent.isDirectory())
|
|
assertEquals(file, result)
|
|
|
|
file.createFile()
|
|
file.createParentDirectories()
|
|
assertTrue(file.exists())
|
|
assertTrue(parent.isDirectory())
|
|
}
|
|
|
|
@Test
|
|
fun createParentDirectoriesRelativePath() {
|
|
run {
|
|
val path = Path("test_path_without_parent")
|
|
path.createParentDirectories()
|
|
assertTrue(path.toAbsolutePath().parent!!.isDirectory())
|
|
}
|
|
|
|
run {
|
|
val path = Path("build/test_subdirectory/test_path")
|
|
val parent = path.parent!!
|
|
assertTrue(parent.notExists())
|
|
parent.cleanupRecursively()
|
|
path.createParentDirectories()
|
|
assertTrue(path.notExists())
|
|
assertTrue(parent.isDirectory())
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun createParentDirectoriesOverExistingSymlink() {
|
|
val root = createTempDirectory("createParent-root").cleanupRecursively()
|
|
val dir = (root / "dir").createDirectory()
|
|
val link = (root / "link").tryCreateSymbolicLinkTo(dir) ?: return
|
|
val file = (link / "file")
|
|
file.createParentDirectories().writeText("txt")
|
|
assertTrue((dir / "file").isRegularFile())
|
|
}
|
|
|
|
@Test
|
|
fun createTempFileDefaultDir() {
|
|
val file1 = createTempFile().cleanup()
|
|
val file2 = createTempFile(directory = null).cleanup()
|
|
|
|
assertEquals(file1.parent, file2.parent)
|
|
}
|
|
|
|
@Test
|
|
fun createTempDirectoryDefaultDir() {
|
|
val dir1 = createTempDirectory().cleanup()
|
|
val dir2 = createTempDirectory(directory = null).cleanupRecursively()
|
|
val dir3 = createTempDirectory(dir2)
|
|
|
|
assertEquals(dir1.parent, dir2.parent)
|
|
assertNotEquals(dir2.parent, dir3.parent)
|
|
}
|
|
|
|
@Test
|
|
fun copyTo() {
|
|
val root = createTempDirectory("copyTo-root").cleanupRecursively()
|
|
val srcFile = createTempFile(root, "src")
|
|
val dstFile = createTempFile(root, "dst")
|
|
|
|
srcFile.writeText("Hello, World!")
|
|
assertFailsWith<FileAlreadyExistsException>("copy do not overwrite existing file") {
|
|
srcFile.copyTo(dstFile)
|
|
}
|
|
|
|
var dst = srcFile.copyTo(dstFile, overwrite = true)
|
|
assertSame(dst, dstFile)
|
|
compareFiles(srcFile, dst, "copy with overwrite over existing file")
|
|
|
|
srcFile.copyTo(srcFile)
|
|
srcFile.copyTo(srcFile, overwrite = true)
|
|
compareFiles(dst, srcFile, "copying file to itself leaves it intact")
|
|
|
|
assertTrue(dstFile.deleteIfExists())
|
|
dst = srcFile.copyTo(dstFile)
|
|
compareFiles(srcFile, dst, "copy to new file")
|
|
|
|
val subDst = dstFile.resolve("foo/bar")
|
|
assertFailsWith<FileSystemException> { srcFile.copyTo(subDst) }
|
|
assertFailsWith<FileSystemException> { srcFile.copyTo(subDst, overwrite = true) }
|
|
assertTrue(dstFile.deleteIfExists())
|
|
assertFailsWith<FileSystemException> { srcFile.copyTo(subDst) }
|
|
|
|
dstFile.createDirectory()
|
|
val child = dstFile.resolve("child").createFile()
|
|
assertFailsWith<DirectoryNotEmptyException>("copy with overwrite do not overwrite non-empty dir") {
|
|
srcFile.copyTo(dstFile, overwrite = true)
|
|
}
|
|
child.deleteExisting()
|
|
|
|
srcFile.copyTo(dstFile, overwrite = true)
|
|
assertEquals(srcFile.readText(), dstFile.readText(), "copy with overwrite over empty dir")
|
|
|
|
assertTrue(srcFile.deleteIfExists())
|
|
assertTrue(dstFile.deleteIfExists())
|
|
|
|
assertFailsWith<NoSuchFileException> {
|
|
srcFile.copyTo(dstFile)
|
|
}
|
|
|
|
srcFile.createDirectory()
|
|
srcFile.resolve("somefile").writeText("some content")
|
|
dstFile.writeText("")
|
|
assertFailsWith<FileAlreadyExistsException>("copy dir do not overwrite file") {
|
|
srcFile.copyTo(dstFile)
|
|
}
|
|
srcFile.copyTo(dstFile, overwrite = true)
|
|
assertTrue(dstFile.isDirectory())
|
|
assertTrue(dstFile.listDirectoryEntries().isEmpty(), "only directory is copied, but not its content")
|
|
|
|
assertFailsWith<FileAlreadyExistsException>("copy dir do not overwrite dir") {
|
|
srcFile.copyTo(dstFile)
|
|
}
|
|
|
|
srcFile.copyTo(dstFile, overwrite = true)
|
|
assertTrue(dstFile.isDirectory())
|
|
assertTrue(dstFile.listDirectoryEntries().isEmpty(), "only directory is copied, but not its content")
|
|
|
|
dstFile.resolve("somefile2").writeText("some content2")
|
|
assertFailsWith<DirectoryNotEmptyException>("copy dir do not overwrite non-empty dir") {
|
|
srcFile.copyTo(dstFile, overwrite = true)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun copyToRestrictedReadSource() {
|
|
val root = createTempDirectory("copyTo-root").cleanupRecursively()
|
|
|
|
// copy file
|
|
val srcFile = createTempFile(root, "srcFile")
|
|
val dstFile = root.resolve("dstFile")
|
|
|
|
withRestrictedRead(srcFile, alsoReset = listOf(dstFile)) {
|
|
assertFailsWith<AccessDeniedException> { srcFile.copyTo(dstFile) } // fails to copy restricted file
|
|
}
|
|
|
|
// copy directory
|
|
val srcDirectory = createTempDirectory(root, "srcDirectory")
|
|
val dstDirectory = root.resolve("dstDirectory")
|
|
|
|
withRestrictedRead(srcDirectory, alsoReset = listOf(dstDirectory)) {
|
|
srcDirectory.copyTo(dstDirectory) // successfully copies restricted directory
|
|
assertFalse(dstDirectory.isReadable()) // copies access permissions
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun copyToRestrictedWriteDestination() {
|
|
val root = createTempDirectory("copyTo-root").cleanupRecursively()
|
|
|
|
// copy file
|
|
val srcFile = createTempFile(root, "srcFile")
|
|
val dstFile = createTempFile(root, "dstFile")
|
|
|
|
withRestrictedWrite(dstFile) {
|
|
assertFailsWith<FileAlreadyExistsException> { srcFile.copyTo(dstFile) }
|
|
try {
|
|
srcFile.copyTo(dstFile, overwrite = true) // successfully overwrites restricted file in Unix
|
|
assertTrue(dstFile.isWritable()) // copies access permissions
|
|
} catch (_: AccessDeniedException) {
|
|
// Windows does not allow to overwrite readonly file
|
|
}
|
|
}
|
|
|
|
// copy directory
|
|
val srcDirectory = createTempDirectory(root, "srcDirectory")
|
|
val dstDirectory = createTempDirectory(root, "dstDirectory")
|
|
|
|
withRestrictedWrite(dstDirectory) {
|
|
assertFailsWith<FileAlreadyExistsException> { srcDirectory.copyTo(dstDirectory) }
|
|
srcDirectory.copyTo(dstDirectory, overwrite = true) // successfully overwrites restricted directory
|
|
assertTrue(dstDirectory.isWritable()) // copies access permissions
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun copyToSymlinkDestination() {
|
|
val root = createTempDirectory("copyTo-root").cleanupRecursively()
|
|
val targetFile = createTempFile(root, "targetFile").also { it.writeText("target file") }
|
|
val targetDirectory = createTempDirectory(root, "targetDirectory").also { it.resolve("a").createFile() }
|
|
|
|
// copy file
|
|
val srcFile = createTempFile(root, "srcFile").also { it.writeText("source file") }
|
|
val dstFile = root.resolve("dstFile").tryCreateSymbolicLinkTo(targetFile) ?: return
|
|
|
|
assertFailsWith<FileAlreadyExistsException> {
|
|
srcFile.copyTo(dstFile)
|
|
}
|
|
assertFailsWith<FileAlreadyExistsException> {
|
|
srcFile.copyTo(dstFile, LinkOption.NOFOLLOW_LINKS)
|
|
}
|
|
assertTrue(dstFile.isSymbolicLink())
|
|
assertEquals("target file", dstFile.readText())
|
|
|
|
// copy directory
|
|
val srcDirectory = createTempDirectory(root, "srcDirectory")
|
|
val dstDirectory = root.resolve("dstDirectory").tryCreateSymbolicLinkTo(targetDirectory) ?: return
|
|
|
|
assertFailsWith<FileAlreadyExistsException> {
|
|
srcDirectory.copyTo(dstDirectory)
|
|
}
|
|
assertFailsWith<FileAlreadyExistsException> {
|
|
srcDirectory.copyTo(dstDirectory, LinkOption.NOFOLLOW_LINKS)
|
|
}
|
|
assertTrue(dstDirectory.isSymbolicLink())
|
|
assertEquals("a", dstDirectory.listDirectoryEntries().single().name)
|
|
|
|
// overwrite file
|
|
srcFile.copyTo(dstFile, overwrite = true)
|
|
assertFalse(dstFile.isSymbolicLink())
|
|
assertEquals("source file", dstFile.readText())
|
|
assertEquals("target file", targetFile.readText())
|
|
|
|
dstFile.deleteExisting()
|
|
dstFile.tryCreateSymbolicLinkTo(targetFile)!!
|
|
srcFile.copyTo(dstFile, StandardCopyOption.REPLACE_EXISTING, LinkOption.NOFOLLOW_LINKS)
|
|
assertFalse(dstFile.isSymbolicLink())
|
|
assertEquals("source file", dstFile.readText())
|
|
assertEquals("target file", targetFile.readText())
|
|
|
|
// overwrite directory
|
|
srcDirectory.copyTo(dstDirectory, overwrite = true)
|
|
assertFalse(dstDirectory.isSymbolicLink())
|
|
assertEquals(emptyList(), dstDirectory.listDirectoryEntries())
|
|
assertEquals("a", targetDirectory.listDirectoryEntries().single().name)
|
|
|
|
dstDirectory.deleteExisting()
|
|
dstDirectory.tryCreateSymbolicLinkTo(targetDirectory)!!
|
|
srcDirectory.copyTo(dstDirectory, StandardCopyOption.REPLACE_EXISTING, LinkOption.NOFOLLOW_LINKS)
|
|
assertFalse(dstDirectory.isSymbolicLink())
|
|
assertEquals(emptyList(), dstDirectory.listDirectoryEntries())
|
|
assertEquals("a", targetDirectory.listDirectoryEntries().single().name)
|
|
}
|
|
|
|
@Test
|
|
fun copyToBrokenSymlinkDestination() {
|
|
val root = createTempDirectory("copyTo-root").cleanupRecursively()
|
|
val symlinkTarget = root.resolve("target")
|
|
|
|
// copy file
|
|
val srcFile = createTempFile(root, "srcFile").also { it.writeText("source file") }
|
|
val dstFile = root.resolve("dstFile").tryCreateSymbolicLinkTo(symlinkTarget) ?: return
|
|
|
|
assertFailsWith<FileAlreadyExistsException> {
|
|
srcFile.copyTo(dstFile)
|
|
}
|
|
assertFailsWith<FileAlreadyExistsException> {
|
|
srcFile.copyTo(dstFile, LinkOption.NOFOLLOW_LINKS)
|
|
}
|
|
assertTrue(dstFile.isSymbolicLink())
|
|
assertFailsWith<NoSuchFileException> {
|
|
dstFile.readText()
|
|
}
|
|
|
|
// copy directory
|
|
val srcDirectory = createTempDirectory(root, "srcDirectory")
|
|
val dstDirectory = root.resolve("dstDirectory").tryCreateSymbolicLinkTo(symlinkTarget) ?: return
|
|
|
|
assertFailsWith<FileAlreadyExistsException> {
|
|
srcDirectory.copyTo(dstDirectory)
|
|
}
|
|
assertFailsWith<FileAlreadyExistsException> {
|
|
srcDirectory.copyTo(dstDirectory, LinkOption.NOFOLLOW_LINKS)
|
|
}
|
|
assertTrue(dstDirectory.isSymbolicLink())
|
|
assertFailsWith<FileSystemException> { // Fails with NoSuchFileException in Unix, NotDirectoryException in Windows.
|
|
dstDirectory.listDirectoryEntries()
|
|
}
|
|
|
|
// overwrite file
|
|
srcFile.copyTo(dstFile, overwrite = true)
|
|
assertFalse(dstFile.isSymbolicLink())
|
|
assertEquals("source file", dstFile.readText())
|
|
|
|
dstFile.deleteExisting()
|
|
dstFile.tryCreateSymbolicLinkTo(symlinkTarget)!!
|
|
srcFile.copyTo(dstFile, StandardCopyOption.REPLACE_EXISTING, LinkOption.NOFOLLOW_LINKS)
|
|
assertFalse(dstFile.isSymbolicLink())
|
|
assertEquals("source file", dstFile.readText())
|
|
|
|
// overwrite directory
|
|
srcDirectory.copyTo(dstDirectory, overwrite = true)
|
|
assertFalse(dstDirectory.isSymbolicLink())
|
|
assertEquals(emptyList(), dstDirectory.listDirectoryEntries())
|
|
|
|
dstDirectory.deleteExisting()
|
|
dstDirectory.tryCreateSymbolicLinkTo(symlinkTarget)!!
|
|
srcDirectory.copyTo(dstDirectory, StandardCopyOption.REPLACE_EXISTING, LinkOption.NOFOLLOW_LINKS)
|
|
assertFalse(dstDirectory.isSymbolicLink())
|
|
assertEquals(emptyList(), dstDirectory.listDirectoryEntries())
|
|
}
|
|
|
|
@Test
|
|
fun copyToNameWithoutParent() {
|
|
val currentDir = Path("").absolute()
|
|
val srcFile = createTempFile().cleanup()
|
|
val dstFile = createTempFile(directory = currentDir).cleanup()
|
|
|
|
srcFile.writeText("Hello, World!", Charsets.UTF_8)
|
|
dstFile.deleteExisting()
|
|
|
|
val dstRelative = Path(dstFile.name)
|
|
|
|
srcFile.copyTo(dstRelative)
|
|
|
|
assertEquals(srcFile.readText(), dstFile.readText())
|
|
}
|
|
|
|
@Test
|
|
fun copyToDstLinkPointingToSrc() {
|
|
for (options in listOf(arrayOf(), arrayOf<CopyOption>(LinkOption.NOFOLLOW_LINKS))) {
|
|
val root = createTempDirectory().cleanupRecursively()
|
|
val src = root.resolve("src").createFile()
|
|
val dstLink = root.resolve("dstLink").tryCreateSymbolicLinkTo(src) ?: return
|
|
|
|
assertTrue(src.isSameFileAs(dstLink))
|
|
assertTrue(dstLink.isSameFileAs(src))
|
|
assertFailsWith<FileAlreadyExistsException> {
|
|
src.copyTo(dstLink, *options)
|
|
}
|
|
assertTrue(dstLink.isSymbolicLink())
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun copyToDstLinkPointingToSrcOverwrite() {
|
|
for (options in listOf(arrayOf(), arrayOf<CopyOption>(LinkOption.NOFOLLOW_LINKS))) {
|
|
val root = createTempDirectory().cleanupRecursively()
|
|
val src = root.resolve("src").createFile()
|
|
val dstLink = root.resolve("dstLink").tryCreateSymbolicLinkTo(src) ?: return
|
|
|
|
src.copyTo(dstLink, StandardCopyOption.REPLACE_EXISTING, *options)
|
|
assertFalse(dstLink.isSymbolicLink())
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun copyToSrcLinkAndDstLinkPointingToSameFile() {
|
|
for (options in listOf(arrayOf(), arrayOf<CopyOption>(LinkOption.NOFOLLOW_LINKS))) {
|
|
val root = createTempDirectory().cleanupRecursively()
|
|
val original = root.resolve("original").createFile()
|
|
val srcLink = root.resolve("srcLink").tryCreateSymbolicLinkTo(original) ?: return
|
|
val dstLink = root.resolve("dstLink").tryCreateSymbolicLinkTo(original) ?: return
|
|
|
|
assertTrue(srcLink.isSameFileAs(dstLink))
|
|
assertTrue(dstLink.isSameFileAs(srcLink))
|
|
assertFailsWith<FileAlreadyExistsException> {
|
|
srcLink.copyTo(dstLink, *options)
|
|
}
|
|
assertTrue(dstLink.isSymbolicLink())
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun copyToSrcLinkAndDstLinkPointingToSameFileOverwrite() {
|
|
for (options in listOf(arrayOf(), arrayOf<CopyOption>(LinkOption.NOFOLLOW_LINKS))) {
|
|
val root = createTempDirectory().cleanupRecursively()
|
|
val original = root.resolve("original").createFile()
|
|
val srcLink = root.resolve("srcLink").tryCreateSymbolicLinkTo(original) ?: return
|
|
val dstLink = root.resolve("dstLink").tryCreateSymbolicLinkTo(original) ?: return
|
|
|
|
srcLink.copyTo(dstLink, StandardCopyOption.REPLACE_EXISTING, *options)
|
|
|
|
if (LinkOption.NOFOLLOW_LINKS in options) {
|
|
assertTrue(dstLink.isSymbolicLink()) // src symlink was copied
|
|
} else {
|
|
assertFalse(dstLink.isSymbolicLink()) // src symlink target was copied
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun copyToSameLinkDifferentRoute() {
|
|
for (options in listOf(arrayOf(), arrayOf<CopyOption>(LinkOption.NOFOLLOW_LINKS))) {
|
|
val root = createTempDirectory().cleanupRecursively()
|
|
val original = root.resolve("original").createFile()
|
|
val srcLink = root.resolve("srcLink").tryCreateSymbolicLinkTo(original) ?: return
|
|
val dstLink = root.resolve("dstLink").tryCreateSymbolicLinkTo(root)?.resolve("srcLink") ?: return
|
|
|
|
assertTrue(srcLink.isSameFileAs(dstLink))
|
|
assertTrue(dstLink.isSameFileAs(srcLink))
|
|
|
|
if (LinkOption.NOFOLLOW_LINKS in options) {
|
|
srcLink.copyTo(dstLink, *options) // same file
|
|
} else {
|
|
assertFailsWith<FileAlreadyExistsException> {
|
|
srcLink.copyTo(dstLink, *options) // target of srcLink copied to srcLink location
|
|
}
|
|
}
|
|
|
|
assertTrue(dstLink.isSymbolicLink())
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun copyToSameLinkDifferentRouteOverwrite() {
|
|
for (options in listOf(arrayOf(), arrayOf<CopyOption>(LinkOption.NOFOLLOW_LINKS))) {
|
|
val root = createTempDirectory().cleanupRecursively()
|
|
val original = root.resolve("original").createFile()
|
|
val srcLink = root.resolve("srcLink").tryCreateSymbolicLinkTo(original) ?: return
|
|
val dstLink = root.resolve("dstLink").tryCreateSymbolicLinkTo(root)?.resolve("srcLink") ?: return
|
|
|
|
if (LinkOption.NOFOLLOW_LINKS in options) {
|
|
srcLink.copyTo(dstLink, StandardCopyOption.REPLACE_EXISTING, *options) // same file
|
|
} else {
|
|
// dstLink is deleted before srcLink gets copied.
|
|
// Actually srcLink gets removed because dstLink is srcLink with different path.
|
|
val error = assertFailsWith<NoSuchFileException> {
|
|
srcLink.copyTo(dstLink, StandardCopyOption.REPLACE_EXISTING, *options)
|
|
}
|
|
assertEquals(srcLink.toString(), error.file)
|
|
assertFalse(srcLink.exists(LinkOption.NOFOLLOW_LINKS))
|
|
assertFalse(dstLink.exists(LinkOption.NOFOLLOW_LINKS))
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun copyToSameFileDifferentRoute() {
|
|
val root = createTempDirectory().cleanupRecursively()
|
|
val src = root.resolve("src").createFile()
|
|
val dst = root.resolve("dstLink").tryCreateSymbolicLinkTo(root)?.resolve("src") ?: return
|
|
|
|
assertTrue(src.isSameFileAs(dst))
|
|
assertTrue(dst.isSameFileAs(src))
|
|
src.copyTo(dst)
|
|
}
|
|
|
|
@Test
|
|
fun copyToSameFileDifferentRouteOverwrite() {
|
|
val root = createTempDirectory().cleanupRecursively()
|
|
val src = root.resolve("src").createFile()
|
|
val dst = root.resolve("dstLink").tryCreateSymbolicLinkTo(root)?.resolve("src") ?: return
|
|
|
|
src.copyTo(dst, overwrite = true)
|
|
}
|
|
|
|
@Test
|
|
fun moveTo() {
|
|
val root = createTempDirectory("moveTo-root").cleanupRecursively()
|
|
val original = createTempFile(root, "original")
|
|
val srcFile = createTempFile(root, "src")
|
|
val dstFile = createTempFile(root, "dst")
|
|
fun restoreSrcFile() { original.copyTo(srcFile, overwrite = true) }
|
|
original.writeText("Hello, World!")
|
|
restoreSrcFile()
|
|
|
|
assertFailsWith<FileAlreadyExistsException>("do not overwrite existing file") {
|
|
srcFile.moveTo(dstFile)
|
|
}
|
|
|
|
var dst = srcFile.moveTo(dstFile, overwrite = true)
|
|
assertSame(dst, dstFile)
|
|
compareFiles(original, dst, "move with overwrite over existing file")
|
|
assertTrue(srcFile.notExists())
|
|
|
|
restoreSrcFile()
|
|
srcFile.moveTo(srcFile)
|
|
srcFile.moveTo(srcFile, overwrite = true)
|
|
|
|
compareFiles(original, srcFile, "move file to itself leaves it intact")
|
|
|
|
assertTrue(dstFile.deleteIfExists())
|
|
dst = srcFile.moveTo(dstFile)
|
|
compareFiles(original, dst, "move to new file")
|
|
|
|
restoreSrcFile()
|
|
val subDst = dstFile.resolve("foo/bar")
|
|
assertFailsWith<FileSystemException> { srcFile.moveTo(subDst) }
|
|
assertFailsWith<FileSystemException> { srcFile.moveTo(subDst, overwrite = true) }
|
|
assertTrue(dstFile.deleteIfExists())
|
|
assertFailsWith<FileSystemException> { srcFile.moveTo(subDst) }
|
|
|
|
dstFile.createDirectory()
|
|
val child = dstFile.resolve("child").createFile()
|
|
assertFailsWith<DirectoryNotEmptyException>("move with overwrite do not overwrite non-empty dir") {
|
|
srcFile.moveTo(dstFile, overwrite = true)
|
|
}
|
|
child.deleteExisting()
|
|
|
|
srcFile.moveTo(dstFile, overwrite = true)
|
|
compareFiles(original, dstFile, "move with overwrite over empty dir")
|
|
|
|
assertTrue(srcFile.notExists())
|
|
assertTrue(dstFile.deleteIfExists())
|
|
|
|
assertFailsWith<NoSuchFileException> {
|
|
srcFile.moveTo(dstFile)
|
|
}
|
|
|
|
srcFile.createDirectory()
|
|
srcFile.resolve("somefile").writeText("some content")
|
|
dstFile.writeText("")
|
|
assertFailsWith<FileAlreadyExistsException>("move dir do not overwrite file") {
|
|
srcFile.moveTo(dstFile)
|
|
}
|
|
srcFile.moveTo(dstFile, overwrite = true)
|
|
assertTrue(dstFile.isDirectory())
|
|
assertEquals(listOf(dstFile / "somefile"), dstFile.listDirectoryEntries(), "directory is moved with its content")
|
|
}
|
|
|
|
private fun compareFiles(src: Path, dst: Path, message: String? = null) {
|
|
assertTrue(dst.exists())
|
|
assertEquals(src.isRegularFile(), dst.isRegularFile(), message)
|
|
assertEquals(src.isDirectory(), dst.isDirectory(), message)
|
|
if (dst.isRegularFile()) {
|
|
assertTrue(src.readBytes().contentEquals(dst.readBytes()), message)
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun fileSize() {
|
|
val file = createTempFile().cleanup()
|
|
assertEquals(0, file.fileSize())
|
|
|
|
file.writeBytes(ByteArray(100))
|
|
assertEquals(100, file.fileSize())
|
|
|
|
file.appendText("Hello", Charsets.US_ASCII)
|
|
assertEquals(105, file.fileSize())
|
|
|
|
file.deleteExisting()
|
|
assertFailsWith<NoSuchFileException> { file.fileSize() }
|
|
}
|
|
|
|
@Test
|
|
fun deleteExisting() {
|
|
val file = createTempFile().cleanup()
|
|
file.deleteExisting()
|
|
assertFailsWith<NoSuchFileException> { file.deleteExisting() }
|
|
|
|
val dir = createTempDirectory().cleanup()
|
|
dir.deleteExisting()
|
|
assertFailsWith<NoSuchFileException> { dir.deleteExisting() }
|
|
}
|
|
|
|
@Test
|
|
fun deleteIfExists() {
|
|
val file = createTempFile().cleanup()
|
|
assertTrue(file.deleteIfExists())
|
|
assertFalse(file.deleteIfExists())
|
|
|
|
val dir = createTempDirectory().cleanup()
|
|
assertTrue(dir.deleteIfExists())
|
|
assertFalse(dir.deleteIfExists())
|
|
}
|
|
|
|
@Test
|
|
fun attributeGettersOnFile() {
|
|
val file = createTempFile("temp", ".file").cleanup()
|
|
assertTrue(file.exists())
|
|
assertFalse(file.notExists())
|
|
assertTrue(file.isRegularFile())
|
|
assertFalse(file.isDirectory())
|
|
assertFalse(file.isSymbolicLink())
|
|
assertTrue(file.isReadable())
|
|
assertTrue(file.isWritable())
|
|
assertTrue(file.isSameFileAs(file))
|
|
|
|
// The default value of these depends on the current operating system, so just check that
|
|
// they don't throw an exception.
|
|
file.isExecutable()
|
|
file.isHidden()
|
|
}
|
|
|
|
@Test
|
|
fun attributeGettersOnDirectory() {
|
|
val file = createTempDirectory(".tmpdir").cleanup()
|
|
assertTrue(file.exists())
|
|
assertFalse(file.notExists())
|
|
assertFalse(file.isRegularFile())
|
|
assertTrue(file.isDirectory())
|
|
assertFalse(file.isSymbolicLink())
|
|
assertTrue(file.isReadable())
|
|
assertTrue(file.isWritable())
|
|
assertTrue(file.isSameFileAs(file))
|
|
|
|
file.isExecutable()
|
|
file.isHidden()
|
|
}
|
|
|
|
@Test
|
|
fun attributeGettersOnNonExistentPath() {
|
|
val file = createTempDirectory().cleanup().resolve("foo")
|
|
assertFalse(file.exists())
|
|
assertTrue(file.notExists())
|
|
assertFalse(file.isRegularFile())
|
|
assertFalse(file.isDirectory())
|
|
assertFalse(file.isSymbolicLink())
|
|
assertFalse(file.isReadable())
|
|
assertFalse(file.isWritable())
|
|
assertTrue(file.isSameFileAs(file))
|
|
|
|
file.isExecutable()
|
|
// This function will either throw an exception or return false,
|
|
// depending on the operating system.
|
|
try {
|
|
assertFalse(file.isHidden())
|
|
} catch (e: IOException) {
|
|
}
|
|
}
|
|
|
|
private interface SpecialFileAttributesView : FileAttributeView
|
|
private interface SpecialFileAttributes : BasicFileAttributes
|
|
|
|
@Test
|
|
fun readWriteAttributes() {
|
|
val file = createTempFile().cleanup()
|
|
val modifiedTime = file.getLastModifiedTime()
|
|
assertEquals(modifiedTime, file.getAttribute("lastModifiedTime"))
|
|
assertEquals(modifiedTime, file.getAttribute("basic:lastModifiedTime"))
|
|
assertEquals(modifiedTime, file.readAttributes<BasicFileAttributes>().lastModifiedTime())
|
|
assertEquals(modifiedTime, file.readAttributes("basic:lastModifiedTime,creationTime")["lastModifiedTime"])
|
|
assertEquals(modifiedTime, file.readAttributes("*")["lastModifiedTime"])
|
|
|
|
assertFailsWith<UnsupportedOperationException> { file.readAttributes<SpecialFileAttributes>() }
|
|
assertFailsWith<UnsupportedOperationException> { file.readAttributes("really_unsupported_view:*") }
|
|
assertFailsWith<IllegalArgumentException> { file.readAttributes("basic:really_unknown_attribute") }
|
|
|
|
val newTime1 = FileTime.fromMillis(modifiedTime.toMillis() + 3600_000)
|
|
file.setLastModifiedTime(newTime1)
|
|
assertEquals(newTime1, file.getLastModifiedTime())
|
|
|
|
val newTime2 = FileTime.fromMillis(modifiedTime.toMillis() + 2 * 3600_000)
|
|
file.setAttribute("lastModifiedTime", newTime2)
|
|
assertEquals(newTime2, file.getLastModifiedTime())
|
|
|
|
val newTime3 = FileTime.fromMillis(modifiedTime.toMillis() + 3 * 3600_000)
|
|
file.fileAttributesView<BasicFileAttributeView>().setTimes(newTime3, null, null)
|
|
assertEquals(newTime3, file.getLastModifiedTime())
|
|
|
|
assertFailsWith<UnsupportedOperationException> { file.fileAttributesView<SpecialFileAttributesView>() }
|
|
assertNull(file.fileAttributesViewOrNull<SpecialFileAttributesView>())
|
|
|
|
file.setAttribute("lastModifiedTime", null)
|
|
assertEquals(newTime3, file.getLastModifiedTime())
|
|
}
|
|
|
|
@Test
|
|
fun links() {
|
|
val dir = createTempDirectory().cleanupRecursively()
|
|
val original = createTempFile(dir)
|
|
original.writeBytes(Random.nextBytes(100))
|
|
|
|
val link = try {
|
|
(dir / ("link-" + original.fileName)).createLinkPointingTo(original)
|
|
} catch (e: IOException) {
|
|
// may require a privilege
|
|
println("Creating a link failed with $e")
|
|
return
|
|
}
|
|
|
|
assertTrue(link.isRegularFile())
|
|
assertTrue(link.isRegularFile(LinkOption.NOFOLLOW_LINKS))
|
|
assertTrue(original.isSameFileAs(link))
|
|
compareFiles(original, link)
|
|
assertFailsWith<NotLinkException> { link.readSymbolicLink() }
|
|
}
|
|
|
|
@Test
|
|
fun symlinks() {
|
|
val dir = createTempDirectory().cleanupRecursively()
|
|
val original = createTempFile(dir)
|
|
original.writeBytes(Random.nextBytes(100))
|
|
|
|
val symlink = try {
|
|
(dir / ("symlink-" + original.fileName)).createSymbolicLinkPointingTo(original)
|
|
} catch (e: IOException) {
|
|
// may require a privilege
|
|
println("Creating a symlink failed with $e")
|
|
return
|
|
}
|
|
|
|
assertTrue(symlink.isRegularFile())
|
|
assertFalse(symlink.isRegularFile(LinkOption.NOFOLLOW_LINKS))
|
|
assertTrue(original.isSameFileAs(symlink))
|
|
compareFiles(original, symlink)
|
|
assertEquals(original, symlink.readSymbolicLink())
|
|
}
|
|
|
|
@Test
|
|
fun directoryEntriesList() {
|
|
val dir = createTempDirectory().cleanupRecursively()
|
|
assertEquals(0, dir.listDirectoryEntries().size)
|
|
|
|
val file = dir.resolve("f1").createFile()
|
|
assertEquals(listOf(file), dir.listDirectoryEntries())
|
|
|
|
val fileTxt = createTempFile(dir, suffix = ".txt")
|
|
assertEquals(listOf(fileTxt), dir.listDirectoryEntries("*.txt"))
|
|
|
|
assertFailsWith<NotDirectoryException> { file.listDirectoryEntries() }
|
|
}
|
|
|
|
@Test
|
|
fun directoryEntriesUseSequence() {
|
|
val dir = createTempDirectory().cleanupRecursively()
|
|
assertEquals(0, dir.useDirectoryEntries { it.toList() }.size)
|
|
|
|
val file = dir.resolve("f1").createFile()
|
|
assertEquals(listOf(file), dir.useDirectoryEntries { it.toList() })
|
|
|
|
val fileTxt = createTempFile(dir, suffix = ".txt")
|
|
assertEquals(listOf(fileTxt), dir.useDirectoryEntries("*.txt") { it.toList() })
|
|
|
|
assertFailsWith<NotDirectoryException> { file.useDirectoryEntries { error("shouldn't get here") } }
|
|
}
|
|
|
|
@Test
|
|
fun directoryEntriesForEach() {
|
|
val dir = createTempDirectory().cleanupRecursively()
|
|
dir.forEachDirectoryEntry { error("shouldn't get here, but received $it") }
|
|
|
|
val file = createTempFile(dir)
|
|
dir.forEachDirectoryEntry { assertEquals(file, it) }
|
|
|
|
val fileTxt = createTempFile(dir, suffix = ".txt")
|
|
dir.forEachDirectoryEntry("*.txt") { assertEquals(fileTxt, it) }
|
|
|
|
assertFailsWith<NotDirectoryException> { file.forEachDirectoryEntry { error("shouldn't get here, but received $it") } }
|
|
}
|
|
|
|
|
|
private fun testRelativeTo(expected: String?, path: String, base: String) =
|
|
testRelativeTo(expected?.let { Path(it) }, Path(path), Path(base))
|
|
private fun testRelativeTo(expected: String, path: Path, base: Path) =
|
|
testRelativeTo(Path(expected), path, base)
|
|
|
|
private fun testRelativeTo(expected: Path?, path: Path, base: Path) {
|
|
val context = "path: '$path', base: '$base'"
|
|
if (expected != null) {
|
|
assertEquals(expected, path.relativeTo(base), context)
|
|
} else {
|
|
val e = assertFailsWith<IllegalArgumentException>(context) { path.relativeTo(base) }
|
|
val message = assertNotNull(e.message)
|
|
assertTrue(path.toString() in message, message)
|
|
assertTrue(base.toString() in message, message)
|
|
}
|
|
assertEquals(expected, path.relativeToOrNull(base), context)
|
|
assertEquals(expected ?: path, path.relativeToOrSelf(base), context)
|
|
}
|
|
|
|
@Test
|
|
fun relativeToRooted() {
|
|
val file1 = "/foo/bar/baz"
|
|
val file2 = "/foo/baa/ghoo"
|
|
|
|
testRelativeTo("../../bar/baz", file1, file2)
|
|
|
|
val file3 = "/foo/bar"
|
|
|
|
testRelativeTo("baz", file1, file3)
|
|
testRelativeTo("..", file3, file1)
|
|
|
|
val file4 = "/foo/bar/"
|
|
|
|
testRelativeTo("baz", file1, file4)
|
|
testRelativeTo("..", file4, file1)
|
|
testRelativeTo("", file3, file4)
|
|
testRelativeTo("", file4, file3)
|
|
|
|
val file5 = "/foo/baran"
|
|
|
|
testRelativeTo("../bar", file3, file5)
|
|
testRelativeTo("../baran", file5, file3)
|
|
testRelativeTo("../bar", file4, file5)
|
|
testRelativeTo("../baran", file5, file4)
|
|
|
|
if (isBackslashSeparator) {
|
|
val file6 = "C:\\Users\\Me"
|
|
val file7 = "C:\\Users\\Me\\Documents"
|
|
|
|
testRelativeTo("..", file6, file7)
|
|
testRelativeTo("Documents", file7, file6)
|
|
|
|
val file8 = """\\my.host\home/user/documents/vip"""
|
|
val file9 = """\\my.host\home/other/images/nice"""
|
|
|
|
testRelativeTo("../../../user/documents/vip", file8, file9)
|
|
testRelativeTo("../../../other/images/nice", file9, file8)
|
|
}
|
|
|
|
if (isCaseInsensitiveFileSystem) {
|
|
testRelativeTo("bar", "C:/bar", "c:/")
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun relativeToRelative() {
|
|
val nested = Path("foo/bar")
|
|
val base = Path("foo")
|
|
|
|
testRelativeTo("bar", nested, base)
|
|
testRelativeTo("..", base, nested)
|
|
|
|
val empty = Path("")
|
|
val current = Path(".")
|
|
val parent = Path("..")
|
|
val outOfRoot = Path("../bar")
|
|
|
|
testRelativeTo("../bar", outOfRoot, empty)
|
|
testRelativeTo("../../bar", outOfRoot, base)
|
|
testRelativeTo("bar", outOfRoot, parent)
|
|
testRelativeTo("..", parent, outOfRoot)
|
|
|
|
val root = Path("/root")
|
|
val files = listOf(nested, base, empty, outOfRoot, current, parent)
|
|
val bases = listOf(nested, base, empty, current)
|
|
|
|
for (file in files)
|
|
// file should have empty path relative to itself
|
|
testRelativeTo("", file, file)
|
|
|
|
for (file in files) {
|
|
@Suppress("NAME_SHADOWING")
|
|
for (base in bases) {
|
|
val rootedFile = root.resolve(file)
|
|
val rootedBase = root.resolve(base)
|
|
assertEquals(rootedFile.relativeTo(rootedBase), file.relativeTo(base), "nested: $file, base: $base")
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test
|
|
fun relativeToFails() {
|
|
val absolute = Path("/foo/bar/baz")
|
|
val relative = Path("foo/bar")
|
|
val networkShare1 = Path("""\\my.host\share1/folder""")
|
|
val networkShare2 = Path("""\\my.host\share2\folder""")
|
|
|
|
val allFiles = listOf(absolute, relative) + if (isBackslashSeparator) listOf(networkShare1, networkShare2) else emptyList()
|
|
for (file in allFiles) {
|
|
for (base in allFiles) {
|
|
if (file != base) testRelativeTo(null, file, base)
|
|
}
|
|
}
|
|
|
|
if (isBackslashSeparator) {
|
|
testRelativeTo(null, "C:/dir1", "D:/dir2")
|
|
}
|
|
|
|
testRelativeTo(null, "foo", "..")
|
|
testRelativeTo(null, "../foo", "../..")
|
|
}
|
|
|
|
@Test
|
|
fun relativeTo() {
|
|
testRelativeTo("kotlin", "src/kotlin", "src")
|
|
testRelativeTo("", "dir", "dir")
|
|
testRelativeTo("..", "dir", "dir/subdir")
|
|
testRelativeTo("../../test", "test", "dir/dir")
|
|
testRelativeTo("foo/bar", "../../foo/bar", "../../sub/../.")
|
|
testRelativeTo(null, "../../foo/bar", "../../sub/../..")
|
|
}
|
|
|
|
@Test
|
|
fun absolutePaths() {
|
|
val relative = Path("./example")
|
|
assertTrue(relative.absolute().isAbsolute)
|
|
assertEquals(relative.absolute().pathString, relative.absolutePathString())
|
|
}
|
|
}
|