commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ggreg...@apache.org
Subject svn commit: r1157231 [3/5] - in /commons/proper/codec/branches/generics: ./ src/java/org/apache/commons/codec/ src/java/org/apache/commons/codec/binary/ src/java/org/apache/commons/codec/language/ src/java/org/apache/commons/codec/language/bm/ src/java...
Date Fri, 12 Aug 2011 19:50:57 GMT
Added: commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/BinaryByteCodecTest.java
URL: http://svn.apache.org/viewvc/commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/BinaryByteCodecTest.java?rev=1157231&view=auto
==============================================================================
--- commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/BinaryByteCodecTest.java (added)
+++ commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/BinaryByteCodecTest.java Fri Aug 12 19:50:56 2011
@@ -0,0 +1,1166 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.codec.binary;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.UnsupportedEncodingException;
+
+import org.apache.commons.codec.DecoderException;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * TestCase for BinaryByteCodec class.
+ * 
+ * @author Apache Software Foundation
+ * @version $Id: BinaryCharCodecTest.java 1156841 2011-08-11 21:33:42Z ggregory $
+ */
+public class BinaryByteCodecTest {
+    /** mask with bit zero based index 0 raised */
+    private static final int BIT_0 = 0x01;
+
+    /** mask with bit zero based index 0 raised */
+    private static final int BIT_1 = 0x02;
+
+    /** mask with bit zero based index 0 raised */
+    private static final int BIT_2 = 0x04;
+
+    /** mask with bit zero based index 0 raised */
+    private static final int BIT_3 = 0x08;
+
+    /** mask with bit zero based index 0 raised */
+    private static final int BIT_4 = 0x10;
+
+    /** mask with bit zero based index 0 raised */
+    private static final int BIT_5 = 0x20;
+
+    /** mask with bit zero based index 0 raised */
+    private static final int BIT_6 = 0x40;
+
+    /** mask with bit zero based index 0 raised */
+    private static final int BIT_7 = 0x80;
+
+    /** an instance of the binary codec */
+    BinaryByteCodec instance = null;
+
+    @Before
+    public void setUp() throws Exception {
+        this.instance = new BinaryByteCodec();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        this.instance = null;
+    }
+
+    /**
+     * Tests for Object decode(Object)
+     */
+    @Test
+    public void testDecodeObject() throws Exception {
+        byte[] bits;
+        // With a single raw binary
+        bits = new byte[1];
+        assertDecodeObject(bits, "00000000");
+        bits = new byte[1];
+        bits[0] = BIT_0;
+        assertDecodeObject(bits, "00000001");
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1;
+        assertDecodeObject(bits, "00000011");
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2;
+        assertDecodeObject(bits, "00000111");
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        assertDecodeObject(bits, "00001111");
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        assertDecodeObject(bits, "00011111");
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        assertDecodeObject(bits, "00111111");
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        assertDecodeObject(bits, "01111111");
+        bits = new byte[1];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        assertDecodeObject(bits, "11111111");
+        // With a two raw binaries
+        bits = new byte[2];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        assertDecodeObject(bits, "0000000011111111");
+        bits = new byte[2];
+        bits[1] = BIT_0;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        assertDecodeObject(bits, "0000000111111111");
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        assertDecodeObject(bits, "0000001111111111");
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        assertDecodeObject(bits, "0000011111111111");
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        assertDecodeObject(bits, "0000111111111111");
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        assertDecodeObject(bits, "0001111111111111");
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        assertDecodeObject(bits, "0011111111111111");
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        assertDecodeObject(bits, "0111111111111111");
+        bits = new byte[2];
+        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        assertDecodeObject(bits, "1111111111111111");
+        assertDecodeObject(new byte[0], null);
+    }
+
+    // ------------------------------------------------------------------------
+    //
+    // Test decode(byte[])
+    //
+    // ------------------------------------------------------------------------
+    /**
+     * Utility used to assert the encoded and decoded values.
+     * 
+     * @param bits
+     *            the pre-encoded data
+     * @param encodeMe
+     *            data to encode and compare
+     */
+    void assertDecodeObject(byte[] bits, String encodeMe) throws DecoderException, UnsupportedEncodingException {
+        byte[] decoded;
+        decoded = instance.decode(encodeMe);
+        assertEquals(new String(bits), new String(decoded));
+        if (encodeMe == null) {
+            decoded = instance.decode((byte[]) null);
+        } else {
+            decoded = instance.decode(encodeMe.getBytes("UTF-8"));
+        }
+        assertEquals(new String(bits), new String(decoded));
+        if (encodeMe == null) {
+            decoded = instance.decode((char[]) null);
+        } else {
+            decoded = instance.decode(encodeMe.toCharArray());
+        }
+        assertEquals(new String(bits), new String(decoded));
+    }
+
+    /*
+     * Tests for byte[] decode(byte[])
+     */
+    @Test
+    public void testDecodeByteArray() throws UnsupportedEncodingException {
+        // With a single raw binary
+        byte[] bits = new byte[1];
+        byte[] decoded = instance.decode("00000000".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0;
+        decoded = instance.decode("00000001".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1;
+        decoded = instance.decode("00000011".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2;
+        decoded = instance.decode("00000111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        decoded = instance.decode("00001111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        decoded = instance.decode("00011111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        decoded = instance.decode("00111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        decoded = instance.decode("01111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.decode("11111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        // With a two raw binaries
+        bits = new byte[2];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.decode("0000000011111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.decode("0000000111111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.decode("0000001111111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.decode("0000011111111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.decode("0000111111111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.decode("0001111111111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.decode("0011111111111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.decode("0111111111111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.decode("1111111111111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+    }
+
+    // ------------------------------------------------------------------------
+    //
+    // Test toByteArray(String)
+    //
+    // ------------------------------------------------------------------------
+    /*
+     * Tests for byte[] toByteArray(String)
+     */
+    @Test
+    public void testToByteArrayFromString() {
+        // With a single raw binary
+        byte[] bits = new byte[1];
+        byte[] decoded = instance.toByteArray("00000000");
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0;
+        decoded = instance.toByteArray("00000001");
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1;
+        decoded = instance.toByteArray("00000011");
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2;
+        decoded = instance.toByteArray("00000111");
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        decoded = instance.toByteArray("00001111");
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        decoded = instance.toByteArray("00011111");
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        decoded = instance.toByteArray("00111111");
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        decoded = instance.toByteArray("01111111");
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.toByteArray("11111111");
+        assertEquals(new String(bits), new String(decoded));
+        // With a two raw binaries
+        bits = new byte[2];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.toByteArray("0000000011111111");
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.toByteArray("0000000111111111");
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.toByteArray("0000001111111111");
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.toByteArray("0000011111111111");
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.toByteArray("0000111111111111");
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.toByteArray("0001111111111111");
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.toByteArray("0011111111111111");
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.toByteArray("0111111111111111");
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = instance.toByteArray("1111111111111111");
+        assertEquals(new String(bits), new String(decoded));
+        assertEquals(0, instance.toByteArray((String) null).length);
+    }
+
+    // ------------------------------------------------------------------------
+    //
+    // Test fromAscii(char[])
+    //
+    // ------------------------------------------------------------------------
+    /*
+     * Tests for byte[] fromAscii(char[])
+     */
+    @Test
+    public void testFromAsciiCharArray() {
+        assertEquals(0, BinaryByteCodec.fromAscii((char[]) null).length);
+        assertEquals(0, BinaryByteCodec.fromAscii(new char[0]).length);
+        // With a single raw binary
+        byte[] bits = new byte[1];
+        byte[] decoded = BinaryByteCodec.fromAscii("00000000".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0;
+        decoded = BinaryByteCodec.fromAscii("00000001".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1;
+        decoded = BinaryByteCodec.fromAscii("00000011".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2;
+        decoded = BinaryByteCodec.fromAscii("00000111".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        decoded = BinaryByteCodec.fromAscii("00001111".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        decoded = BinaryByteCodec.fromAscii("00011111".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        decoded = BinaryByteCodec.fromAscii("00111111".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        decoded = BinaryByteCodec.fromAscii("01111111".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("11111111".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        // With a two raw binaries
+        bits = new byte[2];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("0000000011111111".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("0000000111111111".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("0000001111111111".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("0000011111111111".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("0000111111111111".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("0001111111111111".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("0011111111111111".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("0111111111111111".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("1111111111111111".toCharArray());
+        assertEquals(new String(bits), new String(decoded));
+        assertEquals(0, BinaryByteCodec.fromAscii((char[]) null).length);
+    }
+
+    // ------------------------------------------------------------------------
+    //
+    // Test fromAscii(byte[])
+    //
+    // ------------------------------------------------------------------------
+    /*
+     * Tests for byte[] fromAscii(byte[])
+     */
+    @Test
+    public void testFromAsciiByteArray() throws UnsupportedEncodingException {
+        assertEquals(0, BinaryByteCodec.fromAscii((byte[]) null).length);
+        assertEquals(0, BinaryByteCodec.fromAscii(new byte[0]).length);
+        // With a single raw binary
+        byte[] bits = new byte[1];
+        byte[] decoded = BinaryByteCodec.fromAscii("00000000".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0;
+        decoded = BinaryByteCodec.fromAscii("00000001".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1;
+        decoded = BinaryByteCodec.fromAscii("00000011".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2;
+        decoded = BinaryByteCodec.fromAscii("00000111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        decoded = BinaryByteCodec.fromAscii("00001111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        decoded = BinaryByteCodec.fromAscii("00011111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        decoded = BinaryByteCodec.fromAscii("00111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        decoded = BinaryByteCodec.fromAscii("01111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[1];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("11111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        // With a two raw binaries
+        bits = new byte[2];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("0000000011111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("0000000111111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("0000001111111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("0000011111111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("0000111111111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("0001111111111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("0011111111111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("0111111111111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        bits = new byte[2];
+        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        decoded = BinaryByteCodec.fromAscii("1111111111111111".getBytes("UTF-8"));
+        assertEquals(new String(bits), new String(decoded));
+        assertEquals(0, BinaryByteCodec.fromAscii((byte[]) null).length);
+    }
+
+    // ------------------------------------------------------------------------
+    //
+    // Test encode(byte[])
+    //
+    // ------------------------------------------------------------------------
+    /*
+     * Tests for byte[] encode(byte[])
+     */
+    @Test
+    public void testEncodeByteArray() {
+        // With a single raw binary
+        byte[] bits = new byte[1];
+        String l_encoded = new String(instance.encode(bits));
+        assertEquals("00000000", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("00000001", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("00000011", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("00000111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("00001111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("00011111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("00111111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("01111111", l_encoded);
+        bits = new byte[1];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("11111111", l_encoded);
+        // With a two raw binaries
+        bits = new byte[2];
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000000000000", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000000000001", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000000000011", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000000000111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000000001111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000000011111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000000111111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000001111111", l_encoded);
+        bits = new byte[2];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000011111111", l_encoded);
+        // work on the other byte now
+        bits = new byte[2];
+        bits[1] = BIT_0;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000001111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000011111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000111111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0001111111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0011111111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0111111111111111", l_encoded);
+        bits = new byte[2];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("1111111111111111", l_encoded);
+        assertEquals(0, instance.encode((byte[]) null).length);
+    }
+
+    // ------------------------------------------------------------------------
+    //
+    // Test toAsciiBytes
+    //
+    // ------------------------------------------------------------------------
+    @Test
+    public void testToAsciiBytes() {
+        // With a single raw binary
+        byte[] bits = new byte[1];
+        String l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("00000000", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0;
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("00000001", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1;
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("00000011", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2;
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("00000111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("00001111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("00011111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("00111111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("01111111", l_encoded);
+        bits = new byte[1];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("11111111", l_encoded);
+        // With a two raw binaries
+        bits = new byte[2];
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("0000000000000000", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0;
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("0000000000000001", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1;
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("0000000000000011", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2;
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("0000000000000111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("0000000000001111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("0000000000011111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("0000000000111111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("0000000001111111", l_encoded);
+        bits = new byte[2];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("0000000011111111", l_encoded);
+        // work on the other byte now
+        bits = new byte[2];
+        bits[1] = BIT_0;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("0000000111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("0000001111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("0000011111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("0000111111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("0001111111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("0011111111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("0111111111111111", l_encoded);
+        bits = new byte[2];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+        assertEquals("1111111111111111", l_encoded);
+        assertEquals(0, BinaryByteCodec.toAsciiBytes((byte[]) null).length);
+    }
+
+    // ------------------------------------------------------------------------
+    //
+    // Test toAsciiChars
+    //
+    // ------------------------------------------------------------------------
+    @Test
+    public void testToAsciiChars() {
+        // With a single raw binary
+        byte[] bits = new byte[1];
+        String l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("00000000", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0;
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("00000001", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1;
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("00000011", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2;
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("00000111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("00001111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("00011111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("00111111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("01111111", l_encoded);
+        bits = new byte[1];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("11111111", l_encoded);
+        // With a two raw binaries
+        bits = new byte[2];
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("0000000000000000", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0;
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("0000000000000001", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1;
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("0000000000000011", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2;
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("0000000000000111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("0000000000001111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("0000000000011111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("0000000000111111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("0000000001111111", l_encoded);
+        bits = new byte[2];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("0000000011111111", l_encoded);
+        // work on the other byte now
+        bits = new byte[2];
+        bits[1] = BIT_0;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("0000000111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("0000001111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("0000011111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("0000111111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("0001111111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("0011111111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("0111111111111111", l_encoded);
+        bits = new byte[2];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+        assertEquals("1111111111111111", l_encoded);
+        assertEquals(0, BinaryByteCodec.toAsciiChars((byte[]) null).length);
+    }
+
+    // ------------------------------------------------------------------------
+    //
+    // Test toAsciiString
+    //
+    // ------------------------------------------------------------------------
+    /**
+     * Tests the toAsciiString(byte[]) method
+     */
+    @Test
+    public void testToAsciiString() {
+        // With a single raw binary
+        byte[] bits = new byte[1];
+        String l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("00000000", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0;
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("00000001", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1;
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("00000011", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2;
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("00000111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("00001111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("00011111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("00111111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("01111111", l_encoded);
+        bits = new byte[1];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("11111111", l_encoded);
+        // With a two raw binaries
+        bits = new byte[2];
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("0000000000000000", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0;
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("0000000000000001", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1;
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("0000000000000011", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2;
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("0000000000000111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("0000000000001111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("0000000000011111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("0000000000111111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("0000000001111111", l_encoded);
+        bits = new byte[2];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("0000000011111111", l_encoded);
+        // work on the other byte now
+        bits = new byte[2];
+        bits[1] = BIT_0;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("0000000111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("0000001111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("0000011111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("0000111111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("0001111111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("0011111111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("0111111111111111", l_encoded);
+        bits = new byte[2];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = BinaryByteCodec.toAsciiString(bits);
+        assertEquals("1111111111111111", l_encoded);
+    }
+
+    /*
+     * Tests for Object encode(Object)
+     */
+    @Test
+    public void testEncodeObject() throws Exception {
+        // With a single raw binary
+        byte[] bits = new byte[1];
+        String l_encoded = new String(instance.encode(bits));
+        assertEquals("00000000", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("00000001", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("00000011", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("00000111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("00001111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("00011111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("00111111", l_encoded);
+        bits = new byte[1];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("01111111", l_encoded);
+        bits = new byte[1];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("11111111", l_encoded);
+        // With a two raw binaries
+        bits = new byte[2];
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000000000000", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000000000001", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000000000011", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000000000111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000000001111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000000011111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000000111111", l_encoded);
+        bits = new byte[2];
+        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000001111111", l_encoded);
+        bits = new byte[2];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000011111111", l_encoded);
+        // work on the other byte now
+        bits = new byte[2];
+        bits[1] = BIT_0;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000000111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000001111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000011111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0000111111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0001111111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0011111111111111", l_encoded);
+        bits = new byte[2];
+        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("0111111111111111", l_encoded);
+        bits = new byte[2];
+        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
+        l_encoded = new String(instance.encode(bits));
+        assertEquals("1111111111111111", l_encoded);
+    }
+}



Mime
View raw message