/*
 *  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.lang.reflect;

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

import java.lang.reflect.Array;

@TestTargetClass(Array.class)
public class ArrayTest extends junit.framework.TestCase {

    /**
     * @tests java.lang.reflect.Array#get(java.lang.Object, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "get",
        args = {java.lang.Object.class, int.class}
    )
    public void test_getLjava_lang_ObjectI() {
        // Test for method java.lang.Object
        // java.lang.reflect.Array.get(java.lang.Object, int)

        int[] x = { 1 };
        Object ret = null;
        boolean thrown = false;
        try {
            ret = Array.get(x, 0);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value",
                1, ((Integer) ret).intValue());
        try {
            ret = Array.get(new Object(), 0);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.get(x, 4);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }

        //same test with non primitive component type
        Integer[] y = new Integer[]{ 1 };
        ret = null;
        thrown = false;
        try {
            ret = Array.get(y, 0);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value",
                1, ((Integer) ret).intValue());
        try {
            ret = Array.get(new Object(), 0);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.get(y, 4);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }
    }

    /**
     * @tests java.lang.reflect.Array#getBoolean(java.lang.Object, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getBoolean",
        args = {java.lang.Object.class, int.class}
    )
    public void test_getBooleanLjava_lang_ObjectI() {
        // Test for method boolean
        // java.lang.reflect.Array.getBoolean(java.lang.Object, int)
        boolean[] x = { true };
        boolean ret = false;
        boolean thrown = false;
        try {
            ret = Array.getBoolean(x, 0);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertTrue("Get returned incorrect value", ret);
        try {
            ret = Array.getBoolean(new Object(), 0);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.getBoolean(x, 4);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.getBoolean(null, 0);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * @tests java.lang.reflect.Array#getByte(java.lang.Object, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getByte",
        args = {java.lang.Object.class, int.class}
    )
    public void test_getByteLjava_lang_ObjectI() {
        // Test for method byte
        // java.lang.reflect.Array.getByte(java.lang.Object, int)
        byte[] x = { 1 };
        byte ret = 0;
        boolean thrown = false;
        try {
            ret = Array.getByte(x, 0);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value", 1, ret);
        try {
            ret = Array.getByte(new Object(), 0);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.getByte(x, 4);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.getByte(null, 0);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * @tests java.lang.reflect.Array#getChar(java.lang.Object, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getChar",
        args = {java.lang.Object.class, int.class}
    )
    public void test_getCharLjava_lang_ObjectI() {
        // Test for method char
        // java.lang.reflect.Array.getChar(java.lang.Object, int)
        char[] x = { 1 };
        char ret = 0;
        boolean thrown = false;
        try {
            ret = Array.getChar(x, 0);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value", 1, ret);
        try {
            ret = Array.getChar(new Object(), 0);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.getChar(x, 4);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.getChar(null, 0);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * @tests java.lang.reflect.Array#getDouble(java.lang.Object, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getDouble",
        args = {java.lang.Object.class, int.class}
    )
    public void test_getDoubleLjava_lang_ObjectI() {
        // Test for method double
        // java.lang.reflect.Array.getDouble(java.lang.Object, int)
        double[] x = { 1 };
        double ret = 0;
        boolean thrown = false;
        try {
            ret = Array.getDouble(x, 0);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value", 1, ret, 0.0);
        try {
            ret = Array.getDouble(new Object(), 0);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }

        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.getDouble(x, 4);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.getDouble(null, 0);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * @tests java.lang.reflect.Array#getFloat(java.lang.Object, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getFloat",
        args = {java.lang.Object.class, int.class}
    )
    public void test_getFloatLjava_lang_ObjectI() {
        // Test for method float
        // java.lang.reflect.Array.getFloat(java.lang.Object, int)
        float[] x = { 1 };
        float ret = 0;
        boolean thrown = false;
        try {
            ret = Array.getFloat(x, 0);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value", 1, ret, 0.0);
        try {
            ret = Array.getFloat(new Object(), 0);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.getFloat(x, 4);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.getFloat(null, 0);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * @tests java.lang.reflect.Array#getInt(java.lang.Object, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getInt",
        args = {java.lang.Object.class, int.class}
    )
    public void test_getIntLjava_lang_ObjectI() {
        // Test for method int java.lang.reflect.Array.getInt(java.lang.Object,
        // int)
        int[] x = { 1 };
        int ret = 0;
        boolean thrown = false;
        try {
            ret = Array.getInt(x, 0);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value", 1, ret);
        try {
            ret = Array.getInt(new Object(), 0);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.getInt(x, 4);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.getInt(null, 0);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * @tests java.lang.reflect.Array#getLength(java.lang.Object)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getLength",
        args = {java.lang.Object.class}
    )
    public void test_getLengthLjava_lang_Object() {
        // Test for method int
        // java.lang.reflect.Array.getLength(java.lang.Object)
        long[] x = { 1 };

        assertEquals("Returned incorrect length", 1, Array.getLength(x));
        assertEquals("Returned incorrect length", 10000, Array
                .getLength(new Object[10000]));
        try {
            Array.getLength(new Object());
        } catch (IllegalArgumentException e) {
            // Correct
            return;
        }
        fail("Failed to throw exception when passed non-array");
    }

    /**
     * @tests java.lang.reflect.Array#getLong(java.lang.Object, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getLong",
        args = {java.lang.Object.class, int.class}
    )
    public void test_getLongLjava_lang_ObjectI() {
        // Test for method long
        // java.lang.reflect.Array.getLong(java.lang.Object, int)
        long[] x = { 1 };
        long ret = 0;
        boolean thrown = false;
        try {
            ret = Array.getLong(x, 0);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value", 1, ret);
        try {
            ret = Array.getLong(new Object(), 0);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.getLong(x, 4);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.getLong(null, 0);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * @tests java.lang.reflect.Array#getShort(java.lang.Object, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getShort",
        args = {java.lang.Object.class, int.class}
    )
    public void test_getShortLjava_lang_ObjectI() {
        // Test for method short
        // java.lang.reflect.Array.getShort(java.lang.Object, int)
        short[] x = { 1 };
        short ret = 0;
        boolean thrown = false;
        try {
            ret = Array.getShort(x, 0);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value", 1, ret);
        try {
            ret = Array.getShort(new Object(), 0);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.getShort(x, 4);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }
        thrown = false;
        try {
            ret = Array.getShort(null, 0);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * @tests java.lang.reflect.Array#newInstance(java.lang.Class, int[])
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "newInstance",
        args = {java.lang.Class.class, int[].class}
    )
    public void test_newInstanceLjava_lang_Class$I() {
        // Test for method java.lang.Object
        // java.lang.reflect.Array.newInstance(java.lang.Class, int [])
        int[][] x;
        int[] y = { 2 };

        x = (int[][]) Array.newInstance(int[].class, y);
        assertEquals("Failed to instantiate array properly", 2, x.length);

        boolean thrown = false;
        try {
            x = (int[][]) Array.newInstance(null, y);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }

        thrown = false;
        try {
            Array.newInstance(int[].class, new int[]{1,-1});
        } catch (NegativeArraySizeException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Negative array size failed to throw NegativeArraySizeException");
        }

        thrown = false;
        try {
            Array.newInstance(int[].class, new int[]{});
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Zero array size failed to throw IllegalArgumentException");
        }
    }

    /**
     * @tests java.lang.reflect.Array#newInstance(java.lang.Class, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "newInstance",
        args = {java.lang.Class.class, int.class}
    )
    public void test_newInstanceLjava_lang_ClassI() {
        // Test for method java.lang.Object
        // java.lang.reflect.Array.newInstance(java.lang.Class, int)
        int[] x;

        x = (int[]) Array.newInstance(int.class, 100);
        assertEquals("Failed to instantiate array properly", 100, x.length);

        boolean thrown = false;
        try {
            Array.newInstance(null, 100);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }

        thrown = false;
        try {
           Array.newInstance(int[].class, -1);
        } catch (NegativeArraySizeException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Negative array size failed to throw NegativeArraySizeException");
        }
    }

    /**
     * @tests java.lang.reflect.Array#set(java.lang.Object, int,
     *        java.lang.Object)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "set",
        args = {java.lang.Object.class, int.class, java.lang.Object.class}
    )
    public void test_setLjava_lang_ObjectILjava_lang_Object() {
        // Test for method void java.lang.reflect.Array.set(java.lang.Object,
        // int, java.lang.Object)
        int[] x = { 0 };
        boolean thrown = false;
        try {
            Array.set(x, 0, new Integer(1));
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value", 1, ((Integer) Array.get(x, 0))
                .intValue());
        try {
            Array.set(new Object(), 0, new Object());
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            Array.set(x, 4, new Integer(1));
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }

        // trying to put null in a primitive array causes
        // a IllegalArgumentException in 5.0
        boolean exception = false;
        try {
            Array.set(new int[1], 0, null);
        } catch (IllegalArgumentException e) {
            exception = true;
        }
        assertTrue("expected exception not thrown", exception);

        thrown = false;
        try {
           Array.set(null, 0, 2);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * @tests java.lang.reflect.Array#setBoolean(java.lang.Object, int, boolean)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "setBoolean",
        args = {java.lang.Object.class, int.class, boolean.class}
    )
    public void test_setBooleanLjava_lang_ObjectIZ() {
        // Test for method void
        // java.lang.reflect.Array.setBoolean(java.lang.Object, int, boolean)
        boolean[] x = { false };
        boolean thrown = false;
        try {
            Array.setBoolean(x, 0, true);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertTrue("Failed to set correct value", Array.getBoolean(x, 0));
        try {
            Array.setBoolean(new Object(), 0, false);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown){
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            Array.setBoolean(x, 4, false);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }

        thrown = false;
        try {
           Array.setBoolean(null, 0, true);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * @tests java.lang.reflect.Array#setByte(java.lang.Object, int, byte)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "setByte",
        args = {java.lang.Object.class, int.class, byte.class}
    )
    public void test_setByteLjava_lang_ObjectIB() {
        // Test for method void
        // java.lang.reflect.Array.setByte(java.lang.Object, int, byte)
        byte[] x = { 0 };
        boolean thrown = false;
        try {
            Array.setByte(x, 0, (byte) 1);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value", 1, Array.getByte(x, 0));
        try {
            Array.setByte(new Object(), 0, (byte) 9);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            Array.setByte(x, 4, (byte) 9);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }

        thrown = false;
        try {
           Array.setByte(null, 0, (byte)0);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * @tests java.lang.reflect.Array#setChar(java.lang.Object, int, char)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "setChar",
        args = {java.lang.Object.class, int.class, char.class}
    )
    public void test_setCharLjava_lang_ObjectIC() {
        // Test for method void
        // java.lang.reflect.Array.setChar(java.lang.Object, int, char)
        char[] x = { 0 };
        boolean thrown = false;
        try {
            Array.setChar(x, 0, (char) 1);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value", 1, Array.getChar(x, 0));
        try {
            Array.setChar(new Object(), 0, (char) 9);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            Array.setChar(x, 4, (char) 9);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }

        thrown = false;
        try {
           Array.setChar(null, 0, (char)0);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * @tests java.lang.reflect.Array#setDouble(java.lang.Object, int, double)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "setDouble",
        args = {java.lang.Object.class, int.class, double.class}
    )
    public void test_setDoubleLjava_lang_ObjectID() {
        // Test for method void
        // java.lang.reflect.Array.setDouble(java.lang.Object, int, double)
        double[] x = { 0 };
        boolean thrown = false;
        try {
            Array.setDouble(x, 0, 1);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value", 1, Array.getDouble(x, 0), 0.0);
        try {
            Array.setDouble(new Object(), 0, 9);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            Array.setDouble(x, 4, 9);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }

        thrown = false;
        try {
           Array.setDouble(null, 0, 0);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * @tests java.lang.reflect.Array#setFloat(java.lang.Object, int, float)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "setFloat",
        args = {java.lang.Object.class, int.class, float.class}
    )
    public void test_setFloatLjava_lang_ObjectIF() {
        // Test for method void
        // java.lang.reflect.Array.setFloat(java.lang.Object, int, float)
        float[] x = { 0.0f };
        boolean thrown = false;
        try {
            Array.setFloat(x, 0, (float) 1);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value", 1, Array.getFloat(x, 0), 0.0);
        try {
            Array.setFloat(new Object(), 0, (float) 9);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            Array.setFloat(x, 4, (float) 9);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }

        thrown = false;
        try {
           Array.setFloat(null, 0, 0);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * @tests java.lang.reflect.Array#setInt(java.lang.Object, int, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "setInt",
        args = {java.lang.Object.class, int.class, int.class}
    )
    public void test_setIntLjava_lang_ObjectII() {
        // Test for method void java.lang.reflect.Array.setInt(java.lang.Object,
        // int, int)
        int[] x = { 0 };
        boolean thrown = false;
        try {
            Array.setInt(x, 0, (int) 1);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value", 1, Array.getInt(x, 0));
        try {
            Array.setInt(new Object(), 0, (int) 9);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            Array.setInt(x, 4, (int) 9);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }

        thrown = false;
        try {
           Array.setInt(null, 0, 0);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * @tests java.lang.reflect.Array#setLong(java.lang.Object, int, long)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "setLong",
        args = {java.lang.Object.class, int.class, long.class}
    )
    public void test_setLongLjava_lang_ObjectIJ() {
        // Test for method void
        // java.lang.reflect.Array.setLong(java.lang.Object, int, long)
        long[] x = { 0 };
        boolean thrown = false;
        try {
            Array.setLong(x, 0, 1);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value", 1, Array.getLong(x, 0));
        try {
            Array.setLong(new Object(), 0, 9);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            Array.setLong(x, 4, 9);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }

        thrown = false;
        try {
           Array.setLong(null, 0, 0);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * @tests java.lang.reflect.Array#setShort(java.lang.Object, int, short)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "setShort",
        args = {java.lang.Object.class, int.class, short.class}
    )
    public void test_setShortLjava_lang_ObjectIS() {
        // Test for method void
        // java.lang.reflect.Array.setShort(java.lang.Object, int, short)
        short[] x = { 0 };
        boolean thrown = false;
        try {
            Array.setShort(x, 0, (short) 1);
        } catch (Exception e) {
            fail("Exception during get test : " + e.getMessage());
        }
        assertEquals("Get returned incorrect value", 1, Array.getShort(x, 0));
        try {
            Array.setShort(new Object(), 0, (short) 9);
        } catch (IllegalArgumentException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Passing non-array failed to throw exception");
        }
        thrown = false;
        try {
            Array.setShort(x, 4, (short) 9);
        } catch (ArrayIndexOutOfBoundsException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Invalid index failed to throw exception");
        }

        thrown = false;
        try {
           Array.setShort(null, 0, (short)0);
        } catch (NullPointerException e) {
            // Correct behaviour
            thrown = true;
        }
        if (!thrown) {
            fail("Null argument failed to throw NPE");
        }
    }

    /**
     * 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() {
    }
}
