/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package tests.api.java.io;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargetClass;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import tests.support.Support_OutputStream;
import junit.framework.TestCase;
/**
*
*/
@TestTargetClass(OutputStreamWriter.class)
public class OutputStreamWriterTest extends TestCase {
private static final int UPPER = 0xd800;
private static final int BUFFER_SIZE = 10000;
static private final String[] MINIMAL_CHARSETS = new String[] { "US-ASCII",
"ISO-8859-1", "UTF-16BE", "UTF-16LE", "UTF-16", "UTF-8" };
OutputStreamWriter osw;
InputStreamReader isr;
private Support_OutputStream fos;
public String testString = "This is a test message with Unicode characters. \u4e2d\u56fd is China's name in Chinese";
/*
* @see TestCase#setUp()
*/
protected void setUp() throws Exception {
super.setUp();
fos = new Support_OutputStream(500);
osw = new OutputStreamWriter(fos, "UTF-8");
}
/*
* @see TestCase#tearDown()
*/
protected void tearDown() throws Exception {
try {
if (isr != null) isr.close();
osw.close();
} catch (Exception e) {
}
super.tearDown();
}
/**
* @tests java.io.OutputStreamWriter#OutputStreamWriter(java.io.OutputStream)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "OutputStreamWriter",
args = {java.io.OutputStream.class}
)
public void test_ConstructorLjava_io_OutputStream() throws IOException {
OutputStreamWriter writer = null;
try {
writer = new OutputStreamWriter(null);
fail("Test 1: NullPointerException expected.");
} catch (NullPointerException e) {
// Expected
}
try {
writer = new OutputStreamWriter(new Support_OutputStream());
} catch (Exception e) {
fail("Test 2: Unexpected exception: " + e.getMessage());
}
// Test that the default encoding has been used.
assertEquals("Test 3: Incorrect default encoding used.",
Charset.defaultCharset(),
Charset.forName(writer.getEncoding()));
if (writer != null) writer.close();
}
/**
* @tests java.io.OutputStreamWriter#OutputStreamWriter(java.io.OutputStream,
* java.lang.String)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "OutputStreamWriter",
args = {java.io.OutputStream.class, java.lang.String.class}
)
public void test_ConstructorLjava_io_OutputStreamLjava_lang_String()
throws UnsupportedEncodingException {
try {
osw = new OutputStreamWriter(null, "utf-8");
fail("Test 1: NullPointerException expected.");
} catch (NullPointerException e) {
// Expected
}
try {
osw = new OutputStreamWriter(fos, (String) null);
fail("Test 2: NullPointerException expected.");
} catch (NullPointerException e) {
// Expected
}
try {
osw = new OutputStreamWriter(fos, "");
fail("Test 3: UnsupportedEncodingException expected.");
} catch (UnsupportedEncodingException e) {
// Expected
}
try {
osw = new OutputStreamWriter(fos, "Bogus");
fail("Test 4: UnsupportedEncodingException expected.");
} catch (UnsupportedEncodingException e) {
// Expected
}
try {
osw = new OutputStreamWriter(fos, "8859_1");
} catch (UnsupportedEncodingException e) {
fail("Test 5: Unexpected UnsupportedEncodingException.");
}
assertEquals("Test 6: Encoding not set correctly. ",
Charset.forName("8859_1"),
Charset.forName(osw.getEncoding()));
}
/**
* @tests java.io.OutputStreamWriter#OutputStreamWriter(java.io.OutputStream,
* java.nio.charset.Charset)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "OutputStreamWriter",
args = {java.io.OutputStream.class, java.nio.charset.Charset.class}
)
public void test_ConstructorLjava_io_OutputStreamLjava_nio_charset_Charset()
throws IOException {
OutputStreamWriter writer;
Support_OutputStream out = new Support_OutputStream();
Charset cs = Charset.forName("ascii");
try {
writer = new OutputStreamWriter(null, cs);
fail("Test 1: NullPointerException expected.");
} catch (NullPointerException e) {
// Expected
}
try {
writer = new OutputStreamWriter(out, (Charset) null);
fail("Test 2: NullPointerException expected.");
} catch (NullPointerException e) {
// Expected
}
writer = new OutputStreamWriter(out, cs);
assertEquals("Test 3: Encoding not set correctly. ",
cs, Charset.forName(writer.getEncoding()));
writer.close();
}
/**
* @tests java.io.OutputStreamWriter#OutputStreamWriter(java.io.OutputStream,
* java.nio.charset.CharsetEncoder)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "OutputStreamWriter",
args = {java.io.OutputStream.class, java.nio.charset.CharsetEncoder.class}
)
public void test_ConstructorLjava_io_OutputStreamLjava_nio_charset_CharsetEncoder()
throws IOException {
OutputStreamWriter writer;
Support_OutputStream out = new Support_OutputStream();
Charset cs = Charset.forName("ascii");
CharsetEncoder enc = cs.newEncoder();
try {
writer = new OutputStreamWriter(null, enc);
fail("Test 1: NullPointerException expected.");
} catch (NullPointerException e) {
// Expected
}
try {
writer = new OutputStreamWriter(out, (CharsetEncoder) null);
fail("Test 2: NullPointerException expected.");
} catch (NullPointerException e) {
// Expected
}
writer = new OutputStreamWriter(out, cs);
assertEquals("Test 3: CharacterEncoder not set correctly. ",
cs, Charset.forName(writer.getEncoding()));
writer.close();
}
/**
* @tests java.io.OutputStreamWriter#close()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "An issue in the API code has been identified (ticket #87). This test must be updated when the ticket is closed.",
method = "close",
args = {}
)
public void test_close() {
fos.setThrowsException(true);
try {
osw.close();
fail("Test 1: IOException expected.");
} catch (IOException e) {
// Expected.
}
/* Test 2 does not work and has therefore been disabled (see Ticket #87).
// Test 2: Write should not fail since the closing
// in test 1 has not been successful.
try {
osw.write("Lorem ipsum...");
} catch (IOException e) {
fail("Test 2: Unexpected IOException.");
}
// Test 3: Close should succeed.
fos.setThrowsException(false);
try {
osw.close();
} catch (IOException e) {
fail("Test 3: Unexpected IOException.");
}
*/
ByteArrayOutputStream bout = new ByteArrayOutputStream();
try {
OutputStreamWriter writer = new OutputStreamWriter(bout,
"ISO2022JP");
writer.write(new char[] { 'a' });
writer.close();
// The default is ASCII, there should not be any mode changes.
String converted = new String(bout.toByteArray(), "ISO8859_1");
assertTrue("Test 4: Invalid conversion: " + converted,
converted.equals("a"));
bout.reset();
writer = new OutputStreamWriter(bout, "ISO2022JP");
writer.write(new char[] { '\u3048' });
writer.flush();
// The byte sequence should not switch to ASCII mode until the
// stream is closed.
converted = new String(bout.toByteArray(), "ISO8859_1");
assertTrue("Test 5: Invalid conversion: " + converted,
converted.equals("\u001b$B$("));
writer.close();
converted = new String(bout.toByteArray(), "ISO8859_1");
assertTrue("Test 6: Invalid conversion: " + converted,
converted.equals("\u001b$B$(\u001b(B"));
bout.reset();
writer = new OutputStreamWriter(bout, "ISO2022JP");
writer.write(new char[] { '\u3048' });
writer.write(new char[] { '\u3048' });
writer.close();
// There should not be a mode switch between writes.
assertEquals("Test 7: Invalid conversion. ",
"\u001b$B$($(\u001b(B",
new String(bout.toByteArray(), "ISO8859_1"));
} catch (UnsupportedEncodingException e) {
// Can't test missing converter.
System.out.println(e);
} catch (IOException e) {
fail("Unexpected: " + e);
}
}
/**
* @tests java.io.OutputStreamWriter#flush()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "flush",
args = {}
)
public void test_flush() {
// Test for method void java.io.OutputStreamWriter.flush()
try {
char[] buf = new char[testString.length()];
osw.write(testString, 0, testString.length());
osw.flush();
openInputStream();
isr.read(buf, 0, buf.length);
assertTrue("Test 1: Characters have not been flushed.",
new String(buf, 0, buf.length).equals(testString));
} catch (Exception e) {
fail("Test 1: Unexpected exception: " + e.getMessage());
}
fos.setThrowsException(true);
try {
osw.flush();
fail("Test 2: IOException expected.");
} catch (IOException e) {
// Expected
}
fos.setThrowsException(false);
}
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {int.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "read",
args = {},
clazz = InputStreamReader.class
)
})
public void test_singleCharIO() throws Exception {
int upper;
OutputStreamWriter writer = null;
ByteArrayOutputStream out;
InputStreamReader isr = null;
for (int i = 0; i < MINIMAL_CHARSETS.length; ++i) {
try {
out = new ByteArrayOutputStream();
writer = new OutputStreamWriter(out, MINIMAL_CHARSETS[i]);
switch (i) {
case 0:
upper = 128;
break;
case 1:
upper = 256;
break;
default:
upper = UPPER;
}
for (int c = 0; c < upper; ++c) {
writer.write(c);
}
writer.flush();
byte[] result = out.toByteArray();
isr = new InputStreamReader(new ByteArrayInputStream(result),
MINIMAL_CHARSETS[i]);
for (int expected = 0; expected < upper; ++expected) {
assertEquals("Error when reading bytes in "
+ MINIMAL_CHARSETS[i], expected, isr.read());
}
} finally {
try {
if (isr != null) isr.close();
} catch (Exception e) {
}
try {
if (writer != null) writer.close();
} catch (Exception e) {
}
}
}
}
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
method = "write",
args = {char[].class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "read",
args = {},
clazz = InputStreamReader.class
)
})
public void test_write$C() throws Exception {
int upper;
InputStreamReader isr = null;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
OutputStreamWriter writer = null;
char[] largeBuffer = new char[BUFFER_SIZE];
for (int i = 0; i < MINIMAL_CHARSETS.length; ++i) {
try {
baos = new ByteArrayOutputStream();
writer = new OutputStreamWriter(baos, MINIMAL_CHARSETS[i]);
switch (i) {
case 0:
upper = 128;
break;
case 1:
upper = 256;
break;
default:
upper = UPPER;
}
int m = 0;
for (int c = 0; c < upper; ++c) {
largeBuffer[m++] = (char) c;
if (m == BUFFER_SIZE) {
writer.write(largeBuffer);
m = 0;
}
}
writer.write(largeBuffer, 0, m);
writer.flush();
byte[] result = baos.toByteArray();
isr = new InputStreamReader(new ByteArrayInputStream(result),
MINIMAL_CHARSETS[i]);
int expected = 0, read = 0, j = 0;
while (expected < upper) {
if (j == read) {
read = isr.read(largeBuffer);
j = 0;
}
assertEquals("Error when reading bytes in "
+ MINIMAL_CHARSETS[i] + " at " + j, expected++, largeBuffer[j++]);
}
} finally {
try {
if (isr != null) isr.close();
} catch (Exception e) {
}
try {
if (writer != null) writer.close();
} catch (Exception e) {
}
}
}
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {char[].class}
)
public void test_write_US_ASCII() throws Exception {
testEncodeCharset("US-ASCII", 128);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {char[].class}
)
public void test_write_ISO_8859_1() throws Exception {
testEncodeCharset("ISO-8859-1", 256);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {char[].class}
)
public void test_write_UTF_16BE() throws Exception {
testEncodeCharset("UTF-16BE", 0xd800);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {char[].class}
)
public void test_write_UTF_16LE() throws Exception {
testEncodeCharset("UTF-16LE", 0xd800);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {char[].class}
)
public void test_write_UTF_16() throws Exception {
testEncodeCharset("UTF-16", 0xd800);
}
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {char[].class}
)
public void test_write_UTF_8() throws Exception {
testEncodeCharset("UTF-8", 0xd800);
}
private void testEncodeCharset(String charset, int maxChar) throws Exception {
char[] chars = new char[maxChar];
for (int i = 0; i < maxChar; i++) {
chars[i] = (char) i;
}
// to byte array
ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
OutputStreamWriter charsOut = new OutputStreamWriter(bytesOut, charset);
charsOut.write(chars);
charsOut.flush();
// decode from byte array, one character at a time
ByteArrayInputStream bytesIn = new ByteArrayInputStream(bytesOut.toByteArray());
InputStreamReader charsIn = new InputStreamReader(bytesIn, charset);
for (int i = 0; i < maxChar; i++) {
assertEquals(i, charsIn.read());
}
assertEquals(-1, charsIn.read());
// decode from byte array, using byte buffers
bytesIn = new ByteArrayInputStream(bytesOut.toByteArray());
charsIn = new InputStreamReader(bytesIn, charset);
char[] decoded = new char[maxChar];
for (int r = 0; r < maxChar; ) {
r += charsIn.read(decoded, r, maxChar - r);
}
assertEquals(-1, charsIn.read());
for (int i = 0; i < maxChar; i++) {
assertEquals(i, decoded[i]);
}
}
/**
* @tests java.io.OutputStreamWriter#getEncoding()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getEncoding",
args = {}
)
public void test_getEncoding() throws IOException {
OutputStreamWriter writer;
writer = new OutputStreamWriter(new Support_OutputStream(), "utf-8");
assertEquals("Test 1: Incorrect encoding returned.",
Charset.forName("utf-8"),
Charset.forName(writer.getEncoding()));
writer.close();
assertNull("Test 2: getEncoding() did not return null for a closed writer.",
writer.getEncoding());
}
/**
* @tests java.io.OutputStreamWriter#write(char[], int, int)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {char[].class, int.class, int.class}
)
public void test_write$CII() throws IOException {
char[] chars = testString.toCharArray();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
Support_OutputStream out = new Support_OutputStream(500);
OutputStreamWriter writer;
writer = new OutputStreamWriter(out, "utf-8");
try {
writer.write(chars, -1, 1);
fail("Test 1: IndexOutOfBoundsException expected.");
} catch (IndexOutOfBoundsException e) {
// Expected
}
try {
writer.write(chars, 0, -1);
fail("Test 2: IndexOutOfBoundsException expected.");
} catch (IndexOutOfBoundsException e) {
// Expected
}
try {
writer.write(new char[0], 0, 1);
fail("Test 3: IndexOutOfBoundsException expected.");
} catch (IndexOutOfBoundsException e) {
// Expected
}
try {
writer.write((char[]) null, 0, 1);
fail("Test 4: NullPointerException expected.");
} catch (NullPointerException e) {
// Expected
}
try {
writer.write(chars, 1, chars.length);
fail("Test 5a: IndexOutOfBoundsException expected.");
} catch (IndexOutOfBoundsException e) {
// Expected
}
try {
writer.write(chars, 0, chars.length + 1);
fail("Test 5b: IndexOutOfBoundsException expected.");
} catch (IndexOutOfBoundsException e) {
// Expected
}
try {
writer.write(chars, chars.length, 1);
fail("Test 5c: IndexOutOfBoundsException expected.");
} catch (IndexOutOfBoundsException e) {
// Expected
}
try {
writer.write(chars, chars.length + 1, 0);
fail("Test 5d: IndexOutOfBoundsException expected.");
} catch (IndexOutOfBoundsException e) {
// Expected
}
out.setThrowsException(true);
try {
for (int i = 0; i < 200; i++) {
writer.write(chars, 0, chars.length);
}
fail("Test 6: IOException expected.");
} catch (IOException e) {
// Expected
}
out.setThrowsException(false);
writer.close();
writer = new OutputStreamWriter(baos, "utf-8");
writer.write(chars, 1, 2);
writer.flush();
assertEquals("Test 7: write(char[], int, int) has not produced the " +
"expected content in the output stream.",
"hi", baos.toString("utf-8"));
writer.write(chars, 0, chars.length);
writer.flush();
assertEquals("Test 8: write(char[], int, int) has not produced the " +
"expected content in the output stream.",
"hi" + testString, baos.toString("utf-8"));
writer.close();
try {
writer.write((char[]) null, -1, -1);
fail("Test 9: IOException expected.");
} catch (IOException e) {
// Expected
}
}
/**
* @tests java.io.OutputStreamWriter#write(int)
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {int.class}
)
public void test_writeI() throws IOException {
Support_OutputStream out = new Support_OutputStream(500);
OutputStreamWriter writer;
out.setThrowsException(true);
writer = new OutputStreamWriter(out, "utf-8");
try {
// Since there is an internal buffer in the encoder, more than
// one character needs to be written.
for (int i = 0; i < 200; i++) {
for (int j = 0; j < testString.length(); j++) {
writer.write(testString.charAt(j));
}
}
fail("Test 1: IOException expected.");
} catch (IOException e) {
// Expected
}
out.setThrowsException(false);
writer.close();
writer = new OutputStreamWriter(out, "utf-8");
writer.write(1);
writer.flush();
String str = new String(out.toByteArray(), "utf-8");
assertEquals("Test 2: ", "\u0001", str);
writer.write(2);
writer.flush();
str = new String(out.toByteArray(), "utf-8");
assertEquals("Test 3: ", "\u0001\u0002", str);
writer.write(-1);
writer.flush();
str = new String(out.toByteArray(), "utf-8");
assertEquals("Test 4: ", "\u0001\u0002\uffff", str);
writer.write(0xfedcb);
writer.flush();
str = new String(out.toByteArray(), "utf-8");
assertEquals("Test 5: ", "\u0001\u0002\uffff\uedcb", str);
writer.close();
try {
writer.write(1);
fail("Test 6: IOException expected.");
} catch (IOException e) {
// Expected
}
}
/**
* @tests java.io.OutputStreamWriter#write(java.lang.String, int, int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "write",
args = {java.lang.String.class, int.class, int.class}
)
public void test_writeLjava_lang_StringII() throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
Support_OutputStream out = new Support_OutputStream(500);
OutputStreamWriter writer;
writer = new OutputStreamWriter(out, "utf-8");
try {
writer.write("Lorem", -1, 0);
fail("Test 1: IndexOutOfBoundsException expected.");
} catch (IndexOutOfBoundsException e) {
// Expected
}
try {
writer.write("Lorem", 0, -1);
fail("Test 2: IndexOutOfBoundsException expected.");
} catch (IndexOutOfBoundsException e) {
// Expected
}
try {
writer.write("", 0, 1);
fail("Test 3: IndexOutOfBoundsException expected.");
} catch (IndexOutOfBoundsException e) {
// Expected
}
try {
writer.write(testString, 1, testString.length());
fail("Test 4a: IndexOutOfBoundsException expected.");
} catch (IndexOutOfBoundsException e) {
// Expected
}
try {
writer.write(testString, 0, testString.length() + 1);
fail("Test 4b: IndexOutOfBoundsException expected.");
} catch (IndexOutOfBoundsException e) {
// Expected
}
try {
writer.write(testString, testString.length(), 1);
fail("Test 4c: IndexOutOfBoundsException expected.");
} catch (IndexOutOfBoundsException e) {
// Expected
}
try {
writer.write(testString, testString.length() + 1, 0);
fail("Test 4d: IndexOutOfBoundsException expected.");
} catch (IndexOutOfBoundsException e) {
// Expected
}
try {
writer.write((String) null, 0, 1);
fail("Test 5: NullPointerException expected.");
} catch (NullPointerException e) {
// Expected
}
out.setThrowsException(true);
try {
for (int i = 0; i < 200; i++) {
writer.write(testString, 0, testString.length());
}
fail("Test 6: IOException expected.");
} catch (IOException e) {
// Expected
}
out.setThrowsException(false);
writer.close();
writer = new OutputStreamWriter(baos, "utf-8");
writer.write("abc", 1, 2);
writer.flush();
assertEquals("Test 7: write(String, int, int) has not produced the " +
"expected content in the output stream.",
"bc", baos.toString("utf-8"));
writer.write(testString, 0, testString.length());
writer.flush();
assertEquals("Test 7: write(String, int, int) has not produced the " +
"expected content in the output stream.",
"bc" + testString, baos.toString("utf-8"));
writer.close();
try {
writer.write("abc", 0, 1);
fail("Test 8: IOException expected.");
} catch (IOException e) {
// Expected
}
}
private void openInputStream() {
try {
isr = new InputStreamReader(new ByteArrayInputStream(fos.toByteArray()), "UTF-8");
} catch (UnsupportedEncodingException e) {
fail("UTF-8 not supported");
}
}
}