libraries/stdlib/jdk7/test/PathRecursiveCopyBetweenIncompatibleFileSystemsTest.kt - third_party/github/JetBrains/kotlin - Git at Google

 /*
  * Copyright 2010-2026 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.File
 import java.net.URI
 import java.nio.channels.SeekableByteChannel
 import java.nio.file.*
 import java.nio.file.attribute.BasicFileAttributes
 import java.nio.file.attribute.FileAttribute
 import java.nio.file.attribute.FileAttributeView
 import java.nio.file.attribute.UserPrincipalLookupService
 import java.nio.file.spi.FileSystemProvider
 import kotlin.io.path.*
 import kotlin.test.Test
 import kotlin.test.assertContains
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 import kotlin.test.assertIs
 import kotlin.test.assertTrue

 class PathRecursiveCopyBetweenIncompatibleFileSystemsTest : AbstractPathTest() {
     @Test // Regression test for KT-85020
     fun copyBetweenFilesystemsWithIncompatiblePathSeparators() {
         val root = createTempDirectory().cleanupRecursively()

         val srcDirOriginal = root.resolve("src").also {
             it.resolve("a")
                 .resolve("b")
                 .resolve("c")
                 .resolve("test.txt")
                 .createParentDirectories()
                 .writeText("hello")
         }

         val dst = root.resolve("dst").createDirectory()

         val mockFs = SharpFileSystemProvider().newTestFileSystem(srcDirOriginal.fileSystem)
         val mockedSrc = mockFs.wrap(srcDirOriginal)

         mockedSrc.copyToRecursively(dst, followLinks = false, overwrite = false)

         val expectedPaths = srcDirOriginal.walk(PathWalkOption.INCLUDE_DIRECTORIES)
             .map { it.relativeTo(srcDirOriginal).toString() }
             .toSet()
         val actualPaths = dst.walk(PathWalkOption.INCLUDE_DIRECTORIES)
             .map { it.relativeTo(dst).toString() }
             .toSet()
         assertEquals(expectedPaths, actualPaths)
     }

     @Test
     fun copyFileWithNameCorrespondingToMultipleSegments() {
         val root = createTempDirectory().cleanupRecursively()

         val src = root.resolve("src").also {
             it.resolve("a")
                 .resolve("b#test.txt")
                 .createParentDirectories()
                 .writeText("hello")
         }

         val dst = root.resolve("dst").createDirectory()

         val mockFs = SharpFileSystemProvider().newTestFileSystem(dst.fileSystem)
         val mockedDst = mockFs.wrap(dst)

         var failed = false
         src.copyToRecursively(mockedDst, followLinks = false, overwrite = false, onError = { srcPath, dstPath, exception ->
             assertIs<IllegalFileNameException>(exception)
             assertEquals(
                 src.fileSystem.getPath("a", "b#test.txt").toString(),
                 srcPath.relativeTo(src).toString()
             )
             assertEquals("a#b#test.txt", dstPath.relativeTo(mockedDst).toString())
             failed = true
             OnErrorResult.SKIP_SUBTREE
         })
         assertTrue(failed, "Expected onError to be called, but it never happened")
     }
 }

 // FileSystemProvider, FileSystem and Path implementations below exists for testing purposes only,
 // and solve the only one purpose - wrap an existing file system so that all
 // its path will use "#" as a path separator. Thus, the name - SharpSomething.
 private class SharpFileSystemProvider : FileSystemProvider() {
     private var fileSystem: SharpFileSystem? = null

     fun newTestFileSystem(delegateFileSystem: FileSystem): SharpFileSystem {
         check(fileSystem == null) { "Only one test filesystem can be registered in the provider" }
         return SharpFileSystem(this, delegateFileSystem).also { fileSystem = it }
     }

     override fun getScheme(): String = "sharp"

     override fun newFileSystem(uri: URI, env: MutableMap<String, *>): FileSystem = TODO()

     override fun getFileSystem(uri: URI): FileSystem = requireRegisteredFileSystem()

     override fun getPath(uri: URI): Path = requireRegisteredFileSystem().getPath(uri.path ?: "")

     override fun newByteChannel(
         path: Path,
         options: MutableSet<out OpenOption>,
         vararg attrs: FileAttribute<*>,
     ): SeekableByteChannel = delegateProvider().newByteChannel(path.toDelegatePath(), options, *attrs)

     override fun newDirectoryStream(dir: Path, filter: DirectoryStream.Filter<in Path>): DirectoryStream<Path> {
         val testDir = dir as SharpPath
         val stream = delegateProvider().newDirectoryStream(testDir.delegatePath) { delegatePath ->
             filter.accept(testDir.fileSystem.wrap(delegatePath))
         }
         return object : DirectoryStream<Path> {
             override fun iterator(): MutableIterator<Path> = object : MutableIterator<Path> {
                 private val iterator = stream.iterator()

                 override fun hasNext(): Boolean = iterator.hasNext()

                 override fun next(): Path = testDir.fileSystem.wrap(iterator.next())

                 override fun remove() = iterator.remove()
             }

             override fun close() = stream.close()
         }
     }

     override fun createDirectory(dir: Path, vararg attrs: FileAttribute<*>) {
         delegateProvider().createDirectory(dir.toDelegatePath(), *attrs)
     }

     override fun delete(path: Path) {
         delegateProvider().delete(path.toDelegatePath())
     }

     override fun copy(source: Path, target: Path, vararg options: CopyOption) {
         delegateProvider().copy(source.toDelegatePath(), target.toDelegatePath(), *options)
     }

     override fun move(source: Path, target: Path, vararg options: CopyOption) {
         delegateProvider().move(source.toDelegatePath(), target.toDelegatePath(), *options)
     }

     override fun isSameFile(path: Path, path2: Path): Boolean {
         if (path !is SharpPath || path2 !is SharpPath) return false
         return delegateProvider().isSameFile(path.toDelegatePath(), path2.toDelegatePath())
     }

     override fun isHidden(path: Path): Boolean = delegateProvider().isHidden(path.toDelegatePath())

     override fun getFileStore(path: Path): FileStore = delegateProvider().getFileStore(path.toDelegatePath())

     override fun checkAccess(path: Path, vararg modes: AccessMode) {
         delegateProvider().checkAccess(path.toDelegatePath(), *modes)
     }

     override fun <V : FileAttributeView> getFileAttributeView(path: Path, type: Class<V>, vararg options: LinkOption): V? {
         return delegateProvider().getFileAttributeView(path.toDelegatePath(), type, *options)
     }

     override fun <A : BasicFileAttributes> readAttributes(path: Path, type: Class<A>, vararg options: LinkOption): A {
         return delegateProvider().readAttributes(path.toDelegatePath(), type, *options)
     }

     override fun readAttributes(path: Path, attributes: String, vararg options: LinkOption): MutableMap<String, Any> {
         return delegateProvider().readAttributes(path.toDelegatePath(), attributes, *options)
     }

     override fun setAttribute(path: Path, attribute: String, value: Any, vararg options: LinkOption) {
         delegateProvider().setAttribute(path.toDelegatePath(), attribute, value, *options)
     }

     private fun requireRegisteredFileSystem(): SharpFileSystem {
         return fileSystem ?: throw IllegalStateException("No test filesystem is registered in the provider")
     }

     private fun delegateProvider(): FileSystemProvider = requireRegisteredFileSystem().delegateFileSystem.provider()
 }

 private class SharpFileSystem(
     private val provider: SharpFileSystemProvider,
     val delegateFileSystem: FileSystem,
 ) : FileSystem() {
     companion object {
         const val PATH_SEPARATOR = "#"
     }

     override fun provider(): FileSystemProvider = provider

     override fun close() = Unit

     override fun isOpen(): Boolean = delegateFileSystem.isOpen

     override fun isReadOnly(): Boolean = delegateFileSystem.isReadOnly

     override fun getSeparator(): String = PATH_SEPARATOR

     override fun getRootDirectories(): MutableIterable<Path> =
         delegateFileSystem.rootDirectories.mapTo(ArrayList()) { wrap(it) }

     override fun getFileStores(): MutableIterable<FileStore> = delegateFileSystem.fileStores

     override fun supportedFileAttributeViews(): MutableSet<String> =
         delegateFileSystem.supportedFileAttributeViews()

     override fun getPath(first: String, vararg more: String): Path {
         val convertedFirst = first.fromTestSeparators()
         val convertedMore = more.map { it.fromTestSeparators() }.toTypedArray()
         return wrap(delegateFileSystem.getPath(convertedFirst, *convertedMore))
     }

     override fun getPathMatcher(syntaxAndPattern: String): PathMatcher = TODO()

     override fun getUserPrincipalLookupService(): UserPrincipalLookupService =
         delegateFileSystem.userPrincipalLookupService

     override fun newWatchService(): WatchService = TODO()
     fun wrap(delegatePath: Path): SharpPath = SharpPath(this, delegatePath)

     private fun String.fromTestSeparators(): String =
         replace(PATH_SEPARATOR, delegateFileSystem.separator)
 }

 private class SharpPath(
     val fileSystem: SharpFileSystem,
     val delegatePath: Path,
 ) : Path {
     override fun getFileSystem(): FileSystem = fileSystem

     override fun isAbsolute(): Boolean = delegatePath.isAbsolute

     override fun getRoot(): Path? = delegatePath.root?.let(fileSystem::wrap)

     override fun getFileName(): Path? = delegatePath.fileName?.let(fileSystem::wrap)

     override fun getParent(): Path? = delegatePath.parent?.let(fileSystem::wrap)

     override fun getNameCount(): Int = delegatePath.nameCount

     override fun getName(index: Int): Path = fileSystem.wrap(delegatePath.getName(index))

     override fun subpath(beginIndex: Int, endIndex: Int): Path = fileSystem.wrap(delegatePath.subpath(beginIndex, endIndex))

     override fun startsWith(other: Path): Boolean = other is SharpPath && delegatePath.startsWith(other.delegatePath)

     override fun startsWith(other: String): Boolean = startsWith(fileSystem.getPath(other))

     override fun endsWith(other: Path): Boolean = other is SharpPath && delegatePath.endsWith(other.delegatePath)

     override fun endsWith(other: String): Boolean = endsWith(fileSystem.getPath(other))

     override fun normalize(): Path = fileSystem.wrap(delegatePath.normalize())

     override fun resolve(other: Path): Path {
         other as SharpPath
         return fileSystem.wrap(delegatePath.resolve(other.delegatePath))
     }

     override fun resolve(other: String): Path = resolve(fileSystem.getPath(other))

     override fun resolveSibling(other: Path): Path {
         other as SharpPath
         return fileSystem.wrap(delegatePath.resolveSibling(other.delegatePath))
     }

     override fun resolveSibling(other: String): Path = resolveSibling(fileSystem.getPath(other))

     override fun relativize(other: Path): Path = fileSystem.wrap(delegatePath.relativize((other as SharpPath).delegatePath))

     override fun toUri(): URI = URI("${fileSystem.provider().scheme}:///${toString()}")

     override fun toAbsolutePath(): Path = fileSystem.wrap(delegatePath.toAbsolutePath())

     override fun toRealPath(vararg options: LinkOption): Path = fileSystem.wrap(delegatePath.toRealPath(*options))

     override fun toFile(): File = delegatePath.toFile()

     override fun register(
         watcher: WatchService,
         events: Array<out WatchEvent.Kind<*>>,
         vararg modifiers: WatchEvent.Modifier,
     ): WatchKey = TODO()

     override fun register(watcher: WatchService, vararg events: WatchEvent.Kind<*>): WatchKey = TODO()

     override fun iterator(): MutableIterator<Path> =
         delegatePath.mapTo(ArrayList()) { fileSystem.wrap(it) }.iterator()

     override fun compareTo(other: Path): Int = delegatePath.compareTo((other as SharpPath).delegatePath)

     override fun equals(other: Any?): Boolean =
         other is SharpPath && fileSystem == other.fileSystem && delegatePath == other.delegatePath

     override fun hashCode(): Int = 31 * fileSystem.hashCode() + delegatePath.hashCode()

     override fun toString(): String =
         delegatePath.toString().replace(fileSystem.delegateFileSystem.separator, SharpFileSystem.PATH_SEPARATOR)
 }

 private fun Path.toDelegatePath(): Path = (this as SharpPath).delegatePath
	/*
	* Copyright 2010-2026 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.File
	import java.net.URI
	import java.nio.channels.SeekableByteChannel
	import java.nio.file.*
	import java.nio.file.attribute.BasicFileAttributes
	import java.nio.file.attribute.FileAttribute
	import java.nio.file.attribute.FileAttributeView
	import java.nio.file.attribute.UserPrincipalLookupService
	import java.nio.file.spi.FileSystemProvider
	import kotlin.io.path.*
	import kotlin.test.Test
	import kotlin.test.assertContains
	import kotlin.test.assertEquals
	import kotlin.test.assertFailsWith
	import kotlin.test.assertIs
	import kotlin.test.assertTrue

	class PathRecursiveCopyBetweenIncompatibleFileSystemsTest : AbstractPathTest() {
	@Test // Regression test for KT-85020
	fun copyBetweenFilesystemsWithIncompatiblePathSeparators() {
	val root = createTempDirectory().cleanupRecursively()

	val srcDirOriginal = root.resolve("src").also {
	it.resolve("a")
	.resolve("b")
	.resolve("c")
	.resolve("test.txt")
	.createParentDirectories()
	.writeText("hello")
	}

	val dst = root.resolve("dst").createDirectory()

	val mockFs = SharpFileSystemProvider().newTestFileSystem(srcDirOriginal.fileSystem)
	val mockedSrc = mockFs.wrap(srcDirOriginal)

	mockedSrc.copyToRecursively(dst, followLinks = false, overwrite = false)

	val expectedPaths = srcDirOriginal.walk(PathWalkOption.INCLUDE_DIRECTORIES)
	.map { it.relativeTo(srcDirOriginal).toString() }
	.toSet()
	val actualPaths = dst.walk(PathWalkOption.INCLUDE_DIRECTORIES)
	.map { it.relativeTo(dst).toString() }
	.toSet()
	assertEquals(expectedPaths, actualPaths)
	}

	@Test
	fun copyFileWithNameCorrespondingToMultipleSegments() {
	val root = createTempDirectory().cleanupRecursively()

	val src = root.resolve("src").also {
	it.resolve("a")
	.resolve("b#test.txt")
	.createParentDirectories()
	.writeText("hello")
	}

	val dst = root.resolve("dst").createDirectory()

	val mockFs = SharpFileSystemProvider().newTestFileSystem(dst.fileSystem)
	val mockedDst = mockFs.wrap(dst)

	var failed = false
	src.copyToRecursively(mockedDst, followLinks = false, overwrite = false, onError = { srcPath, dstPath, exception ->
	assertIs<IllegalFileNameException>(exception)
	assertEquals(
	src.fileSystem.getPath("a", "b#test.txt").toString(),
	srcPath.relativeTo(src).toString()
	)
	assertEquals("a#b#test.txt", dstPath.relativeTo(mockedDst).toString())
	failed = true
	OnErrorResult.SKIP_SUBTREE
	})
	assertTrue(failed, "Expected onError to be called, but it never happened")
	}
	}

	// FileSystemProvider, FileSystem and Path implementations below exists for testing purposes only,
	// and solve the only one purpose - wrap an existing file system so that all
	// its path will use "#" as a path separator. Thus, the name - SharpSomething.
	private class SharpFileSystemProvider : FileSystemProvider() {
	private var fileSystem: SharpFileSystem? = null

	fun newTestFileSystem(delegateFileSystem: FileSystem): SharpFileSystem {
	check(fileSystem == null) { "Only one test filesystem can be registered in the provider" }
	return SharpFileSystem(this, delegateFileSystem).also { fileSystem = it }
	}

	override fun getScheme(): String = "sharp"

	override fun newFileSystem(uri: URI, env: MutableMap<String, *>): FileSystem = TODO()

	override fun getFileSystem(uri: URI): FileSystem = requireRegisteredFileSystem()

	override fun getPath(uri: URI): Path = requireRegisteredFileSystem().getPath(uri.path ?: "")

	override fun newByteChannel(
	path: Path,
	options: MutableSet<out OpenOption>,
	vararg attrs: FileAttribute<*>,
	): SeekableByteChannel = delegateProvider().newByteChannel(path.toDelegatePath(), options, *attrs)

	override fun newDirectoryStream(dir: Path, filter: DirectoryStream.Filter<in Path>): DirectoryStream<Path> {
	val testDir = dir as SharpPath
	val stream = delegateProvider().newDirectoryStream(testDir.delegatePath) { delegatePath ->
	filter.accept(testDir.fileSystem.wrap(delegatePath))
	}
	return object : DirectoryStream<Path> {
	override fun iterator(): MutableIterator<Path> = object : MutableIterator<Path> {
	private val iterator = stream.iterator()

	override fun hasNext(): Boolean = iterator.hasNext()

	override fun next(): Path = testDir.fileSystem.wrap(iterator.next())

	override fun remove() = iterator.remove()
	}

	override fun close() = stream.close()
	}
	}

	override fun createDirectory(dir: Path, vararg attrs: FileAttribute<*>) {
	delegateProvider().createDirectory(dir.toDelegatePath(), *attrs)
	}

	override fun delete(path: Path) {
	delegateProvider().delete(path.toDelegatePath())
	}

	override fun copy(source: Path, target: Path, vararg options: CopyOption) {
	delegateProvider().copy(source.toDelegatePath(), target.toDelegatePath(), *options)
	}

	override fun move(source: Path, target: Path, vararg options: CopyOption) {
	delegateProvider().move(source.toDelegatePath(), target.toDelegatePath(), *options)
	}

	override fun isSameFile(path: Path, path2: Path): Boolean {
	if (path !is SharpPath \|\| path2 !is SharpPath) return false
	return delegateProvider().isSameFile(path.toDelegatePath(), path2.toDelegatePath())
	}

	override fun isHidden(path: Path): Boolean = delegateProvider().isHidden(path.toDelegatePath())

	override fun getFileStore(path: Path): FileStore = delegateProvider().getFileStore(path.toDelegatePath())

	override fun checkAccess(path: Path, vararg modes: AccessMode) {
	delegateProvider().checkAccess(path.toDelegatePath(), *modes)
	}

	override fun <V : FileAttributeView> getFileAttributeView(path: Path, type: Class<V>, vararg options: LinkOption): V? {
	return delegateProvider().getFileAttributeView(path.toDelegatePath(), type, *options)
	}

	override fun <A : BasicFileAttributes> readAttributes(path: Path, type: Class<A>, vararg options: LinkOption): A {
	return delegateProvider().readAttributes(path.toDelegatePath(), type, *options)
	}

	override fun readAttributes(path: Path, attributes: String, vararg options: LinkOption): MutableMap<String, Any> {
	return delegateProvider().readAttributes(path.toDelegatePath(), attributes, *options)
	}

	override fun setAttribute(path: Path, attribute: String, value: Any, vararg options: LinkOption) {
	delegateProvider().setAttribute(path.toDelegatePath(), attribute, value, *options)
	}

	private fun requireRegisteredFileSystem(): SharpFileSystem {
	return fileSystem ?: throw IllegalStateException("No test filesystem is registered in the provider")
	}

	private fun delegateProvider(): FileSystemProvider = requireRegisteredFileSystem().delegateFileSystem.provider()
	}

	private class SharpFileSystem(
	private val provider: SharpFileSystemProvider,
	val delegateFileSystem: FileSystem,
	) : FileSystem() {
	companion object {
	const val PATH_SEPARATOR = "#"
	}

	override fun provider(): FileSystemProvider = provider

	override fun close() = Unit

	override fun isOpen(): Boolean = delegateFileSystem.isOpen

	override fun isReadOnly(): Boolean = delegateFileSystem.isReadOnly

	override fun getSeparator(): String = PATH_SEPARATOR

	override fun getRootDirectories(): MutableIterable<Path> =
	delegateFileSystem.rootDirectories.mapTo(ArrayList()) { wrap(it) }

	override fun getFileStores(): MutableIterable<FileStore> = delegateFileSystem.fileStores

	override fun supportedFileAttributeViews(): MutableSet<String> =
	delegateFileSystem.supportedFileAttributeViews()

	override fun getPath(first: String, vararg more: String): Path {
	val convertedFirst = first.fromTestSeparators()
	val convertedMore = more.map { it.fromTestSeparators() }.toTypedArray()
	return wrap(delegateFileSystem.getPath(convertedFirst, *convertedMore))
	}

	override fun getPathMatcher(syntaxAndPattern: String): PathMatcher = TODO()

	override fun getUserPrincipalLookupService(): UserPrincipalLookupService =
	delegateFileSystem.userPrincipalLookupService

	override fun newWatchService(): WatchService = TODO()
	fun wrap(delegatePath: Path): SharpPath = SharpPath(this, delegatePath)

	private fun String.fromTestSeparators(): String =
	replace(PATH_SEPARATOR, delegateFileSystem.separator)
	}

	private class SharpPath(
	val fileSystem: SharpFileSystem,
	val delegatePath: Path,
	) : Path {
	override fun getFileSystem(): FileSystem = fileSystem

	override fun isAbsolute(): Boolean = delegatePath.isAbsolute

	override fun getRoot(): Path? = delegatePath.root?.let(fileSystem::wrap)

	override fun getFileName(): Path? = delegatePath.fileName?.let(fileSystem::wrap)

	override fun getParent(): Path? = delegatePath.parent?.let(fileSystem::wrap)

	override fun getNameCount(): Int = delegatePath.nameCount

	override fun getName(index: Int): Path = fileSystem.wrap(delegatePath.getName(index))

	override fun subpath(beginIndex: Int, endIndex: Int): Path = fileSystem.wrap(delegatePath.subpath(beginIndex, endIndex))

	override fun startsWith(other: Path): Boolean = other is SharpPath && delegatePath.startsWith(other.delegatePath)

	override fun startsWith(other: String): Boolean = startsWith(fileSystem.getPath(other))

	override fun endsWith(other: Path): Boolean = other is SharpPath && delegatePath.endsWith(other.delegatePath)

	override fun endsWith(other: String): Boolean = endsWith(fileSystem.getPath(other))

	override fun normalize(): Path = fileSystem.wrap(delegatePath.normalize())

	override fun resolve(other: Path): Path {
	other as SharpPath
	return fileSystem.wrap(delegatePath.resolve(other.delegatePath))
	}

	override fun resolve(other: String): Path = resolve(fileSystem.getPath(other))

	override fun resolveSibling(other: Path): Path {
	other as SharpPath
	return fileSystem.wrap(delegatePath.resolveSibling(other.delegatePath))
	}

	override fun resolveSibling(other: String): Path = resolveSibling(fileSystem.getPath(other))

	override fun relativize(other: Path): Path = fileSystem.wrap(delegatePath.relativize((other as SharpPath).delegatePath))

	override fun toUri(): URI = URI("${fileSystem.provider().scheme}:///${toString()}")

	override fun toAbsolutePath(): Path = fileSystem.wrap(delegatePath.toAbsolutePath())

	override fun toRealPath(vararg options: LinkOption): Path = fileSystem.wrap(delegatePath.toRealPath(*options))

	override fun toFile(): File = delegatePath.toFile()

	override fun register(
	watcher: WatchService,
	events: Array<out WatchEvent.Kind<*>>,
	vararg modifiers: WatchEvent.Modifier,
	): WatchKey = TODO()

	override fun register(watcher: WatchService, vararg events: WatchEvent.Kind<*>): WatchKey = TODO()

	override fun iterator(): MutableIterator<Path> =
	delegatePath.mapTo(ArrayList()) { fileSystem.wrap(it) }.iterator()

	override fun compareTo(other: Path): Int = delegatePath.compareTo((other as SharpPath).delegatePath)

	override fun equals(other: Any?): Boolean =
	other is SharpPath && fileSystem == other.fileSystem && delegatePath == other.delegatePath

	override fun hashCode(): Int = 31 * fileSystem.hashCode() + delegatePath.hashCode()

	override fun toString(): String =
	delegatePath.toString().replace(fileSystem.delegateFileSystem.separator, SharpFileSystem.PATH_SEPARATOR)
	}

	private fun Path.toDelegatePath(): Path = (this as SharpPath).delegatePath