return get(EsAccessResult.class, sessionId, url);
    }

    @Override
    public List<EsAccessResult> getAccessResultList(final String url, final boolean hasData) {
        return getList(EsAccessResult.class, builder -> builder.setQuery(QueryBuilders.termQuery(URL, url)));
    }

    public List<EsAccessResult> getAccessResultList(final Consumer<SearchRequestBuilder> callback) {

    }

    @Override
    TestFile getVariantSourceFile(String module, VariantContext variantContext) {
        return staticLibrary("${module}/build/lib/main/${variantContext.asPath}${module}").file
    }

    @Override
    Map<String, String> getVariantFileInformation(String linkage, String module, String variantModuleNameWithVersion) {

            tasks.register("run", Exec) {
                dependsOn(compileJava)
                executable = ${Jvm.canonicalName}.current().javaExecutable
                args '-cp', project.layout.files(compileJava).asPath, 'Main' ${formatArgument args["extraArg"], { ", '$it'" }}

                ${formatStreamArgument args, "standardInput"}
                ${formatStreamArgument args, "standardOutput"}

        val hasData = sendBuffer.size > 0L
        val hasTrailers = trailers != null
        when {
          hasTrailers -> {
            while (sendBuffer.size > 0L) {
              emitFrame(false)
            }
            connection.writeHeaders(id, outFinished, trailers!!.toHeaderList())
          }

          hasData -> {
            while (sendBuffer.size > 0L) {

        fixture.workActionThatCreatesFiles.action += """
            execOperations.exec {
                executable org.gradle.internal.jvm.Jvm.current().getJavaExecutable()
                args '-cp', parameters.classpath.asPath, 'org.gradle.TestMain', parameters.projectDir, parameters.testFile
            }
        """
        fixture.withWorkActionClassInBuildScript()

        file('src/main/java/org/gradle/TestMain.java') << testMainSource

    public Iterator<File> iterator() {
        return getFiles().iterator();
    }

    @Override
    public String getAsPath() {
        showGetAsPathDeprecationWarning();
        return GUtil.asPath(this);
    }

    private void showGetAsPathDeprecationWarning() {
        List<String> filesAsPaths = this.getFiles().stream()
            .map(File::getPath)

                args.add("-sourcepath");
                args.add("");
            }
            return;
        }

        args.add("-sourcepath");
        args.add(GUtil.asPath(sourcepath));
    }

    private void addUserProvidedArgs(List<String> compilerArgs) {
        if (!includeMainOptions) {
            return;
        }
        if (compilerArgs != null) {

        buildFile """
            def files = files('${escapeString(path)}')
            tasks.register("getAsPath") {
                doLast {
                    println files.asPath
                }
            }
        """

        when:
        runAndFail "getAsPath"
        then:

                    ["-DtestRuntimeClasspath=\${filteredTestClasspath.asPath}".toString()]
                }
            }
        """.stripIndent()

        when:
        executer.withTasks('build').run()

        then:

    }

    @Override
    TestFile getVariantSourceFile(String module, VariantContext variantContext) {
        def executable = executable("build/exe/main/${variantContext.asPath}${module}")
        return variantContext.buildType.name == 'release' ? executable.strippedRuntimeFile : executable.file
    }

    @Override