assertTrue(parser.getFileConfig().isPresent());

        parser.getFileConfig().ifPresent(config -> {
            assertTrue(config.getPaths().contains("file:///test"));
            assertTrue(config.getPaths().contains("smb://server/share"));
        });
    }

    public void test_parseWithMixedUrls() {
        GsaConfigParser parser = new GsaConfigParser();

                "numOfThread");
        setupEpg(_epgMap, et -> ((FileConfig) et).getPaths(), (et, vl) -> ((FileConfig) et).setPaths(DfTypeUtil.toString(vl)), "paths");
        setupEpg(_epgMap, et -> ((FileConfig) et).getPermissions(), (et, vl) -> ((FileConfig) et).setPermissions((String[]) vl),
                "permissions");

        registerModifiedProperty("numOfThread");
        this.numOfThread = value;
    }

    public String getPaths() {
        checkSpecifiedProperty("paths");
        return convertEmptyToNull(paths);
    }

    public void setPaths(String value) {
        registerModifiedProperty("paths");
        this.paths = value;
    }

    public String[] getPermissions() {

            final Crawler crawler = ComponentUtil.getComponent(Crawler.class);
            crawler.setSessionId(sid);
            sessionIdList.add(sid);

            final String pathsStr = fileConfig.getPaths();
            if (StringUtil.isBlank(pathsStr)) {
                logger.warn("No target uris. Skipped");
                break;
            }

            final int intervalTime =

        return getPath("WEB-INF/", "classes", names);
    }

    /**
     * Gets the path to original files directory.
     *
     * @param names the path components to append to the orig directory
     * @return the Path object pointing to the original files directory
     */
    public static Path getOrigPath(final String... names) {
        return getPath("WEB-INF/", "orig", names);
    }

    }

    /**
     * @throws Exception
     */
    @Test
    public void testReadUTF8() throws Exception {
        assertThat(FileUtil.readUTF8(getPath("hoge_utf8.txt")), is("あ"));
    }

    private String getPath(final String fileName) {
        return getClass().getName().replace('.', '/').replaceFirst(getClass().getSimpleName(), fileName);
    }

  private static class BadLengthFile extends File {

    private final long badLength;

    BadLengthFile(File delegate, long badLength) {
      super(delegate.getPath());
      this.badLength = badLength;
    }

    @Override
    public long length() {
      return badLength;
    }

    private static final long serialVersionUID = 0;
  }

                form.dictId = dictId;
            });
        }).renderWith(data -> {
            stopwordsService.getStopwordsFile(dictId).ifPresent(file -> {
                RenderDataUtil.register(data, "path", file.getPath());
            }).orElse(() -> {
                throwValidationError(messages -> messages.addErrorsFailedToDownloadStopwordsFile(GLOBAL), this::asDictIndexHtml);
            });
        });
    }

    /**

                    throw new DictionaryException("Failed to update " + dictFile.getPath());
                }
            } catch (final IOException e) {
                throw new DictionaryException("Failed to update " + dictFile.getPath(), e);
            }

        }).orElse(() -> {
            throw new DictionaryException(dictFile.getPath() + " does not exist.");
        });
    }

    /**

                form.dictId = dictId;
            });
        }).renderWith(data -> {
            charMappingService.getCharMappingFile(dictId).ifPresent(file -> {
                RenderDataUtil.register(data, "path", file.getPath());
            }).orElse(() -> {
                throwValidationError(messages -> messages.addErrorsFailedToDownloadMappingFile(GLOBAL), this::asDictIndexHtml);
            });
        });
    }

    /**