| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package tests.api.java.lang.reflect; |
| |
| import dalvik.annotation.TestTargets; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestTargetClass; |
| |
| import java.lang.reflect.Modifier; |
| |
| @TestTargetClass(Modifier.class) |
| public class ModifierTest extends junit.framework.TestCase { |
| |
| private static final int ALL_FLAGS = 0x7FF; |
| |
| /** |
| * @tests java.lang.reflect.Modifier#Modifier() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "The only thing I can do", |
| method = "Modifier", |
| args = {} |
| ) |
| public void test_Constructor() { |
| assertNotNull(new Modifier()); |
| } |
| |
| /** |
| * @tests java.lang.reflect.Modifier#isAbstract(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isAbstract", |
| args = {int.class} |
| ) |
| 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)); |
| } |
| |
| /** |
| * @tests java.lang.reflect.Modifier#isFinal(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isFinal", |
| args = {int.class} |
| ) |
| 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)); |
| } |
| |
| /** |
| * @tests java.lang.reflect.Modifier#isInterface(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isInterface", |
| args = {int.class} |
| ) |
| 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)); |
| } |
| |
| /** |
| * @tests java.lang.reflect.Modifier#isNative(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isNative", |
| args = {int.class} |
| ) |
| 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)); |
| } |
| |
| /** |
| * @tests java.lang.reflect.Modifier#isPrivate(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isPrivate", |
| args = {int.class} |
| ) |
| 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)); |
| } |
| |
| /** |
| * @tests java.lang.reflect.Modifier#isProtected(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isProtected", |
| args = {int.class} |
| ) |
| 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)); |
| } |
| |
| /** |
| * @tests java.lang.reflect.Modifier#isPublic(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isPublic", |
| args = {int.class} |
| ) |
| 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)); |
| } |
| |
| /** |
| * @tests java.lang.reflect.Modifier#isStatic(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isStatic", |
| args = {int.class} |
| ) |
| 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)); |
| } |
| |
| /** |
| * @tests java.lang.reflect.Modifier#isStrict(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isStrict", |
| args = {int.class} |
| ) |
| 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)); |
| } |
| |
| /** |
| * @tests java.lang.reflect.Modifier#isSynchronized(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isSynchronized", |
| args = {int.class} |
| ) |
| 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)); |
| } |
| |
| /** |
| * @tests java.lang.reflect.Modifier#isTransient(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isTransient", |
| args = {int.class} |
| ) |
| 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)); |
| } |
| |
| /** |
| * @tests java.lang.reflect.Modifier#isVolatile(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isVolatile", |
| args = {int.class} |
| ) |
| 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)); |
| } |
| |
| /** |
| * @tests java.lang.reflect.Modifier#toString(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "toString", |
| args = {int.class} |
| ) |
| 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")); |
| } |
| |
| /** |
| * 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() { |
| } |
| } |