out.append(format.normalizeFirstWord(s.substring(i, j)));
      } else {
        requireNonNull(out).append(format.normalizeWord(s.substring(i, j)));
      }
      out.append(format.wordSeparator);
      i = j + wordSeparator.length();
    }
    return (i == 0)
        ? format.normalizeFirstWord(s)
        : requireNonNull(out).append(format.normalizeWord(s.substring(i))).toString();
  }

  /**

        if (ind1 == -1 || ind2 == -1) {
            return;
        }

        this.groupId = name.substring(0, ind1);
        if (ind1 == ind2) {
            this.artifactId = name.substring(ind1 + 1);
        } else {
            this.artifactId = name.substring(ind1 + 1, ind2);
            this.version = name.substring(ind2 + 1);
        }
    }

    public ArtifactMetadata(String groupId, String name, String version) {

        final int length = str.length();
        if (length > 1
                && str.startsWith("\"")
                && str.endsWith("\"")
                && str.substring(1, length - 1).indexOf('"') == -1) {
            str = str.substring(1, length - 1);
        }
        return str;
    }

    @Nonnull
    public static Path getCanonicalPath(Path path) {
        requireNonNull(path, "path");

            if (index < 0) {
                locale = new Locale(localeStr);
            } else {
                final String language = localeStr.substring(0, index);
                final String country = localeStr.substring(index + 1);
                locale = new Locale(language, country);
            }
        }
        return locale;
    }

                user = index != -1 ? userInfo.substring(0, index) : userInfo;
                if (index != -1) {
                    password = userInfo.substring(index + 1);
                }
                index = user.indexOf('\\');
                if (index == -1) {
                    index = user.indexOf('/');
                }
                domain = index != -1 ? user.substring(0, index) : domain;

      if (placeholderStart == -1) {
        break;
      }
      builder.append(template.substring(templateStart, placeholderStart));
      builder.append(args[i++]);
      templateStart = placeholderStart + 2;
    }
    builder.append(template.substring(templateStart));

    // if we run out of placeholders, append the extra args in square braces
    if (i < args.length) {

            String[] alphabets;
            if (i + 1 < text.length() && CONVERT_MAP.get(text.substring(i, i + 2)) != null) {
                alphabets = CONVERT_MAP.get(text.substring(i, i + 2));
                i += 2;
            } else {
                if (CONVERT_MAP.get(text.substring(i, i + 1)) != null) {
                    alphabets = CONVERT_MAP.get(text.substring(i, i + 1));
                } else {

        Matcher matcher = GETTER_METHOD_NAME.matcher(name);
        if (matcher.matches()) {
            int startName = matcher.start(2);
            String propName = name.substring(startName, startName + 1).toLowerCase(Locale.ROOT) + name.substring(startName + 1);
            PropertyMetaData property = getCurrentClass().addReadableProperty(propName, returnType, rawCommentText, methodMetaData);

    reader.reset();
    assertEquals(5, reader.skip(5));
    reader.mark(Integer.MAX_VALUE);
    assertEquals(string.substring(5), readFully(reader));
    assertFullyRead(reader);

    // reset to the mark and then read the rest
    reader.reset();
    assertEquals(string.substring(5), readFully(reader));
    assertFullyRead(reader);
  }

  public void testIllegalArguments() throws IOException {

                .filter(m -> m.getName().startsWith("merge"))
                .filter(m -> {
                    String baseName = m.getName().substring(5 /* merge */);
                    String entity = baseName.substring(baseName.indexOf('_') + 1);
                    try {
                        Type returnType = m.getParameterTypes()[0]
                                .getMethod("get" + entity)