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 "class_linker-inl.h"
20#include "common_runtime_test.h"
21#include "mirror/array.h"
22#include "mirror/array-inl.h"
23#include "mirror/object-inl.h"
24#include "mirror/object_array-inl.h"
25#include "mirror/string.h"
26#include "scoped_thread_state_change.h"
27#include "handle_scope-inl.h"
28
29#include "base/memory_tool.h"
30
31namespace art {
32
33std::string PrettyArguments(const char* signature);
34std::string PrettyReturnType(const char* signature);
35
36class UtilsTest : public CommonRuntimeTest {};
37
38TEST_F(UtilsTest, PrettyDescriptor_ArrayReferences) {
39  EXPECT_EQ("java.lang.Class[]", PrettyDescriptor("[Ljava/lang/Class;"));
40  EXPECT_EQ("java.lang.Class[][]", PrettyDescriptor("[[Ljava/lang/Class;"));
41}
42
43TEST_F(UtilsTest, PrettyDescriptor_ScalarReferences) {
44  EXPECT_EQ("java.lang.String", PrettyDescriptor("Ljava.lang.String;"));
45  EXPECT_EQ("java.lang.String", PrettyDescriptor("Ljava/lang/String;"));
46}
47
48TEST_F(UtilsTest, PrettyDescriptor_Primitive) {
49  EXPECT_EQ("boolean", PrettyDescriptor(Primitive::kPrimBoolean));
50  EXPECT_EQ("byte", PrettyDescriptor(Primitive::kPrimByte));
51  EXPECT_EQ("char", PrettyDescriptor(Primitive::kPrimChar));
52  EXPECT_EQ("short", PrettyDescriptor(Primitive::kPrimShort));
53  EXPECT_EQ("int", PrettyDescriptor(Primitive::kPrimInt));
54  EXPECT_EQ("float", PrettyDescriptor(Primitive::kPrimFloat));
55  EXPECT_EQ("long", PrettyDescriptor(Primitive::kPrimLong));
56  EXPECT_EQ("double", PrettyDescriptor(Primitive::kPrimDouble));
57  EXPECT_EQ("void", PrettyDescriptor(Primitive::kPrimVoid));
58}
59
60TEST_F(UtilsTest, PrettyDescriptor_PrimitiveArrays) {
61  EXPECT_EQ("boolean[]", PrettyDescriptor("[Z"));
62  EXPECT_EQ("boolean[][]", PrettyDescriptor("[[Z"));
63  EXPECT_EQ("byte[]", PrettyDescriptor("[B"));
64  EXPECT_EQ("byte[][]", PrettyDescriptor("[[B"));
65  EXPECT_EQ("char[]", PrettyDescriptor("[C"));
66  EXPECT_EQ("char[][]", PrettyDescriptor("[[C"));
67  EXPECT_EQ("double[]", PrettyDescriptor("[D"));
68  EXPECT_EQ("double[][]", PrettyDescriptor("[[D"));
69  EXPECT_EQ("float[]", PrettyDescriptor("[F"));
70  EXPECT_EQ("float[][]", PrettyDescriptor("[[F"));
71  EXPECT_EQ("int[]", PrettyDescriptor("[I"));
72  EXPECT_EQ("int[][]", PrettyDescriptor("[[I"));
73  EXPECT_EQ("long[]", PrettyDescriptor("[J"));
74  EXPECT_EQ("long[][]", PrettyDescriptor("[[J"));
75  EXPECT_EQ("short[]", PrettyDescriptor("[S"));
76  EXPECT_EQ("short[][]", PrettyDescriptor("[[S"));
77}
78
79TEST_F(UtilsTest, PrettyDescriptor_PrimitiveScalars) {
80  EXPECT_EQ("boolean", PrettyDescriptor("Z"));
81  EXPECT_EQ("byte", PrettyDescriptor("B"));
82  EXPECT_EQ("char", PrettyDescriptor("C"));
83  EXPECT_EQ("double", PrettyDescriptor("D"));
84  EXPECT_EQ("float", PrettyDescriptor("F"));
85  EXPECT_EQ("int", PrettyDescriptor("I"));
86  EXPECT_EQ("long", PrettyDescriptor("J"));
87  EXPECT_EQ("short", PrettyDescriptor("S"));
88}
89
90TEST_F(UtilsTest, PrettyArguments) {
91  EXPECT_EQ("()", PrettyArguments("()V"));
92  EXPECT_EQ("(int)", PrettyArguments("(I)V"));
93  EXPECT_EQ("(int, int)", PrettyArguments("(II)V"));
94  EXPECT_EQ("(int, int, int[][])", PrettyArguments("(II[[I)V"));
95  EXPECT_EQ("(int, int, int[][], java.lang.Poop)", PrettyArguments("(II[[ILjava/lang/Poop;)V"));
96  EXPECT_EQ("(int, int, int[][], java.lang.Poop, java.lang.Poop[][])", PrettyArguments("(II[[ILjava/lang/Poop;[[Ljava/lang/Poop;)V"));
97}
98
99TEST_F(UtilsTest, PrettyReturnType) {
100  EXPECT_EQ("void", PrettyReturnType("()V"));
101  EXPECT_EQ("int", PrettyReturnType("()I"));
102  EXPECT_EQ("int[][]", PrettyReturnType("()[[I"));
103  EXPECT_EQ("java.lang.Poop", PrettyReturnType("()Ljava/lang/Poop;"));
104  EXPECT_EQ("java.lang.Poop[][]", PrettyReturnType("()[[Ljava/lang/Poop;"));
105}
106
107TEST_F(UtilsTest, PrettyTypeOf) {
108  ScopedObjectAccess soa(Thread::Current());
109  EXPECT_EQ("null", PrettyTypeOf(nullptr));
110
111  StackHandleScope<2> hs(soa.Self());
112  Handle<mirror::String> s(hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "")));
113  EXPECT_EQ("java.lang.String", PrettyTypeOf(s.Get()));
114
115  Handle<mirror::ShortArray> a(hs.NewHandle(mirror::ShortArray::Alloc(soa.Self(), 2)));
116  EXPECT_EQ("short[]", PrettyTypeOf(a.Get()));
117
118  mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
119  ASSERT_TRUE(c != nullptr);
120  mirror::Object* o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
121  EXPECT_EQ("java.lang.String[]", PrettyTypeOf(o));
122  EXPECT_EQ("java.lang.Class<java.lang.String[]>", PrettyTypeOf(o->GetClass()));
123}
124
125TEST_F(UtilsTest, PrettyClass) {
126  ScopedObjectAccess soa(Thread::Current());
127  EXPECT_EQ("null", PrettyClass(nullptr));
128  mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
129  ASSERT_TRUE(c != nullptr);
130  mirror::Object* o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
131  EXPECT_EQ("java.lang.Class<java.lang.String[]>", PrettyClass(o->GetClass()));
132}
133
134TEST_F(UtilsTest, PrettyClassAndClassLoader) {
135  ScopedObjectAccess soa(Thread::Current());
136  EXPECT_EQ("null", PrettyClassAndClassLoader(nullptr));
137  mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
138  ASSERT_TRUE(c != nullptr);
139  mirror::Object* o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
140  EXPECT_EQ("java.lang.Class<java.lang.String[],null>", PrettyClassAndClassLoader(o->GetClass()));
141}
142
143TEST_F(UtilsTest, PrettyField) {
144  ScopedObjectAccess soa(Thread::Current());
145  EXPECT_EQ("null", PrettyField(nullptr));
146
147  mirror::Class* java_lang_String = class_linker_->FindSystemClass(soa.Self(),
148                                                                   "Ljava/lang/String;");
149
150  ArtField* f;
151  f = java_lang_String->FindDeclaredInstanceField("count", "I");
152  EXPECT_EQ("int java.lang.String.count", PrettyField(f));
153  EXPECT_EQ("java.lang.String.count", PrettyField(f, false));
154}
155
156TEST_F(UtilsTest, PrettySize) {
157  EXPECT_EQ("1GB", PrettySize(1 * GB));
158  EXPECT_EQ("2GB", PrettySize(2 * GB));
159  if (sizeof(size_t) > sizeof(uint32_t)) {
160    EXPECT_EQ("100GB", PrettySize(100 * GB));
161  }
162  EXPECT_EQ("1024KB", PrettySize(1 * MB));
163  EXPECT_EQ("10MB", PrettySize(10 * MB));
164  EXPECT_EQ("100MB", PrettySize(100 * MB));
165  EXPECT_EQ("1024B", PrettySize(1 * KB));
166  EXPECT_EQ("10KB", PrettySize(10 * KB));
167  EXPECT_EQ("100KB", PrettySize(100 * KB));
168  EXPECT_EQ("0B", PrettySize(0));
169  EXPECT_EQ("1B", PrettySize(1));
170  EXPECT_EQ("10B", PrettySize(10));
171  EXPECT_EQ("100B", PrettySize(100));
172  EXPECT_EQ("512B", PrettySize(512));
173}
174
175TEST_F(UtilsTest, MangleForJni) {
176  ScopedObjectAccess soa(Thread::Current());
177  EXPECT_EQ("hello_00024world", MangleForJni("hello$world"));
178  EXPECT_EQ("hello_000a9world", MangleForJni("hello\xc2\xa9world"));
179  EXPECT_EQ("hello_1world", MangleForJni("hello_world"));
180  EXPECT_EQ("Ljava_lang_String_2", MangleForJni("Ljava/lang/String;"));
181  EXPECT_EQ("_3C", MangleForJni("[C"));
182}
183
184TEST_F(UtilsTest, JniShortName_JniLongName) {
185  ScopedObjectAccess soa(Thread::Current());
186  mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/String;");
187  ASSERT_TRUE(c != nullptr);
188  ArtMethod* m;
189
190  m = c->FindVirtualMethod("charAt", "(I)C", sizeof(void*));
191  ASSERT_TRUE(m != nullptr);
192  EXPECT_EQ("Java_java_lang_String_charAt", JniShortName(m));
193  EXPECT_EQ("Java_java_lang_String_charAt__I", JniLongName(m));
194
195  m = c->FindVirtualMethod("indexOf", "(Ljava/lang/String;I)I", sizeof(void*));
196  ASSERT_TRUE(m != nullptr);
197  EXPECT_EQ("Java_java_lang_String_indexOf", JniShortName(m));
198  EXPECT_EQ("Java_java_lang_String_indexOf__Ljava_lang_String_2I", JniLongName(m));
199
200  m = c->FindDirectMethod("copyValueOf", "([CII)Ljava/lang/String;", sizeof(void*));
201  ASSERT_TRUE(m != nullptr);
202  EXPECT_EQ("Java_java_lang_String_copyValueOf", JniShortName(m));
203  EXPECT_EQ("Java_java_lang_String_copyValueOf___3CII", JniLongName(m));
204}
205
206TEST_F(UtilsTest, Split) {
207  std::vector<std::string> actual;
208  std::vector<std::string> expected;
209
210  expected.clear();
211
212  actual.clear();
213  Split("", ':', &actual);
214  EXPECT_EQ(expected, actual);
215
216  actual.clear();
217  Split(":", ':', &actual);
218  EXPECT_EQ(expected, actual);
219
220  expected.clear();
221  expected.push_back("foo");
222
223  actual.clear();
224  Split(":foo", ':', &actual);
225  EXPECT_EQ(expected, actual);
226
227  actual.clear();
228  Split("foo:", ':', &actual);
229  EXPECT_EQ(expected, actual);
230
231  actual.clear();
232  Split(":foo:", ':', &actual);
233  EXPECT_EQ(expected, actual);
234
235  expected.push_back("bar");
236
237  actual.clear();
238  Split("foo:bar", ':', &actual);
239  EXPECT_EQ(expected, actual);
240
241  actual.clear();
242  Split(":foo:bar", ':', &actual);
243  EXPECT_EQ(expected, actual);
244
245  actual.clear();
246  Split("foo:bar:", ':', &actual);
247  EXPECT_EQ(expected, actual);
248
249  actual.clear();
250  Split(":foo:bar:", ':', &actual);
251  EXPECT_EQ(expected, actual);
252
253  expected.push_back("baz");
254
255  actual.clear();
256  Split("foo:bar:baz", ':', &actual);
257  EXPECT_EQ(expected, actual);
258
259  actual.clear();
260  Split(":foo:bar:baz", ':', &actual);
261  EXPECT_EQ(expected, actual);
262
263  actual.clear();
264  Split("foo:bar:baz:", ':', &actual);
265  EXPECT_EQ(expected, actual);
266
267  actual.clear();
268  Split(":foo:bar:baz:", ':', &actual);
269  EXPECT_EQ(expected, actual);
270}
271
272TEST_F(UtilsTest, Join) {
273  std::vector<std::string> strings;
274
275  strings.clear();
276  EXPECT_EQ("", Join(strings, ':'));
277
278  strings.clear();
279  strings.push_back("foo");
280  EXPECT_EQ("foo", Join(strings, ':'));
281
282  strings.clear();
283  strings.push_back("");
284  strings.push_back("foo");
285  EXPECT_EQ(":foo", Join(strings, ':'));
286
287  strings.clear();
288  strings.push_back("foo");
289  strings.push_back("");
290  EXPECT_EQ("foo:", Join(strings, ':'));
291
292  strings.clear();
293  strings.push_back("");
294  strings.push_back("foo");
295  strings.push_back("");
296  EXPECT_EQ(":foo:", Join(strings, ':'));
297
298  strings.clear();
299  strings.push_back("foo");
300  strings.push_back("bar");
301  EXPECT_EQ("foo:bar", Join(strings, ':'));
302
303  strings.clear();
304  strings.push_back("foo");
305  strings.push_back("bar");
306  strings.push_back("baz");
307  EXPECT_EQ("foo:bar:baz", Join(strings, ':'));
308}
309
310TEST_F(UtilsTest, StartsWith) {
311  EXPECT_FALSE(StartsWith("foo", "bar"));
312  EXPECT_TRUE(StartsWith("foo", "foo"));
313  EXPECT_TRUE(StartsWith("food", "foo"));
314  EXPECT_FALSE(StartsWith("fo", "foo"));
315}
316
317TEST_F(UtilsTest, EndsWith) {
318  EXPECT_FALSE(EndsWith("foo", "bar"));
319  EXPECT_TRUE(EndsWith("foo", "foo"));
320  EXPECT_TRUE(EndsWith("foofoo", "foo"));
321  EXPECT_FALSE(EndsWith("oo", "foo"));
322}
323
324TEST_F(UtilsTest, GetDalvikCacheFilenameOrDie) {
325  EXPECT_STREQ("/foo/system@app@Foo.apk@classes.dex",
326               GetDalvikCacheFilenameOrDie("/system/app/Foo.apk", "/foo").c_str());
327
328  EXPECT_STREQ("/foo/data@app@foo-1.apk@classes.dex",
329               GetDalvikCacheFilenameOrDie("/data/app/foo-1.apk", "/foo").c_str());
330  EXPECT_STREQ("/foo/system@framework@core.jar@classes.dex",
331               GetDalvikCacheFilenameOrDie("/system/framework/core.jar", "/foo").c_str());
332  EXPECT_STREQ("/foo/system@framework@boot.art",
333               GetDalvikCacheFilenameOrDie("/system/framework/boot.art", "/foo").c_str());
334  EXPECT_STREQ("/foo/system@framework@boot.oat",
335               GetDalvikCacheFilenameOrDie("/system/framework/boot.oat", "/foo").c_str());
336}
337
338TEST_F(UtilsTest, GetDalvikCache) {
339  EXPECT_STREQ("", GetDalvikCache("should-not-exist123", false).c_str());
340
341  EXPECT_STREQ((android_data_ + "/dalvik-cache/.").c_str(), GetDalvikCache(".", false).c_str());
342  EXPECT_STREQ((android_data_ + "/dalvik-cache/should-not-be-there").c_str(),
343               GetDalvikCache("should-not-be-there", true).c_str());
344}
345
346
347TEST_F(UtilsTest, GetSystemImageFilename) {
348  EXPECT_STREQ("/system/framework/arm/boot.art",
349               GetSystemImageFilename("/system/framework/boot.art", kArm).c_str());
350}
351
352TEST_F(UtilsTest, ExecSuccess) {
353  std::vector<std::string> command;
354  if (kIsTargetBuild) {
355    std::string android_root(GetAndroidRoot());
356    command.push_back(android_root + "/bin/id");
357  } else {
358    command.push_back("/usr/bin/id");
359  }
360  std::string error_msg;
361  if (!(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) {
362    // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks.
363    EXPECT_TRUE(Exec(command, &error_msg));
364  }
365  EXPECT_EQ(0U, error_msg.size()) << error_msg;
366}
367
368TEST_F(UtilsTest, ExecError) {
369  // This will lead to error messages in the log.
370  ScopedLogSeverity sls(LogSeverity::FATAL);
371
372  std::vector<std::string> command;
373  command.push_back("bogus");
374  std::string error_msg;
375  if (!(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) {
376    // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks.
377    EXPECT_FALSE(Exec(command, &error_msg));
378    EXPECT_NE(0U, error_msg.size());
379  }
380}
381
382TEST_F(UtilsTest, IsValidDescriptor) {
383  std::vector<uint8_t> descriptor(
384      { 'L', 'a', '/', 'b', '$', 0xed, 0xa0, 0x80, 0xed, 0xb0, 0x80, ';', 0x00 });
385  EXPECT_TRUE(IsValidDescriptor(reinterpret_cast<char*>(&descriptor[0])));
386
387  std::vector<uint8_t> unpaired_surrogate(
388      { 'L', 'a', '/', 'b', '$', 0xed, 0xa0, 0x80, ';', 0x00 });
389  EXPECT_FALSE(IsValidDescriptor(reinterpret_cast<char*>(&unpaired_surrogate[0])));
390
391  std::vector<uint8_t> unpaired_surrogate_at_end(
392      { 'L', 'a', '/', 'b', '$', 0xed, 0xa0, 0x80, 0x00 });
393  EXPECT_FALSE(IsValidDescriptor(reinterpret_cast<char*>(&unpaired_surrogate_at_end[0])));
394
395  std::vector<uint8_t> invalid_surrogate(
396      { 'L', 'a', '/', 'b', '$', 0xed, 0xb0, 0x80, ';', 0x00 });
397  EXPECT_FALSE(IsValidDescriptor(reinterpret_cast<char*>(&invalid_surrogate[0])));
398
399  std::vector<uint8_t> unpaired_surrogate_with_multibyte_sequence(
400      { 'L', 'a', '/', 'b', '$', 0xed, 0xb0, 0x80, 0xf0, 0x9f, 0x8f, 0xa0, ';', 0x00 });
401  EXPECT_FALSE(
402      IsValidDescriptor(reinterpret_cast<char*>(&unpaired_surrogate_with_multibyte_sequence[0])));
403}
404
405}  // namespace art
406