}
                    },
                    "type": "object",
                    "title": "HTTPValidationError",
                },
                "Item": {
                    "properties": {"data": {"type": "string", "title": "Data"}},
                    "type": "object",
                    "required": ["data"],
                    "title": "Item",
                },

// Copyright (c) 2015-2021 MinIO, Inc.
//
// This file is part of MinIO Object Storage stack
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful

        accessResultDataImpl.setEncoding(Constants.UTF_8);
        accessResultDataImpl.setTransformerName("fileTransformer");

        setBaseDir();

        final Object obj = fileTransformer.getData(accessResultDataImpl);
        assertTrue(obj instanceof File);
        assertEquals(new File(fileTransformer.baseDir, "hoge.txt"), obj);
    }

  }

  /**
   * Copies all characters from a file to an appendable object, using the given character set.
   *
   * @param from the source file
   * @param charset the charset used to decode the input stream; see {@link StandardCharsets} for
   *     helpful predefined constants
   * @param to the appendable object
   * @throws IOException if an I/O error occurs

            final Object obj = source.get(s);
            if (obj instanceof Number) {
                return false;
            }
            return !doubleValidator.isValid(obj.toString(), null);
        }).collect(Collectors.toList()));
    }

    default Map<String, Object> convertToEditableDoc(final Map<String, Object> source) {

import java.util.SortedMap;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * An object representing the differences between two sorted maps.
 *
 * @author Louis Wasserman
 * @since 8.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public interface SortedMapDifference<K extends @Nullable Object, V extends @Nullable Object>
    extends MapDifference<K, V> {

  @Override
  SortedMap<K, V> entriesOnlyOnLeft();

   *
   * @since 14.0
   */
  @SuppressWarnings("unchecked") // ImmediateCancelledFuture can work with any type
  public static <V extends @Nullable Object> ListenableFuture<V> immediateCancelledFuture() {
    ListenableFuture<Object> instance = ImmediateCancelledFuture.INSTANCE;
    if (instance != null) {
      return (ListenableFuture<V>) instance;
    }
    return new ImmediateCancelledFuture<>();
  }

 */
@GwtCompatible(serializable = true, emulated = true)
@ElementTypesAreNonnullByDefault
public final class HashMultiset<E extends @Nullable Object> extends AbstractMapBasedMultiset<E> {

  /** Creates a new, empty {@code HashMultiset} using the default initial capacity. */
  public static <E extends @Nullable Object> HashMultiset<E> create() {
    return new HashMultiset<>();
  }

  /**

                    "required": ["item"],
                    "type": "object",
                    "properties": {"item": {"$ref": "#/components/schemas/Item"}},
                },
                "ValidationError": {
                    "title": "ValidationError",
                    "required": ["loc", "msg", "type"],
                    "type": "object",
                    "properties": {
                        "loc": {

            },
        },
        "components": {
            "schemas": {
                "Body_create_file_files__post": {
                    "title": "Body_create_file_files__post",
                    "type": "object",
                    "properties": {
                        "file": IsDict(
                            {
                                "title": "File",
                                "anyOf": [