for (List<Integer> list : Collections2.permutations(Ints.asList(1, 2, 3, 4, 5))) {
      TopKSelector<Integer> top = TopKSelector.least(4);
      top.offerAll(list);
      assertThat(top.topK()).containsExactly(1, 2, 3, 4).inOrder();
    }
  }

  public void testOfferedThreeK() {
    for (List<Integer> list : Collections2.permutations(Ints.asList(1, 2, 3, 4, 5, 6))) {
      TopKSelector<Integer> top = TopKSelector.least(2);

 * limitations under the License.
 */
package org.gradle.nativeplatform.platform.internal;

import java.util.Arrays;
import java.util.List;

import static java.util.Arrays.asList;

public class Architectures {

    public static final KnownArchitecture X86 = new KnownArchitecture("x86", "i386", "ia-32", "i686");

        dir.file(PROCESSOR_DECLARATION) << "InDir"
        def cp = files(jar, dir)

        when:
        def first = detector.detectProcessors(cp).values().asList()
        def second = detector.detectProcessors(cp).values().asList()

        then:
        for (int i = 0; i < first.size(); i++) {
            assert first.get(i).is(second.get(i))
        }
    }

            this
        }

        InvocationBuilder args(String... args) {
            this.args.addAll(Arrays.asList(args))
            this
        }

        InvocationBuilder jvmArgs(String... args) {
            this.jvmArguments.addAll(Arrays.asList(args))
            this
        }

        InvocationBuilder jvmArgs(Iterable<String> args) {
            this.jvmArguments.addAll(args)

                .append("\n");

        return sb.toString();
    }

    public boolean isAsList() {
        return asList;
    }

    public MetadataResolutionRequest setAsList(boolean asList) {
        this.asList = asList;
        return this;
    }

    public boolean isAsDirtyTree() {
        return asDirtyTree;
    }

    for (int i = 0; i < numStripes; i++) {
      stripes[i] = i;
    }
    List<Integer> asList = Ints.asList(stripes);
    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);
  }

package org.gradle.process.internal;

import java.util.Arrays;

public class TestApp {
    public static void main(String[] args) {
        System.out.print("output args: " + Arrays.asList(args));
        System.err.print("error args: " + Arrays.asList(args));
    }

  }

  public final void clear() {
    throw new UnsupportedOperationException();
  }

  private transient @Nullable ImmutableList<E> asList;

  public ImmutableList<E> asList() {
    ImmutableList<E> list = asList;
    return (list == null) ? (asList = createAsList()) : list;
  }

  ImmutableList<E> createAsList() {
    switch (size()) {
      case 0:
        return ImmutableList.of();
      case 1:

        return methodNameColumnExists
            ? Arrays.asList(test.getDisplayName(), test.getName(), test.getFormattedDuration(), test.getFormattedResultType())
            : Arrays.asList(test.getDisplayName(), test.getFormattedDuration(), test.getFormattedResultType());
    }

    private List<String> determineTableHeaders() {

    attrs=['mode: {"REFLECT", "SYMMETRIC"}'],
    derived_attrs=['T: type', 'Tpaddings: {int32, int64} = DT_INT32'],
    outputs=['output: T'])
def _composite_mirror_pad(input_, paddings, mode):
  shape = input_.shape.as_list()
  for i in range(len(shape)):
    rdims = tf.raw_ops.OneHot(
        indices=i, depth=len(shape), on_value=True, off_value=False, axis=-1)
    rarray = tf.raw_ops.Reverse(tensor=input_, dims=rdims)