}

    public void test_crawlerList_initialization() {
        assertNotNull(webFsIndexHelper.crawlerList);
        assertEquals(0, webFsIndexHelper.crawlerList.size());
    }

    public void test_crawlerList_synchronization() {
        // Test that the crawler list is synchronized
        List<org.codelibs.fess.crawler.Crawler> crawlerList = webFsIndexHelper.crawlerList;

    }

    assertTrue(c1.isClosed());
    assertTrue(c2.isClosed());

    ImmutableSet<Throwable> suppressed = ImmutableSet.copyOf(thrownException.getSuppressed());
    assertEquals(2, suppressed.size());

    assertEquals(ImmutableSet.of(c1Exception, c2Exception), suppressed);
  }

  public void testNullCloseable() throws IOException {
    Closer closer = Closer.create();
    closer.register(null);

                if (!notifications.isEmpty()) {
                    log.debug("Received {} notifications", notifications.size());
                    return notifications.get(0); // Return first notification
                }
            } else {
                log.warn("Async notify failed: {}", message.getErrorMessage());
            }

        case 0: /* not connected - just return */
            return;
        case 2:
            hard = true;
        case 3: /* connected - go ahead and disconnect */
            if (response_map.size() != 0 && !hard) {
                break; /* outstanding requests */
            }
            try {
                doDisconnect(hard);
            } catch (final IOException ioe0) {
                ioe = ioe0;

			// boundaries to fit RFC 2047’s 75-character limit, ensuring HTTP parser
			// compatibility.
			//
			// However, this splitting increases header size and can introduce errors, unlike Go’s
			// mime package in MinIO, which correctly encodes strings with fixed B/Q encodings,
			// avoiding S3’s heuristic-driven issues.
			//

        call.cancel()
      } else {
        threadToCancel!!.interrupt()
      }
      latch.countDown()
    }.apply { start() }
    return latch
  }

  companion object {
    // The size of the socket buffers in bytes.
    private const val SOCKET_BUFFER_SIZE = 256 * 1024
  }
}

class CancelModelParamProvider : SimpleProvider() {
  override fun arguments() =

   *
   * <p>Note: this method is idempotent and safe to call from any thread
   */
  public void dispatch() {
    // iterate by index to avoid concurrent modification exceptions
    for (int i = 0; i < listeners.size(); i++) {
      listeners.get(i).dispatch();
    }
  }

  /**
   * A special purpose queue/executor that dispatches listener events serially on a configured

         */

        if (repositories != null) {
            boolean normalized = false;

            List<ArtifactRepository> repos = new ArrayList<>(repositories.size());

            for (Object repository : repositories) {
                if (repository instanceof Repository repositoryInstance) {
                    try {

            case NODESET:
                final XPathNodes nodeList = (XPathNodes) xObj.value();
                final List<String> strList = new ArrayList<>();
                for (int i = 0; i < nodeList.size(); i++) {
                    final Node node = nodeList.get(i);
                    strList.add(node.getTextContent());
                }
                return strList.toArray(n -> new String[n]);
            case NODE:

		2 + // CRLF
		chunkDataSize +
		2 // CRLF
}

func mustGetPutObjReader(t TestErrHandler, data io.Reader, size int64, md5hex, sha256hex string) *PutObjReader {
	hr, err := hash.NewReader(context.Background(), data, size, md5hex, sha256hex, size)
	if err != nil {
		t.Fatal(err)
	}
	return NewPutObjReader(hr)
}