harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject svn commit: r695470 - in /harmony/enhanced/classlib/trunk/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io: OutputStreamWriterTest.java RandomAccessFileTest.java
Date Mon, 15 Sep 2008 13:54:44 GMT
Author: tellison
Date: Mon Sep 15 06:54:43 2008
New Revision: 695470

URL: http://svn.apache.org/viewvc?rev=695470&view=rev
Log:
Ensure temporary files are deleted after running tests.

Modified:
    harmony/enhanced/classlib/trunk/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/OutputStreamWriterTest.java
    harmony/enhanced/classlib/trunk/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/RandomAccessFileTest.java

Modified: harmony/enhanced/classlib/trunk/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/OutputStreamWriterTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/OutputStreamWriterTest.java?rev=695470&r1=695469&r2=695470&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/OutputStreamWriterTest.java (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/OutputStreamWriterTest.java Mon Sep 15 06:54:43 2008
@@ -1,702 +1,703 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-package org.apache.harmony.luni.tests.java.io;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileReader;
-import java.io.FileWriter;
-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 junit.framework.TestCase;
-
-public class OutputStreamWriterTest extends TestCase {
-
-    private static final int UPPER = 0xd800;
-
-    private static final int BUFFER_SIZE = 10000;
-
-    private ByteArrayOutputStream out;
-
-    private OutputStreamWriter writer;
-
-    static private final String source = "This is a test message with Unicode character. \u4e2d\u56fd is China's name in Chinese";
-
-    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 ByteArrayOutputStream fos;
-
-    String testString = "Test_All_Tests\nTest_java_io_BufferedInputStream\nTest_java_io_BufferedOutputStream\nTest_java_io_ByteArrayInputStream\nTest_java_io_ByteArrayOutputStream\nTest_java_io_DataInputStream\n";
-
-    /*
-     * @see TestCase#setUp()
-     */
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-        out = new ByteArrayOutputStream();
-        writer = new OutputStreamWriter(out, "utf-8");
-
-        fos = new ByteArrayOutputStream();
-        osw = new OutputStreamWriter(fos);
-    }
-
-    /*
-     * @see TestCase#tearDown()
-     */
-    @Override
-    protected void tearDown() throws Exception {
-        try {
-            writer.close();
-
-            if (isr != null) {
-                isr.close();
-            }
-            osw.close();
-        } catch (Exception e) {
-            // Ignored
-        }
-
-        super.tearDown();
-    }
-
-    public void testClose() throws Exception {
-        writer.flush();
-        writer.close();
-        try {
-            writer.flush();
-            fail();
-        } catch (IOException e) {
-            // Expected
-        }
-    }
-
-    public void testFlush() throws Exception {
-        writer.write(source);
-        writer.flush();
-        String result = out.toString("utf-8");
-        assertEquals(source, result);
-    }
-
-    /*
-     * Class under test for void write(char[], int, int)
-     */
-    public void testWritecharArrayintint() throws IOException {
-        char[] chars = source.toCharArray();
-
-        // Throws IndexOutOfBoundsException if offset is negative
-        try {
-            writer.write((char[]) null, -1, -1);
-            fail("should throw IndexOutOfBoundsException");
-        } catch (IndexOutOfBoundsException e) {
-            // Expected
-        }
-
-        // throws NullPointerException though count is negative
-        try {
-            writer.write((char[]) null, 1, -1);
-            fail("should throw NullPointerException");
-        } catch (NullPointerException e) {
-            // Expected
-        }
-
-        try {
-            writer.write((char[]) null, 1, 1);
-            fail();
-        } catch (NullPointerException e) {
-            // Expected
-        }
-        try {
-            writer.write(new char[0], 0, 1);
-            fail();
-        } catch (IndexOutOfBoundsException e) {
-            // Expected
-        }
-        try {
-            writer.write(chars, -1, 1);
-            fail();
-        } catch (IndexOutOfBoundsException e) {
-            // Expected
-        }
-        try {
-            writer.write(chars, 0, -1);
-            fail();
-        } catch (IndexOutOfBoundsException e) {
-            // Expected
-        }
-        try {
-            writer.write(chars, 1, chars.length);
-            fail();
-        } catch (IndexOutOfBoundsException e) {
-            // Expected
-        }
-        writer.write(chars, 1, 2);
-        writer.flush();
-        assertEquals("hi", out.toString("utf-8"));
-        writer.write(chars, 0, chars.length);
-        writer.flush();
-        assertEquals("hi" + source, out.toString("utf-8"));
-
-        writer.close();
-        // After the stream is closed, should throw IOException first
-        try {
-            writer.write((char[]) null, -1, -1);
-            fail("should throw IOException");
-        } catch (IOException e) {
-            // Expected
-        }
-    }
-
-    /*
-     * Class under test for void write(int)
-     */
-    public void testWriteint() throws IOException {
-        writer.write(1);
-        writer.flush();
-        String str = new String(out.toByteArray(), "utf-8");
-        assertEquals("\u0001", str);
-
-        writer.write(2);
-        writer.flush();
-        str = new String(out.toByteArray(), "utf-8");
-        assertEquals("\u0001\u0002", str);
-
-        writer.write(-1);
-        writer.flush();
-        str = new String(out.toByteArray(), "utf-8");
-        assertEquals("\u0001\u0002\uffff", str);
-
-        writer.write(0xfedcb);
-        writer.flush();
-        str = new String(out.toByteArray(), "utf-8");
-        assertEquals("\u0001\u0002\uffff\uedcb", str);
-
-        writer.close();
-        // After the stream is closed, should throw IOException
-        try {
-            writer.write(1);
-            fail("should throw IOException");
-        } catch (IOException e) {
-            // expected
-        }
-    }
-
-    /*
-     * Class under test for void write(String, int, int)
-     */
-    public void testWriteStringintint() throws IOException {
-        try {
-            writer.write((String) null, 1, 1);
-            fail();
-        } catch (NullPointerException e) {
-            // Expected
-        }
-        try {
-            writer.write("", 0, 1);
-            fail();
-        } catch (StringIndexOutOfBoundsException e) {
-            // Expected
-        }
-        try {
-            writer.write("abc", -1, 1);
-            fail();
-        } catch (StringIndexOutOfBoundsException e) {
-            // Expected
-        }
-        try {
-            writer.write("abc", 0, -1);
-            fail();
-        } catch (IndexOutOfBoundsException e) {
-            // Expected
-        }
-        try {
-            writer.write("abc", 1, 3);
-            fail();
-        } catch (StringIndexOutOfBoundsException e) {
-            // Expected
-        }
-
-        // Throws IndexOutOfBoundsException before NullPointerException if count
-        // is negative
-        try {
-            writer.write((String) null, -1, -1);
-            fail("should throw IndexOutOfBoundsException");
-        } catch (IndexOutOfBoundsException e) {
-            // Expected
-        }
-
-        // Throws NullPointerException before StringIndexOutOfBoundsException
-        try {
-            writer.write((String) null, -1, 0);
-            fail("should throw NullPointerException");
-        } catch (NullPointerException e) {
-            // expected
-        }
-
-        writer.write("abc", 1, 2);
-        writer.flush();
-        assertEquals("bc", out.toString("utf-8"));
-        writer.write(source, 0, source.length());
-        writer.flush();
-        assertEquals("bc" + source, out.toString("utf-8"));
-
-        writer.close();
-        // Throws IndexOutOfBoundsException first if count is negative
-        try {
-            writer.write((String) null, 0, -1);
-            fail("should throw IndexOutOfBoundsException");
-        } catch (IndexOutOfBoundsException e) {
-            // Expected
-        }
-
-        try {
-            writer.write((String) null, -1, 0);
-            fail("should throw NullPointerException");
-        } catch (NullPointerException e) {
-            // Expected
-        }
-
-        try {
-            writer.write("abc", -1, 0);
-            fail("should throw StringIndexOutOfBoundsException");
-        } catch (StringIndexOutOfBoundsException e) {
-            // Expected
-        }
-
-        // Throws IOException
-        try {
-            writer.write("abc", 0, 1);
-            fail("should throw IOException");
-        } catch (IOException e) {
-            // expected
-        }
-    }
-
-    /*
-     * Class under test for void OutputStreamWriter(OutputStream)
-     */
-    public void testOutputStreamWriterOutputStream() throws IOException {
-        try {
-            writer = new OutputStreamWriter(null);
-            fail();
-        } catch (NullPointerException e) {
-            // Expected
-        }
-        OutputStreamWriter writer2 = new OutputStreamWriter(out);
-        writer2.close();
-    }
-
-    /*
-     * Class under test for void OutputStreamWriter(OutputStream, String)
-     */
-    public void testOutputStreamWriterOutputStreamString() throws IOException {
-        try {
-            writer = new OutputStreamWriter(null, "utf-8");
-            fail();
-        } catch (NullPointerException e) {
-            // Expected
-        }
-        try {
-            writer = new OutputStreamWriter(out, "");
-            fail();
-        } catch (UnsupportedEncodingException e) {
-            // Expected
-        }
-        try {
-            writer = new OutputStreamWriter(out, "badname");
-            fail();
-        } catch (UnsupportedEncodingException e) {
-            // Expected
-        }
-        try {
-            writer = new OutputStreamWriter(out, (String) null);
-            fail();
-        } catch (NullPointerException e) {
-            // Expected
-        }
-        OutputStreamWriter writer2 = new OutputStreamWriter(out, "ascii");
-        assertEquals(Charset.forName("ascii"), Charset.forName(writer2
-                .getEncoding()));
-        writer2.close();
-    }
-
-    /*
-     * Class under test for void OutputStreamWriter(OutputStream)
-     */
-    public void testOutputStreamWriterOutputStreamCharset() throws IOException {
-        Charset cs = Charset.forName("ascii");
-        try {
-            writer = new OutputStreamWriter(null, cs);
-            fail();
-        } catch (NullPointerException e) {
-            // Expected
-        }
-        try {
-            writer = new OutputStreamWriter(out, (Charset) null);
-            fail();
-        } catch (NullPointerException e) {
-            // Expected
-        }
-        OutputStreamWriter writer2 = new OutputStreamWriter(out, cs);
-        assertEquals(cs, Charset.forName(writer2.getEncoding()));
-        writer2.close();
-    }
-
-    /*
-     * Class under test for void OutputStreamWriter(OutputStream, String)
-     */
-    public void testOutputStreamWriterOutputStreamCharsetEncoder()
-            throws IOException {
-        Charset cs = Charset.forName("ascii");
-        CharsetEncoder enc = cs.newEncoder();
-        try {
-            writer = new OutputStreamWriter(null, enc);
-            fail();
-        } catch (NullPointerException e) {
-            // Expected
-        }
-        try {
-            writer = new OutputStreamWriter(out, (CharsetEncoder) null);
-            fail();
-        } catch (NullPointerException e) {
-            // Expected
-        }
-        OutputStreamWriter writer2 = new OutputStreamWriter(out, enc);
-        assertEquals(cs, Charset.forName(writer2.getEncoding()));
-        writer2.close();
-    }
-
-    public void testGetEncoding() {
-        Charset cs = Charset.forName("utf-8");
-        assertEquals(cs, Charset.forName(writer.getEncoding()));
-    }
-
-    public void testHandleEarlyEOFChar_1() throws IOException {
-        String str = "All work and no play makes Jack a dull boy\n"; //$NON-NLS-1$
-        int NUMBER = 2048;
-        int j = 0;
-        int len = str.length() * NUMBER;
-        char[] strChars = new char[len];
-        for (int i = 0; i < NUMBER; ++i) {
-            for (int k = 0; k < str.length(); ++k) {
-                strChars[j++] = str.charAt(k);
-            }
-        }
-
-        File f = File.createTempFile("one", "by_one");
-        FileWriter fw = new FileWriter(f);
-        fw.write(strChars);
-        fw.close();
-        FileInputStream fis = new FileInputStream(f);
-        InputStreamReader in = new InputStreamReader(fis);
-        for (int offset = 0; offset < strChars.length; ++offset) {
-            int b = in.read();
-            assertFalse("Early EOF at offset", -1 == b);
-        }
-    }
-
-    public void testHandleEarlyEOFChar_2() throws IOException {
-        int capacity = 65536;
-        byte[] bytes = new byte[capacity];
-        byte[] bs = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H' };
-        for (int i = 0; i < bytes.length; i++) {
-            bytes[i] = bs[i / 8192];
-        }
-        String inputStr = new String(bytes);
-        int len = inputStr.length();
-        File f = File.createTempFile("FileWriterBugTest ", null); //$NON-NLS-1$
-        FileWriter writer = new FileWriter(f);
-        writer.write(inputStr);
-        writer.close();
-        long flen = f.length();
-
-        FileReader reader = new FileReader(f);
-        char[] outChars = new char[capacity];
-        int outCount = reader.read(outChars);
-        String outStr = new String(outChars, 0, outCount);
-
-        f.deleteOnExit();
-        assertEquals(len, flen);
-        assertEquals(inputStr, outStr);
-    }
-
-    public void testSingleCharIO() throws Exception {
-        InputStreamReader isr = null;
-        for (int i = 0; i < MINIMAL_CHARSETS.length; ++i) {
-            try {
-                out = new ByteArrayOutputStream();
-                writer = new OutputStreamWriter(out, MINIMAL_CHARSETS[i]);
-
-                int upper = UPPER;
-                switch (i) {
-                case 0:
-                    upper = 128;
-                    break;
-                case 1:
-                    upper = 256;
-                    break;
-                }
-
-                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 {
-                    isr.close();
-                } catch (Exception e) {
-                }
-                try {
-                    writer.close();
-                } catch (Exception e) {
-                }
-            }
-        }
-    }
-
-    public void testBlockIO() throws Exception {
-        InputStreamReader isr = null;
-        char[] largeBuffer = new char[BUFFER_SIZE];
-        for (int i = 0; i < MINIMAL_CHARSETS.length; ++i) {
-            try {
-                out = new ByteArrayOutputStream();
-                writer = new OutputStreamWriter(out, MINIMAL_CHARSETS[i]);
-
-                int upper = UPPER;
-                switch (i) {
-                case 0:
-                    upper = 128;
-                    break;
-                case 1:
-                    upper = 256;
-                    break;
-                }
-
-                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 = out.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], expected++, largeBuffer[j++]);
-                }
-            } finally {
-                try {
-                    isr.close();
-                } catch (Exception e) {
-                }
-                try {
-                    writer.close();
-                } catch (Exception e) {
-                }
-            }
-        }
-    }
-
-    /**
-     * @tests java.io.OutputStreamWriter#OutputStreamWriter(java.io.OutputStream)
-     */
-    public void test_ConstructorLjava_io_OutputStream() {
-        assertTrue("Used in tests", true);
-    }
-
-    /**
-     * @tests java.io.OutputStreamWriter#OutputStreamWriter(java.io.OutputStream,
-     *        java.lang.String)
-     */
-    public void test_ConstructorLjava_io_OutputStreamLjava_lang_String()
-            throws UnsupportedEncodingException {
-        osw = new OutputStreamWriter(fos, "8859_1");
-        try {
-            osw = new OutputStreamWriter(fos, "Bogus");
-            fail("Failed to throw Unsupported Encoding exception");
-        } catch (UnsupportedEncodingException e) {
-            // Expected
-        }
-    }
-
-    /**
-     * @tests java.io.OutputStreamWriter#close()
-     */
-    public void test_close() throws IOException {
-        osw.close();
-
-        try {
-            osw.write(testString, 0, testString.length());
-            fail("Chars written after close");
-        } catch (IOException e) {
-            // Expected
-        }
-
-        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("invalid conversion 1: " + 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("invalid conversion 2: " + converted, converted
-                    .equals("\u001b$B$("));
-            writer.close();
-            converted = new String(bout.toByteArray(), "ISO8859_1");
-            assertTrue("invalid conversion 3: " + 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("invalid conversion 4", "\u001b$B$($(\u001b(B",
-                    new String(bout.toByteArray(), "ISO8859_1"));
-        } catch (UnsupportedEncodingException e) {
-            // Can't test missing converter
-            System.out.println(e);
-        }
-    }
-
-    /**
-     * @tests java.io.OutputStreamWriter#flush()
-     */
-    public void test_flush() throws IOException {
-        char[] buf = new char[testString.length()];
-        osw.write(testString, 0, testString.length());
-        osw.flush();
-        openInputStream();
-        isr.read(buf, 0, buf.length);
-        assertTrue("Chars not flushed", new String(buf, 0, buf.length)
-                .equals(testString));
-    }
-
-    /**
-     * @tests java.io.OutputStreamWriter#getEncoding()
-     */
-    public void test_getEncoding() throws IOException {
-        try {
-            osw = new OutputStreamWriter(fos, "8859_1");
-        } catch (UnsupportedEncodingException e) {
-            assertEquals("Returned incorrect encoding", "8859_1", osw
-                    .getEncoding());
-        }
-
-        OutputStreamWriter out = new OutputStreamWriter(
-                new ByteArrayOutputStream(), "UTF-16BE");
-        out.close();
-
-        String result = out.getEncoding();
-        assertNull(result);
-
-        out = null;
-        try {
-            out = new OutputStreamWriter(new ByteArrayOutputStream(),
-                    "UTF-16BE");
-        } catch (UnsupportedEncodingException e) {
-            // ok
-        }
-        result = out.getEncoding();
-        assertEquals("UnicodeBigUnmarked", result);
-    }
-
-    /**
-     * @tests java.io.OutputStreamWriter#write(char[], int, int)
-     */
-    public void test_write$CII() throws IOException {
-        char[] buf = new char[testString.length()];
-        osw.write(testString, 0, testString.length());
-        osw.close();
-        openInputStream();
-        isr.read(buf, 0, buf.length);
-        assertTrue("Incorrect chars returned", new String(buf, 0, buf.length)
-                .equals(testString));
-    }
-
-    /**
-     * @tests java.io.OutputStreamWriter#write(int)
-     */
-    public void test_writeI() throws IOException {
-        osw.write('T');
-        osw.close();
-        openInputStream();
-        int c = isr.read();
-        assertEquals("Incorrect char returned", 'T', (char) c);
-    }
-
-    /**
-     * @tests java.io.OutputStreamWriter#write(java.lang.String, int, int)
-     */
-    public void test_writeLjava_lang_StringII() throws IOException {
-        char[] buf = new char[testString.length()];
-        osw.write(testString, 0, testString.length());
-        osw.close();
-        openInputStream();
-        isr.read(buf);
-        assertTrue("Incorrect chars returned", new String(buf, 0, buf.length)
-                .equals(testString));
-    }
-
-    private void openInputStream() {
-        isr = new InputStreamReader(new ByteArrayInputStream(fos.toByteArray()));
-    }
-}
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You under the Apache License, Version 2.0
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package org.apache.harmony.luni.tests.java.io;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+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 junit.framework.TestCase;
+
+public class OutputStreamWriterTest extends TestCase {
+
+    private static final int UPPER = 0xd800;
+
+    private static final int BUFFER_SIZE = 10000;
+
+    private ByteArrayOutputStream out;
+
+    private OutputStreamWriter writer;
+
+    static private final String source = "This is a test message with Unicode character. \u4e2d\u56fd is China's name in Chinese";
+
+    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 ByteArrayOutputStream fos;
+
+    String testString = "Test_All_Tests\nTest_java_io_BufferedInputStream\nTest_java_io_BufferedOutputStream\nTest_java_io_ByteArrayInputStream\nTest_java_io_ByteArrayOutputStream\nTest_java_io_DataInputStream\n";
+
+    /*
+     * @see TestCase#setUp()
+     */
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        out = new ByteArrayOutputStream();
+        writer = new OutputStreamWriter(out, "utf-8");
+
+        fos = new ByteArrayOutputStream();
+        osw = new OutputStreamWriter(fos);
+    }
+
+    /*
+     * @see TestCase#tearDown()
+     */
+    @Override
+    protected void tearDown() throws Exception {
+        try {
+            writer.close();
+
+            if (isr != null) {
+                isr.close();
+            }
+            osw.close();
+        } catch (Exception e) {
+            // Ignored
+        }
+
+        super.tearDown();
+    }
+
+    public void testClose() throws Exception {
+        writer.flush();
+        writer.close();
+        try {
+            writer.flush();
+            fail();
+        } catch (IOException e) {
+            // Expected
+        }
+    }
+
+    public void testFlush() throws Exception {
+        writer.write(source);
+        writer.flush();
+        String result = out.toString("utf-8");
+        assertEquals(source, result);
+    }
+
+    /*
+     * Class under test for void write(char[], int, int)
+     */
+    public void testWritecharArrayintint() throws IOException {
+        char[] chars = source.toCharArray();
+
+        // Throws IndexOutOfBoundsException if offset is negative
+        try {
+            writer.write((char[]) null, -1, -1);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // Expected
+        }
+
+        // throws NullPointerException though count is negative
+        try {
+            writer.write((char[]) null, 1, -1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // Expected
+        }
+
+        try {
+            writer.write((char[]) null, 1, 1);
+            fail();
+        } catch (NullPointerException e) {
+            // Expected
+        }
+        try {
+            writer.write(new char[0], 0, 1);
+            fail();
+        } catch (IndexOutOfBoundsException e) {
+            // Expected
+        }
+        try {
+            writer.write(chars, -1, 1);
+            fail();
+        } catch (IndexOutOfBoundsException e) {
+            // Expected
+        }
+        try {
+            writer.write(chars, 0, -1);
+            fail();
+        } catch (IndexOutOfBoundsException e) {
+            // Expected
+        }
+        try {
+            writer.write(chars, 1, chars.length);
+            fail();
+        } catch (IndexOutOfBoundsException e) {
+            // Expected
+        }
+        writer.write(chars, 1, 2);
+        writer.flush();
+        assertEquals("hi", out.toString("utf-8"));
+        writer.write(chars, 0, chars.length);
+        writer.flush();
+        assertEquals("hi" + source, out.toString("utf-8"));
+
+        writer.close();
+        // After the stream is closed, should throw IOException first
+        try {
+            writer.write((char[]) null, -1, -1);
+            fail("should throw IOException");
+        } catch (IOException e) {
+            // Expected
+        }
+    }
+
+    /*
+     * Class under test for void write(int)
+     */
+    public void testWriteint() throws IOException {
+        writer.write(1);
+        writer.flush();
+        String str = new String(out.toByteArray(), "utf-8");
+        assertEquals("\u0001", str);
+
+        writer.write(2);
+        writer.flush();
+        str = new String(out.toByteArray(), "utf-8");
+        assertEquals("\u0001\u0002", str);
+
+        writer.write(-1);
+        writer.flush();
+        str = new String(out.toByteArray(), "utf-8");
+        assertEquals("\u0001\u0002\uffff", str);
+
+        writer.write(0xfedcb);
+        writer.flush();
+        str = new String(out.toByteArray(), "utf-8");
+        assertEquals("\u0001\u0002\uffff\uedcb", str);
+
+        writer.close();
+        // After the stream is closed, should throw IOException
+        try {
+            writer.write(1);
+            fail("should throw IOException");
+        } catch (IOException e) {
+            // expected
+        }
+    }
+
+    /*
+     * Class under test for void write(String, int, int)
+     */
+    public void testWriteStringintint() throws IOException {
+        try {
+            writer.write((String) null, 1, 1);
+            fail();
+        } catch (NullPointerException e) {
+            // Expected
+        }
+        try {
+            writer.write("", 0, 1);
+            fail();
+        } catch (StringIndexOutOfBoundsException e) {
+            // Expected
+        }
+        try {
+            writer.write("abc", -1, 1);
+            fail();
+        } catch (StringIndexOutOfBoundsException e) {
+            // Expected
+        }
+        try {
+            writer.write("abc", 0, -1);
+            fail();
+        } catch (IndexOutOfBoundsException e) {
+            // Expected
+        }
+        try {
+            writer.write("abc", 1, 3);
+            fail();
+        } catch (StringIndexOutOfBoundsException e) {
+            // Expected
+        }
+
+        // Throws IndexOutOfBoundsException before NullPointerException if count
+        // is negative
+        try {
+            writer.write((String) null, -1, -1);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // Expected
+        }
+
+        // Throws NullPointerException before StringIndexOutOfBoundsException
+        try {
+            writer.write((String) null, -1, 0);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
+        writer.write("abc", 1, 2);
+        writer.flush();
+        assertEquals("bc", out.toString("utf-8"));
+        writer.write(source, 0, source.length());
+        writer.flush();
+        assertEquals("bc" + source, out.toString("utf-8"));
+
+        writer.close();
+        // Throws IndexOutOfBoundsException first if count is negative
+        try {
+            writer.write((String) null, 0, -1);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // Expected
+        }
+
+        try {
+            writer.write((String) null, -1, 0);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // Expected
+        }
+
+        try {
+            writer.write("abc", -1, 0);
+            fail("should throw StringIndexOutOfBoundsException");
+        } catch (StringIndexOutOfBoundsException e) {
+            // Expected
+        }
+
+        // Throws IOException
+        try {
+            writer.write("abc", 0, 1);
+            fail("should throw IOException");
+        } catch (IOException e) {
+            // expected
+        }
+    }
+
+    /*
+     * Class under test for void OutputStreamWriter(OutputStream)
+     */
+    public void testOutputStreamWriterOutputStream() throws IOException {
+        try {
+            writer = new OutputStreamWriter(null);
+            fail();
+        } catch (NullPointerException e) {
+            // Expected
+        }
+        OutputStreamWriter writer2 = new OutputStreamWriter(out);
+        writer2.close();
+    }
+
+    /*
+     * Class under test for void OutputStreamWriter(OutputStream, String)
+     */
+    public void testOutputStreamWriterOutputStreamString() throws IOException {
+        try {
+            writer = new OutputStreamWriter(null, "utf-8");
+            fail();
+        } catch (NullPointerException e) {
+            // Expected
+        }
+        try {
+            writer = new OutputStreamWriter(out, "");
+            fail();
+        } catch (UnsupportedEncodingException e) {
+            // Expected
+        }
+        try {
+            writer = new OutputStreamWriter(out, "badname");
+            fail();
+        } catch (UnsupportedEncodingException e) {
+            // Expected
+        }
+        try {
+            writer = new OutputStreamWriter(out, (String) null);
+            fail();
+        } catch (NullPointerException e) {
+            // Expected
+        }
+        OutputStreamWriter writer2 = new OutputStreamWriter(out, "ascii");
+        assertEquals(Charset.forName("ascii"), Charset.forName(writer2
+                .getEncoding()));
+        writer2.close();
+    }
+
+    /*
+     * Class under test for void OutputStreamWriter(OutputStream)
+     */
+    public void testOutputStreamWriterOutputStreamCharset() throws IOException {
+        Charset cs = Charset.forName("ascii");
+        try {
+            writer = new OutputStreamWriter(null, cs);
+            fail();
+        } catch (NullPointerException e) {
+            // Expected
+        }
+        try {
+            writer = new OutputStreamWriter(out, (Charset) null);
+            fail();
+        } catch (NullPointerException e) {
+            // Expected
+        }
+        OutputStreamWriter writer2 = new OutputStreamWriter(out, cs);
+        assertEquals(cs, Charset.forName(writer2.getEncoding()));
+        writer2.close();
+    }
+
+    /*
+     * Class under test for void OutputStreamWriter(OutputStream, String)
+     */
+    public void testOutputStreamWriterOutputStreamCharsetEncoder()
+            throws IOException {
+        Charset cs = Charset.forName("ascii");
+        CharsetEncoder enc = cs.newEncoder();
+        try {
+            writer = new OutputStreamWriter(null, enc);
+            fail();
+        } catch (NullPointerException e) {
+            // Expected
+        }
+        try {
+            writer = new OutputStreamWriter(out, (CharsetEncoder) null);
+            fail();
+        } catch (NullPointerException e) {
+            // Expected
+        }
+        OutputStreamWriter writer2 = new OutputStreamWriter(out, enc);
+        assertEquals(cs, Charset.forName(writer2.getEncoding()));
+        writer2.close();
+    }
+
+    public void testGetEncoding() {
+        Charset cs = Charset.forName("utf-8");
+        assertEquals(cs, Charset.forName(writer.getEncoding()));
+    }
+
+    public void testHandleEarlyEOFChar_1() throws IOException {
+        String str = "All work and no play makes Jack a dull boy\n"; //$NON-NLS-1$
+        int NUMBER = 2048;
+        int j = 0;
+        int len = str.length() * NUMBER;
+        char[] strChars = new char[len];
+        for (int i = 0; i < NUMBER; ++i) {
+            for (int k = 0; k < str.length(); ++k) {
+                strChars[j++] = str.charAt(k);
+            }
+        }
+
+        File f = File.createTempFile("one", "by_one");
+        f.deleteOnExit();
+        FileWriter fw = new FileWriter(f);
+        fw.write(strChars);
+        fw.close();
+        FileInputStream fis = new FileInputStream(f);
+        InputStreamReader in = new InputStreamReader(fis);
+        for (int offset = 0; offset < strChars.length; ++offset) {
+            int b = in.read();
+            assertFalse("Early EOF at offset", -1 == b);
+        }
+    }
+
+    public void testHandleEarlyEOFChar_2() throws IOException {
+        int capacity = 65536;
+        byte[] bytes = new byte[capacity];
+        byte[] bs = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H' };
+        for (int i = 0; i < bytes.length; i++) {
+            bytes[i] = bs[i / 8192];
+        }
+        String inputStr = new String(bytes);
+        int len = inputStr.length();
+        File f = File.createTempFile("FileWriterBugTest ", null); //$NON-NLS-1$
+        f.deleteOnExit();
+        FileWriter writer = new FileWriter(f);
+        writer.write(inputStr);
+        writer.close();
+        long flen = f.length();
+
+        FileReader reader = new FileReader(f);
+        char[] outChars = new char[capacity];
+        int outCount = reader.read(outChars);
+        String outStr = new String(outChars, 0, outCount);
+
+        assertEquals(len, flen);
+        assertEquals(inputStr, outStr);
+    }
+
+    public void testSingleCharIO() throws Exception {
+        InputStreamReader isr = null;
+        for (int i = 0; i < MINIMAL_CHARSETS.length; ++i) {
+            try {
+                out = new ByteArrayOutputStream();
+                writer = new OutputStreamWriter(out, MINIMAL_CHARSETS[i]);
+
+                int upper = UPPER;
+                switch (i) {
+                case 0:
+                    upper = 128;
+                    break;
+                case 1:
+                    upper = 256;
+                    break;
+                }
+
+                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 {
+                    isr.close();
+                } catch (Exception e) {
+                }
+                try {
+                    writer.close();
+                } catch (Exception e) {
+                }
+            }
+        }
+    }
+
+    public void testBlockIO() throws Exception {
+        InputStreamReader isr = null;
+        char[] largeBuffer = new char[BUFFER_SIZE];
+        for (int i = 0; i < MINIMAL_CHARSETS.length; ++i) {
+            try {
+                out = new ByteArrayOutputStream();
+                writer = new OutputStreamWriter(out, MINIMAL_CHARSETS[i]);
+
+                int upper = UPPER;
+                switch (i) {
+                case 0:
+                    upper = 128;
+                    break;
+                case 1:
+                    upper = 256;
+                    break;
+                }
+
+                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 = out.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], expected++, largeBuffer[j++]);
+                }
+            } finally {
+                try {
+                    isr.close();
+                } catch (Exception e) {
+                }
+                try {
+                    writer.close();
+                } catch (Exception e) {
+                }
+            }
+        }
+    }
+
+    /**
+     * @tests java.io.OutputStreamWriter#OutputStreamWriter(java.io.OutputStream)
+     */
+    public void test_ConstructorLjava_io_OutputStream() {
+        assertTrue("Used in tests", true);
+    }
+
+    /**
+     * @tests java.io.OutputStreamWriter#OutputStreamWriter(java.io.OutputStream,
+     *        java.lang.String)
+     */
+    public void test_ConstructorLjava_io_OutputStreamLjava_lang_String()
+            throws UnsupportedEncodingException {
+        osw = new OutputStreamWriter(fos, "8859_1");
+        try {
+            osw = new OutputStreamWriter(fos, "Bogus");
+            fail("Failed to throw Unsupported Encoding exception");
+        } catch (UnsupportedEncodingException e) {
+            // Expected
+        }
+    }
+
+    /**
+     * @tests java.io.OutputStreamWriter#close()
+     */
+    public void test_close() throws IOException {
+        osw.close();
+
+        try {
+            osw.write(testString, 0, testString.length());
+            fail("Chars written after close");
+        } catch (IOException e) {
+            // Expected
+        }
+
+        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("invalid conversion 1: " + 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("invalid conversion 2: " + converted, converted
+                    .equals("\u001b$B$("));
+            writer.close();
+            converted = new String(bout.toByteArray(), "ISO8859_1");
+            assertTrue("invalid conversion 3: " + 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("invalid conversion 4", "\u001b$B$($(\u001b(B",
+                    new String(bout.toByteArray(), "ISO8859_1"));
+        } catch (UnsupportedEncodingException e) {
+            // Can't test missing converter
+            System.out.println(e);
+        }
+    }
+
+    /**
+     * @tests java.io.OutputStreamWriter#flush()
+     */
+    public void test_flush() throws IOException {
+        char[] buf = new char[testString.length()];
+        osw.write(testString, 0, testString.length());
+        osw.flush();
+        openInputStream();
+        isr.read(buf, 0, buf.length);
+        assertTrue("Chars not flushed", new String(buf, 0, buf.length)
+                .equals(testString));
+    }
+
+    /**
+     * @tests java.io.OutputStreamWriter#getEncoding()
+     */
+    public void test_getEncoding() throws IOException {
+        try {
+            osw = new OutputStreamWriter(fos, "8859_1");
+        } catch (UnsupportedEncodingException e) {
+            assertEquals("Returned incorrect encoding", "8859_1", osw
+                    .getEncoding());
+        }
+
+        OutputStreamWriter out = new OutputStreamWriter(
+                new ByteArrayOutputStream(), "UTF-16BE");
+        out.close();
+
+        String result = out.getEncoding();
+        assertNull(result);
+
+        out = null;
+        try {
+            out = new OutputStreamWriter(new ByteArrayOutputStream(),
+                    "UTF-16BE");
+        } catch (UnsupportedEncodingException e) {
+            // ok
+        }
+        result = out.getEncoding();
+        assertEquals("UnicodeBigUnmarked", result);
+    }
+
+    /**
+     * @tests java.io.OutputStreamWriter#write(char[], int, int)
+     */
+    public void test_write$CII() throws IOException {
+        char[] buf = new char[testString.length()];
+        osw.write(testString, 0, testString.length());
+        osw.close();
+        openInputStream();
+        isr.read(buf, 0, buf.length);
+        assertTrue("Incorrect chars returned", new String(buf, 0, buf.length)
+                .equals(testString));
+    }
+
+    /**
+     * @tests java.io.OutputStreamWriter#write(int)
+     */
+    public void test_writeI() throws IOException {
+        osw.write('T');
+        osw.close();
+        openInputStream();
+        int c = isr.read();
+        assertEquals("Incorrect char returned", 'T', (char) c);
+    }
+
+    /**
+     * @tests java.io.OutputStreamWriter#write(java.lang.String, int, int)
+     */
+    public void test_writeLjava_lang_StringII() throws IOException {
+        char[] buf = new char[testString.length()];
+        osw.write(testString, 0, testString.length());
+        osw.close();
+        openInputStream();
+        isr.read(buf);
+        assertTrue("Incorrect chars returned", new String(buf, 0, buf.length)
+                .equals(testString));
+    }
+
+    private void openInputStream() {
+        isr = new InputStreamReader(new ByteArrayInputStream(fos.toByteArray()));
+    }
+}

