You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2012/11/30 16:32:16 UTC
svn commit: r1415694 -
/commons/proper/io/trunk/src/test/java/org/apache/commons/io/input/CharSequenceInputStreamTest.java
Author: ggregory
Date: Fri Nov 30 15:32:16 2012
New Revision: 1415694
URL: http://svn.apache.org/viewvc?rev=1415694&view=rev
Log:
Redo some test to use all required charsets. This revealed likely bugs in new @Ignore tests.
Modified:
commons/proper/io/trunk/src/test/java/org/apache/commons/io/input/CharSequenceInputStreamTest.java
Modified: commons/proper/io/trunk/src/test/java/org/apache/commons/io/input/CharSequenceInputStreamTest.java
URL: http://svn.apache.org/viewvc/commons/proper/io/trunk/src/test/java/org/apache/commons/io/input/CharSequenceInputStreamTest.java?rev=1415694&r1=1415693&r2=1415694&view=diff
==============================================================================
--- commons/proper/io/trunk/src/test/java/org/apache/commons/io/input/CharSequenceInputStreamTest.java (original)
+++ commons/proper/io/trunk/src/test/java/org/apache/commons/io/input/CharSequenceInputStreamTest.java Fri Nov 30 15:32:16 2012
@@ -24,32 +24,98 @@ import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.util.Random;
+import java.util.Set;
+import org.apache.commons.io.Charsets;
+import org.junit.Ignore;
import org.junit.Test;
public class CharSequenceInputStreamTest {
-
+
private static final String ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
private static final String LARGE_TEST_STRING;
-
+
private static final String TEST_STRING = "\u00e0 peine arriv\u00e9s nous entr\u00e2mes dans sa chambre";
-
+
static {
StringBuilder buffer = new StringBuilder();
- for (int i=0; i<100; i++) {
+ for (int i = 0; i < 100; i++) {
buffer.append(TEST_STRING);
}
LARGE_TEST_STRING = buffer.toString();
}
private Random random = new Random();
-
+
+ private Set<String> getRequiredCharsetNames() {
+ return Charsets.requiredCharsets().keySet();
+ }
+
+ private void testBufferedRead(String testString, String charsetName) throws IOException {
+ byte[] expected = testString.getBytes(charsetName);
+ InputStream in = new CharSequenceInputStream(testString, charsetName, 512);
+ try {
+ byte[] buffer = new byte[128];
+ int offset = 0;
+ while (true) {
+ int bufferOffset = random.nextInt(64);
+ int bufferLength = random.nextInt(64);
+ int read = in.read(buffer, bufferOffset, bufferLength);
+ if (read == -1) {
+ assertEquals("EOF: offset should equal length", expected.length, offset);
+ break;
+ } else {
+ assertTrue("Read " + read + " <= " + bufferLength, read <= bufferLength);
+ while (read > 0) {
+ assertTrue("offset " + offset + " < " + expected.length, offset < expected.length);
+ assertEquals("bytes should agree", expected[offset], buffer[bufferOffset]);
+ offset++;
+ bufferOffset++;
+ read--;
+ }
+ }
+ }
+ } finally {
+ in.close();
+ }
+ }
+
+ /**
+ * Fails with java.lang.UnsupportedOperationException at sun.nio.cs.ext.ISO2022_CN.newEncoder(Unknown Source).
+ * Probably not a good idea to use {@link Charset#availableCharsets()} because any encoding can fail for any
+ * reason.
+ */
+ @Test
+ @Ignore
+ public void testBufferedRead_AvailableCharset() throws IOException {
+ for (String csName : Charset.availableCharsets().keySet()) {
+ testBufferedRead(TEST_STRING, csName);
+ }
+ }
+
+ @Test
+ public void testBufferedRead_RequiredCharset() throws IOException {
+ for (String csName : getRequiredCharsetNames()) {
+ testBufferedRead(TEST_STRING, csName);
+ }
+ }
+
+ @Test
+ public void testBufferedRead_UTF8() throws IOException {
+ testBufferedRead(TEST_STRING, "UTF-8");
+ }
+
@Test
- public void testCharsetMismatchInfiniteLoop() throws IOException {
+ public void testCharsetMismatchInfiniteLoop_RequiredCharsets() throws IOException {
+ for (String csName : getRequiredCharsetNames()) {
+ testCharsetMismatchInfiniteLoop(csName);
+ }
+ }
+
+ private void testCharsetMismatchInfiniteLoop(String csName) throws IOException {
// Input is UTF-8 bytes: 0xE0 0xB2 0xA0
char[] inputChars = new char[] { (char) 0xE0, (char) 0xB2, (char) 0xA0 };
- // Charset charset = Charset.forName("UTF-8"); // works
- Charset charset = Charset.forName("ASCII"); // infinite loop
+ Charset charset = Charset.forName(csName); // infinite loop for US-ASCII, UTF-8 OK
InputStream stream = new CharSequenceInputStream(new String(inputChars), charset, 512);
try {
while (stream.read() != -1) {
@@ -58,19 +124,19 @@ public class CharSequenceInputStreamTest
stream.close();
}
}
-
+
@Test
public void testIO_356() throws Exception {
testIO_356(10, 10); // OK
testIO_356(10, 20); // OK
testIO_356(10, 13); // fails
- for(int bs = 1; bs <= 10; bs++) {
- for(int ds = 1; ds <= 20; ds++) {
- testIO_356(bs, ds);
+ for (int bs = 1; bs <= 10; bs++) {
+ for (int ds = 1; ds <= 20; ds++) {
+ testIO_356(bs, ds);
}
}
}
-
+
private void testIO_356(int bufferSize, int dataSize) throws Exception {
CharSequenceInputStream is = new CharSequenceInputStream(ALPHABET, "UTF-8", bufferSize);
@@ -85,114 +151,170 @@ public class CharSequenceInputStreamTest
is.read(data2);
is.close();
- assertArrayEquals("bufferSize="+bufferSize+" dataSize="+dataSize, data1, data2); // data buffers should be identical
+ assertArrayEquals("bufferSize=" + bufferSize + " dataSize=" + dataSize, data1, data2); // data buffers should
+ // be identical
}
-
+
@Test
- public void testLargeUTF8WithBufferedRead() throws IOException {
- testWithBufferedRead(LARGE_TEST_STRING, "UTF-8");
+ public void testLargeBufferedRead_RequiredCharsets() throws IOException {
+ for (String csName : getRequiredCharsetNames()) {
+ testBufferedRead(LARGE_TEST_STRING, csName);
+ }
}
-
+
@Test
- public void testLargeUTF8WithSingleByteRead() throws IOException {
- testWithSingleByteRead(LARGE_TEST_STRING, "UTF-8");
+ public void testLargeBufferedRead_UTF8() throws IOException {
+ testBufferedRead(LARGE_TEST_STRING, "UTF-8");
}
-
+
@Test
- public void testMarkReset() throws Exception {
- InputStream r = new CharSequenceInputStream("test", "UTF-8");
- r.skip(2);
- r.mark(0);
- assertEquals('s', r.read());
- assertEquals('t', r.read());
- assertEquals(-1, r.read());
- r.reset();
- assertEquals('s', r.read());
- assertEquals('t', r.read());
- assertEquals(-1, r.read());
- r.reset();
- r.reset();
+ public void testLargeSingleByteRead_RequiredCharsets() throws IOException {
+ for (String csName : getRequiredCharsetNames()) {
+ testSingleByteRead(LARGE_TEST_STRING, csName);
+ }
}
-
+
@Test
- public void testMarkSupported() throws Exception {
- InputStream r = new CharSequenceInputStream("test", "UTF-8");
- assertTrue(r.markSupported());
+ public void testLargeSingleByteRead_UTF8() throws IOException {
+ testSingleByteRead(LARGE_TEST_STRING, "UTF-8");
+ }
+
+ private void testMarkReset(String csName) throws Exception {
+ InputStream r = new CharSequenceInputStream("test", csName);
+ try {
+ r.skip(2);
+ r.mark(0);
+ assertEquals(csName, 's', r.read());
+ assertEquals(csName, 't', r.read());
+ assertEquals(csName, -1, r.read());
+ r.reset();
+ assertEquals(csName, 's', r.read());
+ assertEquals(csName, 't', r.read());
+ assertEquals(csName, -1, r.read());
+ r.reset();
+ r.reset();
+ } finally {
+ r.close();
+ }
}
-
+
@Test
- public void testReadZero() throws Exception {
- InputStream r = new CharSequenceInputStream("test", "UTF-8");
- byte[] bytes = new byte[30];
- assertEquals(0, r.read(bytes, 0, 0));
+ @Ignore
+ public void testMarkReset_RequiredCharsets() throws Exception {
+ for (String csName : getRequiredCharsetNames()) {
+ testMarkReset(csName);
+ }
}
@Test
- public void testReadZeroEmptyString() throws Exception {
- InputStream r = new CharSequenceInputStream("", "UTF-8");
- byte[] bytes = new byte[30];
- assertEquals(0, r.read(bytes, 0, 0));
+ public void testMarkReset_USASCII() throws Exception {
+ testMarkReset("US-ASCII");
}
-
+
@Test
- public void testSkip() throws Exception {
- InputStream r = new CharSequenceInputStream("test", "UTF-8");
- r.skip(1);
- r.skip(2);
- assertEquals('t', r.read());
- r.skip(100);
- assertEquals(-1, r.read());
+ public void testMarkReset_UTF8() throws Exception {
+ testMarkReset("UTF-8");
}
@Test
- public void testUTF16WithSingleByteRead() throws IOException {
- testWithSingleByteRead(TEST_STRING, "UTF-16");
+ public void testMarkSupported() throws Exception {
+ InputStream r = new CharSequenceInputStream("test", "UTF-8");
+ try {
+ assertTrue(r.markSupported());
+ } finally {
+ r.close();
+ }
+ }
+
+ public void testReadZero(String csName) throws Exception {
+ InputStream r = new CharSequenceInputStream("test", csName);
+ try {
+ byte[] bytes = new byte[30];
+ assertEquals(0, r.read(bytes, 0, 0));
+ } finally {
+ r.close();
+ }
}
@Test
- public void testUTF8WithBufferedRead() throws IOException {
- testWithBufferedRead(TEST_STRING, "UTF-8");
+ public void testReadZero_EmptyString() throws Exception {
+ InputStream r = new CharSequenceInputStream("", "UTF-8");
+ try {
+ byte[] bytes = new byte[30];
+ assertEquals(0, r.read(bytes, 0, 0));
+ } finally {
+ r.close();
+ }
}
@Test
- public void testUTF8WithSingleByteRead() throws IOException {
- testWithSingleByteRead(TEST_STRING, "UTF-8");
+ public void testReadZero_RequiredCharsets() throws Exception {
+ for (String csName : getRequiredCharsetNames()) {
+ testReadZero(csName);
+ }
}
- private void testWithBufferedRead(String testString, String charsetName) throws IOException {
- byte[] expected = testString.getBytes(charsetName);
+ private void testSingleByteRead(String testString, String charsetName) throws IOException {
+ byte[] bytes = testString.getBytes(charsetName);
InputStream in = new CharSequenceInputStream(testString, charsetName, 512);
- byte[] buffer = new byte[128];
- int offset = 0;
- while (true) {
- int bufferOffset = random.nextInt(64);
- int bufferLength = random.nextInt(64);
- int read = in.read(buffer, bufferOffset, bufferLength);
- if (read == -1) {
- assertEquals("EOF: offset should equal length", expected.length, offset);
- break;
- } else {
- assertTrue("Read "+read+" <= "+bufferLength, read <= bufferLength);
- while (read > 0) {
- assertTrue("offset "+offset+" < "+expected.length, offset < expected.length);
- assertEquals("bytes should agree", expected[offset], buffer[bufferOffset]);
- offset++;
- bufferOffset++;
- read--;
- }
+ try {
+ for (byte b : bytes) {
+ int read = in.read();
+ assertTrue("read " + read + " >=0 ", read >= 0);
+ assertTrue("read " + read + " <= 255", read <= 255);
+ assertEquals("Should agree with input", b, (byte) read);
}
+ assertEquals(-1, in.read());
+ } finally {
+ in.close();
}
}
-
- private void testWithSingleByteRead(String testString, String charsetName) throws IOException {
- byte[] bytes = testString.getBytes(charsetName);
- InputStream in = new CharSequenceInputStream(testString, charsetName, 512);
- for (byte b : bytes) {
- int read = in.read();
- assertTrue("read "+read+" >=0 ", read >= 0);
- assertTrue("read "+read+" <= 255", read <= 255);
- assertEquals("Should agree with input", b, (byte)read);
+
+ @Test
+ public void testSingleByteRead_RequiredCharsets() throws IOException {
+ for (String csName : getRequiredCharsetNames()) {
+ testSingleByteRead(TEST_STRING, csName);
}
- assertEquals(-1, in.read());
+ }
+
+ @Test
+ public void testSingleByteRead_UTF16() throws IOException {
+ testSingleByteRead(TEST_STRING, "UTF-16");
+ }
+
+ @Test
+ public void testSingleByteRead_UTF8() throws IOException {
+ testSingleByteRead(TEST_STRING, "UTF-8");
+ }
+
+ public void testSkip(String csName) throws Exception {
+ InputStream r = new CharSequenceInputStream("test", csName);
+ try {
+ r.skip(1);
+ r.skip(2);
+ assertEquals(csName, 't', r.read());
+ r.skip(100);
+ assertEquals(csName, -1, r.read());
+ } finally {
+ r.close();
+ }
+ }
+
+ @Test
+ @Ignore
+ public void testSkip_RequiredCharsets() throws Exception {
+ for (String csName : getRequiredCharsetNames()) {
+ testSkip(csName);
+ }
+ }
+
+ @Test
+ public void testSkip_USASCII() throws Exception {
+ testSkip("US-ASCII");
+ }
+
+ @Test
+ public void testSkip_UTF8() throws Exception {
+ testSkip("UTF-8");
}
}