@EnumSource(RequestParam.class)
    @DisplayName("send handles each RequestParam enum constant")
    void send_eachRequestParam_isAccepted(RequestParam param) throws Exception {
        // Arrange: stub per-call return to ensure interaction with the exact enum
        when(tree.send(eq(request), eq(param))).thenReturn(response);

        // Act
        CommonServerMessageBlockResponse out = tree.send(request, param);

        // Assert

    // explicitly remove the existing value
    cache.asMap().computeIfPresent(1, (key, value) -> null);
    assertThat(notifications).hasSize(1);
    CacheTesting.checkEmpty(cache);

    // ensure no zombie entry remains
    cache.asMap().computeIfPresent(1, (key, value) -> null);
    assertThat(notifications).hasSize(1);
    CacheTesting.checkEmpty(cache);
  }

  public void testUpdates() {

        float boost = 1.5f;

        // Execute and ensure no exceptions are thrown
        QueryBuilder result = matchAllQueryCommand.execute(context, query, boost);

        assertNotNull(result);

        // Note: Actual log output verification would require a log appender mock
        // but we can at least ensure the method executes without errors

    if (Log.isLoggable(tag, logLevel)) {
      var logMessage = message
      if (t != null) logMessage = logMessage + '\n'.toString() + Log.getStackTraceString(t)

      // Split by line, then ensure each line can fit into Log's maximum length.
      var i = 0
      val length = logMessage.length
      while (i < length) {
        var newline = logMessage.indexOf('\n', i)

            setException(failure);
          }
        };

    ExecutionException ee1 = getExpectingExecutionException(future);
    ExecutionException ee2 = getExpectingExecutionException(future);

    // Ensure we get a unique execution exception on each get
    assertNotSame(ee1, ee2);

    assertThat(ee1).hasCauseThat().isSameInstanceAs(failure);
    assertThat(ee2).hasCauseThat().isSameInstanceAs(failure);

		prepared:    make(chan struct{}),
	}
	// Cache the Stmt object with the associated key.
	s.Set(key, cacheStmt)
	// Unlock after completing initialization to prevent deadlocks.
	locker.Unlock()

	// Ensure the prepared channel is closed after the function execution completes.
	defer close(cacheStmt.prepared)

	// Prepare the SQL statement using the provided connection.
	cacheStmt.Stmt, err = conn.PrepareContext(ctx, key)

        assertFalse(Features.deployBuildPom(properties)); // "0".parseBoolean() = false
    }

    @Test
    void testDeployBuildPomWithMutableMap() {
        // Test with a mutable map to ensure the method doesn't modify the input
        Map<String, Object> properties = new HashMap<>();
        properties.put(Constants.MAVEN_DEPLOY_BUILD_POM, "false");

        assertFalse(Features.deployBuildPom(properties));

    withContext(Dispatchers.IO) {
      fileSystem.write(outputFile) {
        importResults.writeOut(this)
      }
    }

  /**
   * These assertions ensure the [PublicSuffixDatabase] remains correct. The specification is
   * very flexible regarding wildcard rules, but this flexibility is not something currently used

    }

    /**
     * Measure the average time for equals operations.
     */
    private long measureEqualsTime(NtlmPasswordAuthenticator auth1, NtlmPasswordAuthenticator auth2, int iterations) {
        // Warm up
        for (int i = 0; i < 100; i++) {
            auth1.equals(auth2);
        }

        // Measure actual timing
        long startTime = System.nanoTime();

/// tip

Note that we're using async/await with the new `AsyncClient` - the request is asynchronous.

///

/// warning

If your application relies on lifespan events, the `AsyncClient` won't trigger these events. To ensure they are triggered, use `LifespanManager` from <a href="https://github.com/florimondmanca/asgi-lifespan#usage" class="external-link" target="_blank">florimondmanca/asgi-lifespan</a>.

///