Author: ggregory
Date: Thu Aug 25 00:35:31 2011
New Revision: 1161343
URL: http://svn.apache.org/viewvc?rev=1161343&view=rev
Log:
Use blocks. Refer to constants and methods where they are defined in BaseNCodec
instead of the Base32 and Base64 subclasses (and other classes.)
Modified:
commons/proper/codec/branches/generics/src/java/org/apache/commons/codec/language/bm/Lang.java
commons/proper/codec/branches/generics/src/java/org/apache/commons/codec/language/bm/PhoneticEngine.java
commons/proper/codec/branches/generics/src/java/org/apache/commons/codec/net/URLStringCodec.java
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base32InputStreamTest.java
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base32OutputStreamTest.java
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base64InputStreamTest.java
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base64OutputStreamTest.java
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base64Test.java
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/BinaryByteCodecTest.java
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/BinaryCharCodecTest.java
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/HexByteTest.java
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/HexCharTest.java
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/net/BCodecTest.java
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/net/QCodecTest.java
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/net/QuotedPrintableBinaryCodecTest.java
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/net/QuotedPrintableStringCodecTest.java
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/net/URLCodecBinaryTest.java
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/net/URLCodecStringTest.java
Modified:
commons/proper/codec/branches/generics/src/java/org/apache/commons/codec/language/bm/Lang.java
URL:
http://svn.apache.org/viewvc/commons/proper/codec/branches/generics/src/java/org/apache/commons/codec/language/bm/Lang.java?rev=1161343&r1=1161342&r2=1161343&view=diff
==============================================================================
---
commons/proper/codec/branches/generics/src/java/org/apache/commons/codec/language/bm/Lang.java
(original)
+++
commons/proper/codec/branches/generics/src/java/org/apache/commons/codec/language/bm/Lang.java
Thu Aug 25 00:35:31 2011
@@ -158,8 +158,9 @@ public class Lang {
// trim leading-trailing whitespace
line = line.trim();
- if (line.length() == 0)
+ if (line.length() == 0) {
continue; // empty lines can be safely skipped
+ }
// split it up
String[] parts = line.split("\\s+");
Modified:
commons/proper/codec/branches/generics/src/java/org/apache/commons/codec/language/bm/PhoneticEngine.java
URL:
http://svn.apache.org/viewvc/commons/proper/codec/branches/generics/src/java/org/apache/commons/codec/language/bm/PhoneticEngine.java?rev=1161343&r1=1161342&r2=1161343&view=diff
==============================================================================
---
commons/proper/codec/branches/generics/src/java/org/apache/commons/codec/language/bm/PhoneticEngine.java
(original)
+++
commons/proper/codec/branches/generics/src/java/org/apache/commons/codec/language/bm/PhoneticEngine.java
Thu Aug 25 00:35:31 2011
@@ -189,8 +189,9 @@ public class PhoneticEngine {
}
public CharSequence subSequence(int start, int end) {
- if (start == end)
+ if (start == end) {
return "";
+ }
CharSequence res = cache[start][end - 1];
if (res == null) {
Modified:
commons/proper/codec/branches/generics/src/java/org/apache/commons/codec/net/URLStringCodec.java
URL:
http://svn.apache.org/viewvc/commons/proper/codec/branches/generics/src/java/org/apache/commons/codec/net/URLStringCodec.java?rev=1161343&r1=1161342&r2=1161343&view=diff
==============================================================================
---
commons/proper/codec/branches/generics/src/java/org/apache/commons/codec/net/URLStringCodec.java
(original)
+++
commons/proper/codec/branches/generics/src/java/org/apache/commons/codec/net/URLStringCodec.java
Thu Aug 25 00:35:31 2011
@@ -52,6 +52,7 @@ public class URLStringCodec extends URLC
*
* @return the default string charset.
*/
+ @Override
public String getDefaultCharset() {
return this.charset;
}
Modified:
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base32InputStreamTest.java
URL:
http://svn.apache.org/viewvc/commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base32InputStreamTest.java?rev=1161343&r1=1161342&r2=1161343&view=diff
==============================================================================
---
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base32InputStreamTest.java
(original)
+++
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base32InputStreamTest.java
Thu Aug 25 00:35:31 2011
@@ -128,7 +128,7 @@ public class Base32InputStreamTest {
*/
@Test
public void testBase32EmptyInputStreamMimeChuckSize() throws Exception {
- testBase32EmptyInputStream(Base32.MIME_CHUNK_SIZE);
+ testBase32EmptyInputStream(BaseNCodec.MIME_CHUNK_SIZE);
}
/**
@@ -139,7 +139,7 @@ public class Base32InputStreamTest {
*/
@Test
public void testBase32EmptyInputStreamPemChuckSize() throws Exception {
- testBase32EmptyInputStream(Base32.PEM_CHUNK_SIZE);
+ testBase32EmptyInputStream(BaseNCodec.PEM_CHUNK_SIZE);
}
private void testBase32EmptyInputStream(int chuckSize) throws Exception {
@@ -160,12 +160,12 @@ public class Base32InputStreamTest {
// Hello World test.
byte[] encoded =
StringUtils.getBytesUtf8(Base32TestData.BASE32_FIXTURE);
byte[] decoded =
StringUtils.getBytesUtf8(Base32TestData.STRING_FIXTURE);
- testByChunk(encoded, decoded, Base32.MIME_CHUNK_SIZE, CRLF);
+ testByChunk(encoded, decoded, BaseNCodec.MIME_CHUNK_SIZE, CRLF);
// Single Byte test.
encoded = StringUtils.getBytesUtf8("AA======\r\n");
decoded = new byte[]{(byte) 0};
- testByChunk(encoded, decoded, Base32.MIME_CHUNK_SIZE, CRLF);
+ testByChunk(encoded, decoded, BaseNCodec.MIME_CHUNK_SIZE, CRLF);
// // OpenSSL interop test.
// encoded =
StringUtils.getBytesUtf8(Base32TestData.ENCODED_32_CHARS_PER_LINE);
@@ -199,12 +199,12 @@ public class Base32InputStreamTest {
// Hello World test.
byte[] encoded =
StringUtils.getBytesUtf8(Base32TestData.BASE32_FIXTURE);
byte[] decoded =
StringUtils.getBytesUtf8(Base32TestData.STRING_FIXTURE);
- testByteByByte(encoded, decoded, Base32.MIME_CHUNK_SIZE, CRLF);
+ testByteByByte(encoded, decoded, BaseNCodec.MIME_CHUNK_SIZE, CRLF);
// Single Byte test.
encoded = StringUtils.getBytesUtf8("AA======\r\n");
decoded = new byte[]{(byte) 0};
- testByteByByte(encoded, decoded, Base32.MIME_CHUNK_SIZE, CRLF);
+ testByteByByte(encoded, decoded, BaseNCodec.MIME_CHUNK_SIZE, CRLF);
// // Single Line test.
// String singleLine =
Base32TestData.ENCODED_32_CHARS_PER_LINE.replaceAll("\n", "");
Modified:
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base32OutputStreamTest.java
URL:
http://svn.apache.org/viewvc/commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base32OutputStreamTest.java?rev=1161343&r1=1161342&r2=1161343&view=diff
==============================================================================
---
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base32OutputStreamTest.java
(original)
+++
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base32OutputStreamTest.java
Thu Aug 25 00:35:31 2011
@@ -66,7 +66,7 @@ public class Base32OutputStreamTest {
*/
@Test
public void testBase32EmptyOutputStreamMimeChunkSize() throws Exception {
- testBase32EmptyOutputStream(Base32.MIME_CHUNK_SIZE);
+ testBase32EmptyOutputStream(BaseNCodec.MIME_CHUNK_SIZE);
}
/**
@@ -77,7 +77,7 @@ public class Base32OutputStreamTest {
*/
@Test
public void testBase32EmptyOutputStreamPemChunkSize() throws Exception {
- testBase32EmptyOutputStream(Base32.PEM_CHUNK_SIZE);
+ testBase32EmptyOutputStream(BaseNCodec.PEM_CHUNK_SIZE);
}
private void testBase32EmptyOutputStream(int chunkSize) throws Exception {
@@ -98,7 +98,7 @@ public class Base32OutputStreamTest {
// Hello World test.
byte[] encoded =
StringUtils.getBytesUtf8(Base32TestData.BASE32_FIXTURE);
byte[] decoded =
StringUtils.getBytesUtf8(Base32TestData.STRING_FIXTURE);
- testByChunk(encoded, decoded, Base32.MIME_CHUNK_SIZE, CRLF);
+ testByChunk(encoded, decoded, BaseNCodec.MIME_CHUNK_SIZE, CRLF);
// // Single Byte test.
// encoded = StringUtils.getBytesUtf8("AA==\r\n");
Modified:
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base64InputStreamTest.java
URL:
http://svn.apache.org/viewvc/commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base64InputStreamTest.java?rev=1161343&r1=1161342&r2=1161343&view=diff
==============================================================================
---
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base64InputStreamTest.java
(original)
+++
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base64InputStreamTest.java
Thu Aug 25 00:35:31 2011
@@ -138,7 +138,7 @@ public class Base64InputStreamTest {
*/
@Test
public void testBase64EmptyInputStreamMimeChuckSize() throws Exception {
- testBase64EmptyInputStream(Base64.MIME_CHUNK_SIZE);
+ testBase64EmptyInputStream(BaseNCodec.MIME_CHUNK_SIZE);
}
/**
@@ -149,7 +149,7 @@ public class Base64InputStreamTest {
*/
@Test
public void testBase64EmptyInputStreamPemChuckSize() throws Exception {
- testBase64EmptyInputStream(Base64.PEM_CHUNK_SIZE);
+ testBase64EmptyInputStream(BaseNCodec.PEM_CHUNK_SIZE);
}
private void testBase64EmptyInputStream(int chuckSize) throws Exception {
@@ -170,17 +170,17 @@ public class Base64InputStreamTest {
// Hello World test.
byte[] encoded = StringUtils.getBytesUtf8("SGVsbG8gV29ybGQ=\r\n");
byte[] decoded = StringUtils.getBytesUtf8(STRING_FIXTURE);
- testByChunk(encoded, decoded, Base64.MIME_CHUNK_SIZE, CRLF);
+ testByChunk(encoded, decoded, BaseNCodec.MIME_CHUNK_SIZE, CRLF);
// Single Byte test.
encoded = StringUtils.getBytesUtf8("AA==\r\n");
decoded = new byte[]{(byte) 0};
- testByChunk(encoded, decoded, Base64.MIME_CHUNK_SIZE, CRLF);
+ testByChunk(encoded, decoded, BaseNCodec.MIME_CHUNK_SIZE, CRLF);
// OpenSSL interop test.
encoded =
StringUtils.getBytesUtf8(Base64TestData.ENCODED_64_CHARS_PER_LINE);
decoded = Base64TestData.DECODED;
- testByChunk(encoded, decoded, Base64.PEM_CHUNK_SIZE, LF);
+ testByChunk(encoded, decoded, BaseNCodec.PEM_CHUNK_SIZE, LF);
// Single Line test.
String singleLine =
Base64TestData.ENCODED_64_CHARS_PER_LINE.replaceAll("\n", "");
@@ -208,17 +208,17 @@ public class Base64InputStreamTest {
// Hello World test.
byte[] encoded = StringUtils.getBytesUtf8("SGVsbG8gV29ybGQ=\r\n");
byte[] decoded = StringUtils.getBytesUtf8(STRING_FIXTURE);
- testByteByByte(encoded, decoded, Base64.MIME_CHUNK_SIZE, CRLF);
+ testByteByByte(encoded, decoded, BaseNCodec.MIME_CHUNK_SIZE, CRLF);
// Single Byte test.
encoded = StringUtils.getBytesUtf8("AA==\r\n");
decoded = new byte[]{(byte) 0};
- testByteByByte(encoded, decoded, Base64.MIME_CHUNK_SIZE, CRLF);
+ testByteByByte(encoded, decoded, BaseNCodec.MIME_CHUNK_SIZE, CRLF);
// OpenSSL interop test.
encoded =
StringUtils.getBytesUtf8(Base64TestData.ENCODED_64_CHARS_PER_LINE);
decoded = Base64TestData.DECODED;
- testByteByByte(encoded, decoded, Base64.PEM_CHUNK_SIZE, LF);
+ testByteByByte(encoded, decoded, BaseNCodec.PEM_CHUNK_SIZE, LF);
// Single Line test.
String singleLine =
Base64TestData.ENCODED_64_CHARS_PER_LINE.replaceAll("\n", "");
Modified:
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base64OutputStreamTest.java
URL:
http://svn.apache.org/viewvc/commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base64OutputStreamTest.java?rev=1161343&r1=1161342&r2=1161343&view=diff
==============================================================================
---
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base64OutputStreamTest.java
(original)
+++
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base64OutputStreamTest.java
Thu Aug 25 00:35:31 2011
@@ -72,7 +72,7 @@ public class Base64OutputStreamTest {
*/
@Test
public void testBase64EmptyOutputStreamMimeChunkSize() throws Exception {
- testBase64EmptyOutputStream(Base64.MIME_CHUNK_SIZE);
+ testBase64EmptyOutputStream(BaseNCodec.MIME_CHUNK_SIZE);
}
/**
@@ -83,7 +83,7 @@ public class Base64OutputStreamTest {
*/
@Test
public void testBase64EmptyOutputStreamPemChunkSize() throws Exception {
- testBase64EmptyOutputStream(Base64.PEM_CHUNK_SIZE);
+ testBase64EmptyOutputStream(BaseNCodec.PEM_CHUNK_SIZE);
}
private void testBase64EmptyOutputStream(int chunkSize) throws Exception {
@@ -104,17 +104,17 @@ public class Base64OutputStreamTest {
// Hello World test.
byte[] encoded = StringUtils.getBytesUtf8("SGVsbG8gV29ybGQ=\r\n");
byte[] decoded = StringUtils.getBytesUtf8(STRING_FIXTURE);
- testByChunk(encoded, decoded, Base64.MIME_CHUNK_SIZE, CRLF);
+ testByChunk(encoded, decoded, BaseNCodec.MIME_CHUNK_SIZE, CRLF);
// Single Byte test.
encoded = StringUtils.getBytesUtf8("AA==\r\n");
decoded = new byte[]{(byte) 0};
- testByChunk(encoded, decoded, Base64.MIME_CHUNK_SIZE, CRLF);
+ testByChunk(encoded, decoded, BaseNCodec.MIME_CHUNK_SIZE, CRLF);
// OpenSSL interop test.
encoded =
StringUtils.getBytesUtf8(Base64TestData.ENCODED_64_CHARS_PER_LINE);
decoded = Base64TestData.DECODED;
- testByChunk(encoded, decoded, Base64.PEM_CHUNK_SIZE, LF);
+ testByChunk(encoded, decoded, BaseNCodec.PEM_CHUNK_SIZE, LF);
// Single Line test.
String singleLine =
Base64TestData.ENCODED_64_CHARS_PER_LINE.replaceAll("\n", "");
Modified:
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base64Test.java
URL:
http://svn.apache.org/viewvc/commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base64Test.java?rev=1161343&r1=1161342&r2=1161343&view=diff
==============================================================================
---
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base64Test.java
(original)
+++
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/Base64Test.java
Thu Aug 25 00:35:31 2011
@@ -82,7 +82,7 @@ public class Base64Test {
encodedContent = StringUtils.newStringUtf8(encodedBytes);
assertTrue("encoding hello world",
encodedContent.equals("SGVsbG8gV29ybGQ="));
- Base64 b64 = new Base64(Base64.MIME_CHUNK_SIZE, null); // null
lineSeparator same as saying no-chunking
+ Base64 b64 = new Base64(BaseNCodec.MIME_CHUNK_SIZE, null); // null
lineSeparator same as saying no-chunking
encodedBytes = b64.encode(StringUtils.getBytesUtf8(content));
encodedContent = StringUtils.newStringUtf8(encodedBytes);
assertTrue("encoding hello world",
encodedContent.equals("SGVsbG8gV29ybGQ="));
@@ -519,7 +519,7 @@ public class Base64Test {
*/
@Test
public void testRfc2045Section6Dot8ChunkSizeDefinition() {
- assertEquals(76, Base64.MIME_CHUNK_SIZE);
+ assertEquals(76, BaseNCodec.MIME_CHUNK_SIZE);
}
/**
@@ -527,7 +527,7 @@ public class Base64Test {
*/
@Test
public void testRfc1421Section6Dot8ChunkSizeDefinition() {
- assertEquals(64, Base64.PEM_CHUNK_SIZE);
+ assertEquals(64, BaseNCodec.PEM_CHUNK_SIZE);
}
/**
Modified:
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=1161343&r1=1161342&r2=1161343&view=diff
==============================================================================
---
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/BinaryByteCodecTest.java
(original)
+++
commons/proper/codec/branches/generics/src/test/org/apache/commons/codec/binary/BinaryByteCodecTest.java
Thu Aug 25 00:35:31 2011
@@ -365,90 +365,90 @@ public class BinaryByteCodecTest {
*/
@Test
public void testFromAsciiCharArray() {
- assertEquals(0, BinaryByteCodec.fromAscii((char[]) null).length);
- assertEquals(0, BinaryByteCodec.fromAscii(new char[0]).length);
+ assertEquals(0, BinaryCodec.fromAscii((char[]) null).length);
+ assertEquals(0, BinaryCodec.fromAscii(new char[0]).length);
// With a single raw binary
byte[] bits = new byte[1];
- byte[] decoded = BinaryByteCodec.fromAscii("00000000".toCharArray());
+ byte[] decoded = BinaryCodec.fromAscii("00000000".toCharArray());
assertEquals(new String(bits), new String(decoded));
bits = new byte[1];
bits[0] = BIT_0;
- decoded = BinaryByteCodec.fromAscii("00000001".toCharArray());
+ decoded = BinaryCodec.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());
+ decoded = BinaryCodec.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());
+ decoded = BinaryCodec.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());
+ decoded = BinaryCodec.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());
+ decoded = BinaryCodec.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());
+ decoded = BinaryCodec.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());
+ decoded = BinaryCodec.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());
+ decoded = BinaryCodec.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());
+ decoded = BinaryCodec.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());
+ decoded = BinaryCodec.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());
+ decoded = BinaryCodec.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());
+ decoded = BinaryCodec.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());
+ decoded = BinaryCodec.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());
+ decoded = BinaryCodec.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());
+ decoded = BinaryCodec.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());
+ decoded = BinaryCodec.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());
+ decoded = BinaryCodec.fromAscii("1111111111111111".toCharArray());
assertEquals(new String(bits), new String(decoded));
- assertEquals(0, BinaryByteCodec.fromAscii((char[]) null).length);
+ assertEquals(0, BinaryCodec.fromAscii((char[]) null).length);
}
// ------------------------------------------------------------------------
@@ -461,90 +461,90 @@ public class BinaryByteCodecTest {
*/
@Test
public void testFromAsciiByteArray() throws UnsupportedEncodingException {
- assertEquals(0, BinaryByteCodec.fromAscii((byte[]) null).length);
- assertEquals(0, BinaryByteCodec.fromAscii(new byte[0]).length);
+ assertEquals(0, BinaryCodec.fromAscii((byte[]) null).length);
+ assertEquals(0, BinaryCodec.fromAscii(new byte[0]).length);
// With a single raw binary
byte[] bits = new byte[1];
- byte[] decoded =
BinaryByteCodec.fromAscii("00000000".getBytes("UTF-8"));
+ byte[] decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.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"));
+ decoded = BinaryCodec.fromAscii("1111111111111111".getBytes("UTF-8"));
assertEquals(new String(bits), new String(decoded));
- assertEquals(0, BinaryByteCodec.fromAscii((byte[]) null).length);
+ assertEquals(0, BinaryCodec.fromAscii((byte[]) null).length);
}
// ------------------------------------------------------------------------
@@ -682,118 +682,118 @@ public class BinaryByteCodecTest {
public void testToAsciiBytes() {
// With a single raw binary
byte[] bits = new byte[1];
- String l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+ String l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
assertEquals("00000000", l_encoded);
bits = new byte[1];
bits[0] = BIT_0;
- l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+ l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
assertEquals("00000001", l_encoded);
bits = new byte[1];
bits[0] = BIT_0 | BIT_1;
- l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
assertEquals("11111111", l_encoded);
// With a two raw binaries
bits = new byte[2];
- l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+ l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
assertEquals("0000000000000000", l_encoded);
bits = new byte[2];
bits[0] = BIT_0;
- l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+ l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
assertEquals("0000000000000001", l_encoded);
bits = new byte[2];
bits[0] = BIT_0 | BIT_1;
- l_encoded = new String(BinaryByteCodec.toAsciiBytes(bits));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.toAsciiBytes(bits));
assertEquals("1111111111111111", l_encoded);
- assertEquals(0, BinaryByteCodec.toAsciiBytes((byte[]) null).length);
+ assertEquals(0, BinaryCodec.toAsciiBytes((byte[]) null).length);
}
// ------------------------------------------------------------------------
@@ -805,118 +805,118 @@ public class BinaryByteCodecTest {
public void testToAsciiChars() {
// With a single raw binary
byte[] bits = new byte[1];
- String l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+ String l_encoded = new String(BinaryCodec.toAsciiChars(bits));
assertEquals("00000000", l_encoded);
bits = new byte[1];
bits[0] = BIT_0;
- l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+ l_encoded = new String(BinaryCodec.toAsciiChars(bits));
assertEquals("00000001", l_encoded);
bits = new byte[1];
bits[0] = BIT_0 | BIT_1;
- l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.toAsciiChars(bits));
assertEquals("11111111", l_encoded);
// With a two raw binaries
bits = new byte[2];
- l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+ l_encoded = new String(BinaryCodec.toAsciiChars(bits));
assertEquals("0000000000000000", l_encoded);
bits = new byte[2];
bits[0] = BIT_0;
- l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+ l_encoded = new String(BinaryCodec.toAsciiChars(bits));
assertEquals("0000000000000001", l_encoded);
bits = new byte[2];
bits[0] = BIT_0 | BIT_1;
- l_encoded = new String(BinaryByteCodec.toAsciiChars(bits));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.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));
+ l_encoded = new String(BinaryCodec.toAsciiChars(bits));
assertEquals("1111111111111111", l_encoded);
- assertEquals(0, BinaryByteCodec.toAsciiChars((byte[]) null).length);
+ assertEquals(0, BinaryCodec.toAsciiChars((byte[]) null).length);
}
// ------------------------------------------------------------------------
@@ -931,116 +931,116 @@ public class BinaryByteCodecTest {
public void testToAsciiString() {
// With a single raw binary
byte[] bits = new byte[1];
- String l_encoded = BinaryByteCodec.toAsciiString(bits);
+ String l_encoded = BinaryCodec.toAsciiString(bits);
assertEquals("00000000", l_encoded);
bits = new byte[1];
bits[0] = BIT_0;
- l_encoded = BinaryByteCodec.toAsciiString(bits);
+ l_encoded = BinaryCodec.toAsciiString(bits);
assertEquals("00000001", l_encoded);
bits = new byte[1];
bits[0] = BIT_0 | BIT_1;
- l_encoded = BinaryByteCodec.toAsciiString(bits);
+ l_encoded = BinaryCodec.toAsciiString(bits);
assertEquals("00000011", l_encoded);
bits = new byte[1];
bits[0] = BIT_0 | BIT_1 | BIT_2;
- l_encoded = BinaryByteCodec.toAsciiString(bits);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.toAsciiString(bits);
assertEquals("11111111", l_encoded);
// With a two raw binaries
bits = new byte[2];
- l_encoded = BinaryByteCodec.toAsciiString(bits);
+ l_encoded = BinaryCodec.toAsciiString(bits);
assertEquals("0000000000000000", l_encoded);
bits = new byte[2];
bits[0] = BIT_0;
- l_encoded = BinaryByteCodec.toAsciiString(bits);
+ l_encoded = BinaryCodec.toAsciiString(bits);
assertEquals("0000000000000001", l_encoded);
bits = new byte[2];
bits[0] = BIT_0 | BIT_1;
- l_encoded = BinaryByteCodec.toAsciiString(bits);
+ l_encoded = BinaryCodec.toAsciiString(bits);
assertEquals("0000000000000011", l_encoded);
bits = new byte[2];
bits[0] = BIT_0 | BIT_1 | BIT_2;
- l_encoded = BinaryByteCodec.toAsciiString(bits);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.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);
+ l_encoded = BinaryCodec.toAsciiString(bits);
assertEquals("1111111111111111", l_encoded);
}
