@SuppressWarnings("UseCorrectAssertInTests") // TODO(b/345814817): Remove or convert assertion.
  private static BigInteger oldSlowFactorial(int n1, int n2) {
    assert n1 <= n2;
    if (IntMath.log2(n2, CEILING) * (n2 - n1) < Long.SIZE - 1) {
      // the result will definitely fit into a long
      long result = 1;
      for (int i = n1 + 1; i <= n2; i++) {
        result *= i;
      }
      return BigInteger.valueOf(result);
    }

    /*

		file := c.Args().Get(0)
		if strings.HasSuffix(file, ".zip") {
			var sz int64
			f, err := os.Open(file)
			if err != nil {
				return err
			}
			if st, err := f.Stat(); err == nil {
				sz = st.Size()
			}
			defer f.Close()
			zr, err := zip.NewReader(f, sz)
			if err != nil {
				return err
			}
			for _, file := range zr.File {

      require(!outFinished || trailers.size == 0) {
        "unsupported: no body and non-empty trailers $trailers"
      }

      socket.sleepWhileOpen(response.headersDelayNanos)
      stream.writeHeaders(response.toHttp2Headers(), outFinished, flushHeaders)

      if (trailers.size > 0) {
        stream.enqueueTrailers(trailers)
      }

        }

        if (_specification != null) {
            builder.setFetchSource(_specification.columnList.toArray(new String[_specification.columnList.size()]), null);
        }

        return builder;
    }

    // ===================================================================================

                    mergedIdSet.add(item1Id);
                }
            }
            mergedList.add(mergedItem);
        }

        return mergedList.toArray(new SuggestItem[mergedList.size()]);
    }

            bufferIndex += 28; // ???
        }

        bufferIndex = start + daclOffset;

        if (daclOffset != 0) {
            bufferIndex++; // revision
            bufferIndex++;
            final int size = ServerMessageBlock.readInt2(buffer, bufferIndex);
            bufferIndex += 2;
            final int numAces = ServerMessageBlock.readInt4(buffer, bufferIndex);
            bufferIndex += 4;

  public void testValuesRemove() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k1(), v0()), mapEntry(k0(), v3()));
    assertTrue(multimap().asMap().values().remove(singleton(v0())));
    assertEquals(2, multimap().size());
    assertEquals(singletonMap(k0(), newHashSet(v0(), v3())), multimap().asMap());
  }

        Set<String> needsInlining = needsInlining(session);
        if (needsInlining.isEmpty()) {
            return artifacts;
        }
        ArrayList<Artifact> newArtifacts = new ArrayList<>(artifacts.size());
        for (Artifact artifact : artifacts) {
            if ("pom".equals(artifact.getExtension())
                    && artifact.getClassifier().isEmpty()) {
                try {

      map.put(i, Integer.toString(i));
    }
    map.trimToSize();
    assertThat(map.entries).hasLength(10);
    assertThat(map.keys).hasLength(10);
    assertThat(map.values).hasLength(10);
    assertEquals(10, map.size());
    for (int i = 0; i < 10; i++) {
      assertEquals(Integer.toString(i), map.get(i));
    }
  }

  public void testEntrySetValueAfterRemoved() {

    try {
      Object unused = digest.clone();
      return true;
    } catch (CloneNotSupportedException e) {
      return false;
    }
  }

  @Override
  public int bits() {
    return bytes * Byte.SIZE;
  }

  @Override
  public String toString() {
    return toString;
  }

  private static MessageDigest getMessageDigest(String algorithmName) {
    try {