return checkedEntry(from);
          }
        };
      }

      @Override
      public Object[] toArray() {
        /*
         * standardToArray returns `@Nullable Object[]` rather than `Object[]` but only because it
         * can be used with collections that may contain null. This collection is a collection of

        Supplier<Object> supplier = () -> null;

        monitorTarget.append(buf, "testKey", supplier);
        assertEquals("\"testKey\":null", buf.toString());
    }

    // Test append method with Integer value
    @Test
    public void test_append_integerValue() {
        StringBuilder buf = new StringBuilder();
        Supplier<Object> supplier = () -> Integer.valueOf(123);

    override fun createSocket(): Socket {
      return object : Socket() {
        override fun connect(
          endpoint: SocketAddress?,
          timeout: Int,
        ) {
          onConnect(timeout)
          super.connect(endpoint, timeout)
        }

        override fun getInputStream(): InputStream {
          return object : FilterInputStream(super.inputStream) {
            override fun read(

package cmd

import (
	"io"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/klauspost/compress/gzhttp"
)

// Tests object location.
func TestObjectLocation(t *testing.T) {
	testCases := []struct {
		request          *http.Request
		bucket, object   string
		domains          []string
		expectedLocation string
	}{
		// Server binding to localhost IP with https.
		{
			request: &http.Request{

    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),

    /**
     * Returns {@literal true} if the object is an array. Returns {@literal false} if the object is {@literal null}.
     *
     * @param object
     *            the object
     * @return {@literal true} if the object is an array; {@literal false} if the object is {@literal null}
     */
    public static boolean isArray(final Object object) {
        return object != null && object.getClass().isArray();
    }

        final List<Map<String, Object>> list = List.of(Map.of("id", "1"), Map.of("id", "2"));
        final Map<String, Object> map = Map.of("items", list);
        final List<Map<String, Object>> result = coordinatorHelper.getListValue(map, "items");
        assertNotNull(result);
        assertEquals(2, result.size());
    }

    @Test
    public void test_getListValue_notList() {

	if HasSuffix(object, globalDirSuffix) {
		return strings.TrimSuffix(object, globalDirSuffix) + slashSeparator
	}
	return object
}

func isDirObject(object string) bool {
	if obj := encodeDirObject(object); obj != object {
		object = obj
	}
	return HasSuffix(object, globalDirSuffix)
}

// Helper method to return total number of nodes in cluster
func totalNodeCount() int {

    return comparator.compare(a, b);
  }

  @Override
  public boolean equals(@Nullable Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof ComparatorOrdering) {
      ComparatorOrdering<?> that = (ComparatorOrdering<?>) object;
      return this.comparator.equals(that.comparator);
    }
    return false;
  }

  @Override

        Map<Object, Object> map = new HashMap<Object, Object>();
        assertEquals(0, (int) StreamUtil.stream(map).get(s -> s.toArray().length));
    }

    public void test_ofMap() {
        Map<String, String> map = new HashMap<String, String>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        StreamUtil.stream(map).of(s -> s.forEach(m -> assertEquals(map.get(m.getKey()), m.getValue())));
    }