* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.nativeintegration.filesystem.services;

import org.gradle.internal.file.FileModeAccessor;
import org.gradle.internal.nativeintegration.filesystem.FileSystem;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;

class FallbackStat implements FileModeAccessor {

import org.gradle.api.internal.file.DefaultFileTreeElement;
import org.gradle.internal.nativeintegration.filesystem.FileSystem;

import java.io.File;

public abstract class DirectoryTrees {
    private DirectoryTrees() {
    }

    public static boolean contains(FileSystem fileSystem, DirectoryTree tree, File file) {
        String prefix = tree.getDir().getAbsolutePath() + File.separator;

        this.relativePath = relativePath;
        this.stat = stat;
    }

    public static DefaultFileTreeElement of(File file, FileSystem fileSystem) {
        RelativePath path = RelativePath.parse(!file.isDirectory(), file.getAbsolutePath());
        return new DefaultFileTreeElement(file, path, fileSystem, fileSystem);
    }

    @Override
    public File getFile() {
        return file;
    }

    @Override

import org.gradle.api.Action
import org.gradle.api.file.FileVisitDetails
import org.gradle.api.file.FileVisitor
import org.gradle.api.internal.file.FileTreeInternal
import org.gradle.internal.nativeintegration.filesystem.FileSystem
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.gradle.util.UsesNativeServices
import org.junit.Rule
import spock.lang.Specification

@UsesNativeServices

class PostPath {
  private val client = OkHttpClient()
  private val fileSystem = FakeFileSystem()
  val path = "test.json".toPath()

  fun run() {
    fileSystem.write(path) {
      writeUtf8("{}")
    }

    val request =
      Request.Builder()
        .url("https://httpbin.org/anything")
        .put(path.asRequestBody(fileSystem, MEDIA_TYPE_JSON))
        .build()

        private final FileSystem fileSystem;

        public FilePermissionsAccessAdapter(FileSystem fileSystem) {
            this.fileSystem = fileSystem;
        }

        @Override
        public int getUnixMode(File f) throws FileException {
            return fileSystem.getUnixMode(f);
        }

        @Override

 *
 *
 * The resulting file is used by [PublicSuffixDatabase].
 */
class PublicSuffixListGenerator(
  projectRoot: Path = ".".toPath(),
  val fileSystem: FileSystem = FileSystem.SYSTEM,
  val client: OkHttpClient = OkHttpClient(),
) {
  private val resources = projectRoot / "okhttp/src/main/resources/okhttp3/internal/publicsuffix"

        }
    };
    private final File localFile;
    private final FileSystem fileSystem;
    private final FileResourceListener listener;

    public LocalFileStandInExternalResource(File localFile, FileSystem fileSystem, FileResourceListener listener) {
        this.localFile = localFile;
        this.fileSystem = fileSystem;
        this.listener = listener;
    }

      .build()
  private val STORY_JSON_ADAPTER = MOSHI.adapter(Story::class.java)

  private val fileSystem = FileSystem.SYSTEM

  private fun readStory(source: BufferedSource): Story {
    return STORY_JSON_ADAPTER.fromJson(source)!!
  }

  private fun readStory(file: Path): Story {
    fileSystem.read(file) {
      return readStory(this)
    }
  }

import okhttp3.internal.connection.Exchange
import okhttp3.internal.connection.RealCall
import okhttp3.internal.connection.RealConnection
import okio.FileSystem
import okio.Path

internal fun buildCache(
  file: Path,
  maxSize: Long,
  fileSystem: FileSystem,
): Cache {
  return Cache(fileSystem, file, maxSize)
}

internal var RealConnection.idleAtNsAccessor: Long
  get() = idleAtNs
  set(value) {
    idleAtNs = value
  }