}

    void calculateNextPermutation() {
      int j = findNextJ();
      if (j == -1) {
        nextPermutation = null;
        return;
      }
      /*
       * requireNonNull is safe because we don't clear nextPermutation until we're done calling this
       * method.
       */
      requireNonNull(nextPermutation);

      int l = findNextL(j);
      Collections.swap(nextPermutation, j, l);

    fname = [x.path for x in fname.files.to_list()][0]
    toks = fname[:-5].split("/")
    findex = -1
    for s in _PREFIXES:
        findex = _SafeIndex(toks, s)
        if findex != -1:
            break
    if findex == -1:
        fail("%s does not contain any of %s" % (fname, _PREFIXES))
    return ".".join(toks[findex:]) + ".class"

def _impl(ctx):
    classes = ",".join(

    def "file backed text resource"() {
        when:
        run("generateConfigFile")
        run("fileText")

        then:
        result.assertTasksExecuted(":fileText")
        file("output.txt").text == "my config"

        when:
        run("fileText")

        then:
        result.assertTasksSkipped(":fileText")
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)

        this.environments = environments
    }
    
    static NMToolFixture of(List<String> environments) {
        return new NMToolFixture(environments)
    }

    private findExe(String exe) {
        // *nix OS correctly handle search inside the process's PATH environment variable
        if (!OperatingSystem.current().windows) {
            return [exe]
        }

    }

    void calculateNextPermutation() {
      int j = findNextJ();
      if (j == -1) {
        nextPermutation = null;
        return;
      }
      /*
       * requireNonNull is safe because we don't clear nextPermutation until we're done calling this
       * method.
       */
      requireNonNull(nextPermutation);

      int l = findNextL(j);
      Collections.swap(nextPermutation, j, l);

 */
fun main() {
  val knownTestFile = File("native-image-tests/src/main/resources/testlist.txt")
  val testSelector = DiscoverySelectors.selectPackage("okhttp3")
  val testClasses =
    findTests(listOf(testSelector))
      .filter { it.isContainer }
      .mapNotNull { (it as? ClassBasedTestDescriptor)?.testClass?.name }
      .filterNot { it in avoidedTests }
      .sorted()
      .distinct()

}

class KaResolveExtensionFileForTests(
    private val fileName: String,
    private val packageName: FqName,
    topLevelClassifiersNames: Set<String>,
    topLevelCallableNames: Set<String>,
    private val fileText: String,
    private val navigationTargetsProvider: KaResolveExtensionNavigationTargetsProvider? = null
) : KaResolveExtensionFile() {

}

dependencies {
    sharedConfig generateConfigZip.outputs.files
}

task stringText(type: MyTask) {
    config = resources.text.fromString("my config")
    output = project.file("output.txt")
}

task fileText(type: MyTask) {
    config = resources.text.fromFile("config.txt")
    output = project.file("output.txt")
}

task fileCollectionText(type: MyTask) {
    config = resources.text.fromFile(generateConfigFile.get())

            }*/
        }

        where:
        accessKind          | inputRead
        "file"              | (TestFile it) -> { UndeclaredFileAccess.fileText(testFilePath(it)) }
        "file system entry" | (TestFile it) -> { UndeclaredFileAccess.fileExists(testFilePath(it)) }
        "directory content" | (TestFile it) -> { UndeclaredFileAccess.directoryContent(testFilePath(it)) }

                fileName = name,
                packageName = packageName,
                topLevelClassifiersNames = classifierNames,
                topLevelCallableNames = callableNames,
                fileText = originalContent,
            )
        }
    }

    @OptIn(TestInfrastructureInternals::class)
    fun configure(builder: TestConfigurationBuilder) = with(builder) {
        defaultDirectives {