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())));
    }

    }

    @Input
    public Map<String, Object> getHostEnv() {
        return hostEnv.get();
    }

    public void hostEnv(String name, Object value) {
        hostEnv.put(name, value);
    }

    @Input
    public Map<String, Object> getVmEnv() {
        return vmEnv.get();
    }

    public void vmEnv(String name, Object value) {
        vmEnv.put(name, value);
    }

    @Input

    /**
     * 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();
    }

  }

  /**
   * A sensible definition of {@link #subMultiset(Object, BoundType, Object, BoundType)} in terms of
   * {@link #headMultiset(Object, BoundType) headMultiset} and {@link #tailMultiset(Object,
   * BoundType) tailMultiset}.
   *
   * <p>If you override either of these methods, you may wish to override {@link
   * #subMultiset(Object, BoundType, Object, BoundType)} to forward to this implementation.
   */

        // Test with supported document type
        Map<String, Object> docMap = new HashMap<>();
        docMap.put("mimetype", "application/pdf");
        assertTrue(thumbnailGenerator.isTarget(docMap));
    }

    @Test
    public void test_isTarget_withUnsupportedMimeType() {
        // Test with unsupported document type
        Map<String, Object> docMap = new HashMap<>();

import java.util.concurrent.ExecutionException;
import org.jspecify.annotations.Nullable;

/**
 * A semi-persistent mapping from keys to values. Cache entries are manually added using {@link
 * #get(Object, Callable)} or {@link #put(Object, Object)}, and are stored in the cache until either
 * evicted or manually invalidated. The common way to build instances is using {@link CacheBuilder}.
 *

            processor.init();

            // Should handle exception gracefully and return results from working searcher
            final List<Map<String, Object>> results = processor.search("*", new TestSearchRequestParams(0, 10, 0), OptionalThing.empty());
            assertNotNull(results);
        }
    }

    /**

        Map<String, Object> doc = new HashMap<>();

        languageHelper.updateDocument(doc);

        // Should not add any language fields
        assertNull(doc.get("lang"));
        assertEquals(0, doc.size());
    }

    @Test
    public void test_updateDocument_skipExistingLangFields() {
        Map<String, Object> doc = new HashMap<>();
        doc.put("lang", "ja");

public abstract class DiscreteDomain<C extends Comparable> {

  /**
   * Returns the discrete domain for values of type {@code Integer}.
   *
   * <p>This method always returns the same object. That object is serializable; deserializing it
   * results in the same object too.
   *
   * @since 14.0 (since 10.0 as {@code DiscreteDomains.integers()})
   */
  public static DiscreteDomain<Integer> integers() {
    return IntegerDomain.INSTANCE;
  }

    }

    @Override
    public int count(@Nullable Object element) {
      return standardCount(element);
    }

    @Override
    public boolean equals(@Nullable Object object) {
      return standardEquals(object);
    }

    @Override
    public int hashCode() {
      return standardHashCode();
    }

    @Override