// from bytes to OutputStream
    //
    /**
     * バイト配列から出力ストリームへコピーします。
     * <p>
     * 出力ストリームはクローズされません。
     * </p>
     *
     * @param in
     *            バイト配列。{@literal null}であってはいけません
     * @param out
     *            出力ストリーム。{@literal null}であってはいけません
     * @return コピーしたバイト数
     */
    public static int copy(final byte[] in, final OutputStream out) {

     * 
     * @return receive buffer size, in bytes
     * @deprecated use getReceiveBufferSize instead
     */
    @Deprecated
    int getRecieveBufferSize ();


    /**
     * 
     * Property <tt>jcifs.smb.client.rcv_buf_size</tt> (int, default 65535)
     * 
     * @return receive buffer size, in bytes
     */
    int getReceiveBufferSize ();


    /**
     * 

/**
 * byte配列用の変換ユーティリティです。
 *
 * @author higa
 */
public abstract class BinaryConversionUtil {

    /**
     * {@literal byte}の配列に変換します。
     *
     * @param o
     *            変換元のオブジェクト
     * @return {@literal byte}の配列
     */
    public static byte[] toBinary(final Object o) {
        if (o instanceof byte[]) {
            return (byte[]) o;
        } else if (o == null) {

    private static final int NEED_CHAR = Integer.MAX_VALUE;

    private static final int QUOTE = '\'';

    private static final byte CT_WHITESPACE = 1;

    private static final byte CT_ALPHA = 4;

    private final byte[] ctype;

    private static byte[] defaultCtype = new byte[256];

    private final String str;

    private int colno = 0;

    private int ttype = TT_NOTHING;

    private String sval;

    public NegTokenInit ( ASN1ObjectIdentifier[] mechanisms, int contextFlags, byte[] mechanismToken, byte[] mechanismListMIC ) {
        setMechanisms(mechanisms);
        setContextFlags(contextFlags);
        setMechanismToken(mechanismToken);
        setMechanismListMIC(mechanismListMIC);
    }


    public NegTokenInit ( byte[] token ) throws IOException {
        parse(token);
    }

public class ContentCache implements Closeable {

    protected static final Logger logger = Logger.getLogger(ContentCache.class.getName());

    private final byte[] data;

    private final File file;

    public ContentCache(final byte[] data) {
        this.data = data;
        this.file = null;
    }

    public ContentCache(final File file) {
        this.data = null;
        this.file = file;
    }

        assertEquals("3", "2", b[1]);
    }

    /**
     * @throws Exception
     */
    public void testObjectAndBinary() throws Exception {
        final String o = "hoge";
        final byte[] binary = SerializeUtil.fromObjectToBinary(o);
        assertEquals(o, SerializeUtil.fromBinaryToObject(binary));
    }

        public int getResponseCode() throws IOException {
            return 200;
        }

        @Override
        public InputStream getInputStream() throws IOException {
            return new ByteArrayInputStream(new byte[100]); // dummy payload
        }
    }

    @Test
    public void test_TmpFileHasBeenDeletedAfterResponseWasClosed() throws Exception {
        // ## Arrange ##

     * @param argValue
     *            引数の値
     * @throws EmptyArgumentException
     *             引数が<code>null</code>または空の配列の場合。
     */
    public static void assertArgumentNotEmpty(final String argName, final byte[] argValue) {
        if (ArrayUtil.isEmpty(argValue)) {
            throw new EmptyArgumentException(argName, "ECL0011", asArray(argName));
        }
    }

    /**

                return b;
            }
            return Boolean.FALSE;
        } else if (type == byte.class) {
            final Byte b = ByteConversionUtil.toByte(o);
            if (b != null) {
                return b;
            }
            return Byte.valueOf((byte) 0);
        }
        return o;
    }

    /**
     * デリミタを削除します。
     *
     * @param value