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

import dalvik.annotation.AndroidOnly;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargetNew;

@TestTargetClass(CharArrayReader.class)
public class CharArrayReaderTest extends junit.framework.TestCase {

    char[] hw = { 'H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd' };

    CharArrayReader cr;

    /**
     * @tests java.io.CharArrayReader#CharArrayReader(char[])
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies CharArrayReader(char[] buf) constructor.",
        method = "CharArrayReader",
        args = {char[].class}
    )
    public void test_Constructor$C() {
        // Test for method java.io.CharArrayReader(char [])

        try {
            cr = new CharArrayReader(hw);
            assertTrue("Failed to create reader", cr.ready());
        } catch (IOException e) {
            fail("Exception determining ready state : " + e.getMessage());
        }
    }

    /**
     * @tests java.io.CharArrayReader#CharArrayReader(char[], int, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "CharArrayReader",
        args = {char[].class, int.class, int.class}
    )
    public void test_Constructor$CII() throws IOException {
        try {
            cr = new CharArrayReader(null, 0, 0);
            fail("Test 1: NullPointerException expected.");
        } catch (NullPointerException e) {
            // Expected.
        }
        try {
            cr = new CharArrayReader(hw, -1, 0);
            fail("Test 2: IllegalArgumentException expected.");
        } catch (IllegalArgumentException e) {
            // Expected.
        }
        try {
            cr = new CharArrayReader(hw, 0, -1);
            fail("Test 3: IllegalArgumentException expected.");
        } catch (IllegalArgumentException e) {
            // Expected.
        }
        try {
            cr = new CharArrayReader(hw, hw.length + 1, 1);
            fail("Test 4: IllegalArgumentException expected.");
        } catch (IllegalArgumentException e) {
            // Expected.
        }

        cr = new CharArrayReader(hw, 5, 5);
        assertTrue("Test 5: Failed to create reader", cr.ready());
        assertEquals("Test 6: Incorrect character read;",
                'W', cr.read());
    }

    /**
     * @tests java.io.CharArrayReader#close()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies close() method.",
        method = "close",
        args = {}
    )
    public void test_close() {
        cr = new CharArrayReader(hw);
        cr.close();
        try {
            cr.read();
            fail("Failed to throw exception on read from closed stream");
        } catch (IOException e) {
            // Expected.
        }

    }

    /**
     * @tests java.io.CharArrayReader#mark(int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "mark",
        args = {int.class}
    )
    public void test_markI() throws IOException {
        // Test for method void java.io.CharArrayReader.mark(int)
        cr = new CharArrayReader(hw);
        cr.skip(5L);
        cr.mark(100);
        cr.read();
        cr.reset();
        assertEquals("Test 1: Failed to mark correct position;",
                'W', cr.read());

        cr.close();
        try {
            cr.mark(100);
            fail("Test 2: IOException expected.");
        } catch (IOException e) {
            // Expected.
        }
    }

    /**
     * @tests java.io.CharArrayReader#markSupported()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies markSupported() method.",
        method = "markSupported",
        args = {}
    )
    public void test_markSupported() {
        // Test for method boolean java.io.CharArrayReader.markSupported()
        cr = new CharArrayReader(hw);
        assertTrue("markSupported returned false", cr.markSupported());
    }

    /**
     * @tests java.io.CharArrayReader#read()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "read",
        args = {}
    )
    public void test_read() throws IOException {
        cr = new CharArrayReader(hw);
        assertEquals("Test 1: Read returned incorrect char;",
                'H', cr.read());
        cr = new CharArrayReader(new char[] { '\u8765' });
        assertTrue("Test 2: Incorrect double byte char;",
                cr.read() == '\u8765');

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

    /**
     * @tests java.io.CharArrayReader#read(char[], int, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "read",
        args = {char[].class, int.class, int.class}
    )
    @AndroidOnly("The RI throws an IndexOutOfBoundsException instead of an" +
            "ArrayIndexOutOfBoundsException. The RI specification does not" +
            "define the expected behavior.")
    public void test_read$CII() throws IOException {
        // Test for method int java.io.CharArrayReader.read(char [], int, int)
        char[] c = new char[11];
        cr = new CharArrayReader(hw);
        cr.read(c, 1, 10);
        assertTrue("Test 1: Read returned incorrect chars.",
                new String(c, 1, 10).equals(new String(hw, 0, 10)));

        // Illegal argument checks.
        try {
            cr.read(null, 1, 0);
            fail("Test 2: NullPointerException expected.");
        } catch (NullPointerException e) {
            // Expected.
        }

        try {
            cr.read(c , -1, 1);
            fail("Test 3: ArrayIndexOutOfBoundsException expected.");
        } catch (IndexOutOfBoundsException e) {
            // Expected
        }

        try {
            cr.read(c , 1, -1);
            fail("Test 4: ArrayIndexOutOfBoundsException expected.");
        } catch (IndexOutOfBoundsException e) {
            // Expected
        }

        try {
            cr.read(c, 1, c.length);
            fail("Test 5: ArrayIndexOutOfBoundsException expected.");
        } catch (IndexOutOfBoundsException e) {
            // Expected
        }

        cr.close();
        try {
            cr.read(c, 1, 1);
            fail("Test 6: IOException expected.");
        } catch (IOException e) {
            // Expected.
        }
    }

    /**
     * @tests java.io.CharArrayReader#ready()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies ready() method.",
        method = "ready",
        args = {}
    )
    public void test_ready() {
        // Test for method boolean java.io.CharArrayReader.ready()
        cr = new CharArrayReader(hw);
        boolean expectException = false;
        try {
            assertTrue("ready returned false", cr.ready());
            cr.skip(1000);
            assertTrue("ready returned true", !cr.ready());
            cr.close();
            expectException = true;
            cr.ready();
            fail("No exception 1");
        } catch (IOException e) {
            if (!expectException)
                fail("Unexpected: " + e);
        }
        try {
            cr = new CharArrayReader(hw);
            cr.close();
            cr.ready();
            fail("No exception 2");
        } catch (IOException e) {
        }

    }

    /**
     * @tests java.io.CharArrayReader#reset()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "reset",
        args = {}
    )
    public void test_reset() throws IOException {
        cr = new CharArrayReader(hw);
        cr.skip(5L);
        cr.mark(100);
        cr.read();
        cr.reset();
        assertEquals("Test 1: Reset failed to return to marker position.",
                'W', cr.read());

        cr.close();
        try {
            cr.reset();
            fail("Test 2: IOException expected.");
        } catch (IOException e) {
            // Expected.
        }
    }

    /**
     * @tests java.io.CharArrayReader#skip(long)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "skip",
        args = {long.class}
    )
    public void test_skipJ() throws IOException {
        long skipped = 0;
        cr = new CharArrayReader(hw);
        skipped = cr.skip(5L);
        assertEquals("Test 1: Failed to skip correct number of chars;",
                5L, skipped);
        assertEquals("Test 2: Skip skipped wrong chars;",
                'W', cr.read());

        cr.close();
        try {
            cr.skip(1);
            fail("Test 3: IOException expected.");
        } catch (IOException e) {
            // Expected.
        }
    }

    /**
     * Sets up the fixture, for example, open a network connection. This method
     * is called before a test is executed.
     */
    protected void setUp() {
    }

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