@ElementTypesAreNonnullByDefault
public class TreeTraverserTest extends TestCase {
  private static class Node {
    final char value;

    Node(char value) {
      this.value = value;
    }
  }

  private static final class Tree extends Node {
    final List<Tree> children;

    public Tree(char value, Tree... children) {
      super(value);
      this.children = Arrays.asList(children);
    }
  }

 */
@GwtIncompatible
public class DefaultsTest extends TestCase {
  public void testGetDefaultValue() {
    assertEquals(false, Defaults.defaultValue(boolean.class).booleanValue());
    assertEquals('\0', Defaults.defaultValue(char.class).charValue());
    assertEquals(0, Defaults.defaultValue(byte.class).byteValue());
    assertEquals(0, Defaults.defaultValue(short.class).shortValue());
    assertEquals(0, Defaults.defaultValue(int.class).intValue());

          private final char[] unknown = new char[] {'?'};

          @Override
          protected char[] escapeUnsafe(char c) {
            return unknown;
          }
        };
    EscaperAsserts.assertBasic(replacingEscaper);

    // Replacements are applied first regardless of whether the character is in
    // the safe range or not ('&' is a safe char while '\t' and '\n' are not).
    assertEquals(

                .map(HttpServletRequest::getCharacterEncoding).orElse(Constants.UTF_8);
        final StringBuilder buf = new StringBuilder(url.length() + 100);
        for (final char c : url.toCharArray()) {
            if (CharUtil.isUrlChar(c)) {
                buf.append(c);
            } else {
                try {
                    buf.append(URLEncoder.encode(String.valueOf(c), enc));

    private String unescape(final String s) {
        if (s.indexOf('\\') >= 0) {
            final StringBuilder sb = new StringBuilder();
            for (int i = 0; i < s.length(); i++) {
                final char ch = s.charAt(i);
                if (ch == '\\' && i < s.length() - 1) {
                    i++;
                    sb.append(s.charAt(i));
                } else {
                    sb.append(ch);

    /** WAVE DASH */
    public static final char WAVE_DASH = '\u301C';

    /** FULLWIDTH TILDE */
    public static final char FULLWIDTH_TILDE = '\uFF5E';

    /** DOUBLE VERTICAL LINE */
    public static final char DOUBLE_VERTICAL_LINE = '\u2016';

    /** PARALLEL TO */
    public static final char PARALLEL_TO = '\u2225';

    /** MINUS SIGN */
    public static final char MINUS_SIGN = '\u2212';

    // read char by char
    CharSequenceReader reader = new CharSequenceReader(charSequence);
    for (int i = 0; i < expected.length(); i++) {
      assertEquals(expected.charAt(i), reader.read());
    }
    assertFullyRead(reader);

    // read all to one array
    reader = new CharSequenceReader(charSequence);
    char[] buf = new char[expected.length()];

    @Override
    MessageBuilder append(char c);

    /**
     * Append content to the message buffer.
     *
     * @param value the content to append
     * @param offset the index of the first {@code char} to append
     * @param len the number of {@code char}s to append
     * @return the current builder
     */
    @Nonnull
    default MessageBuilder a(char[] value, int offset, int len) {

        Settings settings = new Settings();
        Mirror mirror = new Mirror();
        mirror.setId("local");
        settings.addMirror(mirror);
        mirror = new Mirror();
        mirror.setId("illegal\\:/chars");
        mirror.setUrl("http://void");
        mirror.setMirrorOf("void");
        settings.addMirror(mirror);

        SimpleProblemCollector problems = new SimpleProblemCollector();

/**
 * FlatRepositoryLayout
 */
@Named("flat")
@Singleton
@Deprecated
public class FlatRepositoryLayout implements ArtifactRepositoryLayout {

    private static final char ARTIFACT_SEPARATOR = '-';

    private static final char GROUP_SEPARATOR = '.';

    public String getId() {
        return "flat";
    }

    public String pathOf(Artifact artifact) {