}
        };
    List<Object> list = Collections.singletonList(object);
    for (int i = 0; i < 10; i++) {
      Object[] array = new Object[500];
      Arrays.fill(array, list);
      list = Arrays.asList(array);
    }
    future2.set(list);

    unused = future.toString();
  }

  public void testToString_notDone() throws Exception {

            samr.SamrSamArray array = new samr.SamrSamArray();
            array.count = 0;
            array.entries = null;

            // When: Encoding array
            array.encode(mockNdrBuffer);

            // Then: Should encode null referent
            verify(mockNdrBuffer).align(4);
            verify(mockNdrBuffer).enc_ndr_long(0);

        List<String> stubCleanCycle = Arrays.asList(PRE_CLEAN.getPhase(), CLEAN.getPhase(), POST_CLEAN.getPhase());

        List<String> stubSiteCycle =
                Arrays.asList(PRE_SITE.getPhase(), SITE.getPhase(), POST_SITE.getPhase(), SITE_DEPLOY.getPhase());

        Iterator<List<String>> lcs =
                Arrays.asList(stubDefaultCycle, stubCleanCycle, stubSiteCycle).iterator();

     * Asserts that the argument is neither <code>null</code> nor an empty array.
     *
     * @param argName
     *            The name of the argument that must not be {@code null} or an empty array.
     * @param argValue
     *            The value of the argument.
     * @throws EmptyArgumentException
     *             If the argument is <code>null</code> or an empty array.
     */

 */
package org.apache.maven.internal.impl;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import org.apache.maven.api.services.ChecksumAlgorithmService;
import org.apache.maven.impl.DefaultChecksumAlgorithmService;

import org.jspecify.annotations.Nullable;

/**
 * Simple helper class to build a "sparse" array of objects based on the indexes that were added to
 * it. The array will be from 0 to the maximum index given. All non-set indexes will contain null
 * (so it's not really a sparse array, just a pseudo sparse array). The builder can also return a
 * CharEscaper based on the generated array.
 *
 * @author Sven Mawson
 * @since 15.0
 */
@GwtCompatible

        assertThat(ArrayUtil.addAll(emptyArray, array), is(sameInstance(array)));
        assertThat(ArrayUtil.addAll(array, emptyArray), is(sameInstance(array)));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testAdd_int() throws Exception {
        final int[] array = new int[] { 1 };
        final int[] newArray = ArrayUtil.add(array, 2);
        assertThat(newArray.length, is(2));

        ArtifactRepository repository =
                repositorySystem.createArtifactRepository("repository", "http://foo", null, null, null);
        repositorySystem.injectAuthentication(Arrays.asList(repository), Arrays.asList(server));
        Authentication authentication = repository.getAuthentication();
        assertNotNull(authentication);
        assertEquals("jason", authentication.getUsername());

        LifecycleMojo mojo1 = new LifecycleMojo();
        mojo1.setGoal("jar:jar");
        phase.setMojos(Arrays.asList(mojo1));
        assertEquals("jar:jar", phase.toString());

        LifecycleMojo mojo2 = new LifecycleMojo();
        mojo2.setGoal("war:war");
        phase.setMojos(Arrays.asList(mojo1, mojo2));
        assertEquals("jar:jar,war:war", phase.toString());
    }

    @Test
    void testSet() {

    int len = string.length();
    int size = len * count;
    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);
  }