@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
final class ReflectionFreeAssertThrows {
  interface ThrowingRunnable {
    void run() throws Throwable;
  }

  interface ThrowingSupplier {
    @Nullable Object get() throws Throwable;
  }

  @CanIgnoreReturnValue
  static <T extends Throwable> T assertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier) {

    multiset.add("a");
    assertThrows(UnsupportedOperationException.class, () -> multiset.remove("a"));
    assertTrue(multiset.contains("a"));
  }

  private static class NoRemoveMultiset<E extends @Nullable Object> extends AbstractMultiset<E>
      implements Serializable {
    final Map<E, Integer> backingMap = Maps.newHashMap();

    @Override
    public int size() {
      return Multisets.linearTimeSizeImpl(this);
    }

     *             メソッド呼び出し変換によってパラメータ値を対応する仮パラメータ型に変換できない場合、
     *             このコンストラクタが列挙型に関連している場合
     * @see Constructor#newInstance(Object[])
     */
    public static <T> T newInstance(final Constructor<T> constructor, final Object... args)
            throws InstantiationRuntimeException, IllegalAccessRuntimeException {
        assertArgumentNotNull("constructor", constructor);

        try {

public class DefaultArtifactDeployer extends AbstractLogEnabled implements ArtifactDeployer {

    @Inject
    private RepositorySystem repoSystem;

    @Inject
    private LegacySupport legacySupport;

    private Map<Object, MergeableMetadata> relatedMetadata = new ConcurrentHashMap<>();

    /**
     * @deprecated we want to use the artifact method only, and ensure artifact.file is set
     *             correctly.
     */
    @Deprecated

                                "type": "array",
                                "title": "Detail",
                            }
                        },
                        "type": "object",
                        "title": "HTTPValidationError",
                    },
                    "ValidationError": {
                        "properties": {
                            "loc": {

// 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

/**
 * @author shinsuke
 *
 */
public class DataServiceImpl implements DataService<AccessResultImpl<Long>> {

    protected static volatile long idCount = 0L;

    private static Object idCountLock = new Object();

    @Resource
    protected MemoryDataHelper dataHelper;

    /*
     * (non-Javadoc)
     *
     * @see org.codelibs.fess.crawler.service.DataService#store(org.codelibs.fess.crawler.entity.

  // dataSourceRef specifies the object from which to populate the volume with data, if a non-empty
  // volume is desired. This may be any object from a non-empty API group (non
  // core object) or a PersistentVolumeClaim object.
  // When this field is specified, volume binding will only succeed if the type of
  // the specified object matches some installed volume populator or dynamic
  // provisioner.

    assertThrows(
        NullPointerException.class,
        () -> {
          ImmutableMap<Object, Integer> unused =
              fluent(1, null, 2)
                  .uniqueIndex(
                      new Function<Integer, Object>() {
                        @Override
                        public Object apply(@Nullable Integer input) {
                          return String.valueOf(input);
                        }

 */