diff --git a/src/class_linker.cc b/src/class_linker.cc
index 50b1a07..3437a5a 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -27,7 +27,7 @@
 }
 
 void ClassLinker::Init(const std::vector<DexFile*>& boot_class_path) {
-  init_done_ = false;
+  CHECK(!init_done_);
 
   // java_lang_Class comes first, its needed for AllocClass
   Class* java_lang_Class = down_cast<Class*>(Heap::AllocObject(NULL, sizeof(Class)));
@@ -61,14 +61,17 @@
   Class* char_array_class = AllocClass(java_lang_Class);
   CHECK(char_array_class != NULL);
   char_array_class->descriptor_ = "[C";
+  CharArray::SetArrayClass(char_array_class);
 
   // int[] and long[] are used for static field storage
   Class* int_array_class = AllocClass(java_lang_Class);
   CHECK(int_array_class != NULL);
   int_array_class->descriptor_ = "[I";
+  IntArray::SetArrayClass(int_array_class);
   Class* long_array_class = AllocClass(java_lang_Class);
   CHECK(long_array_class != NULL);
   long_array_class->descriptor_ = "[J";
+  LongArray::SetArrayClass(long_array_class);
 
   // Field and Method are necessary so that FindClass can link members
   Class* java_lang_reflect_Field = AllocClass(java_lang_Class);
@@ -95,7 +98,7 @@
   class_roots_->Set(kJavaLangReflectMethod, java_lang_reflect_Method);
   // now that these are registered, we can use AllocClass() and AllocObjectArray
 
-  String::InitClasses(java_lang_String, char_array_class);
+  String::InitClasses(java_lang_String);
   // Now AllocString* can be used
 
   // setup boot_class_path_ now that we can use AllocObjectArray to
@@ -172,6 +175,7 @@
   CHECK_EQ(java_io_Serializable, object_array_class->GetInterface(1));
 
   // Setup the primitive type classes.
+  class_roots_->Set(kPrimitiveBoolean, CreatePrimitiveClass("Z"));
   class_roots_->Set(kPrimitiveByte, CreatePrimitiveClass("B"));
   class_roots_->Set(kPrimitiveChar, CreatePrimitiveClass("C"));
   class_roots_->Set(kPrimitiveDouble, CreatePrimitiveClass("D"));
@@ -179,7 +183,6 @@
   class_roots_->Set(kPrimitiveInt, CreatePrimitiveClass("I"));
   class_roots_->Set(kPrimitiveLong, CreatePrimitiveClass("J"));
   class_roots_->Set(kPrimitiveShort, CreatePrimitiveClass("S"));
-  class_roots_->Set(kPrimitiveBoolean, CreatePrimitiveClass("Z"));
   class_roots_->Set(kPrimitiveVoid, CreatePrimitiveClass("V"));
   // now we can use FindSystemClass for anything, including for "[C"
 
@@ -191,6 +194,19 @@
   Class* found_long_array_class = FindSystemClass("[J");
   CHECK_EQ(long_array_class, found_long_array_class);
 
+  // Initialize all the other primitive array types for PrimitiveArray::Alloc.
+  // These are easy because everything we need has already been set up.
+  class_roots_->Set(kBooleanArrayClass, FindSystemClass("[Z"));
+  class_roots_->Set(kByteArrayClass, FindSystemClass("[B"));
+  class_roots_->Set(kDoubleArrayClass, FindSystemClass("[D"));
+  class_roots_->Set(kFloatArrayClass, FindSystemClass("[F"));
+  class_roots_->Set(kShortArrayClass, FindSystemClass("[S"));
+  BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
+  ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
+  DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
+  FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
+  ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
+
   // ensure all class_roots_ were initialized
   for (size_t i = 0; i < kClassRootsMax; i++) {
     CHECK(GetClassRoot(static_cast<ClassRoot>(i)));
@@ -1378,12 +1394,10 @@
     klass->static_references_ = ObjectArray<Object>::Alloc(array_class, next_reference_slot);
   }
   if (next_32bit_primitive_slot > 0) {
-    Class* array_class = GetClassRoot(kIntArrayClass);
-    klass->static_32bit_primitives_ = IntArray::Alloc(array_class, next_32bit_primitive_slot);
+    klass->static_32bit_primitives_ = IntArray::Alloc(next_32bit_primitive_slot);
   }
   if (next_64bit_primitive_slot > 0) {
-    Class* array_class = GetClassRoot(kLongArrayClass);
-    klass->static_64bit_primitives_ = LongArray::Alloc(array_class, next_64bit_primitive_slot);
+    klass->static_64bit_primitives_ = LongArray::Alloc(next_64bit_primitive_slot);
   }
 
   return true;
diff --git a/src/class_linker.h b/src/class_linker.h
index fa50537..b2b4c95 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -31,6 +31,8 @@
   Class* FindClass(const StringPiece& descriptor,
                    ClassLoader* class_loader);
 
+  Class* FindPrimitiveClass(char type);
+
   Class* FindSystemClass(const StringPiece& descriptor) {
     return FindClass(descriptor, NULL);
   }
@@ -42,8 +44,9 @@
   void VisitRoots(Heap::RootVistor* root_visitor, void* arg);
 
  private:
-  ClassLinker() {
-    classes_lock_ = Mutex::Create("ClassLinker::Lock");
+  ClassLinker()
+      : classes_lock_(Mutex::Create("ClassLinker::Lock")),
+        init_done_(false) {
   }
 
   void Init(const std::vector<DexFile*>& boot_class_path_);
@@ -69,8 +72,6 @@
   Class* CreateArrayClass(const StringPiece& descriptor,
                           ClassLoader* class_loader);
 
-  Class* FindPrimitiveClass(char type);
-
   const DexFile& FindDexFile(const DexCache* dex_cache) const;
 
   DexCache* FindDexCache(const DexFile* dex_file) const;
@@ -165,23 +166,28 @@
     kJavaLangObject,
     kObjectArrayClass,
     kJavaLangString,
-    kCharArrayClass,
-    kIntArrayClass,
-    kLongArrayClass,
     kJavaLangReflectField,
     kJavaLangReflectMethod,
     kJavaLangClassLoader,
     kDalvikSystemBaseDexClassLoader,
     kDalvikSystemPathClassLoader,
     kPrimitiveBoolean,
-    kPrimitiveChar,
-    kPrimitiveFloat,
-    kPrimitiveDouble,
     kPrimitiveByte,
-    kPrimitiveShort,
+    kPrimitiveChar,
+    kPrimitiveDouble,
+    kPrimitiveFloat,
     kPrimitiveInt,
     kPrimitiveLong,
+    kPrimitiveShort,
     kPrimitiveVoid,
+    kBooleanArrayClass,
+    kByteArrayClass,
+    kCharArrayClass,
+    kDoubleArrayClass,
+    kFloatArrayClass,
+    kIntArrayClass,
+    kLongArrayClass,
+    kShortArrayClass,
     kClassRootsMax,
   };
   ObjectArray<Class>* class_roots_;
diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index 25b03b2..683310d 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -372,8 +372,8 @@
 }
 
 TEST_F(ClassLinkerTest, ValidatePrimitiveArrayElementsOffset) {
-  Class* array_class = class_linker_->FindSystemClass("[J");
-  LongArray* array = LongArray::Alloc(array_class, 0);
+  LongArray* array = LongArray::Alloc(0);
+  EXPECT_EQ(class_linker_->FindSystemClass("[J"), array->GetClass());
   uint32_t array_offset = reinterpret_cast<uint32_t>(array);
   uint32_t data_offset = reinterpret_cast<uint32_t>(array->GetData());
   EXPECT_EQ(16U, data_offset - array_offset);
diff --git a/src/image_writer.cc b/src/image_writer.cc
index 0014724..6ac5803 100644
--- a/src/image_writer.cc
+++ b/src/image_writer.cc
@@ -22,7 +22,7 @@
   }
   CalculateNewObjectOffsets();
   CopyAndFixupObjects();
