*
   * <p>The {@link Table#cellSet()} iteration order of the provided table determines the iteration
   * ordering of all views in the returned table. Note that some views of the original table and the
   * copied table may have different iteration orders. For more control over the ordering, create a
   * {@link Builder} and call {@link Builder#orderRowsBy}, {@link Builder#orderColumnsBy}, and
   * {@link Builder#putAll}
   *

        when(mockHit.getIndex()).thenReturn("test-index");
        when(mockHit.getId()).thenReturn("doc1");

        // Setup scroll response (empty on second call)
        when(mockClient.prepareSearchScroll("scroll1")).thenReturn(mockScrollBuilder);
        when(mockScrollBuilder.setScroll(any(Scroll.class))).thenReturn(mockScrollBuilder);

        description =
            "Command line option for the performance test task to enable profiling. " +
                "For example `async-profiler`, `async-profiler-heap`, `async-profiler-wall`, `async-profiler-all` or `jfr`. Use `none` for benchmarking only.",
    )
}

object AdHocPerformanceScenarioLinux : AdHocPerformanceScenario(Os.LINUX)

```

## EventListener events

Cache Events are exposed via the EventListener API.  Typical scenarios are below.

### Cache Hit

In the ideal scenario the cache can fulfill the request without any conditional call to the network.
This will skip the normal events such as DNS, connecting to the network, and downloading the response body.

As recommended by the HTTP RFC the max age of a document is defaulted to 10% of the

    fun onEvent(
      id: String?,
      type: String?,
      data: String,
    )

    fun onRetryChange(timeMs: Long)
  }

  /**
   * Process the next event. This will result in a single call to [Callback.onEvent] *unless* the
   * data section was empty. Any number of calls to [Callback.onRetryChange] may occur while
   * processing an event.
   *
   * @return false when EOF is reached
   */

    /**
     * Constructs a TransCallNamedPipe request to write data to a named pipe.
     *
     * @param config the SMB configuration
     * @param pipeName the name of the pipe to call
     * @param data the data buffer to write to the pipe
     * @param off the offset in the data buffer
     * @param len the length of data to write
     */

   * started execution. It is unclear from the {@code ExecutorService} specification if these should
   * be included, and it's much easier to implement the interpretation that they not be. Finally, a
   * call to {@code shutdown} or {@code shutdownNow} may result in concurrent calls to {@code
   * invokeAll/invokeAny} throwing RejectedExecutionException, although a subset of the tasks may
   * already have been executed.
   *

        assertFalse(filter.accept(mockDir, null), "Should reject null names");

        // Verify getPath was called three times (once for each accept call)
        verify(mockDir, times(3)).getPath();
        verifyNoMoreInteractions(mockDir);
    }

    /**
     * Defensive behavior: implementation throws NPE on null inputs by design.
     */
    @Test

    if (deferredPlans.isNotEmpty()) return deferredPlans.removeFirst() as FakePlan

    if (nextPlanIndex >= plans.size && autoGeneratePlans) addPlan()

    require(nextPlanIndex < plans.size) {
      "not enough plans! call addPlan() or set autoGeneratePlans=true in the test to set this up"
    }
    val result = plans[nextPlanIndex++]
    events += "take plan ${result.id}"

    if (result.yieldBeforePlanReturns) {
      taskFaker.yield()

 * iterators that don't support {@code remove()}. Otherwise, all optional operations are supported.
 * Null row keys, columns keys, and values are not supported.
 *
 * <p>Lookups by row key are often faster than lookups by column key, because the data is stored in
 * a {@code Map<R, Map<C, V>>}. A method call like {@code column(columnKey).get(rowKey)} still runs