}
        };

    recursiveCache = CacheBuilder.newBuilder().weakKeys().weakValues().build(recursiveLoader);
    cacheRef.set(recursiveCache);

    // tells the test when the computation has completed
    CountDownLatch doneSignal = new CountDownLatch(1);

    Thread thread =
        new Thread() {
          @Override
          public void run() {
            try {

        assertFalse(ctx.isMICAvailable());
        verify(this.mechContext, never()).isMICAvailable();
    }

    @Test
    @DisplayName("isEstablished short-circuits on not completed and does not call delegate")
    void testIsEstablishedShortCircuit() {
        SpnegoContext ctx = newContext();
        // The mock setup is unnecessary since we never call it
        assertFalse(ctx.isEstablished());

   * Regression test for an edge case where closing response body in the HTTP engine doesn't release
   * the corresponding stream allocation. This test keeps those response bodies alive and reads
   * them after the redirect has completed. This forces a connection to not be reused where it would
   * be otherwise.
   *
   *
   * This test leaks a response body by not closing it.
   *
   * https://github.com/square/okhttp/issues/2409
   */

	type poolInfo struct {
		position     int
		completed    bool
		decomStarted bool // started but not finished yet
	}

	rememberedPools := make(map[string]poolInfo)
	for idx, pool := range p.Pools {
		complete := false
		decomStarted := false
		if pool.Decommission != nil {
			if pool.Decommission.Complete {
				complete = true
			}
			decomStarted = true
		}

        double totalTimeMs = (end - start) / 1_000_000.0;

        System.out.printf("Overall Performance Test: completed in %.2f ms%n", totalTimeMs);

        // Should complete very quickly with all optimizations
        assertTrue(totalTimeMs < 100, "All operations should complete quickly with performance fixes");

        pool.close();
    }

              docker cp "${sql_file}" "${container_name}":"${sql_file}"
              docker exec -i ${TTY_FLAG} "${container_name}" bash -c "su - omm -c 'gsql -U omm -f ${sql_file}'"
              echo "Database initialization completed."
              break
            fi

            echo "Waiting for database to be ready... (attempt $((retry_count + 1))/$max_retries)"
            sleep 10
            ((++retry_count))
          done

                        try {
                            startLatch.countDown();
                            holdLatch.await();
                            return "completed";
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    });
                } catch (Exception e) {

Since HTTP requests frequently happen in parallel, connection pooling must be thread-safe.

These are the primary classes involved with establishing, sharing, and terminating connections:

            context.invalidate();
            throw new CIFSException("Failed to update preauth integrity hash for session " + sessionId, e);
        }
    }

    /**
     * Validates the preauth integrity for completed negotiation.
     *
     * @param sessionId the session identifier
     * @param expectedHash the expected final hash
     * @return true if validation passes
     * @throws CIFSException if validation fails

		initialized:      make(chan struct{}),
	}
	// When the schema initialization is completed, the channel will be closed
	defer close(schema.initialized)

	// Load exist schema cache, return if exists
	if v, ok := cacheStore.Load(schemaCacheKey); ok {
		s := v.(*Schema)
		// Wait for the initialization of other goroutines to complete
		<-s.initialized
		return s, s.err
	}