final byte[] bytes = FileUtil.readBytes(file, Long.MAX_VALUE);
        assertThat(new String(bytes, "UTF-8"), is(content));
    }

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

        assertEquals(SimpleCircuitBreaker.State.OPEN, circuitBreaker.getState());

        // Wait for timeout
        Thread.sleep(150);

        // Next call should transition to HALF_OPEN
        String result = circuitBreaker.call(() -> "success");
        assertEquals("success", result);
        assertEquals(SimpleCircuitBreaker.State.HALF_OPEN, circuitBreaker.getState());
    }

    @Test

            ResourceUtil.getResource("hoge", "xml");
            fail("2");
        } catch (final ResourceNotFoundRuntimeException e) {
            System.out.println(e);
            assertEquals("3", "hoge.xml", e.getPath());
        }
        System.out.println(ResourceUtil.getResource("."));
    }

    /**
     * @throws Exception
     */
    public void testGetResourceAsStreamNoException() throws Exception {

     *
     * @return  The uncanonicalized full URL of this SMB resource.
     */

    public String getPath() {
        return url.toString();
    }

    String getUncPath0() {
        if (unc == null) {
            final char[] in = url.getPath().toCharArray();
            final char[] out = new char[in.length];
            final int length = in.length;
            int i, o, state;

        final ResultData resultData = fileTransformer.transform(responseData);
        assertEquals("http_CLN_/www.example.com/submit_QUEST_a=1_AMP_b=2", new String(resultData.getData(), "UTF-8"));
        final File file = new File(fileTransformer.baseDir, new String(resultData.getData(), "UTF-8"));
        assertEquals("xyz", new String(FileUtil.readBytes(file)));
    }

    public void test_createFile() throws Exception {

                            responseData.setMimeType(mimeTypeHelper.getContentType(is, file.getName()));
                        } catch (final Exception e) {
                            responseData.setMimeType(mimeTypeHelper.getContentType(null, file.getName()));
                        }
                    } else {
                        if (logger.isDebugEnabled()) {

        verifyTokenKeep(() -> downloadpage(form.dictId));
        return stopwordsService.getStopwordsFile(form.dictId)
                .map(file -> asStream(new File(file.getPath()).getName()).contentTypeOctetStream().stream(out -> {
                    file.writeOut(out);
                }))
                .orElseGet(() -> {

    private static final Logger logger = Logger.getLogger(Jdk7FileFactory.class.getName());

    private final ThreadLocal<Path> fileThreadLocal = new ThreadLocal<>();

    Path createFile() throws IOException {
      Path file = java.nio.file.Files.createTempFile("SinkSourceFile", "txt");
      fileThreadLocal.set(file);
      return file;
    }

    Path getPath() {
      return fileThreadLocal.get();
    }

    }

    /**
     * Returns the name of the item.
     *
     * @return the item name
     */
    public String getName() {
        return name;
    }

    /**
     * Returns the path of the item.
     *
     * @return the item path
     */
    public String getPath() {
        return path;
    }

    /**
     * Returns whether this item is a directory.
     *

                throw new ChildUrlsException(requestDataSet, this.getClass().getName() + "#getResponseData");
            }

            final FTPFile[] files = client.listFiles(null, FTPFileFilters.NON_NULL);
            validateRequest(client);
            for (final FTPFile f : files) {
                if (ftpInfo.getName().equals(f.getName())) {
                    file = f;
                    break;
                }