String[] array = new String[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (String) e;
    }
    return create(array);
  }

  protected abstract Collection<String> create(String[] elements);

  @Override
  public String[] createArray(int length) {
    return new String[length];
  }

  /** Returns the original element list, unchanged. */

    String[] array = new String[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (String) e;
    }
    return create(array);
  }

  protected abstract Queue<String> create(String[] elements);

  @Override
  public String[] createArray(int length) {
    return new String[length];
  }

  /** Returns the original element list, unchanged. */
  @Override

        String[] values = new String[1000];
        for (int i = 0; i < values.length; i++) {
            values[i] = "value" + i;
        }
        RequestParameter param = new RequestParameter(name, values);

        assertEquals(name, param.getName());
        assertNotNull(param.getValues());
        assertEquals(1000, param.getValues().length);
        assertEquals("value0", param.getValues()[0]);

    RandomAccessFile rf = new RandomAccessFile(temp, "rw");
    rf.writeByte(0);
    rf.close();
    assertEquals(asciiFile.length(), temp.length());
    assertFalse(Files.equal(asciiFile, temp));

    assertTrue(Files.asByteSource(asciiFile).contentEquals(Files.asByteSource(asciiFile)));

    // 0-length files have special treatment (/proc, etc.)
    assertTrue(Files.equal(asciiFile, new BadLengthFile(asciiFile, 0)));
  }

    }
  });

  $result.on("click", "a.favorite", function(e) {
    var $favorite = $(this),
        values = $favorite.attr("href").split("#"),
        actionUrl,
        docId;
    if (values.length === 2 && $queryId.length > 0) {
      docId = values[1];
      actionUrl = contextPath + "/api/v1/documents/" + docId + "/favorite";
      $.ajax({
        dataType: "json",
        cache: false,
        type: "post",

    public Entry<Country, String>[] createArray(int length) {
      return (Entry<Country, String>[]) new Entry<?, ?>[length];
    }

    @Override
    public Iterable<Entry<Country, String>> order(List<Entry<Country, String>> insertionOrder) {
      return insertionOrder;
    }

    @Override
    public Country[] createKeyArray(int length) {
      return new Country[length];
    }

    @Override

            final Extractor[] existingExtractors = extractorMap.get(key);

            final Extractor[] newExtractors = new Extractor[existingExtractors.length + 1];
            System.arraycopy(existingExtractors, 0, newExtractors, 0, existingExtractors.length);
            newExtractors[newExtractors.length - 1] = extractor;

            Arrays.sort(newExtractors, Comparator.comparingInt(Extractor::getWeight).reversed());

        type = SESSION_RETARGET_RESPONSE;
        length = 6;
    }

    @Override
    int writeTrailerWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int readTrailerWireFormat(final InputStream in, final byte[] buffer, int bufferIndex) throws IOException {
        if (in.read(buffer, bufferIndex, length) != length) {

      checkArgument(
          nextBytes.length == resultBytes.length, "All hashcodes must have the same bit length.");
      for (int i = 0; i < nextBytes.length; i++) {
        resultBytes[i] = (byte) (resultBytes[i] * 37 ^ nextBytes[i]);
      }
    }
    return HashCode.fromBytesNoCopy(resultBytes);
  }

  /**
   * Returns a hash code, having the same bit length as each of the input hash codes, that combines

                req.setMaxOutputResponse(maxRecvSize);
                final Smb2IoctlResponse resp = th.send(req, RequestParam.NO_RETRY);
                return resp.getOutputLength();
            }
            if (this.transact) {
                final TransTransactNamedPipe req = new TransTransactNamedPipe(th.getConfig(), fh.getFid(), buf, off, length);