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
18package org.apache.harmony.tests.java.lang.reflect;
19
20import tests.support.Support_Field;
21
22import java.lang.annotation.Annotation;
23import java.lang.annotation.ElementType;
24import java.lang.annotation.Inherited;
25import java.lang.annotation.Retention;
26import java.lang.annotation.RetentionPolicy;
27import java.lang.annotation.Target;
28import java.lang.reflect.Field;
29import java.lang.reflect.Modifier;
30import java.lang.reflect.Type;
31import java.lang.reflect.TypeVariable;
32import java.util.HashSet;
33import java.util.Set;
34
35public class FieldTest extends junit.framework.TestCase {
36
37    // BEGIN android-note
38    // This test had a couple of bugs in it. Some parts of the code were
39    // unreachable before. Also some tests expected the wrong excpetions
40    // to be thrown. This version has been validated to pass on a standard
41    // JDK 1.5.
42    // END android-note
43
44    public class TestClass {
45        @AnnotationRuntime0
46        @AnnotationRuntime1
47        @AnnotationClass0
48        @AnnotationSource0
49        public int annotatedField;
50        class Inner{}
51    }
52
53
54    @Retention(RetentionPolicy.RUNTIME)
55    @Target( {ElementType.FIELD})
56    static @interface AnnotationRuntime0 {
57    }
58
59    @Retention(RetentionPolicy.RUNTIME)
60    @Target( { ElementType.FIELD})
61    static @interface AnnotationRuntime1 {
62    }
63
64    @Retention(RetentionPolicy.CLASS)
65    @Target( { ElementType.FIELD})
66    static @interface AnnotationClass0 {
67    }
68
69    @Retention(RetentionPolicy.SOURCE)
70    @Target( {ElementType.FIELD})
71    static @interface AnnotationSource0 {
72    }
73
74    @Inherited
75    @Retention(RetentionPolicy.RUNTIME)
76    @Target( {ElementType.FIELD})
77    static @interface InheritedRuntime {
78    }
79
80    public class GenericField<S, T extends Number> {
81        S field;
82        T boundedField;
83        int intField;
84    }
85
86
87    static class TestField {
88        public static int pubfield1;
89
90        private static int privfield1 = 123;
91
92        protected int intField = Integer.MAX_VALUE;
93        protected final int intFField = Integer.MAX_VALUE;
94        protected static int intSField = Integer.MAX_VALUE;
95        private final int intPFField = Integer.MAX_VALUE;
96
97        protected short shortField = Short.MAX_VALUE;
98        protected final short shortFField = Short.MAX_VALUE;
99        protected static short shortSField = Short.MAX_VALUE;
100        private final short shortPFField = Short.MAX_VALUE;
101
102        protected boolean booleanField = true;
103        protected static boolean booleanSField = true;
104        protected final boolean booleanFField = true;
105        private final boolean booleanPFField = true;
106
107        protected byte byteField = Byte.MAX_VALUE;
108        protected static byte byteSField = Byte.MAX_VALUE;
109        protected final byte byteFField = Byte.MAX_VALUE;
110        private final byte bytePFField = Byte.MAX_VALUE;
111
112        protected long longField = Long.MAX_VALUE;
113        protected final long longFField = Long.MAX_VALUE;
114        protected static long longSField = Long.MAX_VALUE;
115        private final long longPFField = Long.MAX_VALUE;
116
117        protected double doubleField = Double.MAX_VALUE;
118        protected static double doubleSField = Double.MAX_VALUE;
119        protected static final double doubleSFField = Double.MAX_VALUE;
120        protected final double doubleFField = Double.MAX_VALUE;
121        private final double doublePFField = Double.MAX_VALUE;
122
123        protected float floatField = Float.MAX_VALUE;
124        protected final float floatFField = Float.MAX_VALUE;
125        protected static float floatSField = Float.MAX_VALUE;
126        private final float floatPFField = Float.MAX_VALUE;
127
128        protected char charField = 'T';
129        protected static char charSField = 'T';
130        private final char charPFField = 'T';
131
132        protected final char charFField = 'T';
133
134        private static final int x = 1;
135
136        public volatile transient int y = 0;
137
138        protected static transient volatile int prsttrvol = 99;
139    }
140
141    public class TestFieldSub1 extends TestField {
142    }
143
144    public class TestFieldSub2 extends TestField {
145    }
146
147    static class A {
148        protected short shortField = Short.MAX_VALUE;
149    }
150
151    static enum TestEnum {
152        A, B, C;
153        int field;
154    }
155
156    /**
157     * java.lang.reflect.Field#equals(java.lang.Object)
158     */
159    public void test_equalsLjava_lang_Object() {
160        // Test for method boolean
161        // java.lang.reflect.Field.equals(java.lang.Object)
162        TestField x = new TestField();
163        Field f = null;
164        try {
165            f = TestField.class.getDeclaredField("shortField");
166        } catch (Exception e) {
167            fail("Exception during getType test : " + e.getMessage());
168        }
169        try {
170            assertTrue("Same Field returned false", f.equals(f));
171            assertTrue("Inherited Field returned false", f.equals(TestField.class
172                    .getDeclaredField("shortField")));
173            assertTrue("Identical Field from different class returned true", !f
174                    .equals(A.class.getDeclaredField("shortField")));
175        } catch (Exception e) {
176            fail("Exception during getType test : " + e.getMessage());
177        }
178    }
179
180    /**
181     * java.lang.reflect.Field#get(java.lang.Object)
182     */
183    public void test_getLjava_lang_Object() throws Throwable {
184        // Test for method java.lang.Object
185        // java.lang.reflect.Field.get(java.lang.Object)
186        TestField x = new TestField();
187        Field f = TestField.class.getDeclaredField("doubleField");
188        Double val = (Double) f.get(x);
189
190        assertTrue("Returned incorrect double field value",
191                val.doubleValue() == Double.MAX_VALUE);
192        // Test getting a static field;
193        f = TestField.class.getDeclaredField("doubleSField");
194        f.set(x, new Double(1.0));
195        val = (Double) f.get(x);
196        assertEquals("Returned incorrect double field value", 1.0, val.doubleValue());
197
198        // Try a get on a private field in nested member
199        // temporarily commented because it breaks J9 VM
200        // Regression for HARMONY-1309
201        //f = x.getClass().getDeclaredField("privfield1");
202        //assertEquals(x.privfield1, f.get(x));
203
204        // Try a get using an invalid class.
205        boolean thrown = false;
206        try {
207            f = TestField.class.getDeclaredField("doubleField");
208            f.get(new String());
209            fail("No expected IllegalArgumentException");
210        } catch (IllegalArgumentException exc) {
211            // Correct - Passed an Object that does not declare or inherit f
212            thrown = true;
213        }
214        assertTrue("IllegalArgumentException expected but not thrown", thrown);
215
216        //Test NPE
217        thrown = false;
218        try {
219            f = TestField.class.getDeclaredField("intField");
220            f.get(null);
221            fail("Expected NullPointerException not thrown");
222        } catch (NullPointerException exc) {
223            // Correct - Passed an Object that does not declare or inherit f
224            thrown = true;
225        }
226        assertTrue("NullPointerException expected but not thrown", thrown);
227
228        //Test no NPE on static fields
229        thrown = false;
230        try {
231            f = TestField.class.getDeclaredField("doubleSField");
232            f.get(null);
233            assertTrue("Exception thrown", true);
234        } catch (Exception exc) {
235            fail("No exception expected");
236        }
237    }
238
239    class SupportSubClass extends Support_Field {
240
241        Object getField(char primitiveType, Object o, Field f,
242                Class expected) {
243            Object res = null;
244            try {
245                primitiveType = Character.toUpperCase(primitiveType);
246                switch (primitiveType) {
247                case 'I': // int
248                    res = new Integer(f.getInt(o));
249                    break;
250                case 'J': // long
251                    res = new Long(f.getLong(o));
252                    break;
253                case 'Z': // boolean
254                    res = new Boolean(f.getBoolean(o));
255                    break;
256                case 'S': // short
257                    res = new Short(f.getShort(o));
258                    break;
259                case 'B': // byte
260                    res = new Byte(f.getByte(o));
261                    break;
262                case 'C': // char
263                    res = new Character(f.getChar(o));
264                    break;
265                case 'D': // double
266                    res = new Double(f.getDouble(o));
267                    break;
268                case 'F': // float
269                    res = new Float(f.getFloat(o));
270                    break;
271                default:
272                    res = f.get(o);
273                }
274                // Since 2011, members are always accessible and throwing is optional
275                assertTrue("expected " + expected + " for " + f.getName(),
276                        expected == null || expected == IllegalAccessException.class);
277            } catch (Exception e) {
278                if (expected == null) {
279                    fail("unexpected exception " + e);
280                } else {
281                    assertTrue("expected exception "
282                            + expected.getName() + " and got " + e, e
283                            .getClass().equals(expected));
284                }
285            }
286            return res;
287        }
288
289        void setField(char primitiveType, Object o, Field f,
290                Class expected, Object value) {
291            try {
292                primitiveType = Character.toUpperCase(primitiveType);
293                switch (primitiveType) {
294                case 'I': // int
295                    f.setInt(o, ((Integer) value).intValue());
296                    break;
297                case 'J': // long
298                    f.setLong(o, ((Long) value).longValue());
299                    break;
300                case 'Z': // boolean
301                    f.setBoolean(o, ((Boolean) value).booleanValue());
302                    break;
303                case 'S': // short
304                    f.setShort(o, ((Short) value).shortValue());
305                    break;
306                case 'B': // byte
307                    f.setByte(o, ((Byte) value).byteValue());
308                    break;
309                case 'C': // char
310                    f.setChar(o, ((Character) value).charValue());
311                    break;
312                case 'D': // double
313                    f.setDouble(o, ((Double) value).doubleValue());
314                    break;
315                case 'F': // float
316                    f.setFloat(o, ((Float) value).floatValue());
317                    break;
318                default:
319                    f.set(o, value);
320                }
321                // Since 2011, members are always accessible and throwing is optional
322                assertTrue("expected " + expected + " for " + f.getName() + " = " + value,
323                        expected == null || expected == IllegalAccessException.class);
324            } catch (Exception e) {
325                if (expected == null) {
326                    e.printStackTrace();
327                    fail("unexpected exception " + e + " for field "
328                            + f.getName() + ", value " + value);
329                } else {
330                    assertTrue("expected exception "
331                            + expected.getName() + " and got " + e
332                            + " for field " + f.getName() + ", value " + value,
333                            e.getClass().equals(expected));
334                }
335            }
336        }
337    }
338
339    /**
340     * java.lang.reflect.Field#get(java.lang.Object)
341     * java.lang.reflect.Field#getByte(java.lang.Object)
342     * java.lang.reflect.Field#getBoolean(java.lang.Object)
343     * java.lang.reflect.Field#getShort(java.lang.Object)
344     * java.lang.reflect.Field#getInt(java.lang.Object)
345     * java.lang.reflect.Field#getLong(java.lang.Object)
346     * java.lang.reflect.Field#getFloat(java.lang.Object)
347     * java.lang.reflect.Field#getDouble(java.lang.Object)
348     * java.lang.reflect.Field#getChar(java.lang.Object)
349     * java.lang.reflect.Field#set(java.lang.Object, java.lang.Object)
350     * java.lang.reflect.Field#setByte(java.lang.Object, byte)
351     * java.lang.reflect.Field#setBoolean(java.lang.Object, boolean)
352     * java.lang.reflect.Field#setShort(java.lang.Object, short)
353     * java.lang.reflect.Field#setInt(java.lang.Object, int)
354     * java.lang.reflect.Field#setLong(java.lang.Object, long)
355     * java.lang.reflect.Field#setFloat(java.lang.Object, float)
356     * java.lang.reflect.Field#setDouble(java.lang.Object, double)
357     * java.lang.reflect.Field#setChar(java.lang.Object, char)
358     */
359    public void testProtectedFieldAccess() {
360        Class fieldClass = Support_Field.class;
361        String fieldName = null;
362        Field objectField = null;
363        Field booleanField = null;
364        Field byteField = null;
365        Field charField = null;
366        Field shortField = null;
367        Field intField = null;
368        Field longField = null;
369        Field floatField = null;
370        Field doubleField = null;
371        try {
372            fieldName = "objectField";
373            objectField = fieldClass.getDeclaredField(fieldName);
374
375            fieldName = "booleanField";
376            booleanField = fieldClass.getDeclaredField(fieldName);
377
378            fieldName = "byteField";
379            byteField = fieldClass.getDeclaredField(fieldName);
380
381            fieldName = "charField";
382            charField = fieldClass.getDeclaredField(fieldName);
383
384            fieldName = "shortField";
385            shortField = fieldClass.getDeclaredField(fieldName);
386
387            fieldName = "intField";
388            intField = fieldClass.getDeclaredField(fieldName);
389
390            fieldName = "longField";
391            longField = fieldClass.getDeclaredField(fieldName);
392
393            fieldName = "floatField";
394            floatField = fieldClass.getDeclaredField(fieldName);
395
396            fieldName = "doubleField";
397            doubleField = fieldClass.getDeclaredField(fieldName);
398        } catch (NoSuchFieldException e) {
399            fail("missing field " + fieldName + " in test support class "
400                    + fieldClass.getName());
401        }
402
403        // create the various objects that might or might not have an instance
404        // of the field
405        Support_Field parentClass = new Support_Field();
406        SupportSubClass subclass = new SupportSubClass();
407        SupportSubClass otherSubclass = new SupportSubClass();
408        Object plainObject = new Object();
409
410        Class illegalAccessExceptionClass = IllegalAccessException.class;
411        Class illegalArgumentExceptionClass = IllegalArgumentException.class;
412
413        // The test will attempt to use pass an object to set for object, byte,
414        // short, ..., float and double fields
415        // and pass a byte to to setByte for byte, short, ..., float and double
416        // fields and so on.
417        // It will also test if IllegalArgumentException is thrown when the
418        // field does not exist in the given object and that
419        // IllegalAccessException is thrown when trying to access an
420        // inaccessible protected field.
421        // The test will also check that IllegalArgumentException is thrown for
422        // all other attempts.
423
424        // Ordered by widening conversion, except for 'L' at the beg (which
425        // stands for Object).
426        // If the object provided to set can be unwrapped to a primitive, then
427        // the set method can set
428        // primitive fields.
429        char types[] = { 'L', 'B', 'S', 'C', 'I', 'J', 'F', 'D' };
430        Field fields[] = { objectField, byteField, shortField, charField,
431                intField, longField, floatField, doubleField };
432        Object values[] = { new Byte((byte) 1), new Byte((byte) 1),
433                new Short((short) 1), new Character((char) 1), new Integer(1),
434                new Long(1), new Float(1), new Double(1) };
435
436        // test set methods
437        for (int i = 0; i < types.length; i++) {
438            char type = types[i];
439            Object value = values[i];
440            for (int j = i; j < fields.length; j++) {
441                Field field = fields[j];
442                fieldName = field.getName();
443
444                if (field == charField && type != 'C') {
445                    // the exception is that bytes and shorts CANNOT be
446                    // converted into chars even though chars CAN be
447                    // converted into ints, longs, floats and doubles
448                    subclass.setField(type, subclass, field,
449                            illegalArgumentExceptionClass, value);
450                } else {
451                    // setting type into field);
452                    subclass.setField(type, subclass, field, null, value);
453                    subclass.setField(type, otherSubclass, field, null, value);
454                    subclass.setField(type, parentClass, field,
455                            illegalAccessExceptionClass, value);
456                    subclass.setField(type, plainObject, field,
457                            illegalArgumentExceptionClass, value);
458                }
459            }
460            for (int j = 0; j < i; j++) {
461                Field field = fields[j];
462                fieldName = field.getName();
463                // not setting type into field);
464                subclass.setField(type, subclass, field,
465                        illegalArgumentExceptionClass, value);
466            }
467        }
468
469        // test setBoolean
470        Boolean booleanValue = Boolean.TRUE;
471        subclass.setField('Z', subclass, booleanField, null, booleanValue);
472        subclass.setField('Z', otherSubclass, booleanField, null, booleanValue);
473        subclass.setField('Z', parentClass, booleanField,
474                illegalAccessExceptionClass, booleanValue);
475        subclass.setField('Z', plainObject, booleanField,
476                illegalArgumentExceptionClass, booleanValue);
477        for (int j = 0; j < fields.length; j++) {
478            Field listedField = fields[j];
479            fieldName = listedField.getName();
480            // not setting boolean into listedField
481            subclass.setField('Z', subclass, listedField,
482                    illegalArgumentExceptionClass, booleanValue);
483        }
484        for (int i = 0; i < types.length; i++) {
485            char type = types[i];
486            Object value = values[i];
487            subclass.setField(type, subclass, booleanField,
488                    illegalArgumentExceptionClass, value);
489        }
490
491        // We perform the analogous test on the get methods.
492
493        // ordered by widening conversion, except for 'L' at the end (which
494        // stands for Object), to which all primitives can be converted by
495        // wrapping
496        char newTypes[] = new char[] { 'B', 'S', 'C', 'I', 'J', 'F', 'D', 'L' };
497        Field newFields[] = { byteField, shortField, charField, intField,
498                longField, floatField, doubleField, objectField };
499        fields = newFields;
500        types = newTypes;
501        // test get methods
502        for (int i = 0; i < types.length; i++) {
503            char type = types[i];
504            for (int j = 0; j <= i; j++) {
505                Field field = fields[j];
506                fieldName = field.getName();
507                if (type == 'C' && field != charField) {
508                    // the exception is that bytes and shorts CANNOT be
509                    // converted into chars even though chars CAN be
510                    // converted into ints, longs, floats and doubles
511                    subclass.getField(type, subclass, field,
512                            illegalArgumentExceptionClass);
513                } else {
514                    // getting type from field
515                    subclass.getField(type, subclass, field, null);
516                    subclass.getField(type, otherSubclass, field, null);
517                    subclass.getField(type, parentClass, field,
518                            illegalAccessExceptionClass);
519                    subclass.getField(type, plainObject, field,
520                            illegalArgumentExceptionClass);
521                }
522            }
523            for (int j = i + 1; j < fields.length; j++) {
524                Field field = fields[j];
525                fieldName = field.getName();
526                subclass.getField(type, subclass, field,
527                        illegalArgumentExceptionClass);
528            }
529        }
530
531        // test getBoolean
532        subclass.getField('Z', subclass, booleanField, null);
533        subclass.getField('Z', otherSubclass, booleanField, null);
534        subclass.getField('Z', parentClass, booleanField,
535                illegalAccessExceptionClass);
536        subclass.getField('Z', plainObject, booleanField,
537                illegalArgumentExceptionClass);
538        for (int j = 0; j < fields.length; j++) {
539            Field listedField = fields[j];
540            fieldName = listedField.getName();
541            // not getting boolean from listedField
542            subclass.getField('Z', subclass, listedField,
543                    illegalArgumentExceptionClass);
544        }
545        for (int i = 0; i < types.length - 1; i++) {
546            char type = types[i];
547            subclass.getField(type, subclass, booleanField,
548                    illegalArgumentExceptionClass);
549        }
550        Object res = subclass.getField('L', subclass, booleanField, null);
551        assertTrue("unexpected object " + res, res instanceof Boolean);
552    }
553
554    /**
555     * java.lang.reflect.Field#getBoolean(java.lang.Object)
556     */
557    public void test_getBooleanLjava_lang_Object() {
558        TestField x = new TestField();
559        Field f = null;
560        boolean val = false;
561        try {
562            f = TestField.class.getDeclaredField("booleanField");
563            val = f.getBoolean(x);
564        } catch (Exception e) {
565            fail("Exception during getBoolean test: " + e.toString());
566        }
567        assertTrue("Returned incorrect boolean field value", val);
568
569        boolean thrown = false;
570        try {
571            f = TestField.class.getDeclaredField("doubleField");
572            f.getBoolean(x);
573            fail("IllegalArgumentException expected but not thrown");
574        } catch (IllegalArgumentException ex) {
575            thrown = true;
576        } catch (Exception ex) {
577            fail("IllegalArgumentException expected but not thrown");
578        }
579        assertTrue("IllegalArgumentException expected but not thrown", thrown);
580
581        //Test NPE
582        thrown = false;
583        try {
584            f = TestField.class.getDeclaredField("booleanField");
585            f.getBoolean(null);
586            fail("NullPointerException expected but not thrown");
587        } catch (NullPointerException ex) {
588            thrown = true;
589        } catch (Exception ex) {
590            fail("NullPointerException expected but not thrown");
591        }
592        assertTrue("NullPointerException expected but not thrown", thrown);
593
594        //Test no NPE on static field
595        thrown = false;
596        try {
597            f = TestField.class.getDeclaredField("booleanSField");
598            boolean staticValue = f.getBoolean(null);
599            assertTrue("Wrong value returned", staticValue);
600        }  catch (Exception ex) {
601            fail("No exception expected");
602        }
603    }
604
605
606    /**
607     * java.lang.reflect.Field#getByte(java.lang.Object)
608     */
609    public void test_getByteLjava_lang_Object() {
610        // Test for method byte
611        // java.lang.reflect.Field.getByte(java.lang.Object)
612        TestField x = new TestField();
613        Field f = null;
614        byte val = 0;
615        try {
616            f = TestField.class.getDeclaredField("byteField");
617            val = f.getByte(x);
618        } catch (Exception e) {
619            fail("Exception during getbyte test : " + e.getMessage());
620        }
621        assertTrue("Returned incorrect byte field value", val == Byte.MAX_VALUE);
622
623        boolean thrown = false;
624        try {
625            f = TestField.class.getDeclaredField("doubleField");
626            f.getByte(x);
627            fail("IllegalArgumentException expected but not thrown");
628        } catch (IllegalArgumentException ex) {
629            thrown = true;
630        } catch (Exception ex) {
631            fail("IllegalArgumentException expected but not thrown");
632        }
633        assertTrue("IllegalArgumentException expected but not thrown", thrown);
634
635        //Test NPE
636        thrown = false;
637        try {
638            f = TestField.class.getDeclaredField("byteField");
639            f.getByte(null);
640            fail("NullPointerException expected but not thrown");
641        } catch (NullPointerException ex) {
642            thrown = true;
643        } catch (Exception ex) {
644            fail("NullPointerException expected but not thrown");
645        }
646        assertTrue("NullPointerException expected but not thrown", thrown);
647
648        //Test no NPE on static field
649        thrown = false;
650        try {
651            f = TestField.class.getDeclaredField("byteSField");
652            byte staticValue = f.getByte(null);
653            assertEquals("Wrong value returned", Byte.MAX_VALUE, staticValue);
654        }  catch (Exception ex) {
655            fail("No exception expected "+ ex.getMessage());
656        }
657    }
658
659    /**
660     * java.lang.reflect.Field#getChar(java.lang.Object)
661     */
662    public void test_getCharLjava_lang_Object() {
663        // Test for method char
664        // java.lang.reflect.Field.getChar(java.lang.Object)
665        TestField x = new TestField();
666        Field f = null;
667        char val = 0;
668        try {
669            f = TestField.class.getDeclaredField("charField");
670            val = f.getChar(x);
671        } catch (Exception e) {
672            fail("Exception during getCharacter test: " + e.toString());
673        }
674        assertEquals("Returned incorrect char field value", 'T', val);
675
676        boolean thrown = false;
677        try {
678            f = TestField.class.getDeclaredField("doubleField");
679            f.getChar(x);
680            fail("IllegalArgumentException expected but not thrown");
681        } catch (IllegalArgumentException ex) {
682            thrown = true;
683        } catch (Exception ex) {
684            fail("IllegalArgumentException expected but not thrown");
685        }
686        assertTrue("IllegalArgumentException expected but not thrown", thrown);
687
688        //Test NPE
689        thrown = false;
690        try {
691            f = TestField.class.getDeclaredField("charField");
692            f.getChar(null);
693            fail("NullPointerException expected but not thrown");
694        } catch (NullPointerException ex) {
695            thrown = true;
696        } catch (Exception ex) {
697            fail("NullPointerException expected but not thrown");
698        }
699        assertTrue("NullPointerException expected but not thrown", thrown);
700
701        //Test no NPE on static field
702        thrown = false;
703        try {
704            f = TestField.class.getDeclaredField("charSField");
705            char staticValue = f.getChar(null);
706            assertEquals("Wrong value returned", 'T', staticValue);
707        }  catch (Exception ex) {
708            fail("No exception expected "+ ex.getMessage());
709        }
710    }
711
712    /**
713     * java.lang.reflect.Field#getDeclaringClass()
714     */
715    public void test_getDeclaringClass() {
716        // Test for method java.lang.Class
717        // java.lang.reflect.Field.getDeclaringClass()
718        Field[] fields;
719
720        try {
721            fields = TestField.class.getFields();
722            assertTrue("Returned incorrect declaring class", fields[0]
723                    .getDeclaringClass().equals(TestField.class));
724
725            // Check the case where the field is inherited to be sure the parent
726            // is returned as the declarer
727            fields = TestFieldSub1.class.getFields();
728            assertTrue("Returned incorrect declaring class", fields[0]
729                    .getDeclaringClass().equals(TestField.class));
730        } catch (Exception e) {
731            fail("Exception : " + e.getMessage());
732        }
733    }
734
735    /**
736     * java.lang.reflect.Field#getDouble(java.lang.Object)
737     */
738    public void test_getDoubleLjava_lang_Object() {
739        // Test for method double
740        // java.lang.reflect.Field.getDouble(java.lang.Object)
741        TestField x = new TestField();
742        Field f = null;
743        double val = 0.0;
744        try {
745            f = TestField.class.getDeclaredField("doubleField");
746            val = f.getDouble(x);
747        } catch (Exception e) {
748            fail("Exception during getDouble test: " + e.toString());
749        }
750        assertTrue("Returned incorrect double field value",
751                val == Double.MAX_VALUE);
752
753        boolean thrown = false;
754        try {
755            f = TestField.class.getDeclaredField("booleanField");
756            f.getDouble(x);
757            fail("IllegalArgumentException expected but not thrown");
758        } catch (IllegalArgumentException ex) {
759            thrown = true;
760        } catch (Exception ex) {
761            fail("IllegalArgumentException expected but not thrown "
762                    + ex.getMessage());
763        }
764        assertTrue("IllegalArgumentException expected but not thrown", thrown);
765
766        //Test NPE
767        thrown = false;
768        try {
769            f = TestField.class.getDeclaredField("doubleField");
770            f.getDouble(null);
771            fail("NullPointerException expected but not thrown");
772        } catch (NullPointerException ex) {
773            thrown = true;
774        } catch (Exception ex) {
775            fail("NullPointerException expected but not thrown");
776        }
777        assertTrue("NullPointerException expected but not thrown", thrown);
778
779        //Test no NPE on static field
780        thrown = false;
781        try {
782            f = TestField.class.getDeclaredField("doubleSFField");
783            double staticValue = f.getDouble(null);
784            assertEquals("Wrong value returned", Double.MAX_VALUE, staticValue);
785        }  catch (Exception ex) {
786            fail("No exception expected "+ ex.getMessage());
787        }
788    }
789
790    /**
791     * java.lang.reflect.Field#getFloat(java.lang.Object)
792     */
793    public void test_getFloatLjava_lang_Object() {
794        // Test for method float
795        // java.lang.reflect.Field.getFloat(java.lang.Object)
796        TestField x = new TestField();
797        Field f = null;
798        float val = 0;
799        try {
800            f = TestField.class.getDeclaredField("floatField");
801            val = f.getFloat(x);
802        } catch (Exception e) {
803            fail("Exception during getFloat test : " + e.getMessage());
804        }
805        assertTrue("Returned incorrect float field value",
806                val == Float.MAX_VALUE);
807
808        boolean thrown = false;
809        try {
810            f = TestField.class.getDeclaredField("booleanField");
811            f.getFloat(x);
812            fail("IllegalArgumentException expected but not thrown");
813        } catch (IllegalArgumentException ex) {
814            thrown = true;
815        } catch (Exception ex) {
816            fail("IllegalArgumentException expected but not thrown "
817                    + ex.getMessage());
818        }
819        assertTrue("IllegalArgumentException expected but not thrown", thrown);
820
821        //Test NPE
822        thrown = false;
823        try {
824            f = TestField.class.getDeclaredField("floatField");
825            f.getFloat(null);
826            fail("NullPointerException expected but not thrown");
827        } catch (NullPointerException ex) {
828            thrown = true;
829        } catch (Exception ex) {
830            fail("NullPointerException expected but not thrown");
831        }
832        assertTrue("NullPointerException expected but not thrown", thrown);
833
834        //Test no NPE on static field
835        thrown = false;
836        try {
837            f = TestField.class.getDeclaredField("floatSField");
838            float staticValue = f.getFloat(null);
839            assertEquals("Wrong value returned", Float.MAX_VALUE, staticValue);
840        }  catch (Exception ex) {
841            fail("No exception expected "+ ex.getMessage());
842        }
843    }
844
845    /**
846     * java.lang.reflect.Field#getInt(java.lang.Object)
847     */
848    public void test_getIntLjava_lang_Object() {
849        // Test for method int java.lang.reflect.Field.getInt(java.lang.Object)
850        TestField x = new TestField();
851        Field f = null;
852        int val = 0;
853        try {
854            f = TestField.class.getDeclaredField("intField");
855            val = f.getInt(x);
856        } catch (Exception e) {
857            fail("Exception during getInt test : " + e.getMessage());
858        }
859        assertTrue("Returned incorrect Int field value",
860                val == Integer.MAX_VALUE);
861
862        boolean thrown = false;
863        try {
864            f = TestField.class.getDeclaredField("booleanField");
865            f.getInt(x);
866            fail("IllegalArgumentException expected but not thrown");
867        } catch (IllegalArgumentException ex) {
868            thrown = true;
869        } catch (Exception ex) {
870            fail("IllegalArgumentException expected but not thrown "
871                    + ex.getMessage());
872        }
873        assertTrue("IllegalArgumentException expected but not thrown", thrown);
874
875        //Test NPE
876        thrown = false;
877        try {
878            f = TestField.class.getDeclaredField("intField");
879            f.getInt(null);
880            fail("NullPointerException expected but not thrown");
881        } catch (NullPointerException ex) {
882            thrown = true;
883        } catch (Exception ex) {
884            fail("NullPointerException expected but not thrown");
885        }
886        assertTrue("NullPointerException expected but not thrown", thrown);
887
888        //Test no NPE on static field
889        thrown = false;
890        try {
891            f = TestField.class.getDeclaredField("intSField");
892            int staticValue = f.getInt(null);
893            assertEquals("Wrong value returned", Integer.MAX_VALUE, staticValue);
894        } catch (Exception ex) {
895            fail("No exception expected " + ex.getMessage());
896        }
897
898    }
899
900    /**
901     * java.lang.reflect.Field#getLong(java.lang.Object)
902     */
903    public void test_getLongLjava_lang_Object() {
904        // Test for method long
905        // java.lang.reflect.Field.getLong(java.lang.Object)
906        TestField x = new TestField();
907        Field f = null;
908        long val = 0;
909        try {
910            f = TestField.class.getDeclaredField("longField");
911            val = f.getLong(x);
912        } catch (Exception e) {
913            fail("Exception during getLong test : " + e.getMessage());
914        }
915
916        boolean thrown = false;
917        try {
918            f = TestField.class.getDeclaredField("booleanField");
919            f.getLong(x);
920            fail("IllegalArgumentException expected but not thrown");
921        } catch (IllegalArgumentException ex) {
922            thrown = true;
923        } catch (Exception ex) {
924            fail("IllegalArgumentException expected but not thrown "
925                    + ex.getMessage());
926        }
927        assertTrue("IllegalArgumentException expected but not thrown", thrown);
928
929        //Test NPE
930        thrown = false;
931        try {
932            f = TestField.class.getDeclaredField("longField");
933            f.getLong(null);
934            fail("NullPointerException expected but not thrown");
935        } catch (NullPointerException ex) {
936            thrown = true;
937        } catch (Exception ex) {
938            fail("NullPointerException expected but not thrown");
939        }
940        assertTrue("NullPointerException expected but not thrown", thrown);
941
942        //Test no NPE on static field
943        thrown = false;
944        try {
945            f = TestField.class.getDeclaredField("longSField");
946            long staticValue = f.getLong(null);
947            assertEquals("Wrong value returned", Long.MAX_VALUE, staticValue);
948        }  catch (Exception ex) {
949            fail("No exception expected "+ ex.getMessage());
950        }
951    }
952
953    /**
954     * java.lang.reflect.Field#getModifiers()
955     */
956    public void test_getModifiers() {
957        // Test for method int java.lang.reflect.Field.getModifiers()
958        TestField x = new TestField();
959        Field f = null;
960        try {
961            f = TestField.class.getDeclaredField("prsttrvol");
962        } catch (Exception e) {
963            fail("Exception during getModifiers test: " + e.toString());
964        }
965        int mod = f.getModifiers();
966        int mask = (Modifier.PROTECTED | Modifier.STATIC)
967                | (Modifier.TRANSIENT | Modifier.VOLATILE);
968        int nmask = (Modifier.PUBLIC | Modifier.NATIVE);
969        assertTrue("Returned incorrect field modifiers: ",
970                ((mod & mask) == mask) && ((mod & nmask) == 0));
971    }
972
973    /**
974     * java.lang.reflect.Field#getName()
975     */
976    public void test_getName() {
977        // Test for method java.lang.String java.lang.reflect.Field.getName()
978        TestField x = new TestField();
979        Field f = null;
980        try {
981            f = TestField.class.getDeclaredField("shortField");
982        } catch (Exception e) {
983            fail("Exception during getType test : " + e.getMessage());
984        }
985        assertEquals("Returned incorrect field name",
986                "shortField", f.getName());
987    }
988
989    /**
990     * java.lang.reflect.Field#getShort(java.lang.Object)
991     */
992    public void test_getShortLjava_lang_Object() {
993        // Test for method short
994        // java.lang.reflect.Field.getShort(java.lang.Object)
995        TestField x = new TestField();
996        Field f = null;
997        short val = 0;
998        ;
999        try {
1000            f = TestField.class.getDeclaredField("shortField");
1001            val = f.getShort(x);
1002        } catch (Exception e) {
1003            fail("Exception during getShort test : " + e.getMessage());
1004        }
1005        assertTrue("Returned incorrect short field value",
1006                val == Short.MAX_VALUE);
1007
1008        boolean thrown = false;
1009        try {
1010            f = TestField.class.getDeclaredField("booleanField");
1011            f.getShort(x);
1012            fail("IllegalArgumentException expected but not thrown");
1013        } catch (IllegalArgumentException ex) {
1014            thrown = true;
1015        } catch (Exception ex) {
1016            fail("IllegalArgumentException expected but not thrown "
1017                    + ex.getMessage());
1018        }
1019        assertTrue("IllegalArgumentException expected but not thrown", thrown);
1020
1021        //Test NPE
1022        thrown = false;
1023        try {
1024            f = TestField.class.getDeclaredField("shortField");
1025            f.getShort(null);
1026            fail("NullPointerException expected but not thrown");
1027        } catch (NullPointerException ex) {
1028            thrown = true;
1029        } catch (Exception ex) {
1030            fail("NullPointerException expected but not thrown");
1031        }
1032        assertTrue("NullPointerException expected but not thrown", thrown);
1033
1034        //Test no NPE on static field
1035        thrown = false;
1036        try {
1037            f = TestField.class.getDeclaredField("shortSField");
1038            short staticValue = f.getShort(null);
1039            assertEquals("Wrong value returned", Short.MAX_VALUE, staticValue);
1040        }  catch (Exception ex) {
1041            fail("No exception expected "+ ex.getMessage());
1042        }
1043    }
1044
1045    /**
1046     * java.lang.reflect.Field#getType()
1047     */
1048    public void test_getType() {
1049        // Test for method java.lang.Class java.lang.reflect.Field.getType()
1050        TestField x = new TestField();
1051        Field f = null;
1052        try {
1053            f = TestField.class.getDeclaredField("shortField");
1054        } catch (Exception e) {
1055            fail("Exception during getType test : " + e.getMessage());
1056        }
1057        assertTrue("Returned incorrect field type: " + f.getType().toString(),
1058                f.getType().equals(short.class));
1059    }
1060
1061    /**
1062     * java.lang.reflect.Field#set(java.lang.Object, java.lang.Object)
1063     */
1064    public void test_setLjava_lang_ObjectLjava_lang_Object() throws Exception{
1065        // Test for method void java.lang.reflect.Field.set(java.lang.Object,
1066        // java.lang.Object)
1067        TestField x = new TestField();
1068        Field f = null;
1069        double val = 0.0;
1070        try {
1071            f = TestField.class.getDeclaredField("doubleField");
1072            f.set(x, new Double(1.0));
1073            val = f.getDouble(x);
1074        } catch (Exception e) {
1075            fail("Exception during set test : " + e.getMessage());
1076        }
1077        assertEquals("Returned incorrect double field value", 1.0, val);
1078
1079        //test wrong type
1080        boolean thrown = false;
1081        try {
1082            f = TestField.class.getDeclaredField("booleanField");
1083            f.set(x, new Double(1.0));
1084            fail("Accessed field of invalid type");
1085        } catch (IllegalArgumentException ex) {
1086            thrown = true;
1087        }
1088        assertTrue("IllegalArgumentException expected but not thrown", thrown);
1089
1090      //Test NPE
1091        thrown = false;
1092        try {
1093            f = TestField.class.getDeclaredField("booleanField");
1094            f.set(null, true);
1095            fail("NullPointerException expected but not thrown");
1096        } catch (NullPointerException ex) {
1097            thrown = true;
1098        } catch (Exception ex) {
1099            fail("NullPointerException expected but not thrown");
1100        }
1101        assertTrue("NullPointerException expected but not thrown", thrown);
1102
1103        // Test setting a static field;
1104        f = TestField.class.getDeclaredField("doubleSField");
1105        f.set(null, new Double(1.0));
1106        val = f.getDouble(x);
1107        assertEquals("Returned incorrect double field value", 1.0, val);
1108    }
1109
1110    /**
1111     * java.lang.reflect.Field#setBoolean(java.lang.Object, boolean)
1112     */
1113    public void test_setBooleanLjava_lang_ObjectZ() throws Exception{
1114        // Test for method void
1115        // java.lang.reflect.Field.setBoolean(java.lang.Object, boolean)
1116        TestField x = new TestField();
1117        Field f = null;
1118        boolean val = false;
1119        try {
1120            f = TestField.class.getDeclaredField("booleanField");
1121            f.setBoolean(x, false);
1122            val = f.getBoolean(x);
1123        } catch (Exception e) {
1124            fail("Exception during setboolean test: " + e.toString());
1125        }
1126        assertTrue("Returned incorrect float field value", !val);
1127
1128      //test wrong type
1129        boolean thrown = false;
1130        try {
1131            f = TestField.class.getDeclaredField("doubleField");
1132            f.setBoolean(x, false);
1133            fail("Accessed field of invalid type");
1134        } catch (IllegalArgumentException ex) {
1135            thrown = true;
1136        }
1137        assertTrue("IllegalArgumentException expected but not thrown", thrown);
1138
1139      //Test NPE
1140        thrown = false;
1141        try {
1142            f = TestField.class.getDeclaredField("booleanField");
1143            f.setBoolean(null, true);
1144            fail("NullPointerException expected but not thrown");
1145        } catch (NullPointerException ex) {
1146            thrown = true;
1147        } catch (Exception ex) {
1148            fail("NullPointerException expected but not thrown");
1149        }
1150        assertTrue("NullPointerException expected but not thrown", thrown);
1151
1152        // Test setting a static field;
1153        f = TestField.class.getDeclaredField("booleanSField");
1154        f.setBoolean(null, false);
1155        val = f.getBoolean(x);
1156        assertFalse("Returned incorrect boolean field value", val);
1157    }
1158
1159    /**
1160     * java.lang.reflect.Field#setByte(java.lang.Object, byte)
1161     */
1162    public void test_setByteLjava_lang_ObjectB() throws Exception{
1163        // Test for method void
1164        // java.lang.reflect.Field.setByte(java.lang.Object, byte)
1165        TestField x = new TestField();
1166        Field f = null;
1167        byte val = 0;
1168        try {
1169            f = TestField.class.getDeclaredField("byteField");
1170            f.setByte(x, (byte) 1);
1171            val = f.getByte(x);
1172        } catch (Exception e) {
1173            fail("Exception during setByte test : " + e.getMessage());
1174        }
1175        assertEquals("Returned incorrect float field value", 1, val);
1176
1177        //test wrong type
1178        boolean thrown = false;
1179        try {
1180            f = TestField.class.getDeclaredField("booleanField");
1181            f.setByte(x, Byte.MIN_VALUE);
1182            fail("Accessed field of invalid type");
1183        } catch (IllegalArgumentException ex) {
1184            thrown = true;
1185        }
1186        assertTrue("IllegalArgumentException expected but not thrown", thrown);
1187
1188      //Test NPE
1189        thrown = false;
1190        try {
1191            f = TestField.class.getDeclaredField("byteField");
1192            f.setByte(null, Byte.MIN_VALUE);
1193            fail("NullPointerException expected but not thrown");
1194        } catch (NullPointerException ex) {
1195            thrown = true;
1196        } catch (Exception ex) {
1197            fail("NullPointerException expected but not thrown");
1198        }
1199        assertTrue("NullPointerException expected but not thrown", thrown);
1200
1201        // Test setting a static field;
1202        f = TestField.class.getDeclaredField("byteSField");
1203        f.setByte(null, Byte.MIN_VALUE);
1204        val = f.getByte(x);
1205        assertEquals("Returned incorrect byte field value", Byte.MIN_VALUE,
1206                val);
1207    }
1208
1209    /**
1210     * java.lang.reflect.Field#setChar(java.lang.Object, char)
1211     */
1212    public void test_setCharLjava_lang_ObjectC() throws Exception{
1213        // Test for method void
1214        // java.lang.reflect.Field.setChar(java.lang.Object, char)
1215        TestField x = new TestField();
1216        Field f = null;
1217        char val = 0;
1218        try {
1219            f = TestField.class.getDeclaredField("charField");
1220            f.setChar(x, (char) 1);
1221            val = f.getChar(x);
1222        } catch (Exception e) {
1223            fail("Exception during setChar test : " + e.getMessage());
1224        }
1225        assertEquals("Returned incorrect float field value", 1, val);
1226
1227      //test wrong type
1228        boolean thrown = false;
1229        try {
1230            f = TestField.class.getDeclaredField("booleanField");
1231            f.setChar(x, Character.MIN_VALUE);
1232            fail("Accessed field of invalid type");
1233        } catch (IllegalArgumentException ex) {
1234            thrown = true;
1235        }
1236        assertTrue("IllegalArgumentException expected but not thrown", thrown);
1237
1238      //Test NPE
1239        thrown = false;
1240        try {
1241            f = TestField.class.getDeclaredField("charField");
1242            f.setChar(null, Character.MIN_VALUE);
1243            fail("NullPointerException expected but not thrown");
1244        } catch (NullPointerException ex) {
1245            thrown = true;
1246        } catch (Exception ex) {
1247            fail("NullPointerException expected but not thrown");
1248        }
1249        assertTrue("NullPointerException expected but not thrown", thrown);
1250
1251        // Test setting a static field;
1252        f = TestField.class.getDeclaredField("charSField");
1253        f.setChar(null, Character.MIN_VALUE);
1254        val = f.getChar(x);
1255        assertEquals("Returned incorrect char field value",
1256                Character.MIN_VALUE, val);
1257    }
1258
1259    /**
1260     * java.lang.reflect.Field#setDouble(java.lang.Object, double)
1261     */
1262    public void test_setDoubleLjava_lang_ObjectD() throws Exception{
1263        // Test for method void
1264        // java.lang.reflect.Field.setDouble(java.lang.Object, double)
1265        TestField x = new TestField();
1266        Field f = null;
1267        double val = 0.0;
1268        try {
1269            f = TestField.class.getDeclaredField("doubleField");
1270            f.setDouble(x, Double.MIN_VALUE);
1271            val = f.getDouble(x);
1272        } catch (Exception e) {
1273            fail("Exception during setDouble test: " + e.toString());
1274        }
1275        assertEquals("Returned incorrect double field value", Double.MIN_VALUE,
1276                val);
1277
1278      //test wrong type
1279        boolean thrown = false;
1280        try {
1281            f = TestField.class.getDeclaredField("booleanField");
1282            f.setDouble(x, Double.MIN_VALUE);
1283            fail("Accessed field of invalid type");
1284        } catch (IllegalArgumentException ex) {
1285            thrown = true;
1286        }
1287        assertTrue("IllegalArgumentException expected but not thrown", thrown);
1288
1289      //Test NPE
1290        thrown = false;
1291        try {
1292            f = TestField.class.getDeclaredField("doubleField");
1293            f.setDouble(null, Double.MIN_VALUE);
1294            fail("NullPointerException expected but not thrown");
1295        } catch (NullPointerException ex) {
1296            thrown = true;
1297        } catch (Exception ex) {
1298            fail("NullPointerException expected but not thrown");
1299        }
1300        assertTrue("NullPointerException expected but not thrown", thrown);
1301
1302        // Test setting a static field;
1303        f = TestField.class.getDeclaredField("doubleSField");
1304        f.setDouble(null, Double.MIN_VALUE);
1305        val = f.getDouble(x);
1306        assertEquals("Returned incorrect double field value",
1307                Double.MIN_VALUE, val);
1308    }
1309
1310    /**
1311     * java.lang.reflect.Field#setFloat(java.lang.Object, float)
1312     */
1313    public void test_setFloatLjava_lang_ObjectF() throws Exception{
1314        // Test for method void
1315        // java.lang.reflect.Field.setFloat(java.lang.Object, float)
1316        TestField x = new TestField();
1317        Field f = null;
1318        float val = 0.0F;
1319        try {
1320            f = TestField.class.getDeclaredField("floatField");
1321            f.setFloat(x, Float.MIN_VALUE);
1322            val = f.getFloat(x);
1323        } catch (Exception e) {
1324            fail("Exception during setFloat test : " + e.getMessage());
1325        }
1326        assertEquals("Returned incorrect float field value", Float.MIN_VALUE,
1327                val, 0.0);
1328
1329        //test wrong type
1330        boolean thrown = false;
1331        try {
1332            f = TestField.class.getDeclaredField("booleanField");
1333            f.setFloat(x, Float.MIN_VALUE);
1334            fail("Accessed field of invalid type");
1335        } catch (IllegalArgumentException ex) {
1336            thrown = true;
1337        }
1338        assertTrue("IllegalArgumentException expected but not thrown", thrown);
1339
1340      //Test NPE
1341        thrown = false;
1342        try {
1343            f = TestField.class.getDeclaredField("floatField");
1344            f.setFloat(null, Float.MIN_VALUE);
1345            fail("NullPointerException expected but not thrown");
1346        } catch (NullPointerException ex) {
1347            thrown = true;
1348        } catch (Exception ex) {
1349            fail("NullPointerException expected but not thrown");
1350        }
1351        assertTrue("NullPointerException expected but not thrown", thrown);
1352
1353        // Test setting a static field;
1354        f = TestField.class.getDeclaredField("floatSField");
1355        f.setFloat(null, Float.MIN_VALUE);
1356        val = f.getFloat(x);
1357        assertEquals("Returned incorrect float field value",
1358                Float.MIN_VALUE, val);
1359    }
1360
1361    /**
1362     * java.lang.reflect.Field#setInt(java.lang.Object, int)
1363     */
1364    public void test_setIntLjava_lang_ObjectI() throws Exception{
1365        // Test for method void java.lang.reflect.Field.setInt(java.lang.Object,
1366        // int)
1367        TestField x = new TestField();
1368        Field f = null;
1369        int val = 0;
1370        try {
1371            f = TestField.class.getDeclaredField("intField");
1372            f.setInt(x, Integer.MIN_VALUE);
1373            val = f.getInt(x);
1374        } catch (Exception e) {
1375            fail("Exception during setInteger test: " + e.toString());
1376        }
1377        assertEquals("Returned incorrect int field value", Integer.MIN_VALUE,
1378                val);
1379
1380        // test wrong type
1381        boolean thrown = false;
1382        try {
1383            f = TestField.class.getDeclaredField("booleanField");
1384            f.setInt(x, Integer.MIN_VALUE);
1385            fail("Accessed field of invalid type");
1386        } catch (IllegalArgumentException ex) {
1387            thrown = true;
1388        }
1389        assertTrue("IllegalArgumentException expected but not thrown", thrown);
1390
1391        // Test NPE
1392        thrown = false;
1393        try {
1394            f = TestField.class.getDeclaredField("intField");
1395            f.setInt(null, Integer.MIN_VALUE);
1396            fail("NullPointerException expected but not thrown");
1397        } catch (NullPointerException ex) {
1398            thrown = true;
1399        } catch (Exception ex) {
1400            fail("NullPointerException expected but not thrown");
1401        }
1402        assertTrue("NullPointerException expected but not thrown", thrown);
1403
1404        // Test setting a static field;
1405        f = TestField.class.getDeclaredField("intSField");
1406        f.setInt(null, Integer.MIN_VALUE);
1407        val = f.getInt(x);
1408        assertEquals("Returned incorrect int field value",
1409                Integer.MIN_VALUE, val);
1410    }
1411
1412    /**
1413     * java.lang.reflect.Field#setLong(java.lang.Object, long)
1414     */
1415    public void test_setLongLjava_lang_ObjectJ() throws Exception{
1416        // Test for method void
1417        // java.lang.reflect.Field.setLong(java.lang.Object, long)
1418        TestField x = new TestField();
1419        Field f = null;
1420        long val = 0L;
1421        try {
1422            f = TestField.class.getDeclaredField("longField");
1423            f.setLong(x, Long.MIN_VALUE);
1424            val = f.getLong(x);
1425        } catch (Exception e) {
1426            fail("Exception during setLong test : " + e.getMessage());
1427        }
1428        assertEquals("Returned incorrect long field value", Long.MIN_VALUE, val);
1429
1430        // test wrong type
1431        boolean thrown = false;
1432        try {
1433            f = TestField.class.getDeclaredField("booleanField");
1434            f.setLong(x, Long.MIN_VALUE);
1435            fail("Accessed field of invalid type");
1436        } catch (IllegalArgumentException ex) {
1437            thrown = true;
1438        }
1439        assertTrue("IllegalArgumentException expected but not thrown", thrown);
1440
1441        // Test NPE
1442        thrown = false;
1443        try {
1444            f = TestField.class.getDeclaredField("longField");
1445            f.setLong(null, Long.MIN_VALUE);
1446            fail("NullPointerException expected but not thrown");
1447        } catch (NullPointerException ex) {
1448            thrown = true;
1449        } catch (Exception ex) {
1450            fail("NullPointerException expected but not thrown");
1451        }
1452        assertTrue("NullPointerException expected but not thrown", thrown);
1453
1454        // Test setting a static field;
1455        f = TestField.class.getDeclaredField("longSField");
1456        f.setLong(null, Long.MIN_VALUE);
1457        val = f.getLong(x);
1458        assertEquals("Returned incorrect long field value",
1459                Long.MIN_VALUE, val);
1460    }
1461
1462    /**
1463     * java.lang.reflect.Field#setShort(java.lang.Object, short)
1464     */
1465    public void test_setShortLjava_lang_ObjectS() throws Exception{
1466        // Test for method void
1467        // java.lang.reflect.Field.setShort(java.lang.Object, short)
1468        TestField x = new TestField();
1469        Field f = null;
1470        short val = 0;
1471        try {
1472            f = TestField.class.getDeclaredField("shortField");
1473            f.setShort(x, Short.MIN_VALUE);
1474            val = f.getShort(x);
1475        } catch (Exception e) {
1476            fail("Exception during setShort test : " + e.getMessage());
1477        }
1478        assertEquals("Returned incorrect short field value", Short.MIN_VALUE,
1479                val);
1480
1481        // test wrong type
1482        boolean thrown = false;
1483        try {
1484            f = TestField.class.getDeclaredField("booleanField");
1485            f.setShort(x, Short.MIN_VALUE);
1486            fail("Accessed field of invalid type");
1487        } catch (IllegalArgumentException ex) {
1488            thrown = true;
1489        }
1490        assertTrue("IllegalArgumentException expected but not thrown", thrown);
1491
1492        // Test NPE
1493        thrown = false;
1494        try {
1495            f = TestField.class.getDeclaredField("shortField");
1496            f.setShort(null, Short.MIN_VALUE);
1497            fail("NullPointerException expected but not thrown");
1498        } catch (NullPointerException ex) {
1499            thrown = true;
1500        } catch (Exception ex) {
1501            fail("NullPointerException expected but not thrown");
1502        }
1503        assertTrue("NullPointerException expected but not thrown", thrown);
1504
1505        // Test setting a static field;
1506        f = TestField.class.getDeclaredField("shortSField");
1507        f.setShort(null, Short.MIN_VALUE);
1508        val = f.getShort(x);
1509        assertEquals("Returned incorrect short field value",
1510                Short.MIN_VALUE, val);
1511    }
1512
1513    /**
1514     * java.lang.reflect.Field#toString()
1515     */
1516    public void test_toString() {
1517        // Test for method java.lang.String java.lang.reflect.Field.toString()
1518        Field f = null;
1519
1520        try {
1521            f = TestField.class.getDeclaredField("x");
1522        } catch (Exception e) {
1523            fail("Exception getting field : " + e.getMessage());
1524        }
1525        assertEquals("Field returned incorrect string",
1526                "private static final int org.apache.harmony.tests.java.lang.reflect.FieldTest$TestField.x",
1527                        f.toString());
1528    }
1529
1530    public void test_getDeclaredAnnotations() throws Exception {
1531        Field field = TestClass.class.getField("annotatedField");
1532        Annotation[] annotations = field.getDeclaredAnnotations();
1533        assertEquals(2, annotations.length);
1534
1535        Set<Class<?>> ignoreOrder = new HashSet<Class<?>>();
1536        ignoreOrder.add(annotations[0].annotationType());
1537        ignoreOrder.add(annotations[1].annotationType());
1538
1539        assertTrue("Missing @AnnotationRuntime0", ignoreOrder
1540                .contains(AnnotationRuntime0.class));
1541        assertTrue("Missing @AnnotationRuntime1", ignoreOrder
1542                .contains(AnnotationRuntime1.class));
1543    }
1544
1545    public void test_isEnumConstant() throws Exception {
1546        Field field = TestEnum.class.getDeclaredField("A");
1547        assertTrue("Enum constant not recognized", field.isEnumConstant());
1548
1549        field = TestEnum.class.getDeclaredField("field");
1550        assertFalse("Non enum constant wrongly stated as enum constant", field
1551                .isEnumConstant());
1552
1553        field = TestClass.class.getDeclaredField("annotatedField");
1554        assertFalse("Non enum constant wrongly stated as enum constant", field
1555                .isEnumConstant());
1556    }
1557
1558    public void test_isSynthetic() throws Exception {
1559        Field[] fields = TestClass.Inner.class.getDeclaredFields();
1560        assertEquals("Not exactly one field returned", 1, fields.length);
1561
1562        assertTrue("Enum constant not recognized", fields[0].isSynthetic());
1563
1564        Field field = TestEnum.class.getDeclaredField("field");
1565        assertFalse("Non synthetic field wrongly stated as synthetic", field
1566                .isSynthetic());
1567
1568        field = TestClass.class.getDeclaredField("annotatedField");
1569        assertFalse("Non synthetic field wrongly stated as synthetic", field
1570                .isSynthetic());
1571    }
1572
1573
1574    public void test_getGenericType() throws Exception {
1575        Field field = GenericField.class.getDeclaredField("field");
1576        Type type = field.getGenericType();
1577        @SuppressWarnings("unchecked")
1578        TypeVariable typeVar = (TypeVariable) type;
1579        assertEquals("Wrong type name returned", "S", typeVar.getName());
1580
1581        Field boundedField = GenericField.class.getDeclaredField("boundedField");
1582        Type boundedType = boundedField.getGenericType();
1583        @SuppressWarnings("unchecked")
1584        TypeVariable boundedTypeVar = (TypeVariable) boundedType;
1585        assertEquals("Wrong type name returned", "T", boundedTypeVar.getName());
1586        assertEquals("More than one bound found", 1,
1587                boundedTypeVar.getBounds().length);
1588        assertEquals("Wrong bound returned", Number.class,
1589                boundedTypeVar.getBounds()[0]);
1590    }
1591
1592
1593    public void test_toGenericString() throws Exception {
1594        Field field = GenericField.class.getDeclaredField("field");
1595        assertEquals("Wrong generic string returned",
1596                "S org.apache.harmony.tests.java.lang.reflect.FieldTest$GenericField.field",
1597                field.toGenericString());
1598
1599        Field boundedField = GenericField.class
1600                .getDeclaredField("boundedField");
1601        assertEquals(
1602                "Wrong generic string returned",
1603                "T org.apache.harmony.tests.java.lang.reflect.FieldTest$GenericField.boundedField",
1604                boundedField.toGenericString());
1605
1606        Field ordinary = GenericField.class.getDeclaredField("intField");
1607        assertEquals(
1608                "Wrong generic string returned",
1609                "int org.apache.harmony.tests.java.lang.reflect.FieldTest$GenericField.intField",
1610                ordinary.toGenericString());
1611    }
1612
1613
1614    public void test_hashCode() throws Exception {
1615        Field field = TestClass.class.getDeclaredField("annotatedField");
1616        assertEquals("Wrong hashCode returned", field.getName().hashCode()
1617                ^ field.getDeclaringClass().getName().hashCode(), field
1618                .hashCode());
1619    }
1620
1621
1622    /**
1623     * Sets up the fixture, for example, open a network connection. This method
1624     * is called before a test is executed.
1625     */
1626    protected void setUp() {
1627    }
1628
1629    /**
1630     * Tears down the fixture, for example, close a network connection. This
1631     * method is called after a test is executed.
1632     */
1633    protected void tearDown() {
1634    }
1635}
1636
1637class TestAccess {
1638    private static int xxx;
1639}
1640