public void test_register_nullFactory() {
        ComponentUtil.register(null, "scriptEngineFactory");

        try {
            testScriptEngine.register();
            fail("Should throw exception when factory is null");
        } catch (NullPointerException e) {
            // Expected exception
        }
    }

    // Test concrete implementation with different name

 * [okhttp-spring-boot](https://github.com/freefair/okhttp-spring-boot): Spring Boot starters for OkHttp
 * [okhttp-staleiferror-interceptor](https://github.com/PeelTechnologies/okhttp-staleiferror-interceptor/): serve stale responses when the server isn’t reachable.
 * [okhttp-stats](https://github.com/flipkart-incubator/okhttp-stats): Get stats like average network speed.

  fun testSupportedProtocols() {
    val factory = SSLSocketFactory.getDefault()
    assertThat(factory.javaClass.name).isEqualTo("sun.security.ssl.SSLSocketFactoryImpl")
    val s = factory.createSocket() as SSLSocket

    when {
      PlatformVersion.majorVersion > 11 ->
        assertThat(s.enabledProtocols.toList()).containsExactly(
          "TLSv1.3",
          "TLSv1.2",
        )
      // Not much we can guarantee on JDK 11.

                .filter { onlyNativeSubprojectsForIntelMacs(testCoverage, it.subProject.name) }

        return parallelize(subProjectTestClassTimes, testCoverage) { numberOfBatches ->
            when (testCoverage.os) {
                Os.LINUX -> ParallelizationMethod.TestDistribution
                Os.ALPINE -> ParallelizationMethod.TestDistributionAlpine

  quay.io/minio/minio server /data --console-address ":9001"
```

The command creates a new local directory `~/minio/data` in your user home directory. It then starts the MinIO container with the `-v` argument to map the local path (`~/minio/data`) to the specified virtual container directory (`/data`). When MinIO writes data to `/data`, that data is actually written to the local path `~/minio/data` where it can persist between container restarts.

### Windows

    taskFaker.runTasks()
    client.listener.assertFailure(IOException::class.java, "source is closed")
  }

  @Test
  fun closeMessageAndConnectionCloseThrowingDoesNotMaskOriginal() {
    // So when the client sends close it throws an IOException.
    server.source.close()
    client.webSocket!!.close(1000, "Bye!")
    taskFaker.runTasks()
    client.webSocket!!.finishReader()

    assertTrue(set.contains(1));
    assertTrue(set.contains(2));
    assertTrue(set.contains(3));
    assertFalse(set.contains(4));
  }

  // TODO: https://youtrack.jetbrains.com/issue/KT-71001/ - Enable when Kotlin throws expected CCE.
  @J2ktIncompatible
  public void testContains_typeMismatch() {
    ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.open(0, 4), integers());

    private NbtAddress mockQueryAddress;

    private NodeStatusResponse response;

    @BeforeEach
    void setUp() throws Exception {
        // Setup mock configuration with lenient stubbing
        lenient().when(mockConfig.getOemEncoding()).thenReturn("UTF-8");

        // Setup mock query address
        mockQueryAddress = mock(NbtAddress.class);
        Name mockName = new Name(mockConfig, "TEST", 0x20, null);

  @LazyInit private @Nullable ScheduledFuture<?> timer;

  private TimeoutFuture(ListenableFuture<V> delegate) {
    this.delegateRef = Preconditions.checkNotNull(delegate);
  }

  /** A runnable that is called when the delegate or the timer completes. */
  private static final class Fire<V extends @Nullable Object> implements Runnable {
    @LazyInit @Nullable TimeoutFuture<V> timeoutFutureRef;

    Fire(TimeoutFuture<V> timeoutFuture) {

   *       channel have their own file descriptors. Generally this only happens when both channels
   *       are files or sockets. This performs zero copies - the bytes never enter userspace.
   *   <li>Use mmap(2) or equivalent. Requires that either the input channel or the output channel
   *       have file descriptors. Bytes are copied from the file into a kernel buffer, then directly