xref: /dalvik/libcore/luni/src/test/java/tests/api/java/io/PipedReaderTest.java

/*
 *  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.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;

@TestTargetClass(PipedReader.class)
public class PipedReaderTest extends junit.framework.TestCase {

    static class PWriter implements Runnable {
        public PipedWriter pw;

        public PWriter(PipedReader reader) {
            try {
                pw = new PipedWriter(reader);
            } catch (Exception e) {
                System.out.println("Couldn't create writer");
            }
        }

        public PWriter() {
            pw = new PipedWriter();
        }

        public void run() {
            try {
                char[] c = new char[11];
                "Hello World".getChars(0, 11, c, 0);
                pw.write(c);
                Thread.sleep(10000);
            } catch (InterruptedException e) {
            } catch (Exception e) {
                System.out.println("Exception occurred: " + e.toString());
            }
        }
    }

    static class PWriter2 implements Runnable {
        PipedWriter pw;

        public boolean keepRunning = true;

        public void run() {
            try {
                pw.write('H');
                pw.close();
                while (keepRunning) {
                    Thread.sleep(1000);
                }
            } catch (Exception e) {
                e.printStackTrace(System.out);
                System.out.println("Error while running the writer thread.");
            }
        }

        public PWriter2(PipedWriter writer) {
            pw = writer;
        }
    }

    PipedReader preader;

    PWriter pwriter;

    Thread t;

    /**
     * @tests java.io.PipedReader#PipedReader()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "PipedReader",
        args = {}
    )
    public void test_Constructor() {
        preader = new PipedReader();
        assertNotNull(preader);
        try {
            preader.close();
        } catch (IOException e) {
            fail("Unexpeceted IOException");
        }
    }

    /**
     * @tests java.io.PipedReader#PipedReader(java.io.PipedWriter)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "PipedReader",
        args = {java.io.PipedWriter.class}
    )
    public void test_ConstructorLjava_io_PipedWriter() throws IOException {
        // Test for method java.io.PipedReader(java.io.PipedWriter)
        try {
            preader = new PipedReader(new PipedWriter());
        } catch (Exception e) {
            fail("Test 1: Constructor failed: " + e.getMessage());
        }
        preader.close();

        PipedWriter pw = new PipedWriter(new PipedReader());
        try {
            preader = new PipedReader(pw);
            fail("Test 2: IOException expected because the writer is already connected.");
        } catch (IOException e) {
            // Expected.
        }
    }

    /**
     * @tests java.io.PipedReader#close()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "No IOException checking because it is never thrown in the source code.",
        method = "close",
        args = {}
    )
    public void test_close() throws Exception {
        // Test for method void java.io.PipedReader.close()
        char[] c = null;
        preader = new PipedReader();
        t = new Thread(new PWriter(preader), "");
        t.start();
        Thread.sleep(500); // Allow writer to start
        c = new char[11];
        preader.read(c, 0, 5);
        preader.close();

        try {
            preader.read(c, 0, 5);
            fail("IOException expected because the reader is closed.");
        } catch (IOException e) {
            // Expected.
        }
    }

    /**
     * @tests java.io.PipedReader#connect(java.io.PipedWriter)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "connect",
        args = {java.io.PipedWriter.class}
    )
    public void test_connectLjava_io_PipedWriter() throws Exception {
        // Test for method void java.io.PipedReader.connect(java.io.PipedWriter)
        char[] c = null;

        preader = new PipedReader();
        t = new Thread(pwriter = new PWriter(), "");
        preader.connect(pwriter.pw);
        t.start();
        Thread.sleep(500); // Allow writer to start
        c = new char[11];
        preader.read(c, 0, 11);

        assertEquals("Test 1: Wrong characters read. ", "Hello World", new String(c));
        try {
            preader.connect(new PipedWriter());
            fail("Test 2: IOException expected because the reader is already connected.");
        } catch (IOException e) {
            // Expected.
        }
    }

    /**
     * @tests java.io.PipedReader#read()
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "",
        method = "read",
        args = {}
    )
    public void test_read_1() throws Exception {
        // Test for method int java.io.PipedReader.read()
        char[] c = null;
        preader = new PipedReader();
        t = new Thread(new PWriter(preader), "");
        t.start();
        Thread.sleep(500); // Allow writer to start
        c = new char[11];
        for (int i = 0; i < c.length; i++) {
            c[i] = (char) preader.read();
        }
        assertEquals("Test 1: Wrong characters read. ", "Hello World", new String(c));

        try {
            preader.read();
            fail("Test 2: IOException expected since the thread that has " +
                 "written to the pipe is no longer alive.");
        } catch (IOException e) {
            // Expected.
        }

        preader.close();
        try {
            preader.read();
            fail("Test 3: IOException expected.");
        } catch (IOException e) {
            // Expected.
        }
    }

    /**
     * @tests java.io.PipedReader#read()
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Checks that read() returns -1 if the PipedWriter connectedto this PipedReader is closed.",
        method = "read",
        args = {}
    )
    public void test_read_2() throws Exception {
        Thread writerThread;
        PipedWriter pw;
        PWriter2 pwriter;

        preader = new PipedReader();
        pw = new PipedWriter(preader);

        writerThread = new Thread(pwriter = new PWriter2(pw), "PWriter2");
        writerThread.start();
        Thread.sleep(500); // Allow writer to start

        preader.read();
        assertEquals("Test 1: No more data indication expected. ", -1, preader.read());
        pwriter.keepRunning = false;
    }

    /**
     * @tests java.io.PipedReader#read(char[], int, int)
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "IOException checking missed.",
        method = "read",
        args = {char[].class, int.class, int.class}
    )
    public void test_read$CII_1() throws Exception {
        // Test for method int java.io.PipedReader.read(char [], int, int)
        char[] c = null;
        preader = new PipedReader();
        t = new Thread(new PWriter(preader), "");
        t.start();
        Thread.sleep(500); // Allow writer to start
        c = new char[11];
        int n = 0;
        int x = n;
        while (x < 11) {
            n = preader.read(c, x, 11 - x);
            x = x + n;
        }
        assertEquals("Test 1: Wrong characters read. ", "Hello World", new String(c));

        preader.close();
        try {
            preader.read(c, 8, 7);
            fail("Test 2: IOException expected.");
        } catch (IOException e) {
            // Expected.
        }
    }

    /**
     * @tests java.io.PipedReader#read(char[], int, int)
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "",
        method = "read",
        args = {char[].class, int.class, int.class}
    )
    public void test_read$CII_Exception() throws IOException{
        PipedWriter pw = new PipedWriter();
        PipedReader obj = new PipedReader(pw);
        try {
            obj.read(new char[10], 0, -1);
            fail("IndexOutOfBoundsException expected.");
        } catch (IndexOutOfBoundsException e) {
            // Expected.
        }
        try {
            obj.read(new char[10], -1, 1);
            fail("IndexOutOfBoundsException expected.");
        } catch (IndexOutOfBoundsException e) {
            // Expected.
        }
        try {
            obj.read(new char[10], 2, 9);
            fail("IndexOutOfBoundsException expected.");
        } catch (IndexOutOfBoundsException e) {
            // Expected.
        }
        try {
            obj.read(null, 0, 1);
            fail("NullPointerException expected.");
        } catch (NullPointerException e) {
            // Expected.
        }
    }

    /**
     * @tests java.io.PipedReader#read()
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Checks that read() returns -1 if the PipedWriter connectedto this PipedReader is closed.",
        method = "read",
        args = {}
    )
    public void test_read$CII_2() throws Exception {
        Thread writerThread;
        PipedWriter pw;
        PWriter2 pwriter;
        char[] c = new char[1];

        preader = new PipedReader();
        pw = new PipedWriter(preader);

        writerThread = new Thread(pwriter = new PWriter2(pw), "PWriter2");
        writerThread.start();
        Thread.sleep(500); // Allow writer to start

        preader.read(c, 0, 1);
        assertEquals("Test 1: No more data indication expected. ",
                     -1, preader.read(c, 0, 1));
        pwriter.keepRunning = false;
    }

    /**
     * @tests java.io.PipedReader#ready()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "ready",
        args = {}
    )
    public void test_ready() throws Exception {
        // Test for method boolean java.io.PipedReader.ready()
        char[] c = null;
        preader = new PipedReader();

        try {
            preader.ready();
            fail("Test 1: IOException expected.");
        } catch (IOException e) {
            // Expected.
        }

        t = new Thread(new PWriter(preader), "");
        t.start();
        Thread.sleep(500); // Allow writer to start
        assertTrue("Test 2: Reader should be ready", preader.ready());
        c = new char[11];
        for (int i = 0; i < c.length; i++)
            c[i] = (char) preader.read();
        assertFalse("Test 3: Reader should not be ready after reading all chars",
                preader.ready());

        preader.close();
        try {
            preader.ready();
            fail("Test 4: IOException expected.");
        } catch (IOException e) {
            // Expected.
        }
    }

    /**
     * Tears down the fixture, for example, close a network connection. This
     * method is called after a test is executed.
     */
    protected void tearDown() throws Exception {
        if (t != null) {
            t.interrupt();
        }
        super.tearDown();
    }
}