archiveBaseName = "incubating-apis"
    from(allIncubationReports.get().htmlReportFile)
    from(allIncubationReports.get().csvReportFile)
    from(resolver("html"))
}

fun resolver(reportType: String) = configurations.create("incubatingReport${reportType.capitalize()}Path") {
    isCanBeResolved = true
    isCanBeConsumed = false
    attributes {
        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))

            String argline = System.getProperty("tests.jvm.argline");
            if (argline != null) {
                test.jvmArgs((Object[]) argline.split(" "));
            }

            if (Util.getBooleanProperty("tests.asserts", true)) {
                test.jvmArgs("-ea", "-esa");
            }

            Map<String, String> sysprops = Map.of(
                "java.awt.headless",

import java.util.HashMap;
import java.util.Map;
import org.jspecify.annotations.NullMarked;

@GwtCompatible
@NullMarked
public class FilteredMapTest extends AbstractFilteredMapTest {
  @Override
  Map<String, Integer> createUnfiltered() {
    return new HashMap<>();
  }

=================

Support for Kotlin clients using coroutines.

```kotlin
val call = client.newCall(request)

call.executeAsync().use { response ->
  withContext(Dispatchers.IO) {
    println(response.body?.string())
  }
}
```

This is implemented using `suspendCancellableCoroutine`
but uses the standard Dispatcher in OkHttp. This means
that by default Kotlin's Dispatchers are not used.

    repositoryPlugin.deployDirectory(testResourceDir / "deployments")
    repositoryPlugin.deployClassPath()
  }

  private fun createBndRun(workspace: Workspace): Bndrun {
    // Creating the run require string. It will always use the latest version of each bundle
    // available in the repository.
    val runRequireString =
      REQUIRED_BUNDLES.joinToString(separator = ",") {
        "osgi.identity;filter:='(osgi.identity=$it)'"

                  peeker.getDone(future5));
            }

            @Override
            public String toString() {
              return function.toString();
            }
          },
          executor);
    }
  }

  @Override
  public String toString() {
    return state.closingFutureToString();
  }

    }

    /**
     * Get a key match.
     *
     * @param id The ID of the key match.
     * @return An optional entity of the key match.
     */
    public OptionalEntity<KeyMatch> getKeyMatch(final String id) {
        return keyMatchBhv.selectByPK(id);
    }

    /**
     * Store a key match.
     *
     * @param keyMatch The key match to store.
     */
    public void store(final KeyMatch keyMatch) {

  }

  private inline fun <T> assertOnFileDescriptor(
    content: String? = null,
    fn: (FileDescriptor) -> T,
  ): T =
    assertOnPath(content) {
      FileInputStream(filePath.toFile()).use { fis ->
        fn(fis.fd)
      }
    }

  private inline fun <T> assertOnPath(
    content: String? = null,
    fn: (okio.Path) -> T,
  ): T {
    FileSystem.SYSTEM.write(filePath) {

    }
  }

  @Param EncodingOption encoding;

  @Param({"10", "100", "10000"})
  int n;

  private final byte[][] encodingInputs = new byte[INPUTS_COUNT][];
  private final String[] decodingInputs = new String[INPUTS_COUNT];

  @BeforeExperiment
  public void setUp() {
    Random rng = new Random();
    for (int i = 0; i < encodingInputs.length; i++) {
      encodingInputs[i] = new byte[n];

/**
 * @author David Beaumont
 */
@GwtCompatible
@NullMarked
public class ArrayBasedCharEscaperTest extends TestCase {
  private static final ImmutableMap<Character, String> NO_REPLACEMENTS = ImmutableMap.of();
  private static final ImmutableMap<Character, String> SIMPLE_REPLACEMENTS =
      ImmutableMap.of(
          '\n', "<newline>",
          '\t', "<tab>",
          '&', "<and>");