* .
     */
    @Test
    public void testSUnsupportedOperationExceptionStringThrowable() {
        final ClUnsupportedOperationException clUnsupportedOperationException =
                new ClUnsupportedOperationException("hoge", new NullPointerException());
        assertThat(clUnsupportedOperationException.getMessage(), is("hoge"));
        assertThat(clUnsupportedOperationException.getCause(), instanceOf(NullPointerException.class));
    }

    public Entry<K, Collection<V>>[] createArray(int length) {
      return (Entry<K, Collection<V>>[]) new Entry<?, ?>[length];
    }

    @Override
    public Iterable<Entry<K, Collection<V>>> order(List<Entry<K, Collection<V>>> insertionOrder) {
      Map<K, Collection<V>> map = new HashMap<>();
      List<Entry<K, V>> builder = new ArrayList<>();
      for (Entry<K, Collection<V>> entry : insertionOrder) {

      try {
        try {
          urls.add(new File(entry).toURI().toURL());
        } catch (SecurityException e) { // File.toURI checks to see if the file is a directory
          urls.add(new URL("file", null, new File(entry).getAbsolutePath()));
        }
      } catch (MalformedURLException e) {
        AssertionError error = new AssertionError("malformed class path entry: " + entry);
        error.initCause(e);

              ? RegularImmutableMap.makeImmutable(entry, key, value)
              : new NonTerminalImmutableBiMapEntry<>(
                  key, value, nextInKeyBucket, nextInValueBucket);
      keyTable[keyBucket] = newEntry;
      valueTable[valueBucket] = newEntry;
      entries[i] = newEntry;
      hashCode += keyHash ^ valueHash;
    }
    return new RegularImmutableBiMap<>(keyTable, valueTable, entries, mask, hashCode);
  }

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        scriptExecutor = new ScriptExecutor();
        scriptEngineFactory = new ScriptEngineFactory();
        testScriptEngine = new TestScriptEngine();
        ComponentUtil.register(scriptEngineFactory, "scriptEngineFactory");
    }

    @Override

  /** Generator of new random hash codes */
  static final Random rng = new Random();

  /** Number of CPUS, to place bound on table size */
  static final int NCPU = Runtime.getRuntime().availableProcessors();

  /** Table of cells. When non-null, size is a power of 2. */
  transient volatile Cell @Nullable [] cells;

  /**

      Comparator<K0> comparator) {
    checkNotNull(comparator);
    return new MultimapBuilderWithKeys<K0>() {
      @Override
      <K extends K0, V extends @Nullable Object> Map<K, Collection<V>> createMap() {
        return new TreeMap<>(comparator);
      }
    };
  }

  /**
   * Uses an {@link EnumMap} to map keys to value collections.
   *

      Comparator<K0> comparator) {
    checkNotNull(comparator);
    return new MultimapBuilderWithKeys<K0>() {
      @Override
      <K extends K0, V extends @Nullable Object> Map<K, Collection<V>> createMap() {
        return new TreeMap<>(comparator);
      }
    };
  }

  /**
   * Uses an {@link EnumMap} to map keys to value collections.
   *

    if (mockWebServer != null) throw new IllegalStateException();

    mockWebServer = new MockWebServer();
    mockWebServer.setDispatcher(this);
    mockWebServer.start(slackApi.port);
  }

  public HttpUrl newAuthorizeUrl(String scopes, String team, Listener listener) {
    if (mockWebServer == null) throw new IllegalStateException();

    ByteString state = randomToken();
    synchronized (this) {

        throw new RuntimeException("Wrong length: " + x);
      }
    }
  }

  private static String oldRepeat(String string, int count) {
    // If this multiplication overflows, a NegativeArraySizeException or
    // OutOfMemoryError is not far behind
    int len = string.length();
    int size = len * count;
    char[] array = new char[size];
    for (int i = 0; i < size; i += len) {