Home | History | Annotate | Download | only in reflect 
      1 /*
      2  *  Licensed to the Apache Software Foundation (ASF) under one or more
      3  *  contributor license agreements.  See the NOTICE file distributed with
      4  *  this work for additional information regarding copyright ownership.
      5  *  The ASF licenses this file to You under the Apache License, Version 2.0
      6  *  (the "License"); you may not use this file except in compliance with
      7  *  the License.  You may obtain a copy of the License at
      8  *
      9  *     http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  *  Unless required by applicable law or agreed to in writing, software
     12  *  distributed under the License is distributed on an "AS IS" BASIS,
     13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  *  See the License for the specific language governing permissions and
     15  *  limitations under the License.
     16  */
     17 
     18 package org.apache.harmony.luni.tests.java.lang.reflect;
     19 
     20 import java.lang.reflect.Constructor;
     21 import java.lang.reflect.InvocationTargetException;
     22 import java.lang.reflect.Modifier;
     23 import java.util.Vector;
     24 
     25 public class ConstructorTest extends junit.framework.TestCase {
     26 
     27     static class ConstructorTestHelper extends Object {
     28         int cval;
     29 
     30         public ConstructorTestHelper() throws IndexOutOfBoundsException {
     31             cval = 99;
     32         }
     33 
     34         public ConstructorTestHelper(Object x) {
     35         }
     36 
     37         private ConstructorTestHelper(int a) {
     38         }
     39 
     40         protected ConstructorTestHelper(long a) {
     41         }
     42 
     43         public int check() {
     44             return cval;
     45         }
     46     }
     47 
     48     /**
     49      * @tests java.lang.reflect.Constructor#equals(java.lang.Object)
     50      */
     51     public void test_equalsLjava_lang_Object() throws Exception {
     52         Class[] types = null;
     53         Constructor ctor1 = null, ctor2 = null;
     54         ctor1 = new ConstructorTestHelper().getClass().getConstructor(
     55                 new Class[0]);
     56 
     57         Class[] parms = null;
     58         parms = new Class[1];
     59         parms[0] = new Object().getClass();
     60         ctor2 = new ConstructorTestHelper().getClass().getConstructor(parms);
     61 
     62         assertTrue("Different Constructors returned equal", !ctor1
     63                 .equals(ctor2));
     64     }
     65 
     66     /**
     67      * @tests java.lang.reflect.Constructor#getDeclaringClass()
     68      */
     69     public void test_getDeclaringClass() throws Exception {
     70         // Test for method java.lang.Class
     71         // java.lang.reflect.Constructor.getDeclaringClass()
     72         boolean val = false;
     73         Class pclass = new ConstructorTestHelper().getClass();
     74         Constructor ctor = pclass.getConstructor(new Class[0]);
     75         val = ctor.getDeclaringClass().equals(pclass);
     76 
     77         assertTrue("Returned incorrect declaring class", val);
     78     }
     79 
     80     /**
     81      * @tests java.lang.reflect.Constructor#getExceptionTypes()
     82      */
     83     public void test_getExceptionTypes() throws Exception {
     84         Class[] exceptions = null;
     85         Class ex = null;
     86         Constructor ctor = new ConstructorTestHelper().getClass()
     87                 .getConstructor(new Class[0]);
     88         exceptions = ctor.getExceptionTypes();
     89         ex = new IndexOutOfBoundsException().getClass();
     90 
     91         assertEquals("Returned exception list of incorrect length", 1,
     92                 exceptions.length);
     93         assertTrue("Returned incorrect exception", exceptions[0].equals(ex));
     94     }
     95 
     96     /**
     97      * @tests java.lang.reflect.Constructor#getModifiers()
     98      */
     99     public void test_getModifiers() {
    100         int mod = 0;
    101         try {
    102             Constructor ctor = new ConstructorTestHelper().getClass()
    103                     .getConstructor(new Class[0]);
    104             mod = ctor.getModifiers();
    105             assertTrue("Returned incorrect modifers for public ctor",
    106                     ((mod & Modifier.PUBLIC) == Modifier.PUBLIC)
    107                             && ((mod & Modifier.PRIVATE) == 0));
    108         } catch (NoSuchMethodException e) {
    109             fail("Exception during test : " + e.getMessage());
    110         }
    111         try {
    112             Class[] cl = { int.class };
    113             Constructor ctor = new ConstructorTestHelper().getClass()
    114                     .getDeclaredConstructor(cl);
    115             mod = ctor.getModifiers();
    116             assertTrue("Returned incorrect modifers for private ctor",
    117                     ((mod & Modifier.PRIVATE) == Modifier.PRIVATE)
    118                             && ((mod & Modifier.PUBLIC) == 0));
    119         } catch (NoSuchMethodException e) {
    120             fail("Exception during test : " + e.getMessage());
    121         }
    122         try {
    123             Class[] cl = { long.class };
    124             Constructor ctor = new ConstructorTestHelper().getClass()
    125                     .getDeclaredConstructor(cl);
    126             mod = ctor.getModifiers();
    127             assertTrue("Returned incorrect modifers for private ctor",
    128                     ((mod & Modifier.PROTECTED) == Modifier.PROTECTED)
    129                             && ((mod & Modifier.PUBLIC) == 0));
    130         } catch (NoSuchMethodException e) {
    131             fail("NoSuchMethodException during test : " + e.getMessage());
    132         }
    133     }
    134 
    135     /**
    136      * @tests java.lang.reflect.Constructor#getName()
    137      */
    138     public void test_getName() throws Exception {
    139         Constructor ctor = new ConstructorTestHelper().getClass()
    140                 .getConstructor(new Class[0]);
    141         assertTrue(
    142                 "Returned incorrect name: " + ctor.getName(),
    143                 ctor
    144                         .getName()
    145                         .equals(
    146                                 "org.apache.harmony.luni.tests.java.lang.reflect.ConstructorTest$ConstructorTestHelper"));
    147     }
    148 
    149     /**
    150      * @tests java.lang.reflect.Constructor#getParameterTypes()
    151      */
    152     public void test_getParameterTypes() throws Exception {
    153         Class[] types = null;
    154         Constructor ctor = new ConstructorTestHelper().getClass()
    155                 .getConstructor(new Class[0]);
    156         types = ctor.getParameterTypes();
    157 
    158         assertEquals("Incorrect parameter returned", 0, types.length);
    159 
    160         Class[] parms = null;
    161         parms = new Class[1];
    162         parms[0] = new Object().getClass();
    163         ctor = new ConstructorTestHelper().getClass().getConstructor(parms);
    164         types = ctor.getParameterTypes();
    165 
    166         assertTrue("Incorrect parameter returned", types[0].equals(parms[0]));
    167     }
    168 
    169     /**
    170      * @tests java.lang.reflect.Constructor#newInstance(java.lang.Object[])
    171      */
    172     public void test_newInstance$Ljava_lang_Object() throws Exception {
    173         ConstructorTestHelper test = null;
    174         Constructor ctor = new ConstructorTestHelper().getClass()
    175                 .getConstructor(new Class[0]);
    176         test = (ConstructorTestHelper) ctor.newInstance((Object[]) null);
    177 
    178         assertEquals("improper instance created", 99, test.check());
    179     }
    180 
    181     /**
    182      * @tests java.lang.reflect.Constructor#newInstance(java.lang.Object[])
    183      */
    184     public void test_newInstance_IAE() throws Exception {
    185         Constructor constructor = Vector.class
    186                 .getConstructor(new Class[] { Integer.TYPE });
    187 
    188         try {
    189             constructor.newInstance(new Object[] { null });
    190             fail("should throw IllegalArgumentException");
    191         } catch (IllegalArgumentException e) {
    192             // Expected
    193         }
    194     }
    195 
    196     public void test_newInstance_InvocationTargetException() throws Exception {
    197         Constructor constructor = MockObject.class.getConstructor(Class.class);
    198 
    199         try {
    200             constructor.newInstance(InvocationTargetException.class);
    201             fail("should throw InvocationTargetException");
    202         } catch (InvocationTargetException e) {
    203             // Expected
    204         }
    205 
    206         try {
    207             constructor.newInstance(IllegalAccessException.class);
    208             fail("should throw InvocationTargetException");
    209         } catch (InvocationTargetException e) {
    210             // Expected
    211         }
    212 
    213         try {
    214             constructor.newInstance(IllegalArgumentException.class);
    215             fail("should throw InvocationTargetException");
    216         } catch (InvocationTargetException e) {
    217             // Expected
    218         }
    219 
    220         try {
    221             constructor.newInstance(InvocationTargetException.class);
    222             fail("should throw InvocationTargetException");
    223         } catch (InvocationTargetException e) {
    224             // Expected
    225         }
    226 
    227         try {
    228             constructor.newInstance(Throwable.class);
    229             fail("should throw InvocationTargetException");
    230         } catch (InvocationTargetException e) {
    231             // Expected
    232         }
    233     }
    234 
    235     static class MockObject {
    236 
    237         public MockObject(Class<?> clazz) throws Exception {
    238             if (clazz == InstantiationException.class) {
    239                 throw new InstantiationException();
    240             } else if (clazz == IllegalAccessException.class) {
    241                 throw new IllegalAccessException();
    242             } else if (clazz == IllegalArgumentException.class) {
    243                 throw new IllegalArgumentException();
    244             } else if (clazz == InvocationTargetException.class) {
    245                 throw new InvocationTargetException(new Throwable());
    246             } else {
    247                 throw new Exception();
    248             }
    249         }
    250 
    251     }
    252 
    253     /**
    254      * @tests java.lang.reflect.Constructor#toString()
    255      */
    256     public void test_toString() throws Exception {
    257         Class[] parms = null;
    258         Constructor ctor = null;
    259         parms = new Class[1];
    260         parms[0] = new Object().getClass();
    261         ctor = new ConstructorTestHelper().getClass().getConstructor(parms);
    262 
    263         assertTrue(
    264                 "Returned incorrect string representation: " + ctor.toString(),
    265                 ctor
    266                         .toString()
    267                         .equals(
    268                                 "public org.apache.harmony.luni.tests.java.lang.reflect.ConstructorTest$ConstructorTestHelper(java.lang.Object)"));
    269     }
    270 }
    271