final int len = string.length();
    final int size = len * count;
    final char[] array = new char[size];
    string.getChars(0, len, array, 0);
    int n;
    for (n = len; n < size - n; n <<= 1) {
      System.arraycopy(array, 0, array, n, n);
    }
    System.arraycopy(array, 0, array, n, size - n);
    return new String(array);
  }

  @BeforeExperiment
  void setUp() {
    checkArgument(size > 0, "empty collection not supported");
    Set<Integer> set = new LinkedHashSet<>(size);

    Random random = new Random();
    while (set.size() < size) {
      set.add(random.nextInt());
    }
    List<Integer> list = new ArrayList<>(set);
    inputOrder.arrange(list);
    input = ImmutableList.copyOf(list);
  }

  @Benchmark
  int collections(int reps) {

        validator.validate(model, problems);
        assertEquals(0, problems.messages.size());

        Repository repo = new Repository(org.apache.maven.api.settings.Repository.newInstance(false));
        prof.addRepository(repo);
        problems = new SimpleProblemCollector();
        validator.validate(model, problems);
        assertEquals(2, problems.messages.size());

        repo.setUrl("http://xxx.xxx.com");

      MoreFiles.asCharSink(fooCopy, UTF_8).write("boo");
      assertThat(MoreFiles.asByteSource(fooPath).size())
          .isEqualTo(MoreFiles.asByteSource(fooCopy).size());
      assertThat(MoreFiles.equal(fooPath, fooCopy)).isFalse();

      // should also assert that a Path that erroneously reports a size 0 can still be compared,
      // not sure how to do that with the Path API
    }
  }

  @Param({"0", "1", "16", "256", "4096", "65536"})
  int size;

  LinkedHashMultiset<Object> linkedHashMultiset;
  HashMultiset<Object> hashMultiset;

  // TreeMultiset requires a Comparable element.
  TreeMultiset<Integer> treeMultiset;

  @BeforeExperiment
  void setUp() {
    hashMultiset = HashMultiset.create(size);
    linkedHashMultiset = LinkedHashMultiset.create(size);
    treeMultiset = TreeMultiset.create();

  @Param({"0", "1", "16", "256", "4096", "65536"})
  int size;

  LinkedHashMultiset<Object> linkedHashMultiset;
  HashMultiset<Object> hashMultiset;

  // TreeMultiset requires a Comparable element.
  TreeMultiset<Integer> treeMultiset;

  @BeforeExperiment
  void setUp() {
    hashMultiset = HashMultiset.create(size);
    linkedHashMultiset = LinkedHashMultiset.create(size);
    treeMultiset = TreeMultiset.create();

        return byteCountToDisplaySize(BigInteger.valueOf(size));
    }

    private static String byteCountToDisplaySize(final BigInteger size) {
        Objects.requireNonNull(size, "size");
        final String displaySize;

        if (size.divide(ONE_EB_BI).compareTo(BigInteger.ZERO) > 0) {

        char[] c = new char[size];
        toHexChars(val, c, 0, size);
        return new String(c);
    }


    /**
     * 
     * @param src
     * @param srcIndex
     * @param size
     * @return hex string
     */
    public static String toHexString ( byte[] src, int srcIndex, int size ) {
        char[] c = new char[2 * size];
        for ( int i = 0, j = 0; i < size; i++ ) {

  @Param({"0", "1", "16", "256", "4096", "65536"})
  int size;

  // use concrete classes to remove any possible polymorphic overhead?
  Object[] array;
  ArrayList<Object> arrayList;
  LinkedList<Object> linkedList;

  @BeforeExperiment
  void setUp() {
    array = new Object[size];
    arrayList = Lists.newArrayListWithCapacity(size);
    linkedList = Lists.newLinkedList();

                "PlaneItem": {
                    "title": "PlaneItem",
                    "required": IsOneOf(
                        ["description", "type", "size"],
                        # TODO: remove when deprecating Pydantic v1
                        ["description", "size"],
                    ),
                    "type": "object",
                    "properties": {