1 // Copyright 2012 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/android/scoped_java_ref.h"
6
7 #include <iterator>
8 #include <type_traits>
9
10 #include "base/android/jni_android.h"
11 #include "base/android/jni_string.h"
12 #include "testing/gtest/include/gtest/gtest.h"
13
14 #define EXPECT_SAME_OBJECT(a, b) \
15 EXPECT_TRUE(env->IsSameObject((a).obj(), (b).obj()))
16
17 namespace base {
18 namespace android {
19
20 namespace {
21 int g_local_refs = 0;
22 int g_global_refs = 0;
23
24 const JNINativeInterface* g_previous_functions;
25
NewGlobalRef(JNIEnv * env,jobject obj)26 jobject NewGlobalRef(JNIEnv* env, jobject obj) {
27 ++g_global_refs;
28 return g_previous_functions->NewGlobalRef(env, obj);
29 }
30
DeleteGlobalRef(JNIEnv * env,jobject obj)31 void DeleteGlobalRef(JNIEnv* env, jobject obj) {
32 --g_global_refs;
33 return g_previous_functions->DeleteGlobalRef(env, obj);
34 }
35
NewLocalRef(JNIEnv * env,jobject obj)36 jobject NewLocalRef(JNIEnv* env, jobject obj) {
37 ++g_local_refs;
38 return g_previous_functions->NewLocalRef(env, obj);
39 }
40
DeleteLocalRef(JNIEnv * env,jobject obj)41 void DeleteLocalRef(JNIEnv* env, jobject obj) {
42 --g_local_refs;
43 return g_previous_functions->DeleteLocalRef(env, obj);
44 }
45 } // namespace
46
47 class ScopedJavaRefTest : public testing::Test {
48 protected:
SetUp()49 void SetUp() override {
50 g_local_refs = 0;
51 g_global_refs = 0;
52 JNIEnv* env = AttachCurrentThread();
53 g_previous_functions = env->functions;
54 hooked_functions = *g_previous_functions;
55 env->functions = &hooked_functions;
56 // We inject our own functions in JNINativeInterface so we can keep track
57 // of the reference counting ourselves.
58 hooked_functions.NewGlobalRef = &NewGlobalRef;
59 hooked_functions.DeleteGlobalRef = &DeleteGlobalRef;
60 hooked_functions.NewLocalRef = &NewLocalRef;
61 hooked_functions.DeleteLocalRef = &DeleteLocalRef;
62 }
63
TearDown()64 void TearDown() override {
65 JNIEnv* env = AttachCurrentThread();
66 env->functions = g_previous_functions;
67 }
68 // From JellyBean release, the instance of this struct provided in JNIEnv is
69 // read-only, so we deep copy it to allow individual functions to be hooked.
70 JNINativeInterface hooked_functions;
71 };
72
73 // The main purpose of this is testing the various conversions compile.
TEST_F(ScopedJavaRefTest,Conversions)74 TEST_F(ScopedJavaRefTest, Conversions) {
75 JNIEnv* env = AttachCurrentThread();
76 ScopedJavaLocalRef<jstring> str = ConvertUTF8ToJavaString(env, "string");
77 ScopedJavaGlobalRef<jstring> global(str);
78
79 // Contextual conversions to bool should be allowed.
80 EXPECT_TRUE(str);
81 EXPECT_FALSE(JavaRef<jobject>());
82
83 // All the types should convert from nullptr, even JavaRef.
84 {
85 JavaRef<jstring> null_ref(nullptr);
86 EXPECT_FALSE(null_ref);
87 ScopedJavaLocalRef<jobject> null_local(nullptr);
88 EXPECT_FALSE(null_local);
89 ScopedJavaGlobalRef<jarray> null_global(nullptr);
90 EXPECT_FALSE(null_global);
91 }
92
93 // Local and global refs should {copy,move}-{construct,assign}.
94 // Moves should leave the source as null.
95 {
96 ScopedJavaLocalRef<jstring> str2(str);
97 EXPECT_SAME_OBJECT(str2, str);
98 ScopedJavaLocalRef<jstring> str3(std::move(str2));
99 EXPECT_SAME_OBJECT(str3, str);
100 EXPECT_FALSE(str2);
101 ScopedJavaLocalRef<jstring> str4;
102 str4 = str;
103 EXPECT_SAME_OBJECT(str4, str);
104 ScopedJavaLocalRef<jstring> str5;
105 str5 = std::move(str4);
106 EXPECT_SAME_OBJECT(str5, str);
107 EXPECT_FALSE(str4);
108 }
109 {
110 ScopedJavaGlobalRef<jstring> str2(global);
111 EXPECT_SAME_OBJECT(str2, str);
112 ScopedJavaGlobalRef<jstring> str3(std::move(str2));
113 EXPECT_SAME_OBJECT(str3, str);
114 EXPECT_FALSE(str2);
115 ScopedJavaGlobalRef<jstring> str4;
116 str4 = global;
117 EXPECT_SAME_OBJECT(str4, str);
118 ScopedJavaGlobalRef<jstring> str5;
119 str5 = std::move(str4);
120 EXPECT_SAME_OBJECT(str5, str);
121 EXPECT_FALSE(str4);
122 }
123
124 // As above but going from jstring to jobject.
125 {
126 ScopedJavaLocalRef<jobject> obj2(str);
127 EXPECT_SAME_OBJECT(obj2, str);
128 ScopedJavaLocalRef<jobject> obj3(std::move(obj2));
129 EXPECT_SAME_OBJECT(obj3, str);
130 EXPECT_FALSE(obj2);
131 ScopedJavaLocalRef<jobject> obj4;
132 obj4 = str;
133 EXPECT_SAME_OBJECT(obj4, str);
134 ScopedJavaLocalRef<jobject> obj5;
135 obj5 = std::move(obj4);
136 EXPECT_SAME_OBJECT(obj5, str);
137 EXPECT_FALSE(obj4);
138 }
139 {
140 ScopedJavaGlobalRef<jobject> obj2(global);
141 EXPECT_SAME_OBJECT(obj2, str);
142 ScopedJavaGlobalRef<jobject> obj3(std::move(obj2));
143 EXPECT_SAME_OBJECT(obj3, str);
144 EXPECT_FALSE(obj2);
145 ScopedJavaGlobalRef<jobject> obj4;
146 obj4 = global;
147 EXPECT_SAME_OBJECT(obj4, str);
148 ScopedJavaGlobalRef<jobject> obj5;
149 obj5 = std::move(obj4);
150 EXPECT_SAME_OBJECT(obj5, str);
151 EXPECT_FALSE(obj4);
152 }
153
154 // Explicit copy construction or assignment between global<->local is allowed,
155 // but not implicit conversions.
156 {
157 ScopedJavaLocalRef<jstring> new_local(global);
158 EXPECT_SAME_OBJECT(new_local, str);
159 new_local = global;
160 EXPECT_SAME_OBJECT(new_local, str);
161 ScopedJavaGlobalRef<jstring> new_global(str);
162 EXPECT_SAME_OBJECT(new_global, str);
163 new_global = str;
164 EXPECT_SAME_OBJECT(new_local, str);
165 static_assert(!std::is_convertible_v<ScopedJavaLocalRef<jobject>,
166 ScopedJavaGlobalRef<jobject>>,
167 "");
168 static_assert(!std::is_convertible_v<ScopedJavaGlobalRef<jobject>,
169 ScopedJavaLocalRef<jobject>>,
170 "");
171 }
172
173 // Converting between local/global while also converting to jobject also works
174 // because JavaRef<jobject> is the base class.
175 {
176 ScopedJavaGlobalRef<jobject> global_obj(str);
177 ScopedJavaLocalRef<jobject> local_obj(global);
178 const JavaRef<jobject>& obj_ref1(str);
179 const JavaRef<jobject>& obj_ref2(global);
180 EXPECT_SAME_OBJECT(obj_ref1, obj_ref2);
181 EXPECT_SAME_OBJECT(global_obj, obj_ref2);
182 }
183 global.Reset(str);
184 const JavaRef<jstring>& str_ref = str;
185 EXPECT_EQ("string", ConvertJavaStringToUTF8(str_ref));
186 str.Reset();
187 }
188
TEST_F(ScopedJavaRefTest,RefCounts)189 TEST_F(ScopedJavaRefTest, RefCounts) {
190 JNIEnv* env = AttachCurrentThread();
191 ScopedJavaLocalRef<jstring> str;
192 // The ConvertJavaStringToUTF8 below creates a new string that would normally
193 // return a local ref. We simulate that by starting the g_local_refs count at
194 // 1.
195 g_local_refs = 1;
196 str.Reset(ConvertUTF8ToJavaString(env, "string"));
197 EXPECT_EQ(1, g_local_refs);
198 EXPECT_EQ(0, g_global_refs);
199 {
200 ScopedJavaGlobalRef<jstring> global_str(str);
201 ScopedJavaGlobalRef<jobject> global_obj(global_str);
202 EXPECT_EQ(1, g_local_refs);
203 EXPECT_EQ(2, g_global_refs);
204
205 auto str2 = ScopedJavaLocalRef<jstring>::Adopt(env, str.Release());
206 EXPECT_EQ(1, g_local_refs);
207 {
208 ScopedJavaLocalRef<jstring> str3(str2);
209 EXPECT_EQ(2, g_local_refs);
210 }
211 EXPECT_EQ(1, g_local_refs);
212 {
213 ScopedJavaLocalRef<jstring> str4((ScopedJavaLocalRef<jstring>(str2)));
214 EXPECT_EQ(2, g_local_refs);
215 }
216 EXPECT_EQ(1, g_local_refs);
217 {
218 ScopedJavaLocalRef<jstring> str5;
219 str5 = ScopedJavaLocalRef<jstring>(str2);
220 EXPECT_EQ(2, g_local_refs);
221 }
222 EXPECT_EQ(1, g_local_refs);
223 str2.Reset();
224 EXPECT_EQ(0, g_local_refs);
225 global_str.Reset();
226 EXPECT_EQ(1, g_global_refs);
227 ScopedJavaGlobalRef<jobject> global_obj2(global_obj);
228 EXPECT_EQ(2, g_global_refs);
229 }
230
231 EXPECT_EQ(0, g_local_refs);
232 EXPECT_EQ(0, g_global_refs);
233 }
234
235 class JavaObjectArrayReaderTest : public testing::Test {
236 protected:
SetUp()237 void SetUp() override {
238 JNIEnv* env = AttachCurrentThread();
239 int_class_ = GetClass(env, "java/lang/Integer");
240 int_constructor_ = MethodID::Get<MethodID::TYPE_INSTANCE>(
241 env, int_class_.obj(), "<init>", "(I)V");
242 array_ = MakeArray(array_len_);
243
244 // Make array_len_ different Integer objects, keep a reference to each,
245 // and add them to the array.
246 for (jint i = 0; i < array_len_; ++i) {
247 jobject member = env->NewObject(int_class_.obj(), int_constructor_, i);
248 ASSERT_NE(member, nullptr);
249 array_members_[i] = ScopedJavaLocalRef<jobject>::Adopt(env, member);
250 env->SetObjectArrayElement(array_.obj(), i, member);
251 }
252 }
253
254 // Make an Integer[] with len elements, all initialized to null.
MakeArray(jsize len)255 ScopedJavaLocalRef<jobjectArray> MakeArray(jsize len) {
256 JNIEnv* env = AttachCurrentThread();
257 jobjectArray array = env->NewObjectArray(len, int_class_.obj(), nullptr);
258 EXPECT_NE(array, nullptr);
259 return ScopedJavaLocalRef<jobjectArray>::Adopt(env, array);
260 }
261
262 static constexpr jsize array_len_ = 10;
263 ScopedJavaLocalRef<jclass> int_class_;
264 jmethodID int_constructor_;
265 ScopedJavaLocalRef<jobject> array_members_[array_len_];
266 ScopedJavaLocalRef<jobjectArray> array_;
267 };
268
269 // Must actually define the variable until C++17 :(
270 constexpr jsize JavaObjectArrayReaderTest::array_len_;
271
TEST_F(JavaObjectArrayReaderTest,ZeroLengthArray)272 TEST_F(JavaObjectArrayReaderTest, ZeroLengthArray) {
273 JavaObjectArrayReader<jobject> zero_length(MakeArray(0));
274 EXPECT_TRUE(zero_length.empty());
275 EXPECT_EQ(zero_length.size(), 0);
276 EXPECT_EQ(zero_length.begin(), zero_length.end());
277 }
278
279 // Verify that we satisfy the C++ "InputIterator" named requirements.
TEST_F(JavaObjectArrayReaderTest,InputIteratorRequirements)280 TEST_F(JavaObjectArrayReaderTest, InputIteratorRequirements) {
281 typedef JavaObjectArrayReader<jobject>::iterator It;
282
283 JNIEnv* env = AttachCurrentThread();
284 JavaObjectArrayReader<jobject> reader(array_);
285 It i = reader.begin();
286
287 EXPECT_TRUE(std::is_copy_constructible_v<It>);
288 It copy = i;
289 EXPECT_EQ(copy, i);
290 EXPECT_EQ(It(i), i);
291
292 EXPECT_TRUE(std::is_copy_assignable_v<It>);
293 It assign = reader.end();
294 It& assign2 = (assign = i);
295 EXPECT_EQ(assign, i);
296 EXPECT_EQ(assign2, assign);
297
298 EXPECT_TRUE(std::is_destructible_v<It>);
299
300 // Swappable
301 It left = reader.begin(), right = reader.end();
302 std::swap(left, right);
303 EXPECT_EQ(left, reader.end());
304 EXPECT_EQ(right, reader.begin());
305
306 // Basic check that iterator_traits works
307 bool same_type = std::is_same_v<std::iterator_traits<It>::iterator_category,
308 std::input_iterator_tag>;
309 EXPECT_TRUE(same_type);
310
311 // Comparisons
312 EXPECT_EQ(reader.begin(), reader.begin());
313 EXPECT_NE(reader.begin(), reader.end());
314
315 // Dereferencing
316 ScopedJavaLocalRef<jobject> o = *(reader.begin());
317 EXPECT_SAME_OBJECT(o, array_members_[0]);
318 EXPECT_TRUE(env->IsSameObject(o.obj(), reader.begin()->obj()));
319
320 // Incrementing
321 It preinc = ++(reader.begin());
322 EXPECT_SAME_OBJECT(*preinc, array_members_[1]);
323 It postinc = reader.begin();
324 EXPECT_SAME_OBJECT(*postinc++, array_members_[0]);
325 EXPECT_SAME_OBJECT(*postinc, array_members_[1]);
326 }
327
328 // Check that range-based for and the convenience function work as expected.
TEST_F(JavaObjectArrayReaderTest,RangeBasedFor)329 TEST_F(JavaObjectArrayReaderTest, RangeBasedFor) {
330 JNIEnv* env = AttachCurrentThread();
331
332 int i = 0;
333 for (ScopedJavaLocalRef<jobject> element : array_.ReadElements<jobject>()) {
334 EXPECT_SAME_OBJECT(element, array_members_[i++]);
335 }
336 EXPECT_EQ(i, array_len_);
337 }
338
339 } // namespace android
340 } // namespace base
341