}
	send := func(entry metaCacheEntry) error {
		objReturned(entry.metadata)
		select {
		case <-ctx.Done():
			return ctx.Err()
		case out <- entry:
		}
		return nil
	}

	// Fast exit track to check if we are listing an object with
	// a trailing slash, this will avoid to list the object content.
	if HasSuffix(opts.BaseDir, SlashSeparator) {
		metadata, err := s.readMetadata(ctx, pathJoin(volumeDir,

        SmbTransportImpl pooled = pool.getSmbTransport(ctx, address, 445, false);
        SmbTransportImpl nonPooled = pool.getSmbTransport(ctx, address, 445, true);

        // Then: Pool should track pooled but not non-pooled
        assertTrue(pool.contains(pooled), "Pooled connection should be tracked");
        assertFalse(pool.contains(nonPooled), "Non-pooled connection should not be tracked");
    }

    @Test

      private val out: Buffer,
    ) {
      /**
       * In the scenario where the dynamic table size changes multiple times between transmission of
       * header blocks, we need to keep track of the smallest value in that interval.
       */
      private var smallestHeaderTableSizeSetting = Integer.MAX_VALUE
      private var emitDynamicTableSizeUpdate: Boolean = false

    assertThat(testLogHandler.takeAll()).containsExactly(
      "FINE: Q10000 scheduled after 100 µs: task one",
      "FINE: Q10000 scheduled after 200 µs: task two",
    )
  }

  /**
   * We don't track the active task in scheduled tasks. This behavior might be a mistake, but it's
   * cumbersome to implement properly because the active task might be a cancel.
   */
  @Test fun scheduledTasksDoesNotIncludeRunningTask() {

        if (log.isDebugEnabled()) {
            log.debug("New transport connection " + conn + " (pool size: " + connections.size() + "/" + maxPoolSize + ")");
        }

        // Track connection metrics
        String key = getConnectionKey(address, port);
        connectionMetrics.computeIfAbsent(key, k -> new ConnectionMetrics()).recordConnection();
        activeConnections.incrementAndGet();

fun Test.addOsAsInputs() {
    // Add OS as inputs since tests on different OS may behave differently https://github.com/gradle/gradle-private/issues/2831
    // the version currently differs between our dev infrastructure, so we only track the name and the architecture
    inputs.property("operatingSystem", "${OperatingSystem.current().name} ${System.getProperty("os.arch")}")
}

	go func(o listPathOptions) {
		err := z.listMerged(listCtx, o, inCh)
		if err != nil {
			meta.setErr(err.Error())
		}
		o.debugln("listAndSave: listing", o.ID, "finished with ", err)
	}(*o)

	// Keep track of when we return since we no longer have to send entries to output.
	var funcReturned bool
	var funcReturnedMu sync.Mutex
	defer func() {
		funcReturnedMu.Lock()
		funcReturned = true
		funcReturnedMu.Unlock()

	tok := in.Stack.Next()
	if tok != scanner.Ident {
		in.expectText("expected identifier after '#'")
	}
	if !in.enabled() {
		// Can only start including again if we are at #else or #endif but also
		// need to keep track of nested #if[n]defs.
		// We let #line through because it might affect errors.
		switch in.Stack.Text() {
		case "else", "endif", "ifdef", "ifndef", "line":
			// Press on.
		default:
			return false
		}

     * Defaults to normal thread priority.
     */
    protected int crawlerPriority = Thread.NORM_PRIORITY;

    /**
     * Thread-safe list of active data crawling threads.
     * Used to track and manage all currently running crawler threads.
     */
    protected final List<DataCrawlingThread> dataCrawlingThreadList = Collections.synchronizedList(new ArrayList<>());

    /**

    /** Array of supported file protocols for URL classification. */
    protected String[] fileProtocols = { "file:", "smb:", "smb1:", "ftp:", "storage:" };

    /** Queue to track the current XML element hierarchy during parsing. */
    protected LinkedList<String> tagQueue;

    /** List to store parsed label types for access control. */
    protected List<LabelType> labelList;