-  
+
   scoped_ptr<File> file(OS::OpenBinaryFile(filename, true));
   if (file == NULL) {
     return false;
@@ -72,7 +72,7 @@
   DCHECK(obj != NULL);
   DCHECK(arg != NULL);
   ImageWriter* image_writer = reinterpret_cast<ImageWriter*>(arg);
-  
+
   size_t offset = image_writer->GetImageOffset(obj);
   byte* dst = image_writer->mem_map_->GetAddress() + offset;
   byte* src = reinterpret_cast<byte*>(obj);
@@ -96,7 +96,7 @@
 }
 
 void ImageWriter::FixupObjectArray(ObjectArray<Object>* orig, ObjectArray<Object>* copy) {
-  for (size_t i = 0; i < orig->GetLength(); ++i) {
+  for (int32_t i = 0; i < orig->GetLength(); ++i) {
     const Object* element = orig->Get(i);
     copy->Set(i, GetImageAddress(element));
   }
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 23c8273..0e9cb84 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -79,7 +79,7 @@
   return true;
 }
 
-static byte* CreateArgArray(Method* method, va_list ap) {
+byte* CreateArgArray(Method* method, va_list ap) {
   size_t num_bytes = method->NumArgArrayBytes();
   scoped_array<byte> arg_array(new byte[num_bytes]);
   const StringPiece& shorty = method->GetShorty();
@@ -117,7 +117,7 @@
   return arg_array.release();
 }
 
-static byte* CreateArgArray(Method* method, jvalue* args) {
+byte* CreateArgArray(Method* method, jvalue* args) {
   size_t num_bytes = method->NumArgArrayBytes();
   scoped_array<byte> arg_array(new byte[num_bytes]);
   const StringPiece& shorty = method->GetShorty();
@@ -1301,52 +1301,52 @@
   UNIMPLEMENTED(FATAL);
 }
 
+template<typename JniT, typename ArtT>
+JniT NewPrimitiveArray(ScopedJniThreadState& ts, jsize length) {
+  CHECK_GE(length, 0); // TODO: ReportJniError
+  ArtT* result = ArtT::Alloc(length);
+  // TODO: local reference
+  return reinterpret_cast<JniT>(result);
+}
+
 jbooleanArray NewBooleanArray(JNIEnv* env, jsize len) {
   ScopedJniThreadState ts(env);
-  UNIMPLEMENTED(FATAL);
-  return NULL;
+  return NewPrimitiveArray<jbooleanArray, BooleanArray>(ts, len);
 }
 
 jbyteArray NewByteArray(JNIEnv* env, jsize len) {
   ScopedJniThreadState ts(env);
-  UNIMPLEMENTED(FATAL);
-  return NULL;
+  return NewPrimitiveArray<jbyteArray, ByteArray>(ts, len);
 }
 
 jcharArray NewCharArray(JNIEnv* env, jsize len) {
   ScopedJniThreadState ts(env);
-  UNIMPLEMENTED(FATAL);
-  return NULL;
-}
-
-jshortArray NewShortArray(JNIEnv* env, jsize len) {
-  ScopedJniThreadState ts(env);
-  UNIMPLEMENTED(FATAL);
-  return NULL;
-}
-
-jintArray NewIntArray(JNIEnv* env, jsize len) {
-  ScopedJniThreadState ts(env);
-  UNIMPLEMENTED(FATAL);
-  return NULL;
-}
-
-jlongArray NewLongArray(JNIEnv* env, jsize len) {
-  ScopedJniThreadState ts(env);
-  UNIMPLEMENTED(FATAL);
-  return NULL;
-}
-
-jfloatArray NewFloatArray(JNIEnv* env, jsize len) {
-  ScopedJniThreadState ts(env);
-  UNIMPLEMENTED(FATAL);
-  return NULL;
+  return NewPrimitiveArray<jcharArray, CharArray>(ts, len);
 }
 
 jdoubleArray NewDoubleArray(JNIEnv* env, jsize len) {
   ScopedJniThreadState ts(env);
-  UNIMPLEMENTED(FATAL);
-  return NULL;
+  return NewPrimitiveArray<jdoubleArray, DoubleArray>(ts, len);
+}
+
+jfloatArray NewFloatArray(JNIEnv* env, jsize len) {
+  ScopedJniThreadState ts(env);
+  return NewPrimitiveArray<jfloatArray, FloatArray>(ts, len);
+}
+
+jintArray NewIntArray(JNIEnv* env, jsize len) {
+  ScopedJniThreadState ts(env);
+  return NewPrimitiveArray<jintArray, IntArray>(ts, len);
+}
+
+jlongArray NewLongArray(JNIEnv* env, jsize len) {
+  ScopedJniThreadState ts(env);
+  return NewPrimitiveArray<jlongArray, LongArray>(ts, len);
+}
+
+jshortArray NewShortArray(JNIEnv* env, jsize len) {
+  ScopedJniThreadState ts(env);
+  return NewPrimitiveArray<jshortArray, ShortArray>(ts, len);
 }
 
 jboolean* GetBooleanArrayElements(JNIEnv* env,
diff --git a/src/jni_internal_test.cc b/src/jni_internal_test.cc
index 457bae8..ce640e2 100644
--- a/src/jni_internal_test.cc
+++ b/src/jni_internal_test.cc
@@ -57,6 +57,28 @@
   EXPECT_CLASS_NOT_FOUND("K");
 }
 
+TEST_F(JniInternalTest, NewPrimitiveArray) {
+  // TODO: death tests for negative array sizes.
+
+  CHECK(env_->NewBooleanArray(0) != NULL);
+  CHECK(env_->NewByteArray(0) != NULL);
+  CHECK(env_->NewCharArray(0) != NULL);
+  CHECK(env_->NewDoubleArray(0) != NULL);
+  CHECK(env_->NewFloatArray(0) != NULL);
+  CHECK(env_->NewIntArray(0) != NULL);
+  CHECK(env_->NewLongArray(0) != NULL);
+  CHECK(env_->NewShortArray(0) != NULL);
+
+  CHECK(env_->NewBooleanArray(1) != NULL);
+  CHECK(env_->NewByteArray(1) != NULL);
+  CHECK(env_->NewCharArray(1) != NULL);
+  CHECK(env_->NewDoubleArray(1) != NULL);
+  CHECK(env_->NewFloatArray(1) != NULL);
+  CHECK(env_->NewIntArray(1) != NULL);
+  CHECK(env_->NewLongArray(1) != NULL);
+  CHECK(env_->NewShortArray(1) != NULL);
+}
+
 bool EnsureInvokeStub(Method* method);
 
 byte* AllocateCode(void* code, size_t length) {
diff --git a/src/mark_sweep.cc b/src/mark_sweep.cc
index 5d7c139..06a1c92 100644
--- a/src/mark_sweep.cc
+++ b/src/mark_sweep.cc
@@ -204,7 +204,7 @@
   MarkObject(obj->GetClass());
   if (obj->IsObjectArray()) {
     const ObjectArray<Object>* array = obj->AsObjectArray<Object>();
-    for (size_t i = 0; i < array->GetLength(); ++i) {
+    for (int32_t i = 0; i < array->GetLength(); ++i) {
       const Object* element = array->Get(i);
       MarkObject(element);
     }
diff --git a/src/object.cc b/src/object.cc
index 34b0bb9..21f3537 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -5,6 +5,7 @@
 #include <string.h>
 #include <algorithm>
 
+#include "class_linker.h"
 #include "globals.h"
 #include "heap.h"
 #include "logging.h"
@@ -441,13 +442,29 @@
   return NULL;
 }
 
+template<typename T>
+PrimitiveArray<T>* PrimitiveArray<T>::Alloc(size_t length) {
+  Array* raw_array = Array::Alloc(array_class_, length, sizeof(T));
+  return down_cast<PrimitiveArray<T>*>(raw_array);
+}
+
+template <typename T> Class* PrimitiveArray<T>::array_class_ = NULL;
+
+// Explicitly instantiate all the primitive array types.
+template class PrimitiveArray<uint8_t>;   // BooleanArray
+template class PrimitiveArray<int8_t>;    // ByteArray
+template class PrimitiveArray<uint16_t>;  // CharArray
+template class PrimitiveArray<double>;    // DoubleArray
+template class PrimitiveArray<float>;     // FloatArray
+template class PrimitiveArray<int32_t>;   // IntArray
+template class PrimitiveArray<int64_t>;   // LongArray
+template class PrimitiveArray<int16_t>;   // ShortArray
+
 // TODO: get global references for these
 Class* String::java_lang_String_ = NULL;
-Class* String::char_array_ = NULL;
 
-void String::InitClasses(Class* java_lang_String, Class* char_array) {
+void String::InitClasses(Class* java_lang_String) {
   java_lang_String_ = java_lang_String;
-  char_array_ = char_array;
 }
 
 static const char* kClassStatusNames[] = {
diff --git a/src/object.h b/src/object.h
index cb7f379..5110992 100644
--- a/src/object.h
+++ b/src/object.h
@@ -27,9 +27,14 @@
 class String;
 template<class T> class ObjectArray;
 template<class T> class PrimitiveArray;
+typedef PrimitiveArray<uint8_t> BooleanArray;
+typedef PrimitiveArray<int8_t> ByteArray;
 typedef PrimitiveArray<uint16_t> CharArray;
-typedef PrimitiveArray<uint32_t> IntArray;
-typedef PrimitiveArray<uint64_t> LongArray;
+typedef PrimitiveArray<double> DoubleArray;
+typedef PrimitiveArray<float> FloatArray;
+typedef PrimitiveArray<int32_t> IntArray;
+typedef PrimitiveArray<int64_t> LongArray;
+typedef PrimitiveArray<int16_t> ShortArray;
 
 union JValue {
   uint8_t z;
@@ -611,7 +616,7 @@
 
   size_t Size() const;
 
-  uint32_t GetLength() const {
+  int32_t GetLength() const {
     return length_;
   }
 
@@ -644,12 +649,12 @@
     return reinterpret_cast<T**>(&elements_);
   }
 
-  T* Get(uint32_t i) const {
+  T* Get(int32_t i) const {
     CHECK_LT(i, GetLength());
     return GetData()[i];
   }
 
-  void Set(uint32_t i, T* object) {
+  void Set(int32_t i, T* object) {
     CHECK_LT(i, GetLength());
     GetData()[i] = object;  // TODO: write barrier
   }
@@ -662,7 +667,7 @@
     }
   }
 
-  ObjectArray<T>* CopyOf(size_t new_length) {
+  ObjectArray<T>* CopyOf(int32_t new_length) {
     ObjectArray<T>* new_array = Alloc(klass_, new_length);
     Copy(this, 0, new_array, 0, std::min(GetLength(), new_length));
     return new_array;
@@ -795,24 +800,28 @@
     return component_type_;
   }
 
-  size_t GetComponentSize() const {
-    switch (component_type_->descriptor_[0]) {
-      case 'B': return 1;  // byte
-      case 'C': return 2;  // char
-      case 'D': return 8;  // double
-      case 'F': return 4;  // float
-      case 'I': return 4;  // int
-      case 'J': return 8;  // long
-      case 'S': return 2;  // short
-      case 'Z': return 1;  // boolean
-      case 'L': return sizeof(Object*);
-      case '[': return sizeof(Array*);
-      default: 
-        LOG(ERROR) << "Unknown component type " << component_type_->descriptor_;
-        return 0;
+  static size_t GetTypeSize(const StringPiece& descriptor) {
+    switch (descriptor[0]) {
+    case 'B': return 1;  // byte
+    case 'C': return 2;  // char
+    case 'D': return 8;  // double
+    case 'F': return 4;  // float
+    case 'I': return 4;  // int
+    case 'J': return 8;  // long
+    case 'S': return 2;  // short
+    case 'Z': return 1;  // boolean
+    case 'L': return sizeof(Object*);
+    case '[': return sizeof(Array*);
+    default:
+      LOG(ERROR) << "Unknown type " << descriptor;
+      return 0;
     }
   }
 
+  size_t GetComponentSize() const {
+    return GetTypeSize(component_type_->descriptor_);
+  }
+
   const StringPiece& GetDescriptor() const {
     DCHECK_NE(0, descriptor_.size());
     return descriptor_;
@@ -902,7 +911,7 @@
     return (direct_methods_ != NULL) ? direct_methods_->GetLength() : 0;
   }
 
-  Method* GetDirectMethod(uint32_t i) const {
+  Method* GetDirectMethod(int32_t i) const {
     DCHECK_NE(NumDirectMethods(), 0U);
     return direct_methods_->Get(i);
   }
@@ -1186,11 +1195,7 @@
 template<class T>
 class PrimitiveArray : public Array {
  public:
-  static PrimitiveArray<T>* Alloc(Class* element_class, size_t length) {
-    return down_cast<PrimitiveArray<T>*>(Array::Alloc(element_class,
-                                         length,
-                                         sizeof(T)));
-  }
+  static PrimitiveArray<T>* Alloc(size_t length);
 
   const T* GetData() const {
     return reinterpret_cast<const T*>(&elements_);
@@ -1200,20 +1205,27 @@
     return reinterpret_cast<T*>(&elements_);
   }
 
-  T Get(T i) const {
+  T Get(int32_t i) const {
     CHECK_LT(i, GetLength());
     return GetData()[i];
   }
 
-  void Set(uint32_t i, T value) {
+  void Set(int32_t i, T value) {
     CHECK_LT(i, GetLength());
     GetData()[i] = value;
   }
 
+  static void SetArrayClass(Class* array_class) {
+    CHECK(array_class != NULL);
+    array_class_ = array_class;
+  }
+
  private:
   // Location of first element.
   T elements_[0];
 
+  static Class* array_class_;
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(PrimitiveArray);
 };
 
@@ -1245,7 +1257,6 @@
                                 uint16_t* utf16_data_in,
                                 int32_t hash_code) {
     String* string = Alloc(GetJavaLangString(),
-                           GetCharArrayClass(),
                            utf16_length);
     // TODO use 16-bit wide memset variant
     for (int i = 0; i < utf16_length; i++ ) {
@@ -1256,10 +1267,9 @@
   }
 
   static String* AllocFromModifiedUtf8(Class* java_lang_String,
-                                       Class* char_array,
                                        int32_t utf16_length,
                                        const char* utf8_data_in) {
-    String* string = Alloc(java_lang_String, char_array, utf16_length);
+    String* string = Alloc(java_lang_String, utf16_length);
     uint16_t* utf16_data_out = string->array_->GetData();
     ConvertModifiedUtf8ToUtf16(utf16_data_out, utf8_data_in);
     string->ComputeHashCode();
@@ -1270,24 +1280,22 @@
   // using non-ASCII characters as this function assumes one char per byte.
   static String* AllocFromAscii(const char* ascii_data_in) {
     return AllocFromModifiedUtf8(GetJavaLangString(),
-                                 GetCharArrayClass(),
                                  strlen(ascii_data_in),
                                  ascii_data_in);
   }
 
   static String* AllocFromModifiedUtf8(int32_t utf16_length,
                                        const char* utf8_data_in) {
-    return AllocFromModifiedUtf8(GetJavaLangString(), GetCharArrayClass(),
+    return AllocFromModifiedUtf8(GetJavaLangString(),
                                  utf16_length, utf8_data_in);
   }
 
-  static void InitClasses(Class* java_lang_String, Class* char_array);
+  static void InitClasses(Class* java_lang_String);
 
   static String* Alloc(Class* java_lang_String,
-                       Class* char_array,
                        int32_t utf16_length) {
     String* string = down_cast<String*>(java_lang_String->NewInstance());
-    CharArray* array = CharArray::Alloc(char_array, utf16_length);
+    CharArray* array = CharArray::Alloc(utf16_length);
     string->array_ = array;
     string->count_ = utf16_length;
     return string;
@@ -1428,13 +1436,8 @@
     DCHECK(java_lang_String_ != NULL);
     return java_lang_String_;
   }
-  static Class* GetCharArrayClass() {
-    DCHECK(char_array_ != NULL);
-    return char_array_;
-  }
 
   static Class* java_lang_String_;
-  static Class* char_array_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(String);
 };
diff --git a/src/object_test.cc b/src/object_test.cc
index 52fb288..28aecb0 100644
--- a/src/object_test.cc
+++ b/src/object_test.cc
@@ -55,7 +55,7 @@
 
 TEST_F(ObjectTest, AllocObjectArray) {
   ObjectArray<Object>* oa = class_linker_->AllocObjectArray<Object>(2);
-  EXPECT_EQ(2U, oa->GetLength());
+  EXPECT_EQ(2, oa->GetLength());
   EXPECT_TRUE(oa->Get(0) == NULL);
   EXPECT_TRUE(oa->Get(1) == NULL);
   oa->Set(0, oa);