map.put("name", s);
            list.add(map);
        }));
        return list;
    }

    /**
     * Creates a path prefix with trailing slash if path is not empty.
     *
     * @param path the base path
     * @return path with trailing slash or empty string
     */
    protected static String getPathPrefix(final String path) {
        return StringUtil.isEmpty(path) ? StringUtil.EMPTY : path + "/";

# Attempt to set APP_HOME

# Resolve links: $0 may be a link
app_path=$0

# Need this for daisy-chained symlinks.
while
    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
    [ -h "$app_path" ]
do
    ls=$( ls -ld "$app_path" )
    link=${ls#*' -> '}
    case $link in             #(
      /*)   app_path=$link ;; #(
      *)    app_path=$APP_HOME$link ;;

   */
  public void testIsWellFormed_4BytesSamples() {
    // Valid 4 byte.
    assertWellFormed(0xF0, 0xA4, 0xAD, 0xA2);
    // Bad trailing bytes
    assertNotWellFormed(0xF0, 0xA4, 0xAD, 0x7F);
    assertNotWellFormed(0xF0, 0xA4, 0xAD, 0xC0);
    // Special cases for byte2
    assertNotWellFormed(0xF0, 0x8F, 0xAD, 0xA2);

        assertEquals("\"", result[1]);
        assertEquals("\"\"", result[2]);
    }

    public void test_parse_whitespace() {
        String value;
        String[] result;

        // Leading and trailing spaces
        value = " value1 , value2 , value3 ";
        result = KuromojiCSVUtil.parse(value);
        assertEquals(3, result.length);
        assertEquals(" value1 ", result[0]);

          );

  private static final ImmutableSet<String> RS =
      ImmutableSet.of(
          // keep-sorted start
          "\u7f51\u7edc.Cn", // "网络.Cn"
          "co.uk",
          "co.uk.", // Trailing dot
          "co\uFF61uk", // Alternate dot character
          "com",
          "foo.bd",
          "org.mK",
          "us",
          "xxxxxx.bd",
          // keep-sorted end

  InternetDomainName(String name) {
    // Normalize:
    // * ASCII characters to lowercase
    // * All dot-like characters to '.'
    // * Strip trailing '.'

    name = Ascii.toLowerCase(DOTS_MATCHER.replaceFrom(name, '.'));

    if (name.endsWith(".")) {
      name = name.substring(0, name.length() - 1);
    }

        ExecJob result = execJob.logSuffix(testSuffix);
        assertEquals("test_suffix", execJob.logSuffix);
        assertSame(execJob, result);

        // Test with leading/trailing spaces
        result = execJob.logSuffix("  another suffix  ");
        assertEquals("another_suffix", execJob.logSuffix);

        // Test with multiple spaces

   * @param size the desired size of each partition
   * @return an iterable of unmodifiable lists containing the elements of {@code iterable} divided
   *     into partitions (the final iterable may have trailing null elements)
   * @throws IllegalArgumentException if {@code size} is nonpositive
   */
  public static <T extends @Nullable Object> Iterable<List<@Nullable T>> paddedPartition(
      Iterable<T> iterable, int size) {

 *
 * These two URLs are semantically identical, but `java.net.URI` disagrees:
 *
 *  * http://host:80/
 *
 *  * http://host
 *
 * Both the unnecessary port specification (`:80`) and the absent trailing slash (`/`) cause URI to
 * bucket the two URLs separately. This harms URI's usefulness in collections. Any application that
 * stores information-per-URL will need to either canonicalize manually, or suffer unnecessary

   * throwing an exception if parsing fails. Valid inputs are exactly those accepted by {@link
   * Float#valueOf(String)}, except that leading and trailing whitespace is not permitted.
   *
   * <p>This implementation is likely to be faster than {@code Float.parseFloat} if many failures
   * are expected.
   *