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

  /** Returns the original element list, unchanged. */
  @Override
  public List<String> order(List<String> insertionOrder) {
    return insertionOrder;
  }

        assertNull(searchRenderData.getDocumentItems());

        // Test with empty list
        List<Map<String, Object>> emptyList = new ArrayList<>();
        searchRenderData.setDocumentItems(emptyList);
        assertEquals(emptyList, searchRenderData.getDocumentItems());

        // Test with populated list
        List<Map<String, Object>> documentItems = new ArrayList<>();
        Map<String, Object> doc1 = new HashMap<>();

        Artifact rootArtifact;
        DependencyCoordinates root;
        List<DependencyCoordinates> dependencies = Collections.emptyList();
        List<DependencyCoordinates> managedDependencies = Collections.emptyList();
        boolean verbose;
        PathScope pathScope;
        Predicate<PathType> pathTypeFilter;
        List<RemoteRepository> repositories;

        DependencyResolverRequestBuilder() {}

    float[] array = {0.0f, 1.0f};
    List<Float> list = Floats.asList(array);
    list.set(0, 2.0f);
    assertThat(array).isEqualTo(new float[] {2.0f, 1.0f});
    array[1] = 3.0f;
    assertThat(list).containsExactly(2.0f, 3.0f).inOrder();
  }

  public void testAsList_toArray_roundTrip() {
    float[] array = {0.0f, 1.0f, 2.0f};
    List<Float> list = Floats.asList(array);

    int[] array = {(int) 0, (int) 1};
    List<Integer> list = Ints.asList(array);
    list.set(0, (int) 2);
    assertThat(array).isEqualTo(new int[] {(int) 2, (int) 1});
    array[1] = (int) 3;
    assertThat(list).containsExactly((int) 2, (int) 3).inOrder();
  }

  public void testAsList_toArray_roundTrip() {
    int[] array = {(int) 0, (int) 1, (int) 2};
    List<Integer> list = Ints.asList(array);

    float[] array = {0.0f, 1.0f};
    List<Float> list = Floats.asList(array);
    list.set(0, 2.0f);
    assertThat(array).isEqualTo(new float[] {2.0f, 1.0f});
    array[1] = 3.0f;
    assertThat(list).containsExactly(2.0f, 3.0f).inOrder();
  }

  public void testAsList_toArray_roundTrip() {
    float[] array = {0.0f, 1.0f, 2.0f};
    List<Float> list = Floats.asList(array);

     *
     * @return The list of exceptions that occurred during resolution, never {@code null}
     */
    @Nonnull
    List<Exception> getExceptions();

    /**
     * Gets the versions (in ascending order) that matched the requested range.
     *
     * @return The list of matching versions, never {@code null}. An empty list indicates
     *         no versions matched the requested range.

        final Map map = new HashMap();
        String key = connection.getHeaderFieldKey(0);
        String value = connection.getHeaderField(0);
        for (int i = 1; key != null || value != null; i++) {
            List values = (List) map.get(key);
            if (values == null) {
                values = new ArrayList();
                map.put(key, values);
            }
            values.add(value);

      }
    }
  }
  return null
}

/**
 * Inputs must have applied [withoutSectionSpans].
 */
internal fun sections(mappings: List<Mapping>): Map<Int, List<MappedRange>> {
  val result = mutableMapOf<Int, MutableList<MappedRange>>()

  for (mapping in mappings) {
    require(!mapping.spansSections)

    val section = mapping.section

To achieve this, the `:80`-backend must have a list of "allowed origins".

In this case, the list would have to include `http://localhost:8080` for the `:8080`-frontend to work correctly.

## Wildcards { #wildcards }

It's also possible to declare the list as `"*"` (a "wildcard") to say that all are allowed.