* ImmutableClassToInstanceMap}, no copy will actually be performed.
   *
   * @throws NullPointerException if any key or value in {@code map} is null
   * @throws ClassCastException if any value is not an instance of the type specified by its key
   */
  public static <B, S extends B> ImmutableClassToInstanceMap<B> copyOf(
      Map<? extends Class<? extends S>, ? extends S> map) {

    Collections.shuffle(asList, new Random(0xdeadbeef));

    // do bulk gets with exactly 10 keys (possibly <10 stripes) (or less if numStripes is smaller)
    bulkGetSet = ImmutableList.copyOf(limit(cycle(asList), 10));
  }

  @Footprint
  Object sizeOfStriped() {
    return impl.get(numStripes);
  }

  // a place to put the locks in sizeOfPopulatedStriped so they don't get GC'd before we measure

                    int retryFailedDeploymentCount) {
                super(session, trace);
                this.repository = requireNonNull(repository, "repository cannot be null");
                this.artifacts = List.copyOf(requireNonNull(artifacts, "artifacts cannot be null"));
                this.retryFailedDeploymentCount = retryFailedDeploymentCount;
            }

            @Nonnull
            @Override

    this(in, Arrays.asList(options));
  }

  public TestInputStream(InputStream in, Iterable<TestOption> options) throws IOException {
    super(checkNotNull(in));
    this.options = ImmutableSet.copyOf(options);
    throwIf(OPEN_THROWS);
  }

  public boolean closed() {
    return closed;
  }

  @Override
  public int read() throws IOException {
    throwIf(closed);
    throwIf(READ_THROWS);

      Iterable<? extends ListenableFuture<? extends T>> futures) {
    ListenableFuture<? extends T>[] copy = gwtCompatibleToArray(futures);
    InCompletionOrderState<T> state = new InCompletionOrderState<>(copy);
    ImmutableList.Builder<AbstractFuture<T>> delegatesBuilder =
        ImmutableList.builderWithExpectedSize(copy.length);
    for (int i = 0; i < copy.length; i++) {
      delegatesBuilder.add(new InCompletionOrderFuture<T>(state));
    }

   * @since 20.0
   */
  @SafeVarargs
  public static <T extends @Nullable Object> FluentIterable<T> concat(
      Iterable<? extends T>... inputs) {
    return concatNoDefensiveCopy(Arrays.copyOf(inputs, inputs.length));
  }

  /**
   * Returns a fluent iterable that combines several iterables. The returned iterable has an

   * @since 20.0
   */
  @SafeVarargs
  public static <T extends @Nullable Object> FluentIterable<T> concat(
      Iterable<? extends T>... inputs) {
    return concatNoDefensiveCopy(Arrays.copyOf(inputs, inputs.length));
  }

  /**
   * Returns a fluent iterable that combines several iterables. The returned iterable has an

        final String id = form.id;
        labelTypeService.getLabelType(id).ifPresent(entity -> {
            copyBeanToBean(entity, form, copyOp -> {
                copyOp.excludeNull();
                copyOp.exclude(Constants.PERMISSIONS);
            });
            final PermissionHelper permissionHelper = ComponentUtil.getPermissionHelper();

   * can lead to surprising behavior, so serializing the returned list is <b>not recommended</b>.
   * Instead, copy the list using {@link ImmutableList#copyOf(Collection)} (for example), then
   * serialize the copy. Other methods similar to this do not implement serialization at all for
   * this reason.
   *

  }

  private byte[] testBytesA;
  private byte[] testBytesB;

  @BeforeExperiment
  void setUp() {
    testBytesA = new byte[size];
    random.nextBytes(testBytesA);
    testBytesB = Arrays.copyOf(testBytesA, size);
    int indexToDifferAt = -1;
    switch (whereToDiffer) {
      case ONE_PERCENT_IN:
        indexToDifferAt = (int) (size * 0.01);
        break;
      case LAST_BYTE: