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.luni.tests.java.lang.reflect;
19
20import java.lang.reflect.Modifier;
21
22public class ModifierTest extends junit.framework.TestCase {
23
24	private static final int ALL_FLAGS = 0x7FF;
25
26	/**
27	 * @tests java.lang.reflect.Modifier#Modifier()
28	 */
29	public void test_Constructor() {
30		// Test for method java.lang.reflect.Modifier()
31		new Modifier();
32	}
33
34	/**
35	 * @tests java.lang.reflect.Modifier#isAbstract(int)
36	 */
37	public void test_isAbstractI() {
38		// Test for method boolean java.lang.reflect.Modifier.isAbstract(int)
39		assertTrue("ABSTRACT returned false", Modifier.isAbstract(ALL_FLAGS));
40		assertTrue("ABSTRACT returned false", Modifier
41				.isAbstract(Modifier.ABSTRACT));
42		assertTrue("Non-ABSTRACT returned true", !Modifier
43				.isAbstract(Modifier.TRANSIENT));
44	}
45
46	/**
47	 * @tests java.lang.reflect.Modifier#isFinal(int)
48	 */
49	public void test_isFinalI() {
50		// Test for method boolean java.lang.reflect.Modifier.isFinal(int)
51		assertTrue("FINAL returned false", Modifier.isFinal(ALL_FLAGS));
52		assertTrue("FINAL returned false", Modifier.isFinal(Modifier.FINAL));
53		assertTrue("Non-FINAL returned true", !Modifier
54				.isFinal(Modifier.TRANSIENT));
55	}
56
57	/**
58	 * @tests java.lang.reflect.Modifier#isInterface(int)
59	 */
60	public void test_isInterfaceI() {
61		// Test for method boolean java.lang.reflect.Modifier.isInterface(int)
62		assertTrue("INTERFACE returned false", Modifier.isInterface(ALL_FLAGS));
63		assertTrue("INTERFACE returned false", Modifier
64				.isInterface(Modifier.INTERFACE));
65		assertTrue("Non-INTERFACE returned true", !Modifier
66				.isInterface(Modifier.TRANSIENT));
67	}
68
69	/**
70	 * @tests java.lang.reflect.Modifier#isNative(int)
71	 */
72	public void test_isNativeI() {
73		// Test for method boolean java.lang.reflect.Modifier.isNative(int)
74		assertTrue("NATIVE returned false", Modifier.isNative(ALL_FLAGS));
75		assertTrue("NATIVE returned false", Modifier.isNative(Modifier.NATIVE));
76		assertTrue("Non-NATIVE returned true", !Modifier
77				.isNative(Modifier.TRANSIENT));
78	}
79
80	/**
81	 * @tests java.lang.reflect.Modifier#isPrivate(int)
82	 */
83	public void test_isPrivateI() {
84		// Test for method boolean java.lang.reflect.Modifier.isPrivate(int)
85		assertTrue("PRIVATE returned false", Modifier.isPrivate(ALL_FLAGS));
86		assertTrue("PRIVATE returned false", Modifier
87				.isPrivate(Modifier.PRIVATE));
88		assertTrue("Non-PRIVATE returned true", !Modifier
89				.isPrivate(Modifier.TRANSIENT));
90	}
91
92	/**
93	 * @tests java.lang.reflect.Modifier#isProtected(int)
94	 */
95	public void test_isProtectedI() {
96		// Test for method boolean java.lang.reflect.Modifier.isProtected(int)
97		assertTrue("PROTECTED returned false", Modifier.isProtected(ALL_FLAGS));
98		assertTrue("PROTECTED returned false", Modifier
99				.isProtected(Modifier.PROTECTED));
100		assertTrue("Non-PROTECTED returned true", !Modifier
101				.isProtected(Modifier.TRANSIENT));
102	}
103
104	/**
105	 * @tests java.lang.reflect.Modifier#isPublic(int)
106	 */
107	public void test_isPublicI() {
108		// Test for method boolean java.lang.reflect.Modifier.isPublic(int)
109		assertTrue("PUBLIC returned false", Modifier.isPublic(ALL_FLAGS));
110		assertTrue("PUBLIC returned false", Modifier.isPublic(Modifier.PUBLIC));
111		assertTrue("Non-PUBLIC returned true", !Modifier
112				.isPublic(Modifier.TRANSIENT));
113	}
114
115	/**
116	 * @tests java.lang.reflect.Modifier#isStatic(int)
117	 */
118	public void test_isStaticI() {
119		// Test for method boolean java.lang.reflect.Modifier.isStatic(int)
120		assertTrue("STATIC returned false", Modifier.isStatic(ALL_FLAGS));
121		assertTrue("STATIC returned false", Modifier.isStatic(Modifier.STATIC));
122		assertTrue("Non-STATIC returned true", !Modifier
123				.isStatic(Modifier.TRANSIENT));
124	}
125
126	/**
127	 * @tests java.lang.reflect.Modifier#isStrict(int)
128	 */
129	public void test_isStrictI() {
130		// Test for method boolean java.lang.reflect.Modifier.isStrict(int)
131		assertTrue("STRICT returned false", Modifier.isStrict(Modifier.STRICT));
132		assertTrue("Non-STRICT returned true", !Modifier
133				.isStrict(Modifier.TRANSIENT));
134	}
135
136	/**
137	 * @tests java.lang.reflect.Modifier#isSynchronized(int)
138	 */
139	public void test_isSynchronizedI() {
140		// Test for method boolean
141		// java.lang.reflect.Modifier.isSynchronized(int)
142		assertTrue("Synchronized returned false", Modifier
143				.isSynchronized(ALL_FLAGS));
144		assertTrue("Non-Synchronized returned true", !Modifier
145				.isSynchronized(Modifier.VOLATILE));
146	}
147
148	/**
149	 * @tests java.lang.reflect.Modifier#isTransient(int)
150	 */
151	public void test_isTransientI() {
152		// Test for method boolean java.lang.reflect.Modifier.isTransient(int)
153		assertTrue("Transient returned false", Modifier.isTransient(ALL_FLAGS));
154		assertTrue("Transient returned false", Modifier
155				.isTransient(Modifier.TRANSIENT));
156		assertTrue("Non-Transient returned true", !Modifier
157				.isTransient(Modifier.VOLATILE));
158	}
159
160	/**
161	 * @tests java.lang.reflect.Modifier#isVolatile(int)
162	 */
163	public void test_isVolatileI() {
164		// Test for method boolean java.lang.reflect.Modifier.isVolatile(int)
165		assertTrue("Volatile returned false", Modifier.isVolatile(ALL_FLAGS));
166		assertTrue("Volatile returned false", Modifier
167				.isVolatile(Modifier.VOLATILE));
168		assertTrue("Non-Volatile returned true", !Modifier
169				.isVolatile(Modifier.TRANSIENT));
170	}
171
172	/**
173	 * @tests java.lang.reflect.Modifier#toString(int)
174	 */
175	public void test_toStringI() {
176		// Test for method java.lang.String
177		// java.lang.reflect.Modifier.toString(int)
178		assertTrue("Returned incorrect string value: "
179				+ Modifier.toString(java.lang.reflect.Modifier.PUBLIC
180						+ java.lang.reflect.Modifier.ABSTRACT), Modifier
181				.toString(
182						java.lang.reflect.Modifier.PUBLIC
183								+ java.lang.reflect.Modifier.ABSTRACT).equals(
184						"public abstract"));
185
186        int i = 0xFFF;
187        String modification = "public protected private abstract static final transient "
188                + "volatile synchronized native strictfp interface";
189        assertTrue("Returned incorrect string value", Modifier.toString(i)
190                .equals(modification));
191	}
192
193    public void test_Constants_Value() {
194        assertEquals(1024, Modifier.ABSTRACT);
195        assertEquals(16, Modifier.FINAL);
196        assertEquals(512, Modifier.INTERFACE);
197        assertEquals(256, Modifier.NATIVE);
198        assertEquals(2, Modifier.PRIVATE);
199        assertEquals(4, Modifier.PROTECTED);
200        assertEquals(1, Modifier.PUBLIC);
201        assertEquals(8, Modifier.STATIC);
202        assertEquals(2048, Modifier.STRICT);
203        assertEquals(32, Modifier.SYNCHRONIZED);
204        assertEquals(128, Modifier.TRANSIENT);
205        assertEquals(64, Modifier.VOLATILE);
206    }
207
208    abstract class AbstractClazz {
209    }
210
211    final class FinalClazz {
212    }
213
214    static class StaticClazz {
215    }
216
217    interface InterfaceClazz {
218    }
219
220    public class PublicClazz {
221    }
222
223    protected class ProtectedClazz {
224    }
225
226    private class PrivateClazz {
227    }
228
229    public abstract class PublicAbstractClazz {
230    }
231
232    protected abstract class ProtectedAbstractClazz {
233    }
234
235    private abstract class PrivateAbstractClazz {
236    }
237
238    public final class PublicFinalClazz {
239    }
240
241    protected final class ProtectedFinalClazz {
242    }
243
244    private final class PrivateFinalClazz {
245    }
246
247    public static class PublicStaticClazz {
248    }
249
250    protected static class ProtectedStaticClazz {
251    }
252
253    private static class PrivateStaticClazz {
254    }
255
256    public interface PublicInterface {
257    }
258
259    protected interface ProtectedInterface {
260    }
261
262    private interface PrivateInterface {
263    }
264
265    static abstract class StaticAbstractClazz {
266    }
267
268    public static abstract class PublicStaticAbstractClazz {
269    }
270
271    protected static abstract class ProtectedStaticAbstractClazz {
272    }
273
274    private static abstract class PrivateStaticAbstractClazz {
275    }
276
277    static final class StaticFinalClazz {
278    }
279
280    public static final class PublicStaticFinalClazz {
281    }
282
283    protected static final class ProtectedStaticFinalClazz {
284    }
285
286    private static final class PrivateStaticFinalClazz {
287    }
288
289    static interface StaticInterface {
290    }
291
292    public static interface PublicStaticInterface {
293    }
294
295    protected static interface ProtectedStaticInterface {
296    }
297
298    private static interface PrivateStaticInterface {
299    }
300
301    static abstract interface StaticAbstractInterface {
302    }
303
304    public static abstract interface PublicStaticAbstractInterface {
305    }
306
307    protected static abstract interface ProtectedStaticAbstractInterface {
308    }
309
310    private static abstract interface PrivateStaticAbstractInterface {
311    }
312
313    public void test_Class_Modifier() {
314        assertEquals(Modifier.ABSTRACT, AbstractClazz.class.getModifiers());
315        assertEquals(Modifier.FINAL, FinalClazz.class.getModifiers());
316        assertEquals(Modifier.STATIC, StaticClazz.class.getModifiers());
317        assertEquals(Modifier.INTERFACE + Modifier.STATIC + Modifier.ABSTRACT,
318                InterfaceClazz.class.getModifiers());
319
320        assertEquals(Modifier.PUBLIC, PublicClazz.class.getModifiers());
321        assertEquals(Modifier.PROTECTED, ProtectedClazz.class.getModifiers());
322        assertEquals(Modifier.PRIVATE, PrivateClazz.class.getModifiers());
323
324        assertEquals(Modifier.PUBLIC + Modifier.ABSTRACT,
325                PublicAbstractClazz.class.getModifiers());
326        assertEquals(Modifier.PROTECTED + Modifier.ABSTRACT,
327                ProtectedAbstractClazz.class.getModifiers());
328        assertEquals(Modifier.PRIVATE + Modifier.ABSTRACT,
329                PrivateAbstractClazz.class.getModifiers());
330
331        assertEquals(Modifier.PUBLIC + Modifier.FINAL, PublicFinalClazz.class
332                .getModifiers());
333        assertEquals(Modifier.PROTECTED + Modifier.FINAL,
334                ProtectedFinalClazz.class.getModifiers());
335        assertEquals(Modifier.PRIVATE + Modifier.FINAL, PrivateFinalClazz.class
336                .getModifiers());
337
338        assertEquals(Modifier.PUBLIC + Modifier.STATIC, PublicStaticClazz.class
339                .getModifiers());
340        assertEquals(Modifier.PROTECTED + Modifier.STATIC,
341                ProtectedStaticClazz.class.getModifiers());
342        assertEquals(Modifier.PRIVATE + Modifier.STATIC,
343                PrivateStaticClazz.class.getModifiers());
344
345        assertEquals(Modifier.PUBLIC + Modifier.INTERFACE + Modifier.STATIC
346                + Modifier.ABSTRACT, PublicInterface.class.getModifiers());
347        assertEquals(Modifier.STATIC + Modifier.FINAL, StaticFinalClazz.class
348                .getModifiers());
349        assertEquals(Modifier.PRIVATE + Modifier.INTERFACE + Modifier.STATIC
350                + Modifier.ABSTRACT, PrivateInterface.class.getModifiers());
351
352        assertEquals(Modifier.STATIC + Modifier.ABSTRACT,
353                StaticAbstractClazz.class.getModifiers());
354        assertEquals(Modifier.PUBLIC + Modifier.STATIC + Modifier.ABSTRACT,
355                PublicStaticAbstractClazz.class.getModifiers());
356        assertEquals(Modifier.PROTECTED + Modifier.STATIC + Modifier.ABSTRACT,
357                ProtectedStaticAbstractClazz.class.getModifiers());
358        assertEquals(Modifier.PRIVATE + Modifier.STATIC + Modifier.ABSTRACT,
359                PrivateStaticAbstractClazz.class.getModifiers());
360
361        assertEquals(Modifier.STATIC + Modifier.FINAL, StaticFinalClazz.class
362                .getModifiers());
363        assertEquals(Modifier.PUBLIC + Modifier.STATIC + Modifier.FINAL,
364                PublicStaticFinalClazz.class.getModifiers());
365        assertEquals(Modifier.PROTECTED + Modifier.STATIC + Modifier.FINAL,
366                ProtectedStaticFinalClazz.class.getModifiers());
367        assertEquals(Modifier.PRIVATE + Modifier.STATIC + Modifier.FINAL,
368                PrivateStaticFinalClazz.class.getModifiers());
369
370        assertEquals(Modifier.INTERFACE + Modifier.STATIC + Modifier.ABSTRACT,
371                StaticInterface.class.getModifiers());
372        assertEquals(Modifier.PUBLIC + Modifier.INTERFACE + Modifier.STATIC
373                + Modifier.ABSTRACT, PublicStaticInterface.class.getModifiers());
374        assertEquals(Modifier.PROTECTED + Modifier.INTERFACE + Modifier.STATIC
375                + Modifier.ABSTRACT, ProtectedStaticInterface.class
376                .getModifiers());
377        assertEquals(Modifier.PRIVATE + Modifier.INTERFACE + Modifier.STATIC
378                + Modifier.ABSTRACT, PrivateStaticInterface.class
379                .getModifiers());
380
381        assertEquals(Modifier.INTERFACE + Modifier.STATIC + Modifier.ABSTRACT,
382                StaticAbstractInterface.class.getModifiers());
383        assertEquals(Modifier.PUBLIC + Modifier.INTERFACE + Modifier.STATIC
384                + Modifier.ABSTRACT, PublicStaticAbstractInterface.class
385                .getModifiers());
386        assertEquals(Modifier.PROTECTED + Modifier.INTERFACE + Modifier.STATIC
387                + Modifier.ABSTRACT, ProtectedStaticAbstractInterface.class
388                .getModifiers());
389        assertEquals(Modifier.PRIVATE + Modifier.INTERFACE + Modifier.STATIC
390                + Modifier.ABSTRACT, PrivateStaticAbstractInterface.class
391                .getModifiers());
392    }
393
394    static abstract class MethodClass {
395
396        public abstract void publicAbstractMethod();
397
398        public static void publicStaticMethod() {
399        }
400
401        public final void publicFinalMethod() {
402        }
403
404        public static final void publicStaticFinalMethod() {
405        }
406    }
407
408    public void test_Method_Modifier() throws Exception {
409        assertEquals(Modifier.PUBLIC + Modifier.ABSTRACT, MethodClass.class
410                .getMethod("publicAbstractMethod", new Class[0]).getModifiers());
411        assertEquals(Modifier.PUBLIC + Modifier.STATIC, MethodClass.class
412                .getMethod("publicStaticMethod", new Class[0]).getModifiers());
413
414        assertEquals(Modifier.PUBLIC + Modifier.FINAL, MethodClass.class
415                .getMethod("publicFinalMethod", new Class[0]).getModifiers());
416
417        assertEquals(Modifier.PUBLIC + Modifier.STATIC + Modifier.FINAL,
418                MethodClass.class.getMethod("publicStaticFinalMethod",
419                        new Class[0]).getModifiers());
420    }
421
422	/**
423	 * Sets up the fixture, for example, open a network connection. This method
424	 * is called before a test is executed.
425	 */
426	protected void setUp() {
427	}
428
429	/**
430	 * Tears down the fixture, for example, close a network connection. This
431	 * method is called after a test is executed.
432	 */
433	protected void tearDown() {
434	}
435}
436