offerEncryptoCipher(cipher);
        }
        return encrypted;
    }

    public byte[] encrypto(final byte[] data, final Key key) {
        final Cipher cipher = pollEncryptoCipher(key);
        byte[] encrypted;
        try {
            encrypted = cipher.doFinal(data);
        } catch (final IllegalBlockSizeException e) {
            throw new IllegalBlockSizeRuntimeException(e);

    /**
     * @throws Exception
     */
    public void testGetBytes() throws Exception {
        final InputStream is = ResourceUtil.getResourceAsStream(StringUtil.replace(getClass().getName(), ".", "/") + ".class");
        try {
            assertNotNull("1", InputStreamUtil.getBytes(is));
        } finally {
            is.close();
        }
    }

    }

    /**
     * @throws Exception
     */
    @Test
    public void testForEachFile() throws Exception {
        final File rootDir = ResourceUtil.getBuildDir(getClass());
        final String path = ResourceUtil.getResourcePath(getClass());
        final int pos = path.lastIndexOf("/");
        final String baseDirectory = path.substring(0, pos);
        ResourceTraversalUtil.forEach(rootDir, baseDirectory, (ResourceHandler) (path1, is) -> {

public class CommonPoolUtil {
    private static final Logger logger = Logger.getLogger(CommonPoolUtil.class);

    private CommonPoolUtil() {
        // nothing
    }

    public static void execute(final Runnable task) {
        ForkJoinPool.commonPool().execute(() -> {
            final Thread currentThread = Thread.currentThread();
            final ClassLoader orignal = currentThread.getContextClassLoader();

        assertArgumentNotNull("in", in);
        assertArgumentNotNull("out", out);

        final InputStream is = URLUtil.openStream(in);
        try {
            final FileOutputStream os = OutputStreamUtil.create(out);
            try {
                return copyInternal(wrap(is), os);
            } finally {
                CloseableUtil.close(os);
            }
        } finally {

        final ClassLoader context = Thread.currentThread().getContextClassLoader();
        try {
            final ClassLoader cl = new URLClassLoader(new URL[0], getClass().getClassLoader());
            Thread.currentThread().setContextClassLoader(cl);
            assertThat(ClassLoaderUtil.getClassLoader(TestCase.class), is(sameInstance(cl)));
        } finally {

     * <p>
     * {@literal try}ブロックで例外が発生した場合、{@literal finally}ブロックの
     * {@link #close(Closeable)}でも 例外が発生する可能性があります。その場合に{@literal finally}
     * ブロックから例外をスローすると、 {@literal try}ブロックで発生した元の例外が失われてしまいます。
     * </p>
     *
     * @param closeable
     *            クローズ可能なオブジェクト
     * @see Closeable#close()
     */
    public static void close(final Closeable closeable) {
        if (closeable == null) {
            return;

            final ObjectInputStream ois = new ObjectInputStream(bais);
            try {
                return ois.readObject();
            } finally {
                CloseableUtil.close(ois);
            }
        } catch (final IOException ex) {
            throw new IORuntimeException(ex);
        } catch (final ClassNotFoundException ex) {

     * @return ファイルの内容を読み込んだバイト配列
     */
    public static byte[] readBytes(final File file) {
        assertArgumentNotNull("file", file);

        final FileInputStream is = InputStreamUtil.create(file);
        try {
            final FileChannel channel = is.getChannel();
            final ByteBuffer buffer = ByteBuffer.allocate((int) ChannelUtil.size(channel));
            ChannelUtil.read(channel, buffer);

            } catch (final InterruptedException e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Interrupted.", e);
                }
            } finally {
                executorService.shutdownNow();
            }
        }
    }

    private void processTask(final ExecutorService executorService, final TimeoutTask task) {
        try {