}
            if (value instanceof String || value == null) {
                return new Pair<>(key, value);
            }
            if (arrayFieldSet.contains(key)) {
                if (value instanceof String[]) {
                    value = stream((String[]) value).get(stream -> stream.collect(Collectors.joining("\n")));
                } else if (value instanceof List) {

    /**
     * Creates a new empty DataStoreParams instance.
     * Initializes the internal parameter map with a ParamMap wrapper.
     */
    public DataStoreParams() {
        params = new ParamMap<>(new HashMap<>());
    }

    /**
     * Creates a new DataStoreParams instance with a copy of the provided parameters.
     * This protected constructor is used for creating new instances from existing parameter maps.
     *

  }

  @Override
  public void flush() throws IOException {
    checkNotClosed();
    if (target instanceof Flushable) {
      ((Flushable) target).flush();
    }
  }

  @Override
  public void close() throws IOException {
    this.closed = true;
    if (target instanceof Closeable) {
      ((Closeable) target).close();
    }
  }

  @Override

        assertArgumentNotNull("type", type);
        assertArgumentNotNull("clazz", clazz);

        if (type instanceof Class) {
            return clazz.isAssignableFrom((Class<?>) type);
        }
        if (type instanceof ParameterizedType) {
            final ParameterizedType parameterizedType = ParameterizedType.class.cast(type);

    Iterable<? extends E> iterable = elements;
    return copyOf(iterable);
  }

  public static <E> ImmutableSet<E> copyOf(Iterable<? extends E> elements) {
    if (elements instanceof ImmutableSet && !(elements instanceof ImmutableSortedSet)) {
      @SuppressWarnings("unchecked") // all supported methods are covariant
      ImmutableSet<E> set = (ImmutableSet<E>) elements;
      return set;
    }

        params.put("param1", "value1");
        params.put("param2", 123);

        RescorerBuilder<?> result = ltrQueryRescorer.evaluate(params);
        assertNotNull(result);
        assertTrue(result instanceof QueryRescorerBuilder);

        QueryRescorerBuilder queryRescorerBuilder = (QueryRescorerBuilder) result;
        assertEquals(testWindowSize, queryRescorerBuilder.windowSize().intValue());
    }

    @Test

      // Overridden to prevent a ton of boxing
      return (target instanceof Boolean)
          && Booleans.indexOf(array, (Boolean) target, start, end) != -1;
    }

    @Override
    public int indexOf(@Nullable Object target) {
      // Overridden to prevent a ton of boxing
      if (target instanceof Boolean) {
        int i = Booleans.indexOf(array, (Boolean) target, start, end);

    assertTrue(RegularImmutableTable.forCells(CELLS) instanceof DenseImmutableTable<?, ?, ?>);
    assertTrue(
        RegularImmutableTable.forCells(
                ImmutableSet.of(
                    immutableCell('a', 1, "blah"),
                    immutableCell('b', 2, "blah"),
                    immutableCell('c', 3, "blah")))
            instanceof SparseImmutableTable<?, ?, ?>);
  }

  public void testGet() {

            final Object fileAttributeView = metaDataMap.get(FileSystemClient.FILE_ATTRIBUTE_VIEW);
            try {
                if (fileAttributeView instanceof final AclFileAttributeView aclFileAttributeView) {
                    aclFileAttributeView.getAcl().stream().forEach(acl -> {
                        final UserPrincipal principal = acl.principal();

        if (lastModifiedObj instanceof Date) {
            return (Date) lastModifiedObj;
        }
        if (lastModifiedObj instanceof String) {
            final Date lastModified = FessFunctions.parseDate(lastModifiedObj.toString());
            if (lastModified != null) {
                return lastModified;
            }