/*
 * 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())
    }
}