List<String> result = new ArrayList<>();
        StringBuilder sb = new StringBuilder(size);
        // first line
        sb.setLength(0);
        repeat(sb, BOX_CHAR, size);
        result.add(sb.toString());
        // lines
        for (String line : lines) {
            sb.setLength(0);
            String[] words = S_FILTER.split(line);
            for (String word : words) {

        int pad = lastLength - buffer.length();
        lastLength = buffer.length();
        pad(buffer, pad);
        buffer.append('\r');
        out.print(buffer);
        out.flush();
        buffer.setLength(0);
    }

    private void pad(StringBuilder buffer, int spaces) {
        String block = "                                        ";
        while (spaces > 0) {

                // if we're building an argument, keep doing so.
                // if this is the case of "-Dfoo=bar", then we need to adjust the buffer.
                if (!currentArg.isEmpty()) {
                    currentArg.setLength(currentArg.length() - 1);
                }

                cleaned.add(currentArg.toString());

                currentArg = null;
                addedToBuffer = false;
                continue;
            }

    return result;
  }

  // TODO(user): Move this logic to a utility class.
  @JsType(isNative = true, name = "Array", namespace = JsPackage.GLOBAL)
  private interface NativeArray {
    @JsProperty
    void setLength(int length);
  }

  static MapMaker tryWeakKeys(MapMaker mapMaker) {
    return mapMaker;
  }

  static <E extends Enum<E>> Class<E> getDeclaringClassOrObjectForJ2cl(E e) {

import com.google.common.collect.Iterables;
import java.lang.ref.WeakReference;
import junit.framework.TestCase;

/**
 * Tests of basic {@link LoadingCache} operations with all possible combinations of key & value
 * strengths.
 *
 * @author mike nonemacher
 */
public class CacheReferencesTest extends TestCase {

  private static final CacheLoader<Key, String> KEY_TO_STRING_LOADER =
      new CacheLoader<Key, String>() {

        final String target = rightString(buf, size);
        if (!termCache.contains(target)) {
            termCache.add(target);
            return isSpace;
        }
        buf.setLength(buf.length() - size);
        if (!isSpace && !isLastSpaceChar(buf)) {
            buf.appendCodePoint(' ');
            return true;
        }
        return isSpace;
    }

    }

    /**
     * Set the buffer length.
     *
     * @param length the new length
     * @return the current builder
     */
    MessageBuilder setLength(int length);

    /**
     * Return the built message.
     *
     * @return the message
     */
    @Nonnull
    String build();

                if (pathStartsWithSlash) {
                    if (initialUrlEndsWithSlash) {
                        // 1 extra '/' to remove
                        url.setLength(url.length() - 1);
                    }
                } else if (!initialUrlEndsWithSlash) {
                    // add missing '/' between url and path
                    url.append('/');
                }

            regexQueries[i] = Pattern.quote(queries[i]);
            hlQueries[i] = highlightTagPre + queries[i] + highlightTagPost;
        }
        while (m.find()) {
            segBuf.setLength(0);
            m.appendReplacement(segBuf, StringUtil.EMPTY);
            String segment = segBuf.toString();
            for (int i = 0; i < queries.length; i++) {

                }
                buffer.append(buildTimeDuration);
                buffer.append(']');
            }

            logger.info(buffer.toString());
            buffer.setLength(0);
        }
    }

    private void logResult(MavenSession session) {
        infoLine('-');
        MessageBuilder buffer = builder();

        if (session.getResult().hasExceptions()) {