override fun execute() {
        try {
            val versionToIncubating = mutableMapOf<Version, MutableSet<IncubatingDescription>>()
            val repositoryRoot = parameters.repositoryRoot.get().asFile.toPath()
            parameters.srcDirs.forEach { srcDir ->
                if (srcDir.exists()) {
                    val collector = CompositeVersionsToIncubatingCollector(
                        listOf(

   * + i) mod array.length}. This is equivalent to {@code Collections.rotate(Bytes.asList(array),
   * distance)}, but is somewhat faster.
   *
   * <p>The provided "distance" may be negative, which will rotate left.
   *
   * @since 32.0.0
   */
  public static void rotate(byte[] array, int distance) {
    rotate(array, distance, 0, array.length);
  }

  /**

private fun isMappedIpv4Address(address: ByteArray): Boolean {
  if (address.size != 16) return false

  for (i in 0 until 10) {
    if (address[i] != 0.toByte()) return false
  }

  if (address[10] != 255.toByte()) return false
  if (address[11] != 255.toByte()) return false

  return true
}

/** Encodes an IPv4 address in canonical form according to RFC 4001. */

   * + i) mod array.length}. This is equivalent to {@code Collections.rotate(Longs.asList(array),
   * distance)}, but is considerably faster and avoids allocation and garbage collection.
   *
   * <p>The provided "distance" may be negative, which will rotate left.
   *
   * @since 32.0.0
   */
  public static void rotate(long[] array, int distance) {
    rotate(array, distance, 0, array.length);
  }

  /**

        final Path realFolder = temporaryFolder.getRoot().toPath().resolve("real-folder");
        Files.createDirectory(realFolder);
        Files.createFile(realFolder.resolve("file"));
        Files.createSymbolicLink(realFolder.resolve("link-to-file"), Paths.get("./file"));
        final Path linkInFolder = temporaryFolder.getRoot().toPath().resolve("link-in-folder");
        Files.createDirectory(linkInFolder);

        outputFile.getParentFile().mkdirs();
        Files.write(outputFile.toPath(), classWriter.toByteArray());
    }

    private void adjustClass(String classFile, Consumer<ClassNode> adjustor) throws IOException {
        try (InputStream is = Files.newInputStream(inputDir.get().file(classFile).getAsFile().toPath())) {
            ClassReader classReader = new ClassReader(is);

 * limitations under the License.
 */
package okhttp3

import okio.Buffer
import okio.Path
import okio.Path.Companion.toPath

val okHttpRoot: Path
  get() = getEnv("OKHTTP_ROOT")!!.toPath()

fun String(vararg codePoints: Int): String {
  val buffer = Buffer()
  for (codePoint in codePoints) {
    buffer.writeUtf8CodePoint(codePoint)
  }
  return buffer.readUtf8()

    /**
     * Test isPathSafe with safe path
     *
     * @throws Exception
     */
    @Test
    public void testIsPathSafe_SafePath() throws Exception {
        final Path baseDir = tempFolder.getRoot().toPath();
        final Path safePath = baseDir.resolve("subdir/file.txt");

        assertTrue("Safe path should be allowed", FileUtil.isPathSafe(safePath, baseDir));
    }

    /**

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.publicsuffix

import okio.FileSystem
import okio.Path
import okio.Path.Companion.toPath
import okio.Source

internal class ResourcePublicSuffixList(
  override val path: Path = PUBLIC_SUFFIX_RESOURCE,
  val fileSystem: FileSystem = FileSystem.Companion.RESOURCES,
) : BasePublicSuffixList() {

    @Override
    public void merge(File current, File result) throws RepositoryException {
        try {
            if (current.exists()) {
                Files.createDirectories(result.toPath().getParent());
                Files.copy(current.toPath(), result.toPath());
            }
            ArtifactRepository localRepo = new MetadataRepository(result);
            metadata.storeInLocalRepository(localRepo, localRepo);
            merged = true;