Modified: harmony/enhanced/classlib/trunk/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/RandomAccessFileTest.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/classlib/trunk/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/RandomAccessFileTest.java?rev=695470&r1=695469&r2=695470&view=diff
==============================================================================
--- harmony/enhanced/classlib/trunk/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/RandomAccessFileTest.java (original)
+++ harmony/enhanced/classlib/trunk/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/RandomAccessFileTest.java Mon Sep 15 06:54:43 2008
@@ -118,6 +118,7 @@
         raf.write(fileString.getBytes(), 0, 1000);
         assertEquals("Incorrect filePointer returned", 1000, raf
                 .getFilePointer());
+        raf.close();
     }
 
     /**
@@ -129,6 +130,7 @@
         raf.write(fileString.getBytes());
         assertEquals("Incorrect length returned", fileString.length(), raf
                 .length());
+        raf.close();
     }
 
     /**
@@ -143,6 +145,7 @@
         RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "r");
         assertEquals("Incorrect bytes returned from read",
                 fileString.charAt(0), raf.read());
+        raf.close();
     }
 
     /**
@@ -159,7 +162,7 @@
         raf.read(rbuf);
         assertEquals("Incorrect bytes returned from read", fileString,
                 new String(rbuf, 0, fileString.length()));
-
+        raf.close();
     }
 
     /**
@@ -175,6 +178,7 @@
         raf.read(rbuf, 0, fileString.length());
         assertEquals("Incorrect bytes returned from read", fileString,
                 new String(rbuf, 0, fileString.length()));
+        raf.close();
     }
 
     /**
@@ -271,6 +275,7 @@
             raf.readFully(buf, 0, buf.length);
             fail("Reading past end of buffer did not throw EOFException");
         } catch (EOFException e) {}
+        raf.close();
     }
 
     /**
@@ -299,6 +304,8 @@
         assertEquals("Goodbye", raf.readLine());
         assertEquals("Cruel", raf.readLine());
         assertEquals("World", raf.readLine());
+        
+        raf.close();
     }
 
     /**
@@ -374,6 +381,7 @@
         raf.write(fileString.getBytes(), 0, fileString.length());
         raf.seek(12);
         assertEquals("Seek failed to set filePointer", 12, raf.getFilePointer());
+        raf.close();
     }
 
     /**
@@ -431,6 +439,7 @@
         fis.read(rbuf, 0, fileString.length());
         assertEquals("Incorrect bytes written", fileString, new String(rbuf, 0,
                 fileString.length()));    
+        fis.close();
     }
 
     /**
@@ -447,6 +456,7 @@
         fis.read(rbuf, 0, fileString.length());
         assertEquals("Incorrect bytes written", fileString, new String(rbuf, 0,
                 fileString.length()));
+        fis.close();
     }
     
     /**
@@ -601,6 +611,7 @@
         FileInputStream fis = new java.io.FileInputStream(fileName);
         fis.read(rbuf, 0, 1);
         assertEquals("Incorrect byte written", 't', rbuf[0]);
+        fis.close();
     }
 
     /**
@@ -762,6 +773,7 @@
             fail("IOException must be thrown if pos < 0");
         } catch (IOException e) {
         }
+        raf.close();
     }
 
     /**
@@ -857,8 +869,9 @@
      * @tests java.io.RandomAccessFile#read(byte[],int,int) 
      */
     public void test_read_$BII_NullPointerException() throws IOException {
-        RandomAccessFile raf = new RandomAccessFile(File.createTempFile("tmp",
-                "tmp"), "r");
+        File f = File.createTempFile("tmp", "tmp");
+        f.deleteOnExit();
+        RandomAccessFile raf = new RandomAccessFile(f, "r");
         byte[] rbuf = null;
         try {
             raf.read(rbuf, 0, -1);
@@ -866,6 +879,7 @@
         } catch (NullPointerException e) {
             // expected
         }
+        raf.close();
     }
 
     /**



Mime
View raw message