- OkHttp targets the intersection of RFC correct *and* widely implemented.  Incorrect implementations that are very widely implemented e.g. a bug in Apache, Nginx, Google, Firefox should also be handled.

Before your code can be accepted into the project you must also sign the
[Individual Contributor License Agreement (CLA)][1].

interface Callback {
  /**
   * Called when the request could not be executed due to cancellation, a connectivity problem or
   * timeout. Because networks can fail during an exchange, it is possible that the remote server
   * accepted the request before the failure.
   */
  fun onFailure(
    call: Call,
    e: IOException,
  )

  /**
   * Called when the HTTP response was successfully returned by the remote server. The callback may

   *
   * <p>If the supplied future is {@linkplain #isDone done} when this method is called and the call
   * is accepted, then this future is guaranteed to have been completed with the supplied future by
   * the time this method returns. If the supplied future is not done and the call is accepted, then
   * the future will be <i>set asynchronously</i>. Note that such a result, though not yet known,

[many libraries][works_with_okhttp] that sit on top or hook in via existing APIs. If you build
something that integrates with OkHttp, tell us so that we can link it!

Before code can be accepted all contributors must complete our
[Individual Contributor License Agreement (CLA)][cla].


Code Contributions
------------------

Get working code on a personal branch with tests passing before you submit a PR:

```
./gradlew clean check
```

[many libraries][works_with_okhttp] that sit on top or hook in via existing APIs. If you build
something that integrates with OkHttp, tell us so that we can link it!

Before code can be accepted all contributors must complete our
[Individual Contributor License Agreement (CLA)][cla].


Code Contributions
------------------

Get working code on a personal branch with tests passing before you submit a PR:

```
./gradlew clean check
```

import org.gradle.api.GradleException
import org.gradle.api.tasks.CacheableTask
import org.gradle.api.tasks.TaskAction
import java.io.File


/**
 * This [Task][org.gradle.api.Task] checks that the contents of a given accepted API changes files
 * are present in alphabetical order (by type, then member), and throws an exception and reports
 * any changes that are not.
 */
@CacheableTask

        // With filter, resource should be closed due to try-with-resources
        verify(filter).accept(resource);
        verify(resource).close();
    }

    @Test
    @DisplayName("Iterator with rejecting filter - finds next acceptable")
    void iteratorWithRejectingFilter() throws Exception {
        // Setup: first entry rejected, second accepted
        FileEntry entry1 = mock(FileEntry.class);

        // Verify filter interactions: not called for '.' and '..', called for others
        verify(nameFilter, never()).accept(parent, ".");
        verify(nameFilter, never()).accept(parent, "..");
        ArgumentCaptor<String> nameCaptor = ArgumentCaptor.forClass(String.class);
        verify(nameFilter, atLeast(1)).accept(eq(parent), nameCaptor.capture());

        new SecureRandom().nextBytes(standardFileId);
        new SecureRandom().nextBytes(longFileId);

        RequestWithFileId request = new Smb2CloseRequest(mockConfig, emptyFileId);

        // All sizes should be accepted without exception
        assertDoesNotThrow(() -> request.setFileId(shortFileId), "Should handle 8-byte file ID");
        assertDoesNotThrow(() -> request.setFileId(standardFileId), "Should handle 16-byte file ID");

# ADR-0003 - Avoid introducing Groovy types to public API

## Status

- ACCEPTED on 2024-01-12

## Context

Gradle's public API requires equal access from all JVM-based languages.
Kotlin, Groovy, Java, and other JVM-based languages should be able to use the Gradle API without relying on another language's standard library.

Historically, Gradle has shipped with some Groovy types in very prominent APIs.