* see {@link com.google.common.collect.testing.CollectionTestSuiteBuilder}.
 *
 * @author Jared Levy
 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")
// @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class QueueOfferTester<E> extends AbstractQueueTester<E> {

import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Test

/**
 * Apache HttpClient 5.x.
 *
 * https://hc.apache.org/httpcomponents-client-5.0.x/index.html
 *
 * Baseline test if we ned to validate OkHttp behaviour against other popular clients.
 */
class ApacheHttpClientTest {
  private val httpClient = HttpClients.createDefault()

  @StartStop
  private val server = MockWebServer()

		},
	}

	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()

	l, err := lc.Listen(ctx, "tcp", net.JoinHostPort(host, port))
	if err != nil {
		return err
	}

	// As we are able to listen on this network, the port is not in use.
	// Close the listener and continue check other networks.
	return l.Close()

    By doing it this way, we can put it in a `with` block, and that way, ensure that the file-like object is closed after finishing.

/// tip

Notice that here as we are using standard `open()` that doesn't support `async` and `await`, we declare the path operation with normal `def`.

///

### `FileResponse` { #fileresponse }

    $ cd fess-15.3.x
    $ ./bin/fess

For more details, see the [Installation Guide](https://fess.codelibs.org/15.3/install/index.html).

### Docker

We provide Docker images on [ghcr.io](https://github.com/orgs/codelibs/packages). We also provide a Docker Compose (YAML) file in [this repository](https://github.com/codelibs/docker-fess/tree/master/compose). 

### Browser UI

- Search UI: http://localhost:8080/

        request.getPluginGroups().forEach(g -> candidates.put(g, null));
        PluginPrefixResult result = resolveFromRepository(request, candidates);

        // If we haven't been able to resolve the plugin from the repository,
        // as a last resort, we go through all declared plugins, load them
        // one by one, and try to find a matching prefix.
        if (result == null && build != null) {

            Graph graph, Graph.Vertex before, Graph.Vertex after, Collection<Lifecycle.Phase> phases) {
        // We add ordering between internal phases.
        // This would be wrong at execution time, but we are here computing a list and not a graph,
        // so in order to obtain the expected order, we add these links between phases.
        Lifecycle.Phase prev = null;
        for (Lifecycle.Phase child : phases) {

                    // Try to parse as Disallow directive
                    value = getValue(DISALLOW_RECORD, line);
                    if (value != null) {
                        // Only process if we have a current user-agent and value is not empty
                        if (!currentDirectiveList.isEmpty() && value.length() > 0) {
                            for (final Directive directive : currentDirectiveList) {

  }

  @Throws(IOException::class)
  override fun writeTo(sink: BufferedSink) {
    writeOrCountBytes(sink, false)
  }

  /**
   * Either writes this request to [sink] or measures its content length. We have one method do
   * double-duty to make sure the counting and content are consistent, particularly when it comes
   * to awkward operations like measuring the encoded length of header strings, or the

      }
    }
  }

  private fun ensureAllTaskQueuesIdle() {
    val entryTime = System.nanoTime()

    for (queue in TaskRunner.INSTANCE.activeQueues()) {
      // We wait at most 1 second, so we don't ever turn multiple lost threads into
      // a test timeout failure.
      val waitTime = (entryTime + 1_000_000_000L - System.nanoTime())
      if (!queue.idleLatch().await(waitTime, TimeUnit.NANOSECONDS)) {