diff --git a/build/Android.common.mk b/build/Android.common.mk
index b921281..ce04683 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -111,6 +111,7 @@
 	src/java_lang_Throwable.cc \
 	src/java_lang_VMClassLoader.cc \
 	src/java_lang_reflect_Array.cc \
+	src/java_lang_reflect_Constructor.cc \
 	src/java_lang_reflect_Field.cc \
 	src/java_lang_reflect_Method.cc \
 	src/java_util_concurrent_atomic_AtomicLong.cc \
diff --git a/src/class_linker.cc b/src/class_linker.cc
index fb47c48..769a336 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -453,6 +453,17 @@
   init_done_ = true;
 }
 
+void ClassLinker::RunRootClinits() {
+  Thread* self = Thread::Current();
+  for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
+    Class* c = GetClassRoot(ClassRoot(i));
+    if (!c->IsArrayClass() && !c->IsPrimitive()) {
+      EnsureInitialized(GetClassRoot(ClassRoot(i)), true);
+      CHECK(!self->IsExceptionPending());
+    }
+  }
+}
+
 struct ClassLinker::InitFromImageCallbackState {
   ClassLinker* class_linker;
 
diff --git a/src/class_linker.h b/src/class_linker.h
index 09736ce..317490a 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -157,6 +157,10 @@
   // given the restriction that no <clinit> execution is possible.
   bool EnsureInitialized(Class* c, bool can_run_clinit);
 
+  // Initializes classes that have instances in the image but that have
+  // <clinit> methods so they could not be initialized by the compiler.
+  void RunRootClinits();
+
   void RegisterDexFile(const DexFile& dex_file);
   void RegisterDexFile(const DexFile& dex_file, DexCache* dex_cache);
 
diff --git a/src/java_lang_Class.cc b/src/java_lang_Class.cc
index d77e3f0..7d1a4aa 100644
--- a/src/java_lang_Class.cc
+++ b/src/java_lang_Class.cc
@@ -368,6 +368,10 @@
     return NULL;
   }
 
