1 files changed, 435 insertions, 0 deletions
diff --git a/harmony-tests/src/test/java/org/apache/harmony/tests/java/lang/reflect/ModifierTest.java b/harmony-tests/src/test/java/org/apache/harmony/tests/java/lang/reflect/ModifierTest.java
new file mode 100644
index 0000000..71c207f
--- /dev/null
+++ b/harmony-tests/src/test/java/org/apache/harmony/tests/java/lang/reflect/ModifierTest.java
@@ -0,0 +1,435 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You under the Apache License, Version 2.0
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package org.apache.harmony.tests.java.lang.reflect;
+
+import java.lang.reflect.Modifier;
+
+public class ModifierTest extends junit.framework.TestCase {
+
+    private static final int ALL_FLAGS = 0x7FF;
+
+    /**
+     * java.lang.reflect.Modifier#Modifier()
+     */
+    public void test_Constructor() {
+        // Test for method java.lang.reflect.Modifier()
+        new Modifier();
+    }
+
+    /**
+     * java.lang.reflect.Modifier#isAbstract(int)
+     */
+    public void test_isAbstractI() {
+        // Test for method boolean java.lang.reflect.Modifier.isAbstract(int)
+        assertTrue("ABSTRACT returned false", Modifier.isAbstract(ALL_FLAGS));
+        assertTrue("ABSTRACT returned false", Modifier
+                .isAbstract(Modifier.ABSTRACT));
+        assertTrue("Non-ABSTRACT returned true", !Modifier
+                .isAbstract(Modifier.TRANSIENT));
+    }
+
+    /**
+     * java.lang.reflect.Modifier#isFinal(int)
+     */
+    public void test_isFinalI() {
+        // Test for method boolean java.lang.reflect.Modifier.isFinal(int)
+        assertTrue("FINAL returned false", Modifier.isFinal(ALL_FLAGS));
+        assertTrue("FINAL returned false", Modifier.isFinal(Modifier.FINAL));
+        assertTrue("Non-FINAL returned true", !Modifier
+                .isFinal(Modifier.TRANSIENT));
+    }
+
+    /**
+     * java.lang.reflect.Modifier#isInterface(int)
+     */
+    public void test_isInterfaceI() {
+        // Test for method boolean java.lang.reflect.Modifier.isInterface(int)
+        assertTrue("INTERFACE returned false", Modifier.isInterface(ALL_FLAGS));
+        assertTrue("INTERFACE returned false", Modifier
+                .isInterface(Modifier.INTERFACE));
+        assertTrue("Non-INTERFACE returned true", !Modifier
+                .isInterface(Modifier.TRANSIENT));
+    }
+
+    /**
+     * java.lang.reflect.Modifier#isNative(int)
+     */
+    public void test_isNativeI() {
+        // Test for method boolean java.lang.reflect.Modifier.isNative(int)
+        assertTrue("NATIVE returned false", Modifier.isNative(ALL_FLAGS));
+        assertTrue("NATIVE returned false", Modifier.isNative(Modifier.NATIVE));
+        assertTrue("Non-NATIVE returned true", !Modifier
+                .isNative(Modifier.TRANSIENT));
+    }
+
+    /**
+     * java.lang.reflect.Modifier#isPrivate(int)
+     */
+    public void test_isPrivateI() {
+        // Test for method boolean java.lang.reflect.Modifier.isPrivate(int)
+        assertTrue("PRIVATE returned false", Modifier.isPrivate(ALL_FLAGS));
+        assertTrue("PRIVATE returned false", Modifier
+                .isPrivate(Modifier.PRIVATE));
+        assertTrue("Non-PRIVATE returned true", !Modifier
+                .isPrivate(Modifier.TRANSIENT));
+    }
+
+    /**
+     * java.lang.reflect.Modifier#isProtected(int)
+     */
+    public void test_isProtectedI() {
+        // Test for method boolean java.lang.reflect.Modifier.isProtected(int)
+        assertTrue("PROTECTED returned false", Modifier.isProtected(ALL_FLAGS));
+        assertTrue("PROTECTED returned false", Modifier
+                .isProtected(Modifier.PROTECTED));
+        assertTrue("Non-PROTECTED returned true", !Modifier
+                .isProtected(Modifier.TRANSIENT));
+    }
+
+    /**
+     * java.lang.reflect.Modifier#isPublic(int)
+     */
+    public void test_isPublicI() {
+        // Test for method boolean java.lang.reflect.Modifier.isPublic(int)
+        assertTrue("PUBLIC returned false", Modifier.isPublic(ALL_FLAGS));
+        assertTrue("PUBLIC returned false", Modifier.isPublic(Modifier.PUBLIC));
+        assertTrue("Non-PUBLIC returned true", !Modifier
+                .isPublic(Modifier.TRANSIENT));
+    }
+
+    /**
+     * java.lang.reflect.Modifier#isStatic(int)
+     */
+    public void test_isStaticI() {
+        // Test for method boolean java.lang.reflect.Modifier.isStatic(int)
+        assertTrue("STATIC returned false", Modifier.isStatic(ALL_FLAGS));
+        assertTrue("STATIC returned false", Modifier.isStatic(Modifier.STATIC));
+        assertTrue("Non-STATIC returned true", !Modifier
+                .isStatic(Modifier.TRANSIENT));
+    }
+
+    /**
+     * java.lang.reflect.Modifier#isStrict(int)
+     */
+    public void test_isStrictI() {
+        // Test for method boolean java.lang.reflect.Modifier.isStrict(int)
+        assertTrue("STRICT returned false", Modifier.isStrict(Modifier.STRICT));
+        assertTrue("Non-STRICT returned true", !Modifier
+                .isStrict(Modifier.TRANSIENT));
+    }
+
+    /**
+     * java.lang.reflect.Modifier#isSynchronized(int)
+     */
+    public void test_isSynchronizedI() {
+        // Test for method boolean
+        // java.lang.reflect.Modifier.isSynchronized(int)
+        assertTrue("Synchronized returned false", Modifier
+                .isSynchronized(ALL_FLAGS));
+        assertTrue("Non-Synchronized returned true", !Modifier
+                .isSynchronized(Modifier.VOLATILE));
+    }
+
+    /**
+     * java.lang.reflect.Modifier#isTransient(int)
+     */
+    public void test_isTransientI() {
+        // Test for method boolean java.lang.reflect.Modifier.isTransient(int)
+        assertTrue("Transient returned false", Modifier.isTransient(ALL_FLAGS));
+        assertTrue("Transient returned false", Modifier
+                .isTransient(Modifier.TRANSIENT));
+        assertTrue("Non-Transient returned true", !Modifier
+                .isTransient(Modifier.VOLATILE));
+    }
+
+    /**
+     * java.lang.reflect.Modifier#isVolatile(int)
+     */
+    public void test_isVolatileI() {
+        // Test for method boolean java.lang.reflect.Modifier.isVolatile(int)
+        assertTrue("Volatile returned false", Modifier.isVolatile(ALL_FLAGS));
+        assertTrue("Volatile returned false", Modifier
+                .isVolatile(Modifier.VOLATILE));
+        assertTrue("Non-Volatile returned true", !Modifier
+                .isVolatile(Modifier.TRANSIENT));
+    }
+
+    /**
+     * java.lang.reflect.Modifier#toString(int)
+     */
+    public void test_toStringI() {
+        // Test for method java.lang.String
+        // java.lang.reflect.Modifier.toString(int)
+        assertTrue("Returned incorrect string value: "
+                + Modifier.toString(java.lang.reflect.Modifier.PUBLIC
+                + java.lang.reflect.Modifier.ABSTRACT), Modifier
+                .toString(
+                        java.lang.reflect.Modifier.PUBLIC
+                                + java.lang.reflect.Modifier.ABSTRACT).equals(
+                        "public abstract"));
+
+        int i = 0xFFF;
+        String modification = "public protected private abstract static final transient "
+                + "volatile synchronized native strictfp interface";
+        assertTrue("Returned incorrect string value", Modifier.toString(i)
+                .equals(modification));
+    }
+
+    public void test_Constants_Value() {
+        assertEquals(1024, Modifier.ABSTRACT);
+        assertEquals(16, Modifier.FINAL);
+        assertEquals(512, Modifier.INTERFACE);
+        assertEquals(256, Modifier.NATIVE);
+        assertEquals(2, Modifier.PRIVATE);
+        assertEquals(4, Modifier.PROTECTED);
+        assertEquals(1, Modifier.PUBLIC);
+        assertEquals(8, Modifier.STATIC);
+        assertEquals(2048, Modifier.STRICT);
+        assertEquals(32, Modifier.SYNCHRONIZED);
+        assertEquals(128, Modifier.TRANSIENT);
+        assertEquals(64, Modifier.VOLATILE);
+    }
+
+    abstract class AbstractClazz {
+    }
+
+    final class FinalClazz {
+    }
+
+    static class StaticClazz {
+    }
+
+    interface InterfaceClazz {
+    }
+
+    public class PublicClazz {
+    }
+
+    protected class ProtectedClazz {
+    }
+
+    private class PrivateClazz {
+    }
+
+    public abstract class PublicAbstractClazz {
+    }
+
+    protected abstract class ProtectedAbstractClazz {
+    }
+
+    private abstract class PrivateAbstractClazz {
+    }
+
+    public final class PublicFinalClazz {
+    }
+
+    protected final class ProtectedFinalClazz {
+    }
+
+    private final class PrivateFinalClazz {
+    }
+
+    public static class PublicStaticClazz {
+    }
+
+    protected static class ProtectedStaticClazz {
+    }
+
+    private static class PrivateStaticClazz {
+    }
+
+    public interface PublicInterface {
+    }
+
+    protected interface ProtectedInterface {
+    }
+
+    private interface PrivateInterface {
+    }
+
+    static abstract class StaticAbstractClazz {
+    }
+
+    public static abstract class PublicStaticAbstractClazz {
+    }
+
+    protected static abstract class ProtectedStaticAbstractClazz {
+    }
+
+    private static abstract class PrivateStaticAbstractClazz {
+    }
+
+    static final class StaticFinalClazz {
+    }
+
+    public static final class PublicStaticFinalClazz {
+    }
+
+    protected static final class ProtectedStaticFinalClazz {
+    }
+
+    private static final class PrivateStaticFinalClazz {
+    }
+
+    static interface StaticInterface {
+    }
+
+    public static interface PublicStaticInterface {
+    }
+
+    protected static interface ProtectedStaticInterface {
+    }
+
+    private static interface PrivateStaticInterface {
+    }
+
+    static abstract interface StaticAbstractInterface {
+    }
+
+    public static abstract interface PublicStaticAbstractInterface {
+    }
+
+    protected static abstract interface ProtectedStaticAbstractInterface {
+    }
+
+    private static abstract interface PrivateStaticAbstractInterface {
+    }
+
+    public void test_Class_Modifier() {
+        assertEquals(Modifier.ABSTRACT, AbstractClazz.class.getModifiers());
+        assertEquals(Modifier.FINAL, FinalClazz.class.getModifiers());
+        assertEquals(Modifier.STATIC, StaticClazz.class.getModifiers());
+        assertEquals(Modifier.INTERFACE + Modifier.STATIC + Modifier.ABSTRACT,
+                InterfaceClazz.class.getModifiers());
+
+        assertEquals(Modifier.PUBLIC, PublicClazz.class.getModifiers());
+        assertEquals(Modifier.PROTECTED, ProtectedClazz.class.getModifiers());
+        assertEquals(Modifier.PRIVATE, PrivateClazz.class.getModifiers());
+
+        assertEquals(Modifier.PUBLIC + Modifier.ABSTRACT,
+                PublicAbstractClazz.class.getModifiers());
+        assertEquals(Modifier.PROTECTED + Modifier.ABSTRACT,
+                ProtectedAbstractClazz.class.getModifiers());
+        assertEquals(Modifier.PRIVATE + Modifier.ABSTRACT,
+                PrivateAbstractClazz.class.getModifiers());
+
+        assertEquals(Modifier.PUBLIC + Modifier.FINAL, PublicFinalClazz.class
+                .getModifiers());
+        assertEquals(Modifier.PROTECTED + Modifier.FINAL,
+                ProtectedFinalClazz.class.getModifiers());
+        assertEquals(Modifier.PRIVATE + Modifier.FINAL, PrivateFinalClazz.class
+                .getModifiers());
+
+        assertEquals(Modifier.PUBLIC + Modifier.STATIC, PublicStaticClazz.class
+                .getModifiers());
+        assertEquals(Modifier.PROTECTED + Modifier.STATIC,
+                ProtectedStaticClazz.class.getModifiers());
+        assertEquals(Modifier.PRIVATE + Modifier.STATIC,
+                PrivateStaticClazz.class.getModifiers());
+
+        assertEquals(Modifier.PUBLIC + Modifier.INTERFACE + Modifier.STATIC
+                + Modifier.ABSTRACT, PublicInterface.class.getModifiers());
+        assertEquals(Modifier.STATIC + Modifier.FINAL, StaticFinalClazz.class
+                .getModifiers());
+        assertEquals(Modifier.PRIVATE + Modifier.INTERFACE + Modifier.STATIC
+                + Modifier.ABSTRACT, PrivateInterface.class.getModifiers());
+
+        assertEquals(Modifier.STATIC + Modifier.ABSTRACT,
+                StaticAbstractClazz.class.getModifiers());
+        assertEquals(Modifier.PUBLIC + Modifier.STATIC + Modifier.ABSTRACT,
+                PublicStaticAbstractClazz.class.getModifiers());
+        assertEquals(Modifier.PROTECTED + Modifier.STATIC + Modifier.ABSTRACT,
+                ProtectedStaticAbstractClazz.class.getModifiers());
+        assertEquals(Modifier.PRIVATE + Modifier.STATIC + Modifier.ABSTRACT,
+                PrivateStaticAbstractClazz.class.getModifiers());
+
+        assertEquals(Modifier.STATIC + Modifier.FINAL, StaticFinalClazz.class
+                .getModifiers());
+        assertEquals(Modifier.PUBLIC + Modifier.STATIC + Modifier.FINAL,
+                PublicStaticFinalClazz.class.getModifiers());
+        assertEquals(Modifier.PROTECTED + Modifier.STATIC + Modifier.FINAL,
+                ProtectedStaticFinalClazz.class.getModifiers());
+        assertEquals(Modifier.PRIVATE + Modifier.STATIC + Modifier.FINAL,
+                PrivateStaticFinalClazz.class.getModifiers());
+
+        assertEquals(Modifier.INTERFACE + Modifier.STATIC + Modifier.ABSTRACT,
+                StaticInterface.class.getModifiers());
+        assertEquals(Modifier.PUBLIC + Modifier.INTERFACE + Modifier.STATIC
+                + Modifier.ABSTRACT, PublicStaticInterface.class.getModifiers());
+        assertEquals(Modifier.PROTECTED + Modifier.INTERFACE + Modifier.STATIC
+                + Modifier.ABSTRACT, ProtectedStaticInterface.class
+                .getModifiers());
+        assertEquals(Modifier.PRIVATE + Modifier.INTERFACE + Modifier.STATIC
+                + Modifier.ABSTRACT, PrivateStaticInterface.class
+                .getModifiers());
+
+        assertEquals(Modifier.INTERFACE + Modifier.STATIC + Modifier.ABSTRACT,
+                StaticAbstractInterface.class.getModifiers());
+        assertEquals(Modifier.PUBLIC + Modifier.INTERFACE + Modifier.STATIC
+                + Modifier.ABSTRACT, PublicStaticAbstractInterface.class
+                .getModifiers());
+        assertEquals(Modifier.PROTECTED + Modifier.INTERFACE + Modifier.STATIC
+                + Modifier.ABSTRACT, ProtectedStaticAbstractInterface.class
+                .getModifiers());
+        assertEquals(Modifier.PRIVATE + Modifier.INTERFACE + Modifier.STATIC
+                + Modifier.ABSTRACT, PrivateStaticAbstractInterface.class
+                .getModifiers());
+    }
+
+    static abstract class MethodClass {
+
+        public abstract void publicAbstractMethod();
+
+        public static void publicStaticMethod() {
+        }
+
+        public final void publicFinalMethod() {
+        }
+
+        public static final void publicStaticFinalMethod() {
+        }
+    }
+
+    public void test_Method_Modifier() throws Exception {
+        assertEquals(Modifier.PUBLIC + Modifier.ABSTRACT, MethodClass.class
+                .getMethod("publicAbstractMethod", new Class[0]).getModifiers());
+        assertEquals(Modifier.PUBLIC + Modifier.STATIC, MethodClass.class
+                .getMethod("publicStaticMethod", new Class[0]).getModifiers());
+
+        assertEquals(Modifier.PUBLIC + Modifier.FINAL, MethodClass.class
+                .getMethod("publicFinalMethod", new Class[0]).getModifiers());
+
+        assertEquals(Modifier.PUBLIC + Modifier.STATIC + Modifier.FINAL,
+                MethodClass.class.getMethod("publicStaticFinalMethod",
+                        new Class[0]).getModifiers());
+    }
+
+    /**
+     * Sets up the fixture, for example, open a network connection. This method
+     * is called before a test is executed.
+     */
+    protected void setUp() {
+    }
+
+    /**
+     * Tears down the fixture, for example, close a network connection. This
+     * method is called after a test is executed.
+     */
+    protected void tearDown() {
+    }
+}