*
   * <p>Equivalent to {@link #binarySearch(List, Object, Comparator, KeyPresentBehavior,
   * KeyAbsentBehavior)} using {@link Lists#transform(List, Function) Lists.transform(list,
   * keyFunction)}.
   */
  public static <E extends @Nullable Object, K extends @Nullable Object> int binarySearch(
      List<E> list,
      Function<? super E, K> keyFunction,

		{"ChecksumSHA1-full-object", ChecksumSHA1, true, true},     // SHA1 does not support full object
		{"ChecksumSHA256-full-object", ChecksumSHA256, true, true}, // SHA256 does not support full object
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Skip invalid cases where SHA1 or SHA256 is used with full object
			if (tt.checksum.Is(ChecksumSHA1) || tt.checksum.Is(ChecksumSHA256)) && tt.fullobj {

    return (Collector) TO_OPTIONAL;
  }

  private static final Object NULL_PLACEHOLDER = new Object();

  private static final Collector<@Nullable Object, ?, @Nullable Object> ONLY_ELEMENT =
      Collector.<@Nullable Object, ToOptionalState<Object>, @Nullable Object>of(
          () -> new ToOptionalState<>(null),
          (state, o) -> state.add((o == null) ? NULL_PLACEHOLDER : o),

    @Override
    public E remove() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.remove();
    }

    @Override
    public boolean remove(Object object) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.remove(object);
    }

    @Override
    public @Nullable E peek() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.peek();
    }

    @Override

        Assertions.assertEquals(expected, actual, message);
    }

    // assertEquals - JUnit 4 style (message first) - int version
    protected void assertEquals(String message, int expected, int actual) {
        Assertions.assertEquals(expected, actual, message);
    }

    // assertSame - JUnit 5 style (no message)
    protected void assertSame(Object expected, Object actual) {

Modern best practices when developing a Gradle plugin are to use lazy types (ConfigurableFileCollection, Provider API, domain object containers) when defining configurable parts of a plugin (tasks, extensions, domain objects).  The Provider API provides a consistent way to set conventions, wire related configuration together (extension <- domain object <- task) and avoid evaluation ordering problems.

    }

    @Override
    public V getValue() {
      return value;
    }

    @Override
    public boolean equals(@Nullable Object object) {
      // Cannot use key and value equivalence
      if (object instanceof Entry) {
        Entry<?, ?> that = (Entry<?, ?>) object;
        return key.equals(that.getKey()) && value.equals(that.getValue());
      }
      return false;
    }

    @Override

    private static final Object OBJECT = new Object();

    /**
     * Class passed into the constructor used to as
     * the basis for the Method map.
     */
    private final Class<?> clazz;

    /**
     * Cache of Methods, or CACHE_MISS, keyed by method
     * name and actual arguments used to find it.
     */
    private final Map<String, Object> methodCache = new Hashtable<>();

            }
        }
    }

    private void logTracing(Object testId, IllegalArgumentException illegalArgumentException) {
        // Add tracing to diagnose why we see this on CI
        System.out.println("Rerun failure test id = " + testId);
        System.out.println("Active test descriptors:");
        for (Map.Entry<Object, TestDescriptorInternal> entry : activeDescriptorsById.entrySet()) {

        Map<String, Object> map = dataStoreParams.asMap();
        assertNotNull(map);
        assertTrue(map.isEmpty());
    }

    // Test getDataMap with ParamMap
    @Test
    public void test_getDataMapWithParamMap() {
        Map<String, Object> innerMap = new HashMap<>();
        innerMap.put("key1", "value1");
        ParamMap<String, Object> paramMap = new ParamMap<>(innerMap);