* Anyway, the purpose of this method is to implement a BinaryOperator combiner for a Collector,
   * so its return value will get used naturally.
   */
  @SuppressWarnings("CanIgnoreReturnValueSuggester")
  TopKSelector<T> combine(TopKSelector<T> other) {
    for (int i = 0; i < other.bufferSize; i++) {
      this.offer(uncheckedCastNullableTToT(other.buffer[i]));
    }

        ImmutableMap.<String, Integer>builder().put("one", 1);
    ImmutableMap.Builder<String, Integer> zat =
        ImmutableMap.<String, Integer>builder().put("two", 2).put("three", 3);
    assertMapEquals(zis.combine(zat).build(), "one", 1, "two", 2, "three", 3);
  }

  // TODO(b/172823566): Use mainline testToImmutableMap once CollectorTester is usable to java7.
  public void testToImmutableMap_exceptionOnDuplicateKey_java7_combine() {

    @CanIgnoreReturnValue
    @Override
    public Builder<E> addAll(Iterator<? extends E> elements) {
      super.addAll(elements);
      return this;
    }

    @CanIgnoreReturnValue
    Builder<E> combine(Builder<E> builder) {
      checkNotNull(builder);
      contents.addAll(builder.contents);
      return this;
    }

    @Override
    public ImmutableList<E> build() {
      return copyOf(contents);

    ImmutableSet.Builder<String> zis = ImmutableSet.<String>builder().add("a", "b", "a");
    ImmutableSet.Builder<String> zat = ImmutableSet.<String>builder().add("c", "b", "d", "c");
    ImmutableSet<String> set = zis.combine(zat).build();
    assertThat(set).containsExactly("a", "b", "c", "d").inOrder();
  }

  @Override
  <E extends Comparable<E>> Builder<E> builder() {
    return ImmutableSet.builder();
  }

  @Override

   */
  public static HashCode combineOrdered(Iterable<HashCode> hashCodes) {
    Iterator<HashCode> iterator = hashCodes.iterator();
    checkArgument(iterator.hasNext(), "Must be at least 1 hash code to combine.");
    int bits = iterator.next().bits();
    byte[] resultBytes = new byte[bits / 8];
    for (HashCode hashCode : hashCodes) {
      byte[] nextBytes = hashCode.asBytes();
      checkArgument(

        put(entry.getKey(), entry.getValue());
      }
      return this;
    }

    @CanIgnoreReturnValue
    Builder<K, V> combine(Builder<K, V> builder) {
      entries.addAll(builder.entries);
      return this;
    }

    /**
     * Returns an {@code ImmutableRangeMap} containing the associations previously added to this
     * builder.

  bazel cquery --keep_going 'deps(//tensorflow/tools/pip_package:wheel)' | sort -u > $BATS_TEST_TMPDIR/pip_deps
  # Find all Python py_test targets not tagged "no_pip" or "manual", excluding
  # any targets in ignored packages. Combine this list of targets into a bazel
  # query list (e.g. the list becomes "target+target2+target3")

        put(entry.getKey(), entry.getValue());
      }
      return this;
    }

    @CanIgnoreReturnValue
    Builder<K, V> combine(Builder<K, V> builder) {
      entries.addAll(builder.entries);
      return this;
    }

    /**
     * Returns an {@code ImmutableRangeMap} containing the associations previously added to this
     * builder.

        byte[] targetNameData = "TEST".getBytes();
        byte[] avTargetNameData = createAvPairData(AvPair.MsvAvTargetName, targetNameData);

        byte[] eolData = createEolData();

        // Combine all data
        int totalLength = avFlagsData.length + avTimestampData.length + avTargetNameData.length + eolData.length;
        byte[] fullData = new byte[totalLength];
        int pos = 0;

   * input elements. Cells are inserted into the generated {@code Table} in encounter order.
   *
   * <p>If multiple input elements map to the same row and column, the specified merging function is
   * used to combine the values. Like {@link
   * java.util.stream.Collectors#toMap(java.util.function.Function, java.util.function.Function,
   * BinaryOperator, java.util.function.Supplier)}, this Collector throws a {@code