/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed 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 android.core;
import android.test.suitebuilder.annotation.MediumTest;
import android.test.suitebuilder.annotation.SmallTest;
import android.widget.Button;
import junit.framework.TestCase;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashSet;
import java.util.Set;
class ClassWithPrivateConstructor {
private ClassWithPrivateConstructor() {
}
}
public class ClassTest extends TestCase {
@SmallTest
public void testClass() throws Exception {
// Now, never mind the fact that most of this stuff has to work
// for the test harness to get this far....
//System.out.println("Class.forName()");
Class helloClass = Class.forName(ClassTest.class.getName());
//System.out.println("Class.newInstance()");
Object instance = helloClass.newInstance();
assertNotNull(instance);
//System.out.println("Class.forName() nonexisting class");
try {
Class.forName("this.class.DoesNotExist");
fail("unexpected success");
} catch (ClassNotFoundException ex) {
// expected
}
//System.out.println("Class.newInstance() private constructor");
try {
Class.forName("android.core.ClassWithPrivateConstructor").newInstance();
fail("unexpected success");
} catch (IllegalAccessException ex) {
// this is expected
}
//System.out.println("Class.getDeclaredMethod()");
Method method = helloClass.getDeclaredMethod("method", (Class[]) null);
method.invoke(new ClassTest(), (Object[]) null);
//System.out.println("Class.getDeclaredMethod() w/ args");
method = helloClass.getDeclaredMethod("methodWithArgs", Object.class);
Object invokeArgs[] = new Object[1];
invokeArgs[0] = "Hello";
Object ret = method.invoke(new ClassTest(), invokeArgs);
assertEquals(ret, invokeArgs[0]);
//System.out.println("Class.getDeclaredMethod() -- private");
method = helloClass.getDeclaredMethod("privateMethod", (Class[]) null);
method.invoke(new ClassTest(), (Object[]) null);
//fail("unexpected success");
// TODO: I think this actually *should* succeed, because the
// call to the private method is being made from the same class.
// This needs to be replaced with a private call to a different
// class.
//System.out.println("Class.getSuperclass");
Class objectClass = Class.forName("java.lang.Object");
assertEquals(helloClass.getSuperclass().getSuperclass().getSuperclass(), objectClass);
//System.out.println("Class.isAssignableFrom");
assertTrue(objectClass.isAssignableFrom(helloClass));
assertFalse(helloClass.isAssignableFrom(objectClass));
//System.out.println("Class.getConstructor");
Constructor constructor = helloClass.getConstructor((Class[]) null);
assertNotNull(constructor);
//System.out.println("Class.getModifiers");
assertTrue(Modifier.isPublic(helloClass.getModifiers()));
//System.out.println("Modifiers: " + Modifier.toString(helloClass.getModifiers()));
//System.out.println("Class.getMethod");
helloClass.getMethod("method", (Class[]) null);
try {
Class[] argTypes = new Class[1];
argTypes[0] = helloClass;
helloClass.getMethod("method", argTypes);
fail("unexpected success");
} catch (NoSuchMethodException ex) {
// exception expected
}
// Test for public tracker issue 14
SimpleClass obj = new SimpleClass();
Field field = obj.getClass().getDeclaredField("str");
field.set(obj, null);
}
public class SimpleClass {
public String str;
}
public Object methodWithArgs(Object o) {
return o;
}
boolean methodInvoked;
public void method() {
methodInvoked = true;
}
boolean privateMethodInvoked;
public void privateMethod() {
privateMethodInvoked = true;
}
// Regression for 1018067: Class.getMethods() returns the same method over
// and over again from all base classes
@MediumTest
public void testClassGetMethodsNoDupes() {
Method[] methods = Button.class.getMethods();
Set<String> set = new HashSet<String>();
for (int i = 0; i < methods.length; i++) {
String signature = methods[i].toString();
int par = signature.indexOf('(');
int dot = signature.lastIndexOf('.', par);
signature = signature.substring(dot + 1);
assertFalse("Duplicate " + signature, set.contains(signature));
set.add(signature);
}
}
interface MyInterface {
void foo();
}
interface MyOtherInterface extends MyInterface {
void bar();
}
abstract class MyClass implements MyOtherInterface {
public void gabba() {
}
public void hey() {
}
}
// Check if we also reflect methods from interfaces
@SmallTest
public void testGetMethodsInterfaces() {
Method[] methods = MyInterface.class.getMethods();
assertTrue("Interface method must be there", hasMethod(methods, ".foo("));
methods = MyOtherInterface.class.getMethods();
assertTrue("Interface method must be there", hasMethod(methods, ".foo("));
assertTrue("Interface method must be there", hasMethod(methods, ".bar("));
methods = MyClass.class.getMethods();
assertTrue("Interface method must be there", hasMethod(methods, ".foo("));
assertTrue("Interface method must be there", hasMethod(methods, ".bar("));
assertTrue("Declared method must be there", hasMethod(methods, ".gabba("));
assertTrue("Declared method must be there", hasMethod(methods, ".hey("));
assertTrue("Inherited method must be there", hasMethod(methods, ".toString("));
}
private boolean hasMethod(Method[] methods, String signature) {
for (int i = 0; i < methods.length; i++) {
if (methods[i].toString().contains(signature)) {
return true;
}
}
return false;
}
// Test for Class.getPackage();
@SmallTest
public void testClassGetPackage() {
assertNotNull("Package must be non-null", getClass().getPackage());
assertEquals("Package must have expected name", "android.core", getClass().getPackage().getName());
assertEquals("Package must have expected title", "Unknown", getClass().getPackage().getSpecificationTitle());
Package p = java.lang.Object.class.getPackage();
assertNotNull("Package must be non-null", p);
assertEquals("Package must have expected name", "java.lang", p.getName());
assertSame("Package object must be same for each call", p, java.lang.Object.class.getPackage());
}
// Regression test for #1123708: Problem with getCanonicalName(),
// getSimpleName(), and getPackage().
//
// A couple of interesting cases need to be checked: Top-level classes,
// member classes, local classes, and anonymous classes. Also, boundary
// cases with '$' in the class names are checked, since the '$' is used
// as the separator between outer and inner class, so this might lead
// to problems (it did in the previous implementation).
//
// Caution: Adding local or anonymous classes elsewhere in this
// file might affect the test.
private class MemberClass {
// This space intentionally left blank.
}
private class Mi$o$oup {
// This space intentionally left blank.
}
@SmallTest
public void testVariousClassNames() {
Class<?> clazz = this.getClass();
String pkg = (clazz.getPackage() == null ? "" : clazz.getPackage().getName() + ".");
// Simple, top-level class
assertEquals("Top-level class name must be correct", pkg + "ClassTest", clazz.getName());
assertEquals("Top-level class simple name must be correct", "ClassTest", clazz.getSimpleName());
assertEquals("Top-level class canonical name must be correct", pkg + "ClassTest", clazz.getCanonicalName());
clazz = MemberClass.class;
assertEquals("Member class name must be correct", pkg + "ClassTest$MemberClass", clazz.getName());
assertEquals("Member class simple name must be correct", "MemberClass", clazz.getSimpleName());
assertEquals("Member class canonical name must be correct", pkg + "ClassTest.MemberClass", clazz.getCanonicalName());
class LocalClass {
// This space intentionally left blank.
}
clazz = LocalClass.class;
assertEquals("Local class name must be correct", pkg + "ClassTest$1LocalClass", clazz.getName());
assertEquals("Local class simple name must be correct", "LocalClass", clazz.getSimpleName());
assertNull("Local class canonical name must be null", clazz.getCanonicalName());
clazz = new Object() { }.getClass();
assertEquals("Anonymous class name must be correct", pkg + "ClassTest$1", clazz.getName());
assertEquals("Anonymous class simple name must be empty", "", clazz.getSimpleName());
assertNull("Anonymous class canonical name must be null", clazz.getCanonicalName());
// Weird special cases with dollar in name.
clazz = Mou$$aka.class;
assertEquals("Top-level class name must be correct", pkg + "Mou$$aka", clazz.getName());
assertEquals("Top-level class simple name must be correct", "Mou$$aka", clazz.getSimpleName());
assertEquals("Top-level class canonical name must be correct", pkg + "Mou$$aka", clazz.getCanonicalName());
clazz = Mi$o$oup.class;
assertEquals("Member class name must be correct", pkg + "ClassTest$Mi$o$oup", clazz.getName());
assertEquals("Member class simple name must be correct", "Mi$o$oup", clazz.getSimpleName());
assertEquals("Member class canonical name must be correct", pkg + "ClassTest.Mi$o$oup", clazz.getCanonicalName());
class Ma$hedPotatoe$ {
// This space intentionally left blank.
}
clazz = Ma$hedPotatoe$.class;
assertEquals("Member class name must be correct", pkg + "ClassTest$1Ma$hedPotatoe$", clazz.getName());
assertEquals("Member class simple name must be correct", "Ma$hedPotatoe$", clazz.getSimpleName());
assertNull("Member class canonical name must be null", clazz.getCanonicalName());
}
@SmallTest
public void testLocalMemberClass() {
Class<?> clazz = this.getClass();
assertFalse("Class must not be member", clazz.isMemberClass());
assertFalse("Class must not be local", clazz.isLocalClass());
clazz = MemberClass.class;
assertTrue("Class must be member", clazz.isMemberClass());
assertFalse("Class must not be local", clazz.isLocalClass());
class OtherLocalClass {
// This space intentionally left blank.
}
clazz = OtherLocalClass.class;
assertFalse("Class must not be member", clazz.isMemberClass());
assertTrue("Class must be local", clazz.isLocalClass());
clazz = new Object() { }.getClass();
assertFalse("Class must not be member", clazz.isMemberClass());
assertFalse("Class must not be local", clazz.isLocalClass());
}
}
class Mou$$aka {
// This space intentionally left blank.
}