int listenerCount = 20;
    CountDownLatch listenerLatch = new CountDownLatch(listenerCount);

    // Test that listeners added both before and after the value is available
    // get called correctly.
    for (int i = 0; i < 20; i++) {

      // Right in the middle start up a thread to close the latch.
      if (i == 10) {
        new Thread(() -> latch.countDown()).start();
      }

     */
    public FacetInfo() {
        // Default constructor
    }

    /**
     * Initializes the facet configuration from Fess configuration properties.
     * This method is called after dependency injection to load default facet settings.
     */
    @PostConstruct
    public void init() {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

    return seq.length() - pos;
  }

  /*
   * To avoid the need to call requireNonNull so much, we could consider more clever approaches,
   * such as:
   *
   * - Make checkOpen return the non-null `seq`. Then callers can assign that to a local variable or
   *   even back to `this.seq`. However, that may suggest that we're defending against concurrent
   *   mutation, which is not an actual risk because we use `synchronized`.

     */
    public void setPassword(final String password) {
        this.password = password;
    }

    /**
     * Clears the credentials from memory for security purposes.
     * This method should be called after the authentication is no longer needed.
     */
    public void clearCredentials() {
        this.password = null;
        this.username = null;
    }

    /**

Apply shared dependencies at the router level via `dependencies=[Depends(...)]`.

## Async vs Sync *path operations*

Use `async` *path operations* only when fully certain that the logic called inside is compatible with async and await (it's called with `await`) or that doesn't block.

```python
from fastapi import FastAPI

app = FastAPI()


# Use async def when calling async code
@app.get("/async-items/")

Example:

Say you need to make a change to `master` and have a BWC layer in `5.x`. You
will need to:
. Create a branch called `index_req_change` off your remote `${remote}`. This
will contain your change.
. Create a branch called `index_req_bwc_5.x` off `5.x`. This will contain your bwc layer.
. Push both branches to your remote repository.

   * safe to do so. The exact circumstances under which a copy will or will not be performed are
   * undocumented and subject to change.
   *
   * <p>This method is not type-safe, as it may be called on elements that are not mutually
   * comparable.
   *
   * @throws ClassCastException if the elements are not mutually comparable
   * @throws NullPointerException if any of {@code elements} is null
   */

      @ParametricNullness T instance, Funnel<? super T> funnel);

  /**
   * Computes a hash code based on the data that have been provided to this hasher. The result is
   * unspecified if this method is called more than once on the same instance.
   */
  HashCode hash();

  /**
   * {@inheritDoc}
   *
   * @deprecated This returns {@link Object#hashCode()}; you almost certainly mean to call {@code

	}

	_, err := trw.Write([]byte("hello"))
	if err != nil {
		t.Fatalf("Write unexpectedly failed: %v", err)
	}

	// Check that WriteHeader and Write were called on the underlying response writer
	resp := rw.Result()
	if resp.StatusCode != 123 {
		t.Fatalf("unexpected status: %v", resp.StatusCode)
	}
	body, err := io.ReadAll(resp.Body)
	if err != nil {

        assertEquals(name, share.netName);
        assertEquals(type, share.type);
        assertEquals(remark, share.remark);
    }

    @Test
    @DisplayName("Test setUseUnicode is called with false")
    void testSetUseUnicode() throws Exception {
        // Create a spy to verify method call
        NetShareEnumResponse spyResponse = spy(new NetShareEnumResponse(mockConfig));