runtime/utils_test.cc

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