Add functions to convert boolean jni array.

base/android/jni_array_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/android/jni_array.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 27 matching lines @@
   std::vector<uint8_t> expected_vec(kBytes, kBytes + kLen);
   EXPECT_EQ(expected_vec, vectorFromBytes);
   EXPECT_EQ(expected_vec, vectorFromVector);
 
   AppendJavaByteArrayToByteVector(env, bytes.obj(), &vectorFromBytes);
   EXPECT_EQ(8U, vectorFromBytes.size());
   expected_vec.insert(expected_vec.end(), kBytes, kBytes + kLen);
   EXPECT_EQ(expected_vec, vectorFromBytes);
 }
 
+void CheckBoolConversion(JNIEnv* env,
+                         const bool* bool_array,
+                         const size_t len,
+                         const ScopedJavaLocalRef<jbooleanArray>& booleans) {
+  ASSERT_TRUE(booleans.obj());
+
+  jsize java_array_len = env->GetArrayLength(booleans.obj());
+  ASSERT_EQ(static_cast<jsize>(len), java_array_len);
+
+  jboolean value;
+  for (size_t i = 0; i < len; ++i) {
+    env->GetBooleanArrayRegion(booleans.obj(), i, 1, &value);
+    ASSERT_EQ(bool_array[i], value);
+  }
+}
+
+TEST(JniArray, BoolConversions) {
+  const bool kBools[] = {false, true, false};
+  const size_t kLen = arraysize(kBools);
+
+  JNIEnv* env = AttachCurrentThread();
+  CheckBoolConversion(env, kBools, kLen, ToJavaBooleanArray(env, kBools, kLen));
+}
+
 void CheckIntConversion(
     JNIEnv* env,
     const int* int_array,
     const size_t len,
     const ScopedJavaLocalRef<jintArray>& ints) {
   ASSERT_TRUE(ints.obj());
 
   jsize java_array_len = env->GetArrayLength(ints.obj());
   ASSERT_EQ(static_cast<jsize>(len), java_array_len);
 
@@ skipping 48 matching lines @@
                              ScopedJavaLocalRef<jintArray> jints,
                              std::vector<int> int_vector,
                              const size_t len) {
   jint value;
   for (size_t i = 0; i < len; ++i) {
     env->GetIntArrayRegion(jints.obj(), i, 1, &value);
     ASSERT_EQ(int_vector[i], value);
   }
 }
 
+void CheckBoolArrayConversion(JNIEnv* env,
+                              ScopedJavaLocalRef<jbooleanArray> jbooleans,
+                              std::vector<bool> bool_vector,
+                              const size_t len) {
+  jboolean value;
+  for (size_t i = 0; i < len; ++i) {
+    env->GetBooleanArrayRegion(jbooleans.obj(), i, 1, &value);
+    ASSERT_EQ(bool_vector[i], value);
+  }
+}
+
 void CheckFloatConversion(
     JNIEnv* env,
     const float* float_array,
     const size_t len,
     const ScopedJavaLocalRef<jfloatArray>& floats) {
   ASSERT_TRUE(floats.obj());
 
   jsize java_array_len = env->GetArrayLength(floats.obj());
   ASSERT_EQ(static_cast<jsize>(len), java_array_len);
 
   jfloat value;
   for (size_t i = 0; i < len; ++i) {
     env->GetFloatArrayRegion(floats.obj(), i, 1, &value);
     ASSERT_EQ(float_array[i], value);
   }
 }
 
 TEST(JniArray, FloatConversions) {
   const float kFloats[] = { 0.0f, 1.0f, -10.0f};
   const size_t kLen = arraysize(kFloats);
 
   JNIEnv* env = AttachCurrentThread();
   CheckFloatConversion(env, kFloats, kLen,
                        ToJavaFloatArray(env, kFloats, kLen));
 
   const std::vector<float> vec(kFloats, kFloats + kLen);
   CheckFloatConversion(env, kFloats, kLen, ToJavaFloatArray(env, vec));
 }
 
+TEST(JniArray, JavaBooleanArrayToBoolVector) {
+  const bool kBools[] = {false, true, false};
+  const size_t kLen = arraysize(kBools);
+
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jbooleanArray> jbooleans(env, env->NewBooleanArray(kLen));
+  ASSERT_TRUE(jbooleans.obj());
+
+  for (size_t i = 0; i < kLen; ++i) {
+    jboolean j = static_cast<jboolean>(kBools[i]);
+    env->SetBooleanArrayRegion(jbooleans.obj(), i, 1, &j);
+    ASSERT_FALSE(HasException(env));
+  }
+
+  std::vector<bool> bools;
+  JavaBooleanArrayToBoolVector(env, jbooleans.obj(), &bools);
+
+  ASSERT_EQ(static_cast<jsize>(bools.size()),
+            env->GetArrayLength(jbooleans.obj()));
+
+  CheckBoolArrayConversion(env, jbooleans, bools, kLen);
+}
+
 TEST(JniArray, JavaIntArrayToIntVector) {
   const int kInts[] = {0, 1, -1};
   const size_t kLen = arraysize(kInts);
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jintArray> jints(env, env->NewIntArray(kLen));
   ASSERT_TRUE(jints.obj());
 
   for (size_t i = 0; i < kLen; ++i) {
     jint j = static_cast<jint>(kInts[i]);
@@ skipping 167 matching lines @@
 
   EXPECT_EQ(kNumItems, out.size());
   CheckIntArrayConversion(env, int_array0, out[0], kLen0);
   CheckIntArrayConversion(env, int_array1, out[1], kLen1);
   CheckIntArrayConversion(env, int_array2, out[2], kLen2);
   CheckIntArrayConversion(env, int_array3, out[3], kLen3);
 }
 
 }  // namespace android
 }  // namespace base