Adding old unit tests to test suite.
These tests are copied straight over. They'll still run, but they're
using the old system.
Change-Id: If494519e52ddf858a9febfc55bdae830468cb3c8
diff --git a/test/031-class-attributes/expected.txt b/test/031-class-attributes/expected.txt
new file mode 100644
index 0000000..47eaeee
--- /dev/null
+++ b/test/031-class-attributes/expected.txt
@@ -0,0 +1,164 @@
+***** class ClassAttrs:
+ name: ClassAttrs
+ canonical: ClassAttrs
+ simple: ClassAttrs
+ genericSignature: null
+ super: class java.lang.Object
+ declaring: null
+ enclosing: null
+ enclosingCon: null
+ enclosingMeth: null
+ modifiers: 1
+ package: null
+ declaredClasses: [2] class ClassAttrs$PublicMemberClass, class ClassAttrs$MemberClass
+ member classes: [1] class ClassAttrs$PublicMemberClass
+ isAnnotation: false
+ isAnonymous: false
+ isArray: false
+ isEnum: false
+ isInterface: false
+ isLocalClass: false
+ isMemberClass: false
+ isPrimitive: false
+ isSynthetic: false
+***** class OtherClass:
+ name: OtherClass
+ canonical: OtherClass
+ simple: OtherClass
+ genericSignature: null
+ super: class java.lang.Object
+ declaring: null
+ enclosing: null
+ enclosingCon: null
+ enclosingMeth: null
+ modifiers: 0
+ package: null
+ declaredClasses: [0]
+ member classes: [0]
+ isAnnotation: false
+ isAnonymous: false
+ isArray: false
+ isEnum: false
+ isInterface: false
+ isLocalClass: false
+ isMemberClass: false
+ isPrimitive: false
+ isSynthetic: false
+***** class otherpackage.OtherPackageClass:
+ name: otherpackage.OtherPackageClass
+ canonical: otherpackage.OtherPackageClass
+ simple: OtherPackageClass
+ genericSignature: null
+ super: class java.lang.Object
+ declaring: null
+ enclosing: null
+ enclosingCon: null
+ enclosingMeth: null
+ modifiers: 1
+ package: package otherpackage
+ declaredClasses: [0]
+ member classes: [0]
+ isAnnotation: false
+ isAnonymous: false
+ isArray: false
+ isEnum: false
+ isInterface: false
+ isLocalClass: false
+ isMemberClass: false
+ isPrimitive: false
+ isSynthetic: false
+***** class ClassAttrs$1InnerNamed:
+ name: ClassAttrs$1InnerNamed
+ canonical: null
+ simple: InnerNamed
+ genericSignature: null
+ super: class java.lang.Object
+ declaring: null
+ enclosing: class ClassAttrs
+ enclosingCon: null
+ enclosingMeth: public static void ClassAttrs.main()
+ modifiers: 0
+ package: null
+ declaredClasses: [0]
+ member classes: [0]
+ isAnnotation: false
+ isAnonymous: false
+ isArray: false
+ isEnum: false
+ isInterface: false
+ isLocalClass: true
+ isMemberClass: false
+ isPrimitive: false
+ isSynthetic: false
+***** class ClassAttrs$1ConsInnerNamed:
+ name: ClassAttrs$1ConsInnerNamed
+ canonical: null
+ simple: ConsInnerNamed
+ genericSignature: null
+ super: class java.lang.Object
+ declaring: null
+ enclosing: class ClassAttrs
+ enclosingCon: ClassAttrs()
+ enclosingMeth: null
+ modifiers: 0
+ package: null
+ declaredClasses: [0]
+ member classes: [0]
+ isAnnotation: false
+ isAnonymous: false
+ isArray: false
+ isEnum: false
+ isInterface: false
+ isLocalClass: true
+ isMemberClass: false
+ isPrimitive: false
+ isSynthetic: false
+***** class ClassAttrs$1:
+ name: ClassAttrs$1
+ canonical: null
+ simple:
+ genericSignature: null
+ super: class OtherClass
+ declaring: null
+ enclosing: class ClassAttrs
+ enclosingCon: null
+ enclosingMeth: public static void ClassAttrs.main()
+ modifiers: 8
+ package: null
+ declaredClasses: [0]
+ member classes: [0]
+ isAnnotation: false
+ isAnonymous: true
+ isArray: false
+ isEnum: false
+ isInterface: false
+ isLocalClass: false
+ isMemberClass: false
+ isPrimitive: false
+ isSynthetic: false
+***** class ClassAttrs$MemberClass:
+ name: ClassAttrs$MemberClass
+ canonical: ClassAttrs.MemberClass
+ simple: MemberClass
+ genericSignature: <XYZ:Ljava/lang/Object;>Ljava/lang/Object;
+ super: class java.lang.Object
+ declaring: class ClassAttrs
+ enclosing: class ClassAttrs
+ enclosingCon: null
+ enclosingMeth: null
+ modifiers: 8
+ package: null
+ declaredClasses: [0]
+ member classes: [0]
+ isAnnotation: false
+ isAnonymous: false
+ isArray: false
+ isEnum: false
+ isInterface: false
+ isLocalClass: false
+ isMemberClass: true
+ isPrimitive: false
+ isSynthetic: false
+constructor signature: (LClassAttrs$MemberClass<TXYZ;>;)V
+method signature: ()Ljava/lang/Class<TXYZ;>;
+field signature: LClassAttrs$MemberClass<TXYZ;>;
diff --git a/test/031-class-attributes/info.txt b/test/031-class-attributes/info.txt
new file mode 100644
index 0000000..08127da
--- /dev/null
+++ b/test/031-class-attributes/info.txt
@@ -0,0 +1,6 @@
+This is a miscellaneous test that was imported into the new-at-the-time
+runtime test framework. The test is intended to exercise basic features,
+and as such cannot be build on top of junit, since failure of such basic
+features might disrupt junit.
+
+TODO: Real description goes here.
diff --git a/test/031-class-attributes/src/ClassAttrs.java b/test/031-class-attributes/src/ClassAttrs.java
new file mode 100644
index 0000000..c1407bd
--- /dev/null
+++ b/test/031-class-attributes/src/ClassAttrs.java
@@ -0,0 +1,201 @@
+import otherpackage.OtherPackageClass;
+
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+
+public class ClassAttrs {
+ ClassAttrs() {
+ /* local, not anonymous, not member */
+ class ConsInnerNamed {
+ public void showMe() {
+ printClassAttrs(this.getClass());
+ }
+ }
+
+ ConsInnerNamed cinner = new ConsInnerNamed();
+ cinner.showMe();
+ }
+
+ public static void main() {
+ printClassAttrs(ClassAttrs.class);
+ printClassAttrs(OtherClass.class);
+ printClassAttrs(OtherPackageClass.class);
+
+ /* local, not anonymous, not member */
+ class InnerNamed {
+ public void showMe() {
+ printClassAttrs(this.getClass());
+ }
+ }
+ InnerNamed inner = new InnerNamed();
+ inner.showMe();
+
+ ClassAttrs attrs = new ClassAttrs();
+
+ /* anonymous, not local, not member */
+ printClassAttrs((new OtherClass() { int i = 5; }).getClass());
+
+ /* member, not anonymous, not local */
+ printClassAttrs(MemberClass.class);
+
+ try {
+ Constructor cons;
+ cons = MemberClass.class.getConstructor(
+ new Class[] { MemberClass.class });
+ System.out.println("constructor signature: "
+ + getSignatureAttribute(cons));
+
+ Method meth;
+ meth = MemberClass.class.getMethod("foo", (Class[]) null);
+ System.out.println("method signature: "
+ + getSignatureAttribute(meth));
+
+ Field field;
+ field = MemberClass.class.getField("mWha");
+ System.out.println("field signature: "
+ + getSignatureAttribute(field));
+ } catch (NoSuchMethodException nsme) {
+ System.err.println("FAILED: " + nsme);
+ } catch (NoSuchFieldException nsfe) {
+ System.err.println("FAILED: " + nsfe);
+ } catch (RuntimeException re) {
+ System.err.println("FAILED: " + re);
+ re.printStackTrace();
+ }
+ }
+
+ /* to call the (out-of-scope) <code>getSignatureAttribute</code> methods */
+ public static String getSignatureAttribute(Object obj) {
+ Method method;
+ try {
+ if (obj instanceof AccessibleObject) {
+ method = AccessibleObject.class.getDeclaredMethod(
+ "getSignatureAttribute");
+ } else {
+ // Should be a Class.
+ method = Class.class.getDeclaredMethod(
+ "getSignatureAttribute");
+ }
+ method.setAccessible(true);
+ } catch (NoSuchMethodException ex) {
+ System.err.println("getSignatureAttribute() not defined.");
+ ex.printStackTrace();
+ return "<unknown>";
+ }
+
+ try {
+ return (String) method.invoke(obj);
+ } catch (IllegalAccessException ex) {
+ throw new RuntimeException(ex);
+ } catch (InvocationTargetException ex) {
+ throw new RuntimeException(ex);
+ }
+ }
+
+ /* for reflection testing */
+ static class MemberClass<XYZ> {
+ public MemberClass<XYZ> mWha;
+
+ public MemberClass(MemberClass<XYZ> memb) {
+ mWha = memb;
+ }
+
+ public Class<XYZ> foo() throws NoSuchMethodException {
+ return null;
+ }
+ }
+
+ /* for reflection testing (getClasses vs getDeclaredClasses) */
+ static public class PublicMemberClass {
+ float mBlah;
+ }
+
+ /*
+ * Dump a variety of class attributes.
+ */
+ public static void printClassAttrs(Class clazz) {
+ final boolean WORKING = false;
+ Class clazz2;
+
+ System.out.println("***** " + clazz + ":");
+
+ System.out.println(" name: "
+ + clazz.getName());
+ System.out.println(" canonical: "
+ + clazz.getCanonicalName());
+ System.out.println(" simple: "
+ + clazz.getSimpleName());
+ System.out.println(" genericSignature: "
+ + getSignatureAttribute(clazz));
+
+ System.out.println(" super: "
+ + clazz.getSuperclass());
+ if (WORKING) System.out.println(" genericSuperclass: "
+ + clazz.getGenericSuperclass());
+ System.out.println(" declaring: "
+ + clazz.getDeclaringClass());
+ System.out.println(" enclosing: "
+ + clazz.getEnclosingClass());
+ System.out.println(" enclosingCon: "
+ + clazz.getEnclosingConstructor());
+ System.out.println(" enclosingMeth: "
+ + clazz.getEnclosingMethod());
+ System.out.println(" modifiers: "
+ + clazz.getModifiers());
+ System.out.println(" package: "
+ + clazz.getPackage());
+
+ System.out.println(" declaredClasses: "
+ + stringifyTypeArray(clazz.getDeclaredClasses()));
+ System.out.println(" member classes: "
+ + stringifyTypeArray(clazz.getClasses()));
+
+ System.out.println(" isAnnotation: "
+ + clazz.isAnnotation());
+ System.out.println(" isAnonymous: "
+ + clazz.isAnonymousClass());
+ System.out.println(" isArray: "
+ + clazz.isArray());
+ System.out.println(" isEnum: "
+ + clazz.isEnum());
+ System.out.println(" isInterface: "
+ + clazz.isInterface());
+ System.out.println(" isLocalClass: "
+ + clazz.isLocalClass());
+ System.out.println(" isMemberClass: "
+ + clazz.isMemberClass());
+ System.out.println(" isPrimitive: "
+ + clazz.isPrimitive());
+ System.out.println(" isSynthetic: "
+ + clazz.isSynthetic());
+
+ if (WORKING) System.out.println(" genericInterfaces: "
+ + stringifyTypeArray(clazz.getGenericInterfaces()));
+ }
+
+ /*
+ * Convert an array of Type into a string. Start with an array count.
+ */
+ private static String stringifyTypeArray(Type[] types) {
+ StringBuilder stb = new StringBuilder();
+ boolean first = true;
+
+ stb.append("[" + types.length + "]");
+
+ for (Type t: types) {
+ if (first) {
+ stb.append(" ");
+ first = false;
+ } else {
+ stb.append(", ");
+ }
+ stb.append(t.toString());
+ }
+
+ return stb.toString();
+ }
+}
diff --git a/test/031-class-attributes/src/Main.java b/test/031-class-attributes/src/Main.java
new file mode 100644
index 0000000..bc6b749
--- /dev/null
+++ b/test/031-class-attributes/src/Main.java
@@ -0,0 +1,5 @@
+public class Main {
+ public static void main(String[] args) {
+ ClassAttrs.main();
+ }
+}
diff --git a/test/031-class-attributes/src/OtherClass.java b/test/031-class-attributes/src/OtherClass.java
new file mode 100644
index 0000000..0b4526e
--- /dev/null
+++ b/test/031-class-attributes/src/OtherClass.java
@@ -0,0 +1,2 @@
+class OtherClass {
+}
diff --git a/test/031-class-attributes/src/otherpackage/OtherPackageClass.java b/test/031-class-attributes/src/otherpackage/OtherPackageClass.java
new file mode 100644
index 0000000..9652b77
--- /dev/null
+++ b/test/031-class-attributes/src/otherpackage/OtherPackageClass.java
@@ -0,0 +1,4 @@
+package otherpackage;
+
+public class OtherPackageClass {
+}