1 /*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "utils.h"
18
19 #include "common_runtime_test.h"
20 #include "mirror/array.h"
21 #include "mirror/array-inl.h"
22 #include "mirror/object-inl.h"
23 #include "mirror/object_array-inl.h"
24 #include "mirror/string.h"
25 #include "scoped_thread_state_change.h"
26 #include "handle_scope-inl.h"
27
28 #include <valgrind.h>
29
30 namespace art {
31
32 std::string PrettyArguments(const char* signature);
33 std::string PrettyReturnType(const char* signature);
34
35 class UtilsTest : public CommonRuntimeTest {};
36
TEST_F(UtilsTest,PrettyDescriptor_ArrayReferences)37 TEST_F(UtilsTest, PrettyDescriptor_ArrayReferences) {
38 EXPECT_EQ("java.lang.Class[]", PrettyDescriptor("[Ljava/lang/Class;"));
39 EXPECT_EQ("java.lang.Class[][]", PrettyDescriptor("[[Ljava/lang/Class;"));
40 }
41
TEST_F(UtilsTest,PrettyDescriptor_ScalarReferences)42 TEST_F(UtilsTest, PrettyDescriptor_ScalarReferences) {
43 EXPECT_EQ("java.lang.String", PrettyDescriptor("Ljava.lang.String;"));
44 EXPECT_EQ("java.lang.String", PrettyDescriptor("Ljava/lang/String;"));
45 }
46
TEST_F(UtilsTest,PrettyDescriptor_Primitive)47 TEST_F(UtilsTest, PrettyDescriptor_Primitive) {
48 EXPECT_EQ("boolean", PrettyDescriptor(Primitive::kPrimBoolean));
49 EXPECT_EQ("byte", PrettyDescriptor(Primitive::kPrimByte));
50 EXPECT_EQ("char", PrettyDescriptor(Primitive::kPrimChar));
51 EXPECT_EQ("short", PrettyDescriptor(Primitive::kPrimShort));
52 EXPECT_EQ("int", PrettyDescriptor(Primitive::kPrimInt));
53 EXPECT_EQ("float", PrettyDescriptor(Primitive::kPrimFloat));
54 EXPECT_EQ("long", PrettyDescriptor(Primitive::kPrimLong));
55 EXPECT_EQ("double", PrettyDescriptor(Primitive::kPrimDouble));
56 EXPECT_EQ("void", PrettyDescriptor(Primitive::kPrimVoid));
57 }
58
TEST_F(UtilsTest,PrettyDescriptor_PrimitiveArrays)59 TEST_F(UtilsTest, PrettyDescriptor_PrimitiveArrays) {
60 EXPECT_EQ("boolean[]", PrettyDescriptor("[Z"));
61 EXPECT_EQ("boolean[][]", PrettyDescriptor("[[Z"));
62 EXPECT_EQ("byte[]", PrettyDescriptor("[B"));
63 EXPECT_EQ("byte[][]", PrettyDescriptor("[[B"));
64 EXPECT_EQ("char[]", PrettyDescriptor("[C"));
65 EXPECT_EQ("char[][]", PrettyDescriptor("[[C"));
66 EXPECT_EQ("double[]", PrettyDescriptor("[D"));
67 EXPECT_EQ("double[][]", PrettyDescriptor("[[D"));
68 EXPECT_EQ("float[]", PrettyDescriptor("[F"));
69 EXPECT_EQ("float[][]", PrettyDescriptor("[[F"));
70 EXPECT_EQ("int[]", PrettyDescriptor("[I"));
71 EXPECT_EQ("int[][]", PrettyDescriptor("[[I"));
72 EXPECT_EQ("long[]", PrettyDescriptor("[J"));
73 EXPECT_EQ("long[][]", PrettyDescriptor("[[J"));
74 EXPECT_EQ("short[]", PrettyDescriptor("[S"));
75 EXPECT_EQ("short[][]", PrettyDescriptor("[[S"));
76 }
77
TEST_F(UtilsTest,PrettyDescriptor_PrimitiveScalars)78 TEST_F(UtilsTest, PrettyDescriptor_PrimitiveScalars) {
79 EXPECT_EQ("boolean", PrettyDescriptor("Z"));
80 EXPECT_EQ("byte", PrettyDescriptor("B"));
81 EXPECT_EQ("char", PrettyDescriptor("C"));
82 EXPECT_EQ("double", PrettyDescriptor("D"));
83 EXPECT_EQ("float", PrettyDescriptor("F"));
84 EXPECT_EQ("int", PrettyDescriptor("I"));
85 EXPECT_EQ("long", PrettyDescriptor("J"));
86 EXPECT_EQ("short", PrettyDescriptor("S"));
87 }
88
TEST_F(UtilsTest,PrettyArguments)89 TEST_F(UtilsTest, PrettyArguments) {
90 EXPECT_EQ("()", PrettyArguments("()V"));
91 EXPECT_EQ("(int)", PrettyArguments("(I)V"));
92 EXPECT_EQ("(int, int)", PrettyArguments("(II)V"));
93 EXPECT_EQ("(int, int, int[][])", PrettyArguments("(II[[I)V"));
94 EXPECT_EQ("(int, int, int[][], java.lang.Poop)", PrettyArguments("(II[[ILjava/lang/Poop;)V"));
95 EXPECT_EQ("(int, int, int[][], java.lang.Poop, java.lang.Poop[][])", PrettyArguments("(II[[ILjava/lang/Poop;[[Ljava/lang/Poop;)V"));
96 }
97
TEST_F(UtilsTest,PrettyReturnType)98 TEST_F(UtilsTest, PrettyReturnType) {
99 EXPECT_EQ("void", PrettyReturnType("()V"));
100 EXPECT_EQ("int", PrettyReturnType("()I"));
101 EXPECT_EQ("int[][]", PrettyReturnType("()[[I"));
102 EXPECT_EQ("java.lang.Poop", PrettyReturnType("()Ljava/lang/Poop;"));
103 EXPECT_EQ("java.lang.Poop[][]", PrettyReturnType("()[[Ljava/lang/Poop;"));
104 }
105
TEST_F(UtilsTest,PrettyTypeOf)106 TEST_F(UtilsTest, PrettyTypeOf) {
107 ScopedObjectAccess soa(Thread::Current());
108 EXPECT_EQ("null", PrettyTypeOf(NULL));
109
110 StackHandleScope<2> hs(soa.Self());
111 Handle<mirror::String> s(hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "")));
112 EXPECT_EQ("java.lang.String", PrettyTypeOf(s.Get()));
113
114 Handle<mirror::ShortArray> a(hs.NewHandle(mirror::ShortArray::Alloc(soa.Self(), 2)));
115 EXPECT_EQ("short[]", PrettyTypeOf(a.Get()));
116
117 mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
118 ASSERT_TRUE(c != NULL);
119 mirror::Object* o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
120 EXPECT_EQ("java.lang.String[]", PrettyTypeOf(o));
121 EXPECT_EQ("java.lang.Class<java.lang.String[]>", PrettyTypeOf(o->GetClass()));
122 }
123
TEST_F(UtilsTest,PrettyClass)124 TEST_F(UtilsTest, PrettyClass) {
125 ScopedObjectAccess soa(Thread::Current());
126 EXPECT_EQ("null", PrettyClass(NULL));
127 mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
128 ASSERT_TRUE(c != NULL);
129 mirror::Object* o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
130 EXPECT_EQ("java.lang.Class<java.lang.String[]>", PrettyClass(o->GetClass()));
131 }
132
TEST_F(UtilsTest,PrettyClassAndClassLoader)133 TEST_F(UtilsTest, PrettyClassAndClassLoader) {
134 ScopedObjectAccess soa(Thread::Current());
135 EXPECT_EQ("null", PrettyClassAndClassLoader(NULL));
136 mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
137 ASSERT_TRUE(c != NULL);
138 mirror::Object* o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
139 EXPECT_EQ("java.lang.Class<java.lang.String[],null>", PrettyClassAndClassLoader(o->GetClass()));
140 }
141
TEST_F(UtilsTest,PrettyField)142 TEST_F(UtilsTest, PrettyField) {
143 ScopedObjectAccess soa(Thread::Current());
144 EXPECT_EQ("null", PrettyField(NULL));
145
146 mirror::Class* java_lang_String = class_linker_->FindSystemClass(soa.Self(),
147 "Ljava/lang/String;");
148
149 mirror::ArtField* f;
150 f = java_lang_String->FindDeclaredInstanceField("count", "I");
151 EXPECT_EQ("int java.lang.String.count", PrettyField(f));
152 EXPECT_EQ("java.lang.String.count", PrettyField(f, false));
153 f = java_lang_String->FindDeclaredInstanceField("value", "[C");
154 EXPECT_EQ("char[] java.lang.String.value", PrettyField(f));
155 EXPECT_EQ("java.lang.String.value", PrettyField(f, false));
156 }
157
TEST_F(UtilsTest,PrettySize)158 TEST_F(UtilsTest, PrettySize) {
159 EXPECT_EQ("1GB", PrettySize(1 * GB));
160 EXPECT_EQ("2GB", PrettySize(2 * GB));
161 if (sizeof(size_t) > sizeof(uint32_t)) {
162 EXPECT_EQ("100GB", PrettySize(100 * GB));
163 }
164 EXPECT_EQ("1024KB", PrettySize(1 * MB));
165 EXPECT_EQ("10MB", PrettySize(10 * MB));
166 EXPECT_EQ("100MB", PrettySize(100 * MB));
167 EXPECT_EQ("1024B", PrettySize(1 * KB));
168 EXPECT_EQ("10KB", PrettySize(10 * KB));
169 EXPECT_EQ("100KB", PrettySize(100 * KB));
170 EXPECT_EQ("0B", PrettySize(0));
171 EXPECT_EQ("1B", PrettySize(1));
172 EXPECT_EQ("10B", PrettySize(10));
173 EXPECT_EQ("100B", PrettySize(100));
174 EXPECT_EQ("512B", PrettySize(512));
175 }
176
TEST_F(UtilsTest,PrettyDuration)177 TEST_F(UtilsTest, PrettyDuration) {
178 const uint64_t one_sec = 1000000000;
179 const uint64_t one_ms = 1000000;
180 const uint64_t one_us = 1000;
181
182 EXPECT_EQ("1s", PrettyDuration(1 * one_sec));
183 EXPECT_EQ("10s", PrettyDuration(10 * one_sec));
184 EXPECT_EQ("100s", PrettyDuration(100 * one_sec));
185 EXPECT_EQ("1.001s", PrettyDuration(1 * one_sec + one_ms));
186 EXPECT_EQ("1.000001s", PrettyDuration(1 * one_sec + one_us, 6));
187 EXPECT_EQ("1.000000001s", PrettyDuration(1 * one_sec + 1, 9));
188 EXPECT_EQ("1.000s", PrettyDuration(1 * one_sec + one_us, 3));
189
190 EXPECT_EQ("1ms", PrettyDuration(1 * one_ms));
191 EXPECT_EQ("10ms", PrettyDuration(10 * one_ms));
192 EXPECT_EQ("100ms", PrettyDuration(100 * one_ms));
193 EXPECT_EQ("1.001ms", PrettyDuration(1 * one_ms + one_us));
194 EXPECT_EQ("1.000001ms", PrettyDuration(1 * one_ms + 1, 6));
195
196 EXPECT_EQ("1us", PrettyDuration(1 * one_us));
197 EXPECT_EQ("10us", PrettyDuration(10 * one_us));
198 EXPECT_EQ("100us", PrettyDuration(100 * one_us));
199 EXPECT_EQ("1.001us", PrettyDuration(1 * one_us + 1));
200
201 EXPECT_EQ("1ns", PrettyDuration(1));
202 EXPECT_EQ("10ns", PrettyDuration(10));
203 EXPECT_EQ("100ns", PrettyDuration(100));
204 }
205
TEST_F(UtilsTest,MangleForJni)206 TEST_F(UtilsTest, MangleForJni) {
207 ScopedObjectAccess soa(Thread::Current());
208 EXPECT_EQ("hello_00024world", MangleForJni("hello$world"));
209 EXPECT_EQ("hello_000a9world", MangleForJni("hello\xc2\xa9world"));
210 EXPECT_EQ("hello_1world", MangleForJni("hello_world"));
211 EXPECT_EQ("Ljava_lang_String_2", MangleForJni("Ljava/lang/String;"));
212 EXPECT_EQ("_3C", MangleForJni("[C"));
213 }
214
TEST_F(UtilsTest,JniShortName_JniLongName)215 TEST_F(UtilsTest, JniShortName_JniLongName) {
216 ScopedObjectAccess soa(Thread::Current());
217 mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/String;");
218 ASSERT_TRUE(c != NULL);
219 mirror::ArtMethod* m;
220
221 m = c->FindVirtualMethod("charAt", "(I)C");
222 ASSERT_TRUE(m != NULL);
223 EXPECT_EQ("Java_java_lang_String_charAt", JniShortName(m));
224 EXPECT_EQ("Java_java_lang_String_charAt__I", JniLongName(m));
225
226 m = c->FindVirtualMethod("indexOf", "(Ljava/lang/String;I)I");
227 ASSERT_TRUE(m != NULL);
228 EXPECT_EQ("Java_java_lang_String_indexOf", JniShortName(m));
229 EXPECT_EQ("Java_java_lang_String_indexOf__Ljava_lang_String_2I", JniLongName(m));
230
231 m = c->FindDirectMethod("copyValueOf", "([CII)Ljava/lang/String;");
232 ASSERT_TRUE(m != NULL);
233 EXPECT_EQ("Java_java_lang_String_copyValueOf", JniShortName(m));
234 EXPECT_EQ("Java_java_lang_String_copyValueOf___3CII", JniLongName(m));
235 }
236
TEST_F(UtilsTest,Split)237 TEST_F(UtilsTest, Split) {
238 std::vector<std::string> actual;
239 std::vector<std::string> expected;
240
241 expected.clear();
242
243 actual.clear();
244 Split("", ':', actual);
245 EXPECT_EQ(expected, actual);
246
247 actual.clear();
248 Split(":", ':', actual);
249 EXPECT_EQ(expected, actual);
250
251 expected.clear();
252 expected.push_back("foo");
253
254 actual.clear();
255 Split(":foo", ':', actual);
256 EXPECT_EQ(expected, actual);
257
258 actual.clear();
259 Split("foo:", ':', actual);
260 EXPECT_EQ(expected, actual);
261
262 actual.clear();
263 Split(":foo:", ':', actual);
264 EXPECT_EQ(expected, actual);
265
266 expected.push_back("bar");
267
268 actual.clear();
269 Split("foo:bar", ':', actual);
270 EXPECT_EQ(expected, actual);
271
272 actual.clear();
273 Split(":foo:bar", ':', actual);
274 EXPECT_EQ(expected, actual);
275
276 actual.clear();
277 Split("foo:bar:", ':', actual);
278 EXPECT_EQ(expected, actual);
279
280 actual.clear();
281 Split(":foo:bar:", ':', actual);
282 EXPECT_EQ(expected, actual);
283
284 expected.push_back("baz");
285
286 actual.clear();
287 Split("foo:bar:baz", ':', actual);
288 EXPECT_EQ(expected, actual);
289
290 actual.clear();
291 Split(":foo:bar:baz", ':', actual);
292 EXPECT_EQ(expected, actual);
293
294 actual.clear();
295 Split("foo:bar:baz:", ':', actual);
296 EXPECT_EQ(expected, actual);
297
298 actual.clear();
299 Split(":foo:bar:baz:", ':', actual);
300 EXPECT_EQ(expected, actual);
301 }
302
TEST_F(UtilsTest,Join)303 TEST_F(UtilsTest, Join) {
304 std::vector<std::string> strings;
305
306 strings.clear();
307 EXPECT_EQ("", Join(strings, ':'));
308
309 strings.clear();
310 strings.push_back("foo");
311 EXPECT_EQ("foo", Join(strings, ':'));
312
313 strings.clear();
314 strings.push_back("");
315 strings.push_back("foo");
316 EXPECT_EQ(":foo", Join(strings, ':'));
317
318 strings.clear();
319 strings.push_back("foo");
320 strings.push_back("");
321 EXPECT_EQ("foo:", Join(strings, ':'));
322
323 strings.clear();
324 strings.push_back("");
325 strings.push_back("foo");
326 strings.push_back("");
327 EXPECT_EQ(":foo:", Join(strings, ':'));
328
329 strings.clear();
330 strings.push_back("foo");
331 strings.push_back("bar");
332 EXPECT_EQ("foo:bar", Join(strings, ':'));
333
334 strings.clear();
335 strings.push_back("foo");
336 strings.push_back("bar");
337 strings.push_back("baz");
338 EXPECT_EQ("foo:bar:baz", Join(strings, ':'));
339 }
340
TEST_F(UtilsTest,StartsWith)341 TEST_F(UtilsTest, StartsWith) {
342 EXPECT_FALSE(StartsWith("foo", "bar"));
343 EXPECT_TRUE(StartsWith("foo", "foo"));
344 EXPECT_TRUE(StartsWith("food", "foo"));
345 EXPECT_FALSE(StartsWith("fo", "foo"));
346 }
347
TEST_F(UtilsTest,EndsWith)348 TEST_F(UtilsTest, EndsWith) {
349 EXPECT_FALSE(EndsWith("foo", "bar"));
350 EXPECT_TRUE(EndsWith("foo", "foo"));
351 EXPECT_TRUE(EndsWith("foofoo", "foo"));
352 EXPECT_FALSE(EndsWith("oo", "foo"));
353 }
354
TEST_F(UtilsTest,GetDalvikCacheFilenameOrDie)355 TEST_F(UtilsTest, GetDalvikCacheFilenameOrDie) {
356 EXPECT_STREQ("/foo/system@app@Foo.apk@classes.dex",
357 GetDalvikCacheFilenameOrDie("/system/app/Foo.apk", "/foo").c_str());
358
359 EXPECT_STREQ("/foo/data@app@foo-1.apk@classes.dex",
360 GetDalvikCacheFilenameOrDie("/data/app/foo-1.apk", "/foo").c_str());
361 EXPECT_STREQ("/foo/system@framework@core.jar@classes.dex",
362 GetDalvikCacheFilenameOrDie("/system/framework/core.jar", "/foo").c_str());
363 EXPECT_STREQ("/foo/system@framework@boot.art",
364 GetDalvikCacheFilenameOrDie("/system/framework/boot.art", "/foo").c_str());
365 EXPECT_STREQ("/foo/system@framework@boot.oat",
366 GetDalvikCacheFilenameOrDie("/system/framework/boot.oat", "/foo").c_str());
367 }
368
TEST_F(UtilsTest,GetSystemImageFilename)369 TEST_F(UtilsTest, GetSystemImageFilename) {
370 EXPECT_STREQ("/system/framework/arm/boot.art",
371 GetSystemImageFilename("/system/framework/boot.art", kArm).c_str());
372 }
373
TEST_F(UtilsTest,DexFilenameToOdexFilename)374 TEST_F(UtilsTest, DexFilenameToOdexFilename) {
375 EXPECT_STREQ("/foo/bar/arm/baz.odex",
376 DexFilenameToOdexFilename("/foo/bar/baz.jar", kArm).c_str());
377 }
378
TEST_F(UtilsTest,ExecSuccess)379 TEST_F(UtilsTest, ExecSuccess) {
380 std::vector<std::string> command;
381 if (kIsTargetBuild) {
382 command.push_back("/system/bin/id");
383 } else {
384 command.push_back("/usr/bin/id");
385 }
386 std::string error_msg;
387 if (RUNNING_ON_VALGRIND == 0) {
388 // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks.
389 EXPECT_TRUE(Exec(command, &error_msg));
390 }
391 EXPECT_EQ(0U, error_msg.size()) << error_msg;
392 }
393
TEST_F(UtilsTest,ExecError)394 TEST_F(UtilsTest, ExecError) {
395 std::vector<std::string> command;
396 command.push_back("bogus");
397 std::string error_msg;
398 if (RUNNING_ON_VALGRIND == 0) {
399 // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks.
400 EXPECT_FALSE(Exec(command, &error_msg));
401 EXPECT_NE(0U, error_msg.size());
402 }
403 }
404
TEST_F(UtilsTest,RoundUpToPowerOfTwo)405 TEST_F(UtilsTest, RoundUpToPowerOfTwo) {
406 // Tests the constexpr variant since all the parameters are constexpr
407 EXPECT_EQ(0, RoundUpToPowerOfTwo(0));
408 EXPECT_EQ(1, RoundUpToPowerOfTwo(1));
409 EXPECT_EQ(2, RoundUpToPowerOfTwo(2));
410 EXPECT_EQ(4, RoundUpToPowerOfTwo(3));
411 EXPECT_EQ(8, RoundUpToPowerOfTwo(7));
412
413 EXPECT_EQ(0b10000L, RoundUpToPowerOfTwo(0b01101L));
414 EXPECT_EQ(1ULL << 63, RoundUpToPowerOfTwo(1ULL << 62 | 1ULL));
415 }
416
TEST_F(UtilsTest,MostSignificantBit)417 TEST_F(UtilsTest, MostSignificantBit) {
418 EXPECT_EQ(-1, MostSignificantBit(0));
419 EXPECT_EQ(0, MostSignificantBit(1));
420 EXPECT_EQ(31, MostSignificantBit(~static_cast<uint32_t>(0)));
421 EXPECT_EQ(2, MostSignificantBit(0b110));
422 EXPECT_EQ(2, MostSignificantBit(0b100));
423 }
424
TEST_F(UtilsTest,MinimumBitsToStore)425 TEST_F(UtilsTest, MinimumBitsToStore) {
426 EXPECT_EQ(0u, MinimumBitsToStore(0));
427 EXPECT_EQ(1u, MinimumBitsToStore(1));
428 EXPECT_EQ(2u, MinimumBitsToStore(0b10));
429 EXPECT_EQ(2u, MinimumBitsToStore(0b11));
430 EXPECT_EQ(3u, MinimumBitsToStore(0b100));
431 EXPECT_EQ(3u, MinimumBitsToStore(0b110));
432 EXPECT_EQ(3u, MinimumBitsToStore(0b101));
433 EXPECT_EQ(8u, MinimumBitsToStore(0xFF));
434 EXPECT_EQ(32u, MinimumBitsToStore(~static_cast<uint32_t>(0)));
435 }
436
437 } // namespace art
438