// authenticated clients, used to initiate lock REST calls.
type Dsync struct {
	// List of rest client objects, one per lock server.
	GetLockers func() ([]NetLocker, string)

	// Timeouts to apply.
	Timeouts Timeouts

class InternalBwcGitPluginFuncTest extends AbstractGitAwareGradleFuncTest {

    def setup() {
        internalBuild()
        buildFile << """
            import org.elasticsearch.gradle.Version;
            apply plugin: org.elasticsearch.gradle.internal.InternalBwcGitPlugin

            bwcGitConfig {
                 bwcVersion = project.provider { Version.fromString("7.9.1") }
                 bwcBranch = project.provider { "7.x" }

 */

package org.elasticsearch.gradle.fixtures;


abstract class AbstractRestResourcesFuncTest extends AbstractGradleFuncTest {

    def setup() {
        addSubProject(":test:framework") << "apply plugin: 'elasticsearch.java'"

        addSubProject(":rest-api-spec") << """
        configurations { restSpecs\nrestTests }
        artifacts {

  }
}

tasks.shadowJar {
  mergeServiceFiles()
}

tasks.withType<Test> {
  val javaVersion = project.testJavaVersion
  onlyIf("native build requires Java 17") {
    javaVersion > 17
  }
}

apply(plugin = "org.graalvm.buildtools.native")

configure<GraalVMExtension> {
  binaries {
    named("main") {
      imageName = "okcurl"
      mainClass = "okhttp3.curl.MainCommandLineKt"

  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            Deque.class,
            new Function<Deque, Deque<?>>() {
              @Override
              public Deque<?> apply(Deque delegate) {
                return wrap((Deque<?>) delegate);
              }
            });
  }

  private static <T> Deque<T> wrap(Deque<T> delegate) {
    return new ForwardingDeque<T>() {
      @Override

import org.gradle.api.tasks.testing.Test;
import org.gradle.language.base.plugins.LifecycleBasePlugin;

public class PrecommitTaskPlugin implements Plugin<Project> {

    @Override
    public void apply(Project project) {
        TaskProvider<Task> precommit = project.getTasks().register(PrecommitPlugin.PRECOMMIT_TASK_NAME, t -> {
            t.setGroup(JavaBasePlugin.VERIFICATION_GROUP);

    new ForwardingWrapperTester()
        .testForwarding(
            Table.class,
            new Function<Table, Table<?, ?, ?>>() {
              @Override
              public Table<?, ?, ?> apply(Table delegate) {
                return wrap((Table<?, ?, ?>) delegate);
              }
            });
  }

  public void testEquals() {
    Table<Integer, Integer, String> table1 = ImmutableTable.of(1, 1, "one");

  }

  @Override
  protected String getSuccessfulResult() {
    return RESULT_DATA;
  }

  private static final class ComposeFunction implements Function<Integer, String> {
    @Override
    public String apply(Integer input) {
      if (input.intValue() == VALID_INPUT_DATA) {
        return RESULT_DATA;
      } else {
        throw WRAPPED_EXCEPTION;
      }
    }
  }

        project.apply(target -> target.plugin(GradleReleaseNotesPlugin.class));
        project.apply(target -> target.plugin(GradleJavadocsPlugin.class));
        project.apply(target -> target.plugin(GradleKotlinDslReferencePlugin.class));
        project.apply(target -> target.plugin(GradleDslReferencePlugin.class));
        project.apply(target -> target.plugin(GradleUserManualPlugin.class));

- Keep ellipsis style consistent with existing Korean docs (often `...`).
- Never change `...` in code, URLs, or CLI examples.

### Preferred translations / glossary

Use the following preferred translations when they apply in documentation prose:

- request (HTTP): 요청
- response (HTTP): 응답
- path operation: 경로 처리
- path operation function: 경로 처리 함수
- app: 애플리케이션
- command: 명령어
- burger: 햄버거 (NOT 버거)

### `///` admonitions