+  if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c, true)) {
+    return NULL;
+  }
+
   Method* init = c->FindDirectMethod("<init>", "()V");
   if (init == NULL) {
     Thread::Current()->ThrowNewException("Ljava/lang/InstantiationException;",
diff --git a/src/java_lang_reflect_Constructor.cc b/src/java_lang_reflect_Constructor.cc
new file mode 100644
index 0000000..10a8f07
--- /dev/null
+++ b/src/java_lang_reflect_Constructor.cc
@@ -0,0 +1,65 @@
+/*
+ * 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.
+ */
+
+#include "jni_internal.h"
+#include "class_linker.h"
+#include "object.h"
+#include "reflection.h"
+
+#include "JniConstants.h" // Last to avoid problems with LOG redefinition.
+
+namespace art {
+
+namespace {
+
+/*
+ * We get here through Constructor.newInstance().  The Constructor object
+ * would not be available if the constructor weren't public (per the
+ * definition of Class.getConstructor), so we can skip the method access
+ * check.  We can also safely assume the constructor isn't associated
+ * with an interface, array, or primitive class.
+ */
+jobject Constructor_constructNative(JNIEnv* env, jobject javaMethod, jobjectArray javaArgs, jclass javaDeclaringClass, jobjectArray javaParams, jint, jboolean) {
+  Class* c = Decode<Class*>(env, javaDeclaringClass);
+  if (c->IsAbstract()) {
+    Thread::Current()->ThrowNewException("Ljava/lang/InstantiationException;",
+        "Can't instantiate abstract class %s", PrettyDescriptor(c->GetDescriptor()).c_str());
+    return NULL;
+  }
+
+  Object* receiver = c->AllocObject();
+  if (receiver == NULL) {
+    return NULL;
+  }
+
+  jobject javaReceiver = AddLocalReference<jobject>(env, receiver);
+  InvokeMethod(env, javaMethod, javaReceiver, javaArgs, javaParams);
+
+  // Constructors are ()V methods, so we shouldn't touch the result of InvokeMethod.
+  return javaReceiver;
+}
+
+static JNINativeMethod gMethods[] = {
+  NATIVE_METHOD(Constructor, constructNative, "([Ljava/lang/Object;Ljava/lang/Class;[Ljava/lang/Class;IZ)Ljava/lang/Object;"),
+};
+
+}  // namespace
+
+void register_java_lang_reflect_Constructor(JNIEnv* env) {
+  jniRegisterNativeMethods(env, "java/lang/reflect/Constructor", gMethods, NELEM(gMethods));
+}
+
+}  // namespace art
diff --git a/src/java_lang_reflect_Method.cc b/src/java_lang_reflect_Method.cc
index 6ddb436..a988aac 100644
--- a/src/java_lang_reflect_Method.cc
+++ b/src/java_lang_reflect_Method.cc
@@ -25,10 +25,12 @@
 
 namespace {
 
-// We move the DECLARED_SYNCHRONIZED flag into the SYNCHRONIZED
-// position, because the callers of this function are trying to convey
-// the "traditional" meaning of the flags to their callers.
-uint32_t FixupMethodFlags(uint32_t access_flags) {
+jint Method_getMethodModifiers(JNIEnv* env, jclass, jclass javaDeclaringClass, jobject jmethod, jint slot) {
+  Method* m = Decode<Object*>(env, jmethod)->AsMethod();
+  jint access_flags = m->GetAccessFlags();
+  // We move the DECLARED_SYNCHRONIZED flag into the SYNCHRONIZED
+  // position, because the callers of this function are trying to convey
+  // the "traditional" meaning of the flags to their callers.
   access_flags &= ~kAccSynchronized;
   if ((access_flags & kAccDeclaredSynchronized) != 0) {
     access_flags |= kAccSynchronized;
@@ -36,72 +38,8 @@
   return access_flags & kAccMethodFlagsMask;
 }
 
-jint Method_getMethodModifiers(JNIEnv* env, jclass, jclass javaDeclaringClass, jobject jmethod, jint slot) {
-  return FixupMethodFlags(Decode<Object*>(env, jmethod)->AsMethod()->GetAccessFlags());
-}
-
-jobject Method_invokeNative(JNIEnv* env, jobject javaMethod, jobject javaReceiver, jobject javaArgs, jclass javaDeclaringClass, jobject javaParams, jclass, jint, jboolean) {
-  Thread* self = Thread::Current();
-  ScopedThreadStateChange tsc(self, Thread::kRunnable);
-
-  jmethodID mid = env->FromReflectedMethod(javaMethod);
-  Method* m = reinterpret_cast<Method*>(mid);
-  Object* receiver = NULL;
-  if (!m->IsStatic()) {
-    // Check that the receiver is non-null and an instance of the field's declaring class.
-    receiver = Decode<Object*>(env, javaReceiver);
-    Class* declaringClass = Decode<Class*>(env, javaDeclaringClass);
-    if (!VerifyObjectInClass(env, receiver, declaringClass)) {
-      return NULL;
-    }
-
-    // Find the actual implementation of the virtual method.
-    m = receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(m);
-  }
-
-  // Get our arrays of arguments and their types, and check they're the same size.
-  ObjectArray<Object>* objects = Decode<ObjectArray<Object>*>(env, javaArgs);
-  ObjectArray<Class>* classes = Decode<ObjectArray<Class>*>(env, javaParams);
-  int32_t arg_count = (objects != NULL) ? objects->GetLength() : 0;
-  if (arg_count != classes->GetLength()) {
-    self->ThrowNewException("Ljava/lang/IllegalArgumentException;",
-        "wrong number of arguments; expected %d, got %d",
-        classes->GetLength(), arg_count);
-    return NULL;
-  }
-
-  // Translate javaArgs to a jvalue[].
-  UniquePtr<jvalue[]> args(new jvalue[arg_count]);
-  JValue* decoded_args = reinterpret_cast<JValue*>(args.get());
-  for (int32_t i = 0; i < arg_count; ++i) {
-    Object* arg = objects->Get(i);
-    Class* dst_class = classes->Get(i);
-    if (dst_class->IsPrimitive()) {
-      if (!UnboxPrimitive(env, arg, dst_class, decoded_args[i])) {
-        return NULL;
-      }
-    } else {
-      args[i].l = AddLocalReference<jobject>(env, arg);
-    }
-  }
-
-  // Invoke the method.
-  JValue value = InvokeWithJValues(env, javaReceiver, mid, args.get());
-
-  // Wrap any exception with "Ljava/lang/reflect/InvocationTargetException;" and return early.
-  if (self->IsExceptionPending()) {
-    jthrowable th = env->ExceptionOccurred();
-    env->ExceptionClear();
-    jclass exception_class = env->FindClass("java/lang/reflect/InvocationTargetException");
-    jmethodID mid = env->GetMethodID(exception_class, "<init>", "(Ljava/lang/Throwable;)V");
-    jobject exception_instance = env->NewObject(exception_class, mid, th);
-    env->Throw(reinterpret_cast<jthrowable>(exception_instance));
-    return NULL;
-  }
-
-  // Box if necessary and return.
-  BoxPrimitive(env, m->GetReturnType(), value);
-  return AddLocalReference<jobject>(env, value.l);
+jobject Method_invokeNative(JNIEnv* env, jobject javaMethod, jobject javaReceiver, jobject javaArgs, jclass, jobject javaParams, jclass, jint, jboolean) {
+  return InvokeMethod(env, javaMethod, javaReceiver, javaArgs, javaParams);
 }
 
 static JNINativeMethod gMethods[] = {
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 8bc5081..fd6d314 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -2837,7 +2837,7 @@
       return NULL;
     }
   } else {
-    CHECK_GE(c->GetStatus(), Class::kStatusInitializing);
+    CHECK(c->GetStatus() >= Class::kStatusInitializing) << c->GetStatus() << " " << PrettyMethod(m);
   }
 
   std::string detail;
@@ -2848,8 +2848,7 @@
   }
   // throwing can cause libraries_lock to be reacquired
   if (native_method == NULL) {
-    Thread::Current()->ThrowNewException("Ljava/lang/UnsatisfiedLinkError;",
-        "%s", detail.c_str());
+    Thread::Current()->ThrowNewException("Ljava/lang/UnsatisfiedLinkError;", "%s", detail.c_str());
   }
   return native_method;
 }
diff --git a/src/reflection.cc b/src/reflection.cc
index 3edb9f7..c560053 100644
--- a/src/reflection.cc
+++ b/src/reflection.cc
@@ -48,6 +48,75 @@
   InitBoxingMethod(env, gShort_valueOf, JniConstants::shortClass, "(S)Ljava/lang/Short;");
 }
 
+jobject InvokeMethod(JNIEnv* env, jobject javaMethod, jobject javaReceiver, jobject javaArgs, jobject javaParams) {
+  Thread* self = Thread::Current();
+  ScopedThreadStateChange tsc(self, Thread::kRunnable);
+
+  jmethodID mid = env->FromReflectedMethod(javaMethod);
+  Method* m = reinterpret_cast<Method*>(mid);
+
+  Class* declaring_class = m->GetDeclaringClass();
+  if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(declaring_class, true)) {
+    return NULL;
+  }
+
+  Object* receiver = NULL;
+  if (!m->IsStatic()) {
+    // Check that the receiver is non-null and an instance of the field's declaring class.
+    receiver = Decode<Object*>(env, javaReceiver);
+    if (!VerifyObjectInClass(env, receiver, declaring_class)) {
+      return NULL;
+    }
+
+    // Find the actual implementation of the virtual method.
+    m = receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(m);
+  }
+
+  // Get our arrays of arguments and their types, and check they're the same size.
+  ObjectArray<Object>* objects = Decode<ObjectArray<Object>*>(env, javaArgs);
+  ObjectArray<Class>* classes = Decode<ObjectArray<Class>*>(env, javaParams);
+  int32_t arg_count = (objects != NULL) ? objects->GetLength() : 0;
+  if (arg_count != classes->GetLength()) {
+    self->ThrowNewException("Ljava/lang/IllegalArgumentException;",
+        "wrong number of arguments; expected %d, got %d",
+        classes->GetLength(), arg_count);
+    return NULL;
+  }
+
+  // Translate javaArgs to a jvalue[].
+  UniquePtr<jvalue[]> args(new jvalue[arg_count]);
+  JValue* decoded_args = reinterpret_cast<JValue*>(args.get());
+  for (int32_t i = 0; i < arg_count; ++i) {
+    Object* arg = objects->Get(i);
+    Class* dst_class = classes->Get(i);
+    if (dst_class->IsPrimitive()) {
+      if (!UnboxPrimitive(env, arg, dst_class, decoded_args[i])) {
+        return NULL;
+      }
+    } else {
+      args[i].l = AddLocalReference<jobject>(env, arg);
+    }
+  }
+
+  // Invoke the method.
+  JValue value = InvokeWithJValues(env, javaReceiver, mid, args.get());
+
+  // Wrap any exception with "Ljava/lang/reflect/InvocationTargetException;" and return early.
+  if (self->IsExceptionPending()) {
+    jthrowable th = env->ExceptionOccurred();
+    env->ExceptionClear();
+    jclass exception_class = env->FindClass("java/lang/reflect/InvocationTargetException");
+    jmethodID mid = env->GetMethodID(exception_class, "<init>", "(Ljava/lang/Throwable;)V");
+    jobject exception_instance = env->NewObject(exception_class, mid, th);
+    env->Throw(reinterpret_cast<jthrowable>(exception_instance));
+    return NULL;
+  }
+
+  // Box if necessary and return.
+  BoxPrimitive(env, m->GetReturnType(), value);
+  return AddLocalReference<jobject>(env, value.l);
+}
+
 bool VerifyObjectInClass(JNIEnv* env, Object* o, Class* c) {
   if (o == NULL) {
     jniThrowNullPointerException(env, "receiver for non-static field access was null");
diff --git a/src/reflection.h b/src/reflection.h
index 7256754..2d18331 100644
--- a/src/reflection.h
+++ b/src/reflection.h
@@ -31,6 +31,8 @@
 
 bool ConvertPrimitiveValue(Class* src_class, Class* dst_class, const JValue& src, JValue& dst);
 
+jobject InvokeMethod(JNIEnv* env, jobject method, jobject receiver, jobject args, jobject params);
+
 bool VerifyObjectInClass(JNIEnv* env, Object* o, Class* c);
 
 }  // namespace art
diff --git a/src/runtime.cc b/src/runtime.cc
index b1da77d..42bf874 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -365,20 +365,11 @@
 
   Thread::FinishStartup();
 
-  RunImageClinits();
+  class_linker_->RunRootClinits();
 
   StartDaemonThreads();
 }
 
-// initialize classes that have instances in the image but that have
-// <clinit> methods so they could not be initialized by the compiler.
-void Runtime::RunImageClinits() {
-  Class* Field_class = class_linker_->FindSystemClass("Ljava/lang/reflect/Field;");
-  CHECK(Field_class->FindDeclaredDirectMethod("<clinit>", "()V") != NULL);
-  class_linker_->EnsureInitialized(Field_class, true);
-  CHECK(!Thread::Current()->IsExceptionPending());
-}
-
 void Runtime::StartDaemonThreads() {
   signal_catcher_ = new SignalCatcher;
 
@@ -473,7 +464,7 @@
   REGISTER(register_java_lang_VMClassLoader);
   //REGISTER(register_java_lang_reflect_AccessibleObject);
   REGISTER(register_java_lang_reflect_Array);
-  //REGISTER(register_java_lang_reflect_Constructor);
+  REGISTER(register_java_lang_reflect_Constructor);
   REGISTER(register_java_lang_reflect_Field);
   REGISTER(register_java_lang_reflect_Method);
   //REGISTER(register_java_lang_reflect_Proxy);
diff --git a/src/runtime.h b/src/runtime.h
index ee5f524..a6916ac 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -193,7 +193,6 @@
   bool Init(const Options& options, bool ignore_unrecognized);
   void InitNativeMethods();
   void RegisterRuntimeNativeMethods(JNIEnv*);
-  void RunImageClinits();
   void StartDaemonThreads();
 
   std::string boot_class_path_;
diff --git a/test/SystemMethods/SystemMethods.java b/test/SystemMethods/SystemMethods.java
index 429755f..708a053 100644
--- a/test/SystemMethods/SystemMethods.java
+++ b/test/SystemMethods/SystemMethods.java
@@ -14,6 +14,9 @@
  * limitations under the License.
  */
 
+import java.lang.reflect.*;
+import java.util.*;
+
 class SystemMethods {
   public static int test0() {
     System.logI("hello world");
@@ -84,11 +87,14 @@
     return 123;
   }
 
-  private static int i = 4;
-  private static long j = 0x0123456789abcdefL;
-
-  private static float f = 3.14f;
+  private static boolean z = true;
+  private static byte b = 8;
+  private static char c = 'x';
   private static double d = Math.PI;
+  private static float f = 3.14f;
+  private static int i = 32;
+  private static long j = 0x0123456789abcdefL;
+  private static short s = 16;
 
   public static int test4() {
     String s = "int=" + i + " long=" + j;
@@ -119,7 +125,246 @@
     return 123;
   }
 
+  public static void test6() throws Exception {
+    java.lang.reflect.Field f;
+
+    f = SystemMethods.class.getDeclaredField("z");
+    System.out.println(f.getBoolean(null));
+    f = SystemMethods.class.getDeclaredField("b");
+    System.out.println(f.getByte(null));
+    f = SystemMethods.class.getDeclaredField("c");
+    System.out.println(f.getChar(null));
+    f = SystemMethods.class.getDeclaredField("d");
+    System.out.println(f.getDouble(null));
+    f = SystemMethods.class.getDeclaredField("f");
+    System.out.println(f.getFloat(null));
+    f = SystemMethods.class.getDeclaredField("i");
+    System.out.println(f.getInt(null));
+    f = SystemMethods.class.getDeclaredField("j");
+    System.out.println(f.getLong(null));
+    f = SystemMethods.class.getDeclaredField("s");
+    System.out.println(f.getShort(null));
+
+    f = SystemMethods.class.getDeclaredField("z");
+    f.setBoolean(null, false);
+    f = SystemMethods.class.getDeclaredField("b");
+    f.setByte(null, (byte) 7);
+    f = SystemMethods.class.getDeclaredField("c");
+    f.setChar(null, 'y');
+    f = SystemMethods.class.getDeclaredField("d");
+    f.setDouble(null, 2.7);
+    f = SystemMethods.class.getDeclaredField("f");
+    f.setFloat(null, 2.7f);
+    f = SystemMethods.class.getDeclaredField("i");
+    f.setInt(null, 31);
+    f = SystemMethods.class.getDeclaredField("j");
+    f.setLong(null, 63);
+    f = SystemMethods.class.getDeclaredField("s");
+    f.setShort(null, (short) 15);
+
+    f = SystemMethods.class.getDeclaredField("z");
+    System.out.println(f.getBoolean(null));
+    f = SystemMethods.class.getDeclaredField("b");
+    System.out.println(f.getByte(null));
+    f = SystemMethods.class.getDeclaredField("c");
+    System.out.println(f.getChar(null));
+    f = SystemMethods.class.getDeclaredField("d");
+    System.out.println(f.getDouble(null));
+    f = SystemMethods.class.getDeclaredField("f");
+    System.out.println(f.getFloat(null));
+    f = SystemMethods.class.getDeclaredField("i");
+    System.out.println(f.getInt(null));
+    f = SystemMethods.class.getDeclaredField("j");
+    System.out.println(f.getLong(null));
+    f = SystemMethods.class.getDeclaredField("s");
+    System.out.println(f.getShort(null));
+
+    f = SystemMethods.class.getDeclaredField("z");
+    f.set(null, Boolean.valueOf(true));
+    f = SystemMethods.class.getDeclaredField("b");
+    f.set(null, Byte.valueOf((byte) 6));
+    f = SystemMethods.class.getDeclaredField("c");
+    f.set(null, Character.valueOf('z'));
+    f = SystemMethods.class.getDeclaredField("d");
+    f.set(null, Double.valueOf(1.3));
+    f = SystemMethods.class.getDeclaredField("f");
+    f.set(null, Float.valueOf(1.3f));
+    f = SystemMethods.class.getDeclaredField("i");
+    f.set(null, Integer.valueOf(30));
+    f = SystemMethods.class.getDeclaredField("j");
+    f.set(null, Long.valueOf(62));
+    f.set(null, Integer.valueOf(62));
+    f = SystemMethods.class.getDeclaredField("s");
+    f.set(null, Short.valueOf((short) 14));
+
+    f = SystemMethods.class.getDeclaredField("z");
+    System.out.println(f.getBoolean(null));
+    f = SystemMethods.class.getDeclaredField("b");
+    System.out.println(f.getByte(null));
+    f = SystemMethods.class.getDeclaredField("c");
+    System.out.println(f.getChar(null));
+    f = SystemMethods.class.getDeclaredField("d");
+    System.out.println(f.getDouble(null));
+    f = SystemMethods.class.getDeclaredField("f");
+    System.out.println(f.getFloat(null));
+    f = SystemMethods.class.getDeclaredField("i");
+    System.out.println(f.getInt(null));
+    f = SystemMethods.class.getDeclaredField("j");
+    System.out.println(f.getLong(null));
+    f = SystemMethods.class.getDeclaredField("s");
+    System.out.println(f.getShort(null));
+
+    try {
+      f = SystemMethods.class.getDeclaredField("s");
+      f.set(null, Integer.valueOf(14));
+    } catch (Exception ex) {
+      ex.printStackTrace();
+    }
+
+    f = SystemMethods.class.getDeclaredField("z");
+    show(f.get(null));
+    f = SystemMethods.class.getDeclaredField("b");
+    show(f.get(null));
+    f = SystemMethods.class.getDeclaredField("c");
+    show(f.get(null));
+    f = SystemMethods.class.getDeclaredField("d");
+    show(f.get(null));
+    f = SystemMethods.class.getDeclaredField("f");
+    show(f.get(null));
+    f = SystemMethods.class.getDeclaredField("i");
+    show(f.get(null));
+    f = SystemMethods.class.getDeclaredField("j");
+    show(f.get(null));
+    f = SystemMethods.class.getDeclaredField("s");
+    show(f.get(null));
+
+    /*
+    private static boolean z = true;
+    private static byte b = 8;
+    private static char c = 'x';
+    private static double d = Math.PI;
+    private static float f = 3.14f;
+    private static int i = 32;
+    private static long j = 0x0123456789abcdefL;
+    private static short s = 16;
+    */
+  }
+
+  private static void show(Object o) {
+    System.out.println(o + " (" + (o != null ? o.getClass() : "null") + ")");
+  }
+
+  public static void test7() throws Exception {
+    System.out.println(Arrays.toString(String.class.getDeclaredConstructors()));
+    System.out.println(Arrays.toString(String.class.getDeclaredFields()));
+    System.out.println(Arrays.toString(String.class.getDeclaredMethods()));
+
+    System.out.println(Arrays.toString(SystemMethods.class.getInterfaces()));
+    System.out.println(Arrays.toString(String.class.getInterfaces()));
+
+//    System.out.println(SystemMethods.class.getModifiers());
+//    System.out.println(String.class.getModifiers());
+
+    System.out.println(String.class.isAssignableFrom(Object.class));
+    System.out.println(Object.class.isAssignableFrom(String.class));
+
+    System.out.println(String.class.isInstance("hello"));
+    System.out.println(String.class.isInstance(123));
+
+    java.lang.reflect.Method m;
+
+    m = SystemMethods.class.getDeclaredMethod("IV", int.class);
+    System.out.println(Arrays.toString(m.getParameterTypes()));
+    show(m.invoke(null, 4444));
+    System.out.println(Arrays.toString(m.getParameterTypes()));
+
+    m = SystemMethods.class.getDeclaredMethod("IIV", int.class, int.class);
+    System.out.println(Arrays.toString(m.getParameterTypes()));
+    show(m.invoke(null, 1111, 2222));
+
+    m = SystemMethods.class.getDeclaredMethod("III", int.class, int.class);
+    System.out.println(Arrays.toString(m.getParameterTypes()));
+    show(m.invoke(null, 1111, 2222));
+
+    m = SystemMethods.class.getDeclaredMethod("sumArray", int[].class);
+    System.out.println(Arrays.toString(m.getParameterTypes()));
+    show(m.invoke(null, new int[] { 1, 2, 3, 4 }));
+
+    m = SystemMethods.class.getDeclaredMethod("concat", String[].class);
+    System.out.println(Arrays.toString(m.getParameterTypes()));
+    show(m.invoke(null, (Object) new String[] { "h", "e", "l", "l", "o" }));
+
+    m = SystemMethods.class.getDeclaredMethod("ZBCDFIJSV", boolean.class, byte.class, char.class, double.class, float.class, int.class, long.class, short.class);
+    System.out.println(Arrays.toString(m.getParameterTypes()));
+    show(m.invoke(null, true, (byte) 0, '1', 2, 3, 4, 5, (short) 6));
+
+    m = SystemMethods.class.getDeclaredMethod("ZBCDLFIJSV", boolean.class, byte.class, char.class, double.class, String.class, float.class, int.class, long.class, short.class);
+    System.out.println(Arrays.toString(m.getParameterTypes()));
+    show(m.invoke(null, true, (byte) 0, '1', 2, "hello world", 3, 4, 5, (short) 6));
+
+    try {
+      m = SystemMethods.class.getDeclaredMethod("thrower");
+      System.out.println(Arrays.toString(m.getParameterTypes()));
+      show(m.invoke(null));
+      System.out.println("************* should have thrown!");
+    } catch (Exception ex) {
+      ex.printStackTrace();
+    }
+  }
+
+  private static void thrower() {
+    throw new ArithmeticException("surprise!");
+  }
+
+  public static int sumArray(int[] xs) {
+    int result = 0;
+    for (int x : xs) {
+      result += x;
+    }
+    return result;
+  }
+
+  public static String concat(String[] strings) {
+    String result = "";
+    for (String s : strings) {
+      result += s;
+    }
+    return result;
+  }
+
+  public static void IV(int i) {
+    System.out.println(i);
+  }
+
+  public static void IIV(int i, int j) {
+    System.out.println(i + " " + j);
+  }
+
+  public static int III(int i, int j) {
+    System.out.println(i + " " + j);
+    return i + j;
+  }
+
+  public static void ZBCDFIJSV(boolean z, byte b, char c, double d, float f, int i, long l, short s) {
+    System.out.println(z + " " + b + " " + c + " " + d + " " + f + " " + i + " " + l + " " + s);
+  }
+
+  public static void ZBCDLFIJSV(boolean z, byte b, char c, double d, String string, float f, int i, long l, short s) {
+    System.out.println(z + " " + b + " " + c + " " + d + " " + " " + string + " " + f + " " + i + " " + l + " " + s);
+  }
+
+  public static void test8() throws Exception {
+    Constructor<?> ctor;
+
+    ctor = String.class.getConstructor(new Class[0]);
+    show(ctor.newInstance((Object[]) null));
+
+    ctor = String.class.getConstructor(char[].class, int.class, int.class);
+    show(ctor.newInstance(new char[] { 'x', 'y', 'z', '!' }, 1, 2));
+  }
+
   public static void main(String[] args) throws Exception {
-    test5();
+    test7();
+    test8();
   }
 }