001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018package org.apache.commons.codec.binary;
019
020import static org.junit.Assert.assertEquals;
021import static org.junit.Assert.fail;
022
023import org.apache.commons.codec.Charsets;
024import org.apache.commons.codec.DecoderException;
025import org.apache.commons.codec.EncoderException;
026import org.junit.After;
027import org.junit.Before;
028import org.junit.Test;
029
030/**
031 * TestCase for BinaryCodec class.
032 *
033 * @version $Id: BinaryCodecTest.html 891688 2013-12-24 20:49:46Z ggregory $
034 */
035public class BinaryCodecTest {
036    /** mask with bit zero based index 0 raised */
037    private static final int BIT_0 = 0x01;
038
039    /** mask with bit zero based index 0 raised */
040    private static final int BIT_1 = 0x02;
041
042    /** mask with bit zero based index 0 raised */
043    private static final int BIT_2 = 0x04;
044
045    /** mask with bit zero based index 0 raised */
046    private static final int BIT_3 = 0x08;
047
048    /** mask with bit zero based index 0 raised */
049    private static final int BIT_4 = 0x10;
050
051    /** mask with bit zero based index 0 raised */
052    private static final int BIT_5 = 0x20;
053
054    /** mask with bit zero based index 0 raised */
055    private static final int BIT_6 = 0x40;
056
057    /** mask with bit zero based index 0 raised */
058    private static final int BIT_7 = 0x80;
059
060    /** an instance of the binary codec */
061    BinaryCodec instance = null;
062
063    @Before
064    public void setUp() throws Exception {
065        this.instance = new BinaryCodec();
066    }
067
068    @After
069    public void tearDown() throws Exception {
070        this.instance = null;
071    }
072
073    // ------------------------------------------------------------------------
074    //
075    // Test decode(Object)
076    //
077    // ------------------------------------------------------------------------
078    /**
079     * Tests for Object decode(Object)
080     */
081    @Test
082    public void testDecodeObjectException() {
083        try {
084            this.instance.decode(new Object());
085        } catch (final DecoderException e) {
086            // all is well.
087            return;
088        }
089        fail("Expected DecoderException");
090    }
091
092    /**
093     * Tests for Object decode(Object)
094     */
095    @Test
096    public void testDecodeObject() throws Exception {
097        byte[] bits;
098        // With a single raw binary
099        bits = new byte[1];
100        assertDecodeObject(bits, "00000000");
101        bits = new byte[1];
102        bits[0] = BIT_0;
103        assertDecodeObject(bits, "00000001");
104        bits = new byte[1];
105        bits[0] = BIT_0 | BIT_1;
106        assertDecodeObject(bits, "00000011");
107        bits = new byte[1];
108        bits[0] = BIT_0 | BIT_1 | BIT_2;
109        assertDecodeObject(bits, "00000111");
110        bits = new byte[1];
111        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
112        assertDecodeObject(bits, "00001111");
113        bits = new byte[1];
114        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
115        assertDecodeObject(bits, "00011111");
116        bits = new byte[1];
117        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
118        assertDecodeObject(bits, "00111111");
119        bits = new byte[1];
120        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
121        assertDecodeObject(bits, "01111111");
122        bits = new byte[1];
123        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
124        assertDecodeObject(bits, "11111111");
125        // With a two raw binaries
126        bits = new byte[2];
127        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
128        assertDecodeObject(bits, "0000000011111111");
129        bits = new byte[2];
130        bits[1] = BIT_0;
131        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
132        assertDecodeObject(bits, "0000000111111111");
133        bits = new byte[2];
134        bits[1] = BIT_0 | BIT_1;
135        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
136        assertDecodeObject(bits, "0000001111111111");
137        bits = new byte[2];
138        bits[1] = BIT_0 | BIT_1 | BIT_2;
139        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
140        assertDecodeObject(bits, "0000011111111111");
141        bits = new byte[2];
142        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
143        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
144        assertDecodeObject(bits, "0000111111111111");
145        bits = new byte[2];
146        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
147        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
148        assertDecodeObject(bits, "0001111111111111");
149        bits = new byte[2];
150        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
151        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
152        assertDecodeObject(bits, "0011111111111111");
153        bits = new byte[2];
154        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
155        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
156        assertDecodeObject(bits, "0111111111111111");
157        bits = new byte[2];
158        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
159        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
160        assertDecodeObject(bits, "1111111111111111");
161        assertDecodeObject(new byte[0], null);
162    }
163
164    // ------------------------------------------------------------------------
165    //
166    // Test decode(byte[])
167    //
168    // ------------------------------------------------------------------------
169    /**
170     * Utility used to assert the encoded and decoded values.
171     *
172     * @param bits
173     *            the pre-encoded data
174     * @param encodeMe
175     *            data to encode and compare
176     */
177    void assertDecodeObject(final byte[] bits, final String encodeMe) throws DecoderException {
178        byte[] decoded;
179        decoded = (byte[]) instance.decode(encodeMe);
180        assertEquals(new String(bits), new String(decoded));
181        if (encodeMe == null) {
182            decoded = instance.decode((byte[]) null);
183        } else {
184            decoded = (byte[]) instance.decode((Object) encodeMe.getBytes(Charsets.UTF_8));
185        }
186        assertEquals(new String(bits), new String(decoded));
187        if (encodeMe == null) {
188            decoded = (byte[]) instance.decode((char[]) null);
189        } else {
190            decoded = (byte[]) instance.decode(encodeMe.toCharArray());
191        }
192        assertEquals(new String(bits), new String(decoded));
193    }
194
195    /*
196     * Tests for byte[] decode(byte[])
197     */
198    @Test
199    public void testDecodeByteArray() {
200        // With a single raw binary
201        byte[] bits = new byte[1];
202        byte[] decoded = instance.decode("00000000".getBytes(Charsets.UTF_8));
203        assertEquals(new String(bits), new String(decoded));
204        bits = new byte[1];
205        bits[0] = BIT_0;
206        decoded = instance.decode("00000001".getBytes(Charsets.UTF_8));
207        assertEquals(new String(bits), new String(decoded));
208        bits = new byte[1];
209        bits[0] = BIT_0 | BIT_1;
210        decoded = instance.decode("00000011".getBytes(Charsets.UTF_8));
211        assertEquals(new String(bits), new String(decoded));
212        bits = new byte[1];
213        bits[0] = BIT_0 | BIT_1 | BIT_2;
214        decoded = instance.decode("00000111".getBytes(Charsets.UTF_8));
215        assertEquals(new String(bits), new String(decoded));
216        bits = new byte[1];
217        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
218        decoded = instance.decode("00001111".getBytes(Charsets.UTF_8));
219        assertEquals(new String(bits), new String(decoded));
220        bits = new byte[1];
221        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
222        decoded = instance.decode("00011111".getBytes(Charsets.UTF_8));
223        assertEquals(new String(bits), new String(decoded));
224        bits = new byte[1];
225        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
226        decoded = instance.decode("00111111".getBytes(Charsets.UTF_8));
227        assertEquals(new String(bits), new String(decoded));
228        bits = new byte[1];
229        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
230        decoded = instance.decode("01111111".getBytes(Charsets.UTF_8));
231        assertEquals(new String(bits), new String(decoded));
232        bits = new byte[1];
233        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
234        decoded = instance.decode("11111111".getBytes(Charsets.UTF_8));
235        assertEquals(new String(bits), new String(decoded));
236        // With a two raw binaries
237        bits = new byte[2];
238        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
239        decoded = instance.decode("0000000011111111".getBytes(Charsets.UTF_8));
240        assertEquals(new String(bits), new String(decoded));
241        bits = new byte[2];
242        bits[1] = BIT_0;
243        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
244        decoded = instance.decode("0000000111111111".getBytes(Charsets.UTF_8));
245        assertEquals(new String(bits), new String(decoded));
246        bits = new byte[2];
247        bits[1] = BIT_0 | BIT_1;
248        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
249        decoded = instance.decode("0000001111111111".getBytes(Charsets.UTF_8));
250        assertEquals(new String(bits), new String(decoded));
251        bits = new byte[2];
252        bits[1] = BIT_0 | BIT_1 | BIT_2;
253        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
254        decoded = instance.decode("0000011111111111".getBytes(Charsets.UTF_8));
255        assertEquals(new String(bits), new String(decoded));
256        bits = new byte[2];
257        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
258        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
259        decoded = instance.decode("0000111111111111".getBytes(Charsets.UTF_8));
260        assertEquals(new String(bits), new String(decoded));
261        bits = new byte[2];
262        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
263        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
264        decoded = instance.decode("0001111111111111".getBytes(Charsets.UTF_8));
265        assertEquals(new String(bits), new String(decoded));
266        bits = new byte[2];
267        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
268        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
269        decoded = instance.decode("0011111111111111".getBytes(Charsets.UTF_8));
270        assertEquals(new String(bits), new String(decoded));
271        bits = new byte[2];
272        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
273        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
274        decoded = instance.decode("0111111111111111".getBytes(Charsets.UTF_8));
275        assertEquals(new String(bits), new String(decoded));
276        bits = new byte[2];
277        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
278        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
279        decoded = instance.decode("1111111111111111".getBytes(Charsets.UTF_8));
280        assertEquals(new String(bits), new String(decoded));
281    }
282
283    // ------------------------------------------------------------------------
284    //
285    // Test toByteArray(String)
286    //
287    // ------------------------------------------------------------------------
288    /*
289     * Tests for byte[] toByteArray(String)
290     */
291    @Test
292    public void testToByteArrayFromString() {
293        // With a single raw binary
294        byte[] bits = new byte[1];
295        byte[] decoded = instance.toByteArray("00000000");
296        assertEquals(new String(bits), new String(decoded));
297        bits = new byte[1];
298        bits[0] = BIT_0;
299        decoded = instance.toByteArray("00000001");
300        assertEquals(new String(bits), new String(decoded));
301        bits = new byte[1];
302        bits[0] = BIT_0 | BIT_1;
303        decoded = instance.toByteArray("00000011");
304        assertEquals(new String(bits), new String(decoded));
305        bits = new byte[1];
306        bits[0] = BIT_0 | BIT_1 | BIT_2;
307        decoded = instance.toByteArray("00000111");
308        assertEquals(new String(bits), new String(decoded));
309        bits = new byte[1];
310        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
311        decoded = instance.toByteArray("00001111");
312        assertEquals(new String(bits), new String(decoded));
313        bits = new byte[1];
314        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
315        decoded = instance.toByteArray("00011111");
316        assertEquals(new String(bits), new String(decoded));
317        bits = new byte[1];
318        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
319        decoded = instance.toByteArray("00111111");
320        assertEquals(new String(bits), new String(decoded));
321        bits = new byte[1];
322        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
323        decoded = instance.toByteArray("01111111");
324        assertEquals(new String(bits), new String(decoded));
325        bits = new byte[1];
326        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
327        decoded = instance.toByteArray("11111111");
328        assertEquals(new String(bits), new String(decoded));
329        // With a two raw binaries
330        bits = new byte[2];
331        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
332        decoded = instance.toByteArray("0000000011111111");
333        assertEquals(new String(bits), new String(decoded));
334        bits = new byte[2];
335        bits[1] = BIT_0;
336        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
337        decoded = instance.toByteArray("0000000111111111");
338        assertEquals(new String(bits), new String(decoded));
339        bits = new byte[2];
340        bits[1] = BIT_0 | BIT_1;
341        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
342        decoded = instance.toByteArray("0000001111111111");
343        assertEquals(new String(bits), new String(decoded));
344        bits = new byte[2];
345        bits[1] = BIT_0 | BIT_1 | BIT_2;
346        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
347        decoded = instance.toByteArray("0000011111111111");
348        assertEquals(new String(bits), new String(decoded));
349        bits = new byte[2];
350        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
351        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
352        decoded = instance.toByteArray("0000111111111111");
353        assertEquals(new String(bits), new String(decoded));
354        bits = new byte[2];
355        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
356        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
357        decoded = instance.toByteArray("0001111111111111");
358        assertEquals(new String(bits), new String(decoded));
359        bits = new byte[2];
360        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
361        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
362        decoded = instance.toByteArray("0011111111111111");
363        assertEquals(new String(bits), new String(decoded));
364        bits = new byte[2];
365        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
366        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
367        decoded = instance.toByteArray("0111111111111111");
368        assertEquals(new String(bits), new String(decoded));
369        bits = new byte[2];
370        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
371        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
372        decoded = instance.toByteArray("1111111111111111");
373        assertEquals(new String(bits), new String(decoded));
374        assertEquals(0, instance.toByteArray((String) null).length);
375    }
376
377    // ------------------------------------------------------------------------
378    //
379    // Test fromAscii(char[])
380    //
381    // ------------------------------------------------------------------------
382    /*
383     * Tests for byte[] fromAscii(char[])
384     */
385    @Test
386    public void testFromAsciiCharArray() {
387        assertEquals(0, BinaryCodec.fromAscii((char[]) null).length);
388        assertEquals(0, BinaryCodec.fromAscii(new char[0]).length);
389        // With a single raw binary
390        byte[] bits = new byte[1];
391        byte[] decoded = BinaryCodec.fromAscii("00000000".toCharArray());
392        assertEquals(new String(bits), new String(decoded));
393        bits = new byte[1];
394        bits[0] = BIT_0;
395        decoded = BinaryCodec.fromAscii("00000001".toCharArray());
396        assertEquals(new String(bits), new String(decoded));
397        bits = new byte[1];
398        bits[0] = BIT_0 | BIT_1;
399        decoded = BinaryCodec.fromAscii("00000011".toCharArray());
400        assertEquals(new String(bits), new String(decoded));
401        bits = new byte[1];
402        bits[0] = BIT_0 | BIT_1 | BIT_2;
403        decoded = BinaryCodec.fromAscii("00000111".toCharArray());
404        assertEquals(new String(bits), new String(decoded));
405        bits = new byte[1];
406        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
407        decoded = BinaryCodec.fromAscii("00001111".toCharArray());
408        assertEquals(new String(bits), new String(decoded));
409        bits = new byte[1];
410        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
411        decoded = BinaryCodec.fromAscii("00011111".toCharArray());
412        assertEquals(new String(bits), new String(decoded));
413        bits = new byte[1];
414        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
415        decoded = BinaryCodec.fromAscii("00111111".toCharArray());
416        assertEquals(new String(bits), new String(decoded));
417        bits = new byte[1];
418        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
419        decoded = BinaryCodec.fromAscii("01111111".toCharArray());
420        assertEquals(new String(bits), new String(decoded));
421        bits = new byte[1];
422        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
423        decoded = BinaryCodec.fromAscii("11111111".toCharArray());
424        assertEquals(new String(bits), new String(decoded));
425        // With a two raw binaries
426        bits = new byte[2];
427        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
428        decoded = BinaryCodec.fromAscii("0000000011111111".toCharArray());
429        assertEquals(new String(bits), new String(decoded));
430        bits = new byte[2];
431        bits[1] = BIT_0;
432        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
433        decoded = BinaryCodec.fromAscii("0000000111111111".toCharArray());
434        assertEquals(new String(bits), new String(decoded));
435        bits = new byte[2];
436        bits[1] = BIT_0 | BIT_1;
437        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
438        decoded = BinaryCodec.fromAscii("0000001111111111".toCharArray());
439        assertEquals(new String(bits), new String(decoded));
440        bits = new byte[2];
441        bits[1] = BIT_0 | BIT_1 | BIT_2;
442        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
443        decoded = BinaryCodec.fromAscii("0000011111111111".toCharArray());
444        assertEquals(new String(bits), new String(decoded));
445        bits = new byte[2];
446        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
447        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
448        decoded = BinaryCodec.fromAscii("0000111111111111".toCharArray());
449        assertEquals(new String(bits), new String(decoded));
450        bits = new byte[2];
451        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
452        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
453        decoded = BinaryCodec.fromAscii("0001111111111111".toCharArray());
454        assertEquals(new String(bits), new String(decoded));
455        bits = new byte[2];
456        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
457        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
458        decoded = BinaryCodec.fromAscii("0011111111111111".toCharArray());
459        assertEquals(new String(bits), new String(decoded));
460        bits = new byte[2];
461        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
462        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
463        decoded = BinaryCodec.fromAscii("0111111111111111".toCharArray());
464        assertEquals(new String(bits), new String(decoded));
465        bits = new byte[2];
466        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
467        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
468        decoded = BinaryCodec.fromAscii("1111111111111111".toCharArray());
469        assertEquals(new String(bits), new String(decoded));
470        assertEquals(0, BinaryCodec.fromAscii((char[]) null).length);
471    }
472
473    // ------------------------------------------------------------------------
474    //
475    // Test fromAscii(byte[])
476    //
477    // ------------------------------------------------------------------------
478    /*
479     * Tests for byte[] fromAscii(byte[])
480     */
481    @Test
482    public void testFromAsciiByteArray() {
483        assertEquals(0, BinaryCodec.fromAscii((byte[]) null).length);
484        assertEquals(0, BinaryCodec.fromAscii(new byte[0]).length);
485        // With a single raw binary
486        byte[] bits = new byte[1];
487        byte[] decoded = BinaryCodec.fromAscii("00000000".getBytes(Charsets.UTF_8));
488        assertEquals(new String(bits), new String(decoded));
489        bits = new byte[1];
490        bits[0] = BIT_0;
491        decoded = BinaryCodec.fromAscii("00000001".getBytes(Charsets.UTF_8));
492        assertEquals(new String(bits), new String(decoded));
493        bits = new byte[1];
494        bits[0] = BIT_0 | BIT_1;
495        decoded = BinaryCodec.fromAscii("00000011".getBytes(Charsets.UTF_8));
496        assertEquals(new String(bits), new String(decoded));
497        bits = new byte[1];
498        bits[0] = BIT_0 | BIT_1 | BIT_2;
499        decoded = BinaryCodec.fromAscii("00000111".getBytes(Charsets.UTF_8));
500        assertEquals(new String(bits), new String(decoded));
501        bits = new byte[1];
502        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
503        decoded = BinaryCodec.fromAscii("00001111".getBytes(Charsets.UTF_8));
504        assertEquals(new String(bits), new String(decoded));
505        bits = new byte[1];
506        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
507        decoded = BinaryCodec.fromAscii("00011111".getBytes(Charsets.UTF_8));
508        assertEquals(new String(bits), new String(decoded));
509        bits = new byte[1];
510        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
511        decoded = BinaryCodec.fromAscii("00111111".getBytes(Charsets.UTF_8));
512        assertEquals(new String(bits), new String(decoded));
513        bits = new byte[1];
514        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
515        decoded = BinaryCodec.fromAscii("01111111".getBytes(Charsets.UTF_8));
516        assertEquals(new String(bits), new String(decoded));
517        bits = new byte[1];
518        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
519        decoded = BinaryCodec.fromAscii("11111111".getBytes(Charsets.UTF_8));
520        assertEquals(new String(bits), new String(decoded));
521        // With a two raw binaries
522        bits = new byte[2];
523        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
524        decoded = BinaryCodec.fromAscii("0000000011111111".getBytes(Charsets.UTF_8));
525        assertEquals(new String(bits), new String(decoded));
526        bits = new byte[2];
527        bits[1] = BIT_0;
528        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
529        decoded = BinaryCodec.fromAscii("0000000111111111".getBytes(Charsets.UTF_8));
530        assertEquals(new String(bits), new String(decoded));
531        bits = new byte[2];
532        bits[1] = BIT_0 | BIT_1;
533        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
534        decoded = BinaryCodec.fromAscii("0000001111111111".getBytes(Charsets.UTF_8));
535        assertEquals(new String(bits), new String(decoded));
536        bits = new byte[2];
537        bits[1] = BIT_0 | BIT_1 | BIT_2;
538        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
539        decoded = BinaryCodec.fromAscii("0000011111111111".getBytes(Charsets.UTF_8));
540        assertEquals(new String(bits), new String(decoded));
541        bits = new byte[2];
542        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
543        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
544        decoded = BinaryCodec.fromAscii("0000111111111111".getBytes(Charsets.UTF_8));
545        assertEquals(new String(bits), new String(decoded));
546        bits = new byte[2];
547        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
548        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
549        decoded = BinaryCodec.fromAscii("0001111111111111".getBytes(Charsets.UTF_8));
550        assertEquals(new String(bits), new String(decoded));
551        bits = new byte[2];
552        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
553        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
554        decoded = BinaryCodec.fromAscii("0011111111111111".getBytes(Charsets.UTF_8));
555        assertEquals(new String(bits), new String(decoded));
556        bits = new byte[2];
557        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
558        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
559        decoded = BinaryCodec.fromAscii("0111111111111111".getBytes(Charsets.UTF_8));
560        assertEquals(new String(bits), new String(decoded));
561        bits = new byte[2];
562        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
563        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
564        decoded = BinaryCodec.fromAscii("1111111111111111".getBytes(Charsets.UTF_8));
565        assertEquals(new String(bits), new String(decoded));
566        assertEquals(0, BinaryCodec.fromAscii((byte[]) null).length);
567    }
568
569    // ------------------------------------------------------------------------
570    //
571    // Test encode(byte[])
572    //
573    // ------------------------------------------------------------------------
574    /*
575     * Tests for byte[] encode(byte[])
576     */
577    @Test
578    public void testEncodeByteArray() {
579        // With a single raw binary
580        byte[] bits = new byte[1];
581        String l_encoded = new String(instance.encode(bits));
582        assertEquals("00000000", l_encoded);
583        bits = new byte[1];
584        bits[0] = BIT_0;
585        l_encoded = new String(instance.encode(bits));
586        assertEquals("00000001", l_encoded);
587        bits = new byte[1];
588        bits[0] = BIT_0 | BIT_1;
589        l_encoded = new String(instance.encode(bits));
590        assertEquals("00000011", l_encoded);
591        bits = new byte[1];
592        bits[0] = BIT_0 | BIT_1 | BIT_2;
593        l_encoded = new String(instance.encode(bits));
594        assertEquals("00000111", l_encoded);
595        bits = new byte[1];
596        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
597        l_encoded = new String(instance.encode(bits));
598        assertEquals("00001111", l_encoded);
599        bits = new byte[1];
600        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
601        l_encoded = new String(instance.encode(bits));
602        assertEquals("00011111", l_encoded);
603        bits = new byte[1];
604        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
605        l_encoded = new String(instance.encode(bits));
606        assertEquals("00111111", l_encoded);
607        bits = new byte[1];
608        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
609        l_encoded = new String(instance.encode(bits));
610        assertEquals("01111111", l_encoded);
611        bits = new byte[1];
612        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
613        l_encoded = new String(instance.encode(bits));
614        assertEquals("11111111", l_encoded);
615        // With a two raw binaries
616        bits = new byte[2];
617        l_encoded = new String(instance.encode(bits));
618        assertEquals("0000000000000000", l_encoded);
619        bits = new byte[2];
620        bits[0] = BIT_0;
621        l_encoded = new String(instance.encode(bits));
622        assertEquals("0000000000000001", l_encoded);
623        bits = new byte[2];
624        bits[0] = BIT_0 | BIT_1;
625        l_encoded = new String(instance.encode(bits));
626        assertEquals("0000000000000011", l_encoded);
627        bits = new byte[2];
628        bits[0] = BIT_0 | BIT_1 | BIT_2;
629        l_encoded = new String(instance.encode(bits));
630        assertEquals("0000000000000111", l_encoded);
631        bits = new byte[2];
632        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
633        l_encoded = new String(instance.encode(bits));
634        assertEquals("0000000000001111", l_encoded);
635        bits = new byte[2];
636        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
637        l_encoded = new String(instance.encode(bits));
638        assertEquals("0000000000011111", l_encoded);
639        bits = new byte[2];
640        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
641        l_encoded = new String(instance.encode(bits));
642        assertEquals("0000000000111111", l_encoded);
643        bits = new byte[2];
644        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
645        l_encoded = new String(instance.encode(bits));
646        assertEquals("0000000001111111", l_encoded);
647        bits = new byte[2];
648        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
649        l_encoded = new String(instance.encode(bits));
650        assertEquals("0000000011111111", l_encoded);
651        // work on the other byte now
652        bits = new byte[2];
653        bits[1] = BIT_0;
654        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
655        l_encoded = new String(instance.encode(bits));
656        assertEquals("0000000111111111", l_encoded);
657        bits = new byte[2];
658        bits[1] = BIT_0 | BIT_1;
659        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
660        l_encoded = new String(instance.encode(bits));
661        assertEquals("0000001111111111", l_encoded);
662        bits = new byte[2];
663        bits[1] = BIT_0 | BIT_1 | BIT_2;
664        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
665        l_encoded = new String(instance.encode(bits));
666        assertEquals("0000011111111111", l_encoded);
667        bits = new byte[2];
668        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
669        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
670        l_encoded = new String(instance.encode(bits));
671        assertEquals("0000111111111111", l_encoded);
672        bits = new byte[2];
673        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
674        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
675        l_encoded = new String(instance.encode(bits));
676        assertEquals("0001111111111111", l_encoded);
677        bits = new byte[2];
678        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
679        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
680        l_encoded = new String(instance.encode(bits));
681        assertEquals("0011111111111111", l_encoded);
682        bits = new byte[2];
683        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
684        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
685        l_encoded = new String(instance.encode(bits));
686        assertEquals("0111111111111111", l_encoded);
687        bits = new byte[2];
688        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
689        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
690        l_encoded = new String(instance.encode(bits));
691        assertEquals("1111111111111111", l_encoded);
692        assertEquals(0, instance.encode((byte[]) null).length);
693    }
694
695    // ------------------------------------------------------------------------
696    //
697    // Test toAsciiBytes
698    //
699    // ------------------------------------------------------------------------
700    @Test
701    public void testToAsciiBytes() {
702        // With a single raw binary
703        byte[] bits = new byte[1];
704        String l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
705        assertEquals("00000000", l_encoded);
706        bits = new byte[1];
707        bits[0] = BIT_0;
708        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
709        assertEquals("00000001", l_encoded);
710        bits = new byte[1];
711        bits[0] = BIT_0 | BIT_1;
712        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
713        assertEquals("00000011", l_encoded);
714        bits = new byte[1];
715        bits[0] = BIT_0 | BIT_1 | BIT_2;
716        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
717        assertEquals("00000111", l_encoded);
718        bits = new byte[1];
719        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
720        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
721        assertEquals("00001111", l_encoded);
722        bits = new byte[1];
723        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
724        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
725        assertEquals("00011111", l_encoded);
726        bits = new byte[1];
727        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
728        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
729        assertEquals("00111111", l_encoded);
730        bits = new byte[1];
731        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
732        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
733        assertEquals("01111111", l_encoded);
734        bits = new byte[1];
735        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
736        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
737        assertEquals("11111111", l_encoded);
738        // With a two raw binaries
739        bits = new byte[2];
740        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
741        assertEquals("0000000000000000", l_encoded);
742        bits = new byte[2];
743        bits[0] = BIT_0;
744        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
745        assertEquals("0000000000000001", l_encoded);
746        bits = new byte[2];
747        bits[0] = BIT_0 | BIT_1;
748        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
749        assertEquals("0000000000000011", l_encoded);
750        bits = new byte[2];
751        bits[0] = BIT_0 | BIT_1 | BIT_2;
752        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
753        assertEquals("0000000000000111", l_encoded);
754        bits = new byte[2];
755        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
756        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
757        assertEquals("0000000000001111", l_encoded);
758        bits = new byte[2];
759        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
760        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
761        assertEquals("0000000000011111", l_encoded);
762        bits = new byte[2];
763        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
764        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
765        assertEquals("0000000000111111", l_encoded);
766        bits = new byte[2];
767        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
768        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
769        assertEquals("0000000001111111", l_encoded);
770        bits = new byte[2];
771        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
772        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
773        assertEquals("0000000011111111", l_encoded);
774        // work on the other byte now
775        bits = new byte[2];
776        bits[1] = BIT_0;
777        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
778        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
779        assertEquals("0000000111111111", l_encoded);
780        bits = new byte[2];
781        bits[1] = BIT_0 | BIT_1;
782        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
783        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
784        assertEquals("0000001111111111", l_encoded);
785        bits = new byte[2];
786        bits[1] = BIT_0 | BIT_1 | BIT_2;
787        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
788        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
789        assertEquals("0000011111111111", l_encoded);
790        bits = new byte[2];
791        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
792        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
793        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
794        assertEquals("0000111111111111", l_encoded);
795        bits = new byte[2];
796        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
797        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
798        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
799        assertEquals("0001111111111111", l_encoded);
800        bits = new byte[2];
801        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
802        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
803        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
804        assertEquals("0011111111111111", l_encoded);
805        bits = new byte[2];
806        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
807        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
808        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
809        assertEquals("0111111111111111", l_encoded);
810        bits = new byte[2];
811        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
812        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
813        l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
814        assertEquals("1111111111111111", l_encoded);
815        assertEquals(0, BinaryCodec.toAsciiBytes((byte[]) null).length);
816    }
817
818    // ------------------------------------------------------------------------
819    //
820    // Test toAsciiChars
821    //
822    // ------------------------------------------------------------------------
823    @Test
824    public void testToAsciiChars() {
825        // With a single raw binary
826        byte[] bits = new byte[1];
827        String l_encoded = new String(BinaryCodec.toAsciiChars(bits));
828        assertEquals("00000000", l_encoded);
829        bits = new byte[1];
830        bits[0] = BIT_0;
831        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
832        assertEquals("00000001", l_encoded);
833        bits = new byte[1];
834        bits[0] = BIT_0 | BIT_1;
835        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
836        assertEquals("00000011", l_encoded);
837        bits = new byte[1];
838        bits[0] = BIT_0 | BIT_1 | BIT_2;
839        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
840        assertEquals("00000111", l_encoded);
841        bits = new byte[1];
842        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
843        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
844        assertEquals("00001111", l_encoded);
845        bits = new byte[1];
846        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
847        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
848        assertEquals("00011111", l_encoded);
849        bits = new byte[1];
850        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
851        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
852        assertEquals("00111111", l_encoded);
853        bits = new byte[1];
854        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
855        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
856        assertEquals("01111111", l_encoded);
857        bits = new byte[1];
858        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
859        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
860        assertEquals("11111111", l_encoded);
861        // With a two raw binaries
862        bits = new byte[2];
863        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
864        assertEquals("0000000000000000", l_encoded);
865        bits = new byte[2];
866        bits[0] = BIT_0;
867        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
868        assertEquals("0000000000000001", l_encoded);
869        bits = new byte[2];
870        bits[0] = BIT_0 | BIT_1;
871        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
872        assertEquals("0000000000000011", l_encoded);
873        bits = new byte[2];
874        bits[0] = BIT_0 | BIT_1 | BIT_2;
875        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
876        assertEquals("0000000000000111", l_encoded);
877        bits = new byte[2];
878        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
879        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
880        assertEquals("0000000000001111", l_encoded);
881        bits = new byte[2];
882        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
883        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
884        assertEquals("0000000000011111", l_encoded);
885        bits = new byte[2];
886        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
887        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
888        assertEquals("0000000000111111", l_encoded);
889        bits = new byte[2];
890        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
891        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
892        assertEquals("0000000001111111", l_encoded);
893        bits = new byte[2];
894        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
895        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
896        assertEquals("0000000011111111", l_encoded);
897        // work on the other byte now
898        bits = new byte[2];
899        bits[1] = BIT_0;
900        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
901        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
902        assertEquals("0000000111111111", l_encoded);
903        bits = new byte[2];
904        bits[1] = BIT_0 | BIT_1;
905        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
906        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
907        assertEquals("0000001111111111", l_encoded);
908        bits = new byte[2];
909        bits[1] = BIT_0 | BIT_1 | BIT_2;
910        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
911        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
912        assertEquals("0000011111111111", l_encoded);
913        bits = new byte[2];
914        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
915        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
916        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
917        assertEquals("0000111111111111", l_encoded);
918        bits = new byte[2];
919        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
920        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
921        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
922        assertEquals("0001111111111111", l_encoded);
923        bits = new byte[2];
924        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
925        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
926        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
927        assertEquals("0011111111111111", l_encoded);
928        bits = new byte[2];
929        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
930        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
931        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
932        assertEquals("0111111111111111", l_encoded);
933        bits = new byte[2];
934        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
935        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
936        l_encoded = new String(BinaryCodec.toAsciiChars(bits));
937        assertEquals("1111111111111111", l_encoded);
938        assertEquals(0, BinaryCodec.toAsciiChars((byte[]) null).length);
939    }
940
941    // ------------------------------------------------------------------------
942    //
943    // Test toAsciiString
944    //
945    // ------------------------------------------------------------------------
946    /**
947     * Tests the toAsciiString(byte[]) method
948     */
949    @Test
950    public void testToAsciiString() {
951        // With a single raw binary
952        byte[] bits = new byte[1];
953        String l_encoded = BinaryCodec.toAsciiString(bits);
954        assertEquals("00000000", l_encoded);
955        bits = new byte[1];
956        bits[0] = BIT_0;
957        l_encoded = BinaryCodec.toAsciiString(bits);
958        assertEquals("00000001", l_encoded);
959        bits = new byte[1];
960        bits[0] = BIT_0 | BIT_1;
961        l_encoded = BinaryCodec.toAsciiString(bits);
962        assertEquals("00000011", l_encoded);
963        bits = new byte[1];
964        bits[0] = BIT_0 | BIT_1 | BIT_2;
965        l_encoded = BinaryCodec.toAsciiString(bits);
966        assertEquals("00000111", l_encoded);
967        bits = new byte[1];
968        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
969        l_encoded = BinaryCodec.toAsciiString(bits);
970        assertEquals("00001111", l_encoded);
971        bits = new byte[1];
972        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
973        l_encoded = BinaryCodec.toAsciiString(bits);
974        assertEquals("00011111", l_encoded);
975        bits = new byte[1];
976        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
977        l_encoded = BinaryCodec.toAsciiString(bits);
978        assertEquals("00111111", l_encoded);
979        bits = new byte[1];
980        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
981        l_encoded = BinaryCodec.toAsciiString(bits);
982        assertEquals("01111111", l_encoded);
983        bits = new byte[1];
984        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
985        l_encoded = BinaryCodec.toAsciiString(bits);
986        assertEquals("11111111", l_encoded);
987        // With a two raw binaries
988        bits = new byte[2];
989        l_encoded = BinaryCodec.toAsciiString(bits);
990        assertEquals("0000000000000000", l_encoded);
991        bits = new byte[2];
992        bits[0] = BIT_0;
993        l_encoded = BinaryCodec.toAsciiString(bits);
994        assertEquals("0000000000000001", l_encoded);
995        bits = new byte[2];
996        bits[0] = BIT_0 | BIT_1;
997        l_encoded = BinaryCodec.toAsciiString(bits);
998        assertEquals("0000000000000011", l_encoded);
999        bits = new byte[2];
1000        bits[0] = BIT_0 | BIT_1 | BIT_2;
1001        l_encoded = BinaryCodec.toAsciiString(bits);
1002        assertEquals("0000000000000111", l_encoded);
1003        bits = new byte[2];
1004        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
1005        l_encoded = BinaryCodec.toAsciiString(bits);
1006        assertEquals("0000000000001111", l_encoded);
1007        bits = new byte[2];
1008        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
1009        l_encoded = BinaryCodec.toAsciiString(bits);
1010        assertEquals("0000000000011111", l_encoded);
1011        bits = new byte[2];
1012        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
1013        l_encoded = BinaryCodec.toAsciiString(bits);
1014        assertEquals("0000000000111111", l_encoded);
1015        bits = new byte[2];
1016        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
1017        l_encoded = BinaryCodec.toAsciiString(bits);
1018        assertEquals("0000000001111111", l_encoded);
1019        bits = new byte[2];
1020        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1021        l_encoded = BinaryCodec.toAsciiString(bits);
1022        assertEquals("0000000011111111", l_encoded);
1023        // work on the other byte now
1024        bits = new byte[2];
1025        bits[1] = BIT_0;
1026        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1027        l_encoded = BinaryCodec.toAsciiString(bits);
1028        assertEquals("0000000111111111", l_encoded);
1029        bits = new byte[2];
1030        bits[1] = BIT_0 | BIT_1;
1031        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1032        l_encoded = BinaryCodec.toAsciiString(bits);
1033        assertEquals("0000001111111111", l_encoded);
1034        bits = new byte[2];
1035        bits[1] = BIT_0 | BIT_1 | BIT_2;
1036        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1037        l_encoded = BinaryCodec.toAsciiString(bits);
1038        assertEquals("0000011111111111", l_encoded);
1039        bits = new byte[2];
1040        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
1041        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1042        l_encoded = BinaryCodec.toAsciiString(bits);
1043        assertEquals("0000111111111111", l_encoded);
1044        bits = new byte[2];
1045        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
1046        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1047        l_encoded = BinaryCodec.toAsciiString(bits);
1048        assertEquals("0001111111111111", l_encoded);
1049        bits = new byte[2];
1050        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
1051        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1052        l_encoded = BinaryCodec.toAsciiString(bits);
1053        assertEquals("0011111111111111", l_encoded);
1054        bits = new byte[2];
1055        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
1056        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1057        l_encoded = BinaryCodec.toAsciiString(bits);
1058        assertEquals("0111111111111111", l_encoded);
1059        bits = new byte[2];
1060        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1061        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1062        l_encoded = BinaryCodec.toAsciiString(bits);
1063        assertEquals("1111111111111111", l_encoded);
1064    }
1065
1066    // ------------------------------------------------------------------------
1067    //
1068    // Test encode(Object)
1069    //
1070    // ------------------------------------------------------------------------
1071    /*
1072     * Tests for Object encode(Object)
1073     */
1074    @Test
1075    public void testEncodeObjectNull() throws Exception {
1076        final Object obj = new byte[0];
1077        assertEquals(0, ((char[]) instance.encode(obj)).length);
1078    }
1079
1080    /*
1081     * Tests for Object encode(Object)
1082     */
1083    @Test
1084    public void testEncodeObjectException() {
1085        try {
1086            instance.encode("");
1087        } catch (final EncoderException e) {
1088            // all is well.
1089            return;
1090        }
1091        fail("Expected EncoderException");
1092    }
1093
1094    /*
1095     * Tests for Object encode(Object)
1096     */
1097    @Test
1098    public void testEncodeObject() throws Exception {
1099        // With a single raw binary
1100        byte[] bits = new byte[1];
1101        String l_encoded = new String((char[]) instance.encode((Object) bits));
1102        assertEquals("00000000", l_encoded);
1103        bits = new byte[1];
1104        bits[0] = BIT_0;
1105        l_encoded = new String((char[]) instance.encode((Object) bits));
1106        assertEquals("00000001", l_encoded);
1107        bits = new byte[1];
1108        bits[0] = BIT_0 | BIT_1;
1109        l_encoded = new String((char[]) instance.encode((Object) bits));
1110        assertEquals("00000011", l_encoded);
1111        bits = new byte[1];
1112        bits[0] = BIT_0 | BIT_1 | BIT_2;
1113        l_encoded = new String((char[]) instance.encode((Object) bits));
1114        assertEquals("00000111", l_encoded);
1115        bits = new byte[1];
1116        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
1117        l_encoded = new String((char[]) instance.encode((Object) bits));
1118        assertEquals("00001111", l_encoded);
1119        bits = new byte[1];
1120        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
1121        l_encoded = new String((char[]) instance.encode((Object) bits));
1122        assertEquals("00011111", l_encoded);
1123        bits = new byte[1];
1124        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
1125        l_encoded = new String((char[]) instance.encode((Object) bits));
1126        assertEquals("00111111", l_encoded);
1127        bits = new byte[1];
1128        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
1129        l_encoded = new String((char[]) instance.encode((Object) bits));
1130        assertEquals("01111111", l_encoded);
1131        bits = new byte[1];
1132        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1133        l_encoded = new String((char[]) instance.encode((Object) bits));
1134        assertEquals("11111111", l_encoded);
1135        // With a two raw binaries
1136        bits = new byte[2];
1137        l_encoded = new String((char[]) instance.encode((Object) bits));
1138        assertEquals("0000000000000000", l_encoded);
1139        bits = new byte[2];
1140        bits[0] = BIT_0;
1141        l_encoded = new String((char[]) instance.encode((Object) bits));
1142        assertEquals("0000000000000001", l_encoded);
1143        bits = new byte[2];
1144        bits[0] = BIT_0 | BIT_1;
1145        l_encoded = new String((char[]) instance.encode((Object) bits));
1146        assertEquals("0000000000000011", l_encoded);
1147        bits = new byte[2];
1148        bits[0] = BIT_0 | BIT_1 | BIT_2;
1149        l_encoded = new String((char[]) instance.encode((Object) bits));
1150        assertEquals("0000000000000111", l_encoded);
1151        bits = new byte[2];
1152        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
1153        l_encoded = new String((char[]) instance.encode((Object) bits));
1154        assertEquals("0000000000001111", l_encoded);
1155        bits = new byte[2];
1156        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
1157        l_encoded = new String((char[]) instance.encode((Object) bits));
1158        assertEquals("0000000000011111", l_encoded);
1159        bits = new byte[2];
1160        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
1161        l_encoded = new String((char[]) instance.encode((Object) bits));
1162        assertEquals("0000000000111111", l_encoded);
1163        bits = new byte[2];
1164        bits[0] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
1165        l_encoded = new String((char[]) instance.encode((Object) bits));
1166        assertEquals("0000000001111111", l_encoded);
1167        bits = new byte[2];
1168        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1169        l_encoded = new String((char[]) instance.encode((Object) bits));
1170        assertEquals("0000000011111111", l_encoded);
1171        // work on the other byte now
1172        bits = new byte[2];
1173        bits[1] = BIT_0;
1174        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1175        l_encoded = new String((char[]) instance.encode((Object) bits));
1176        assertEquals("0000000111111111", l_encoded);
1177        bits = new byte[2];
1178        bits[1] = BIT_0 | BIT_1;
1179        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1180        l_encoded = new String((char[]) instance.encode((Object) bits));
1181        assertEquals("0000001111111111", l_encoded);
1182        bits = new byte[2];
1183        bits[1] = BIT_0 | BIT_1 | BIT_2;
1184        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1185        l_encoded = new String((char[]) instance.encode((Object) bits));
1186        assertEquals("0000011111111111", l_encoded);
1187        bits = new byte[2];
1188        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3;
1189        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1190        l_encoded = new String((char[]) instance.encode((Object) bits));
1191        assertEquals("0000111111111111", l_encoded);
1192        bits = new byte[2];
1193        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4;
1194        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1195        l_encoded = new String((char[]) instance.encode((Object) bits));
1196        assertEquals("0001111111111111", l_encoded);
1197        bits = new byte[2];
1198        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5;
1199        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1200        l_encoded = new String((char[]) instance.encode((Object) bits));
1201        assertEquals("0011111111111111", l_encoded);
1202        bits = new byte[2];
1203        bits[1] = BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6;
1204        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1205        l_encoded = new String((char[]) instance.encode((Object) bits));
1206        assertEquals("0111111111111111", l_encoded);
1207        bits = new byte[2];
1208        bits[0] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1209        bits[1] = (byte) (BIT_0 | BIT_1 | BIT_2 | BIT_3 | BIT_4 | BIT_5 | BIT_6 | BIT_7);
1210        l_encoded = new String((char[]) instance.encode((Object) bits));
1211        assertEquals("1111111111111111", l_encoded);
1212    }
1213}