list.Lock()
	defer list.Unlock()

	for id := range targetIDSet {
		target, ok := list.targets[id]
		if ok {
			target.Close()
			delete(list.targets, id)
		}
	}
}

// Targets - list all targets
func (list *TargetList) Targets() []Target {
	if list == nil {
		return []Target{}
	}

	list.RLock()
	defer list.RUnlock()

	targets := make([]Target, 0, len(list.targets))

        assertNotNull(str);
        assertTrue(str.contains("allRecordCount=100"));
        assertTrue(str.contains("queryTime=50"));
    }

    /**
     * Test SearchResult with all fields populated.
     */
    @Test
    public void test_allFieldsPopulated() {
        final Map<String, Object> doc = new HashMap<>();
        doc.put("_id", "doc1");

     */
    protected
    fun setupPluginRequirements() {
        projectDir.resolve("version.txt").writeText("9999999.0") // All released versions should be lower than this
        projectDir.resolve("released-versions.json").writeText(
            """
                {
                  "latestReleaseSnapshot": {

  /**
   * Indicates that a collection has a well-defined ordering of its elements. The ordering may
   * depend on the element values, such as a {@link SortedSet}, or on the insertion ordering, such
   * as a {@link LinkedHashSet}. All list tests and sorted-collection tests automatically specify
   * this feature.
   */
  KNOWN_ORDER,

  /**
   * Indicates that a collection has a different {@link Object#toString} representation than most

 * only a secondary goal.
 *
 * @author Kurt Alfred Kluever
 */
@NullUnmarked
public class HashCodeBenchmark {

  // Use a statically configured random instance for all of the benchmarks
  private static final Random random = new Random(42);

  @Param({"1000", "100000"})
  private int size;

  @Param WhereToDiffer whereToDiffer;

  @Param EqualsImplementation equalsImpl;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.jspecify.annotations.Nullable;

/**
 * Abstract {@link Hasher} that handles converting primitives to bytes using a scratch {@code
 * ByteBuffer} and streams all bytes to a sink to compute the hash.
 *
 * @author Colin Decker
 */
abstract class AbstractByteHasher extends AbstractHasher {
  private @Nullable ByteBuffer scratch;

  /** Updates this hasher with the given byte. */

import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.jspecify.annotations.Nullable;

/**
 * An executor service which forwards all its method calls to another executor service. Subclasses
 * should override one or more methods to modify the behavior of the backing executor service as

        return String.format("BufferCache: queued=%d, max=%d, utilization=%.1f%%", queueSize.get(), MAX_BUFFERS,
                (queueSize.get() * 100.0 / MAX_BUFFERS));
    }

    /**
     * Clear all cached buffers (for testing or cleanup)
     */
    public static void clearCache() {
        bufferQueue.clear();
        queueSize.set(0);
    }

  - family-names: Yu
    given-names: Yuan
  - family-names: Zheng
    given-names: Xiaoqiang
identifiers:
  - type: doi
    value: 10.5281/zenodo.4724125
    description: The concept DOI for the collection containing all versions of the Citation File Format.
date-released: "2015-11-09"
license: "Apache-2.0"
doi: 10.5281/zenodo.4724125

        }
        // TODO Long, Integer, String supported only.

        // setup condition
        cb.query().addOrderBy_Hostname_Asc();

        // search

    }

    /**
     * Retrieves all file authentication configurations associated with a specific file configuration.
     *
     * @param fileConfigId the ID of the file configuration to retrieve authentications for