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

            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 {

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

    @Override
    public File getFile() {
        return null;
    }

    @Override
    public MetadataBridge setFile(File file) {
        return this;
    }

    @Override
    public Path getPath() {
        return null;
    }

    @Override
    public Nature getNature() {
        if (metadata instanceof RepositoryMetadata repositoryMetadata) {

        childUrlRuleMap.put("//SCRIPT", "src");
        htmlTransformer.setChildUrlRuleMap(childUrlRuleMap);
    }

    public void test_name() {
        assertEquals("htmlTransformer", htmlTransformer.getName());
    }

    public void test_transform() {
        final byte[] data = new String("xyz").getBytes();
        final ResponseData responseData = new ResponseData();
        responseData.setUrl("http://hoge/");

            // Act & Assert
            assertEquals("file.txt", smbFile.getName());
        }

        @Test
        void testGetPath() {
            // Arrange
            doReturn("/share/file.txt").when(smbFile).getPath();

            // Act & Assert
            assertEquals("/share/file.txt", smbFile.getPath());
        }
    }

    @Nested
    class WhenHandlingStreams {

     *
     * @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;

     */
    public static void appendAttr(final Attr attr, final StringBuilder buf) {
        assertArgumentNotNull("attr", attr);
        assertArgumentNotNull("buf", buf);

        buf.append(attr.getName());
        buf.append("=\"");
        buf.append(encodeAttrQuot(attr.getValue()));
        buf.append('\"');
    }

    /**
     * Appends the string representation of a {@link Text}.
     *

        assertEquals("share/", b.getName());

        // host when no path/share
        SmbResourceLocatorImpl c = locator("smb://server/");
        assertEquals("server/", c.getName());

        // root fallback
        SmbResourceLocatorImpl d = locator("smb:///");
        assertEquals("smb://", d.getName());
    }

    @Test
    @DisplayName("Parent URL is computed correctly")

        if (!fessConfig.isLdapAdminEnabled(user.getName())) {
            return;
        }

        final Supplier<Hashtable<String, String>> adminEnv = this::createAdminEnv;
        final String userDN = fessConfig.getLdapAdminUserSecurityPrincipal(user.getName());
        // attributes
        search(fessConfig.getLdapAdminUserBaseDn(), fessConfig.getLdapAdminUserFilter(user.getName()), null, adminEnv, result -> {