Remove duplication, split tests
The code move to libdexfile/dex/descriptors_names.cc apparently did not
remove the original code from runtime/utils.cc. Fix that duplication
and all the header mentions needed. Also, split the test files to go
along with the new locations for the code to be tested.
Bug: 22322814
Test: make -j 50 checkbuild
make -j 50 test-art-host-gtest
flash & boot marlin
Change-Id: Ie734672c4bca2c647d8016291f910b5608674545
diff --git a/runtime/Android.bp b/runtime/Android.bp
index 1ac770f..86cdc8b 100644
--- a/runtime/Android.bp
+++ b/runtime/Android.bp
@@ -544,6 +544,7 @@
"base/bit_struct_test.cc",
"base/bit_utils_test.cc",
"base/bit_vector_test.cc",
+ "base/file_utils_test.cc",
"base/hash_set_test.cc",
"base/hex_dump_test.cc",
"base/histogram_test.cc",
@@ -566,6 +567,7 @@
"entrypoints/math_entrypoints_test.cc",
"entrypoints/quick/quick_trampoline_entrypoints_test.cc",
"entrypoints_order_test.cc",
+ "exec_utils_test.cc",
"gc/accounting/card_table_test.cc",
"gc/accounting/mod_union_table_test.cc",
"gc/accounting/space_bitmap_test.cc",
diff --git a/runtime/art_field.cc b/runtime/art_field.cc
index dbba2b0..3f70958 100644
--- a/runtime/art_field.cc
+++ b/runtime/art_field.cc
@@ -18,6 +18,7 @@
#include "art_field-inl.h"
#include "class_linker-inl.h"
+#include "dex/descriptors_names.h"
#include "gc/accounting/card_table-inl.h"
#include "handle_scope.h"
#include "mirror/class-inl.h"
diff --git a/runtime/art_method.cc b/runtime/art_method.cc
index efdf599..bbc6007 100644
--- a/runtime/art_method.cc
+++ b/runtime/art_method.cc
@@ -25,6 +25,7 @@
#include "base/stringpiece.h"
#include "class_linker-inl.h"
#include "debugger.h"
+#include "dex/descriptors_names.h"
#include "dex/dex_file-inl.h"
#include "dex/dex_file_exception_helpers.h"
#include "dex/dex_instruction.h"
diff --git a/runtime/base/file_magic.cc b/runtime/base/file_magic.cc
index e668699..2b9bed0 100644
--- a/runtime/base/file_magic.cc
+++ b/runtime/base/file_magic.cc
@@ -24,7 +24,6 @@
#include <android-base/stringprintf.h>
#include "base/unix_file/fd_file.h"
-#include "dex/dex_file.h"
namespace art {
diff --git a/runtime/base/file_utils.cc b/runtime/base/file_utils.cc
index 58990f3..dd3f8d5 100644
--- a/runtime/base/file_utils.cc
+++ b/runtime/base/file_utils.cc
@@ -45,15 +45,12 @@
#include "android-base/stringprintf.h"
#include "android-base/strings.h"
+#include "base/bit_utils.h"
#include "base/stl_util.h"
#include "base/unix_file/fd_file.h"
-#include "dex/dex_file-inl.h"
#include "dex/dex_file_loader.h"
-#include "dex/dex_instruction.h"
-#include "dex/utf-inl.h"
-#include "oat_quick_method_header.h"
+#include "globals.h"
#include "os.h"
-#include "scoped_thread_state_change-inl.h"
#if defined(__APPLE__)
#include <crt_externs.h>
diff --git a/runtime/base/file_utils_test.cc b/runtime/base/file_utils_test.cc
new file mode 100644
index 0000000..cf6e34d
--- /dev/null
+++ b/runtime/base/file_utils_test.cc
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "base/file_utils.h"
+
+#include <libgen.h>
+#include <stdlib.h>
+
+#include "base/stl_util.h"
+#include "common_runtime_test.h"
+
+namespace art {
+
+class FileUtilsTest : public CommonRuntimeTest {};
+
+TEST_F(FileUtilsTest, GetDalvikCacheFilename) {
+ std::string name;
+ std::string error;
+
+ EXPECT_TRUE(GetDalvikCacheFilename("/system/app/Foo.apk", "/foo", &name, &error)) << error;
+ EXPECT_EQ("/foo/system@app@Foo.apk@classes.dex", name);
+
+ EXPECT_TRUE(GetDalvikCacheFilename("/data/app/foo-1.apk", "/foo", &name, &error)) << error;
+ EXPECT_EQ("/foo/data@app@foo-1.apk@classes.dex", name);
+
+ EXPECT_TRUE(GetDalvikCacheFilename("/system/framework/core.jar", "/foo", &name, &error)) << error;
+ EXPECT_EQ("/foo/system@framework@core.jar@classes.dex", name);
+
+ EXPECT_TRUE(GetDalvikCacheFilename("/system/framework/boot.art", "/foo", &name, &error)) << error;
+ EXPECT_EQ("/foo/system@framework@boot.art", name);
+
+ EXPECT_TRUE(GetDalvikCacheFilename("/system/framework/boot.oat", "/foo", &name, &error)) << error;
+ EXPECT_EQ("/foo/system@framework@boot.oat", name);
+}
+
+TEST_F(FileUtilsTest, GetDalvikCache) {
+ EXPECT_STREQ("", GetDalvikCache("should-not-exist123").c_str());
+
+ EXPECT_STREQ((android_data_ + "/dalvik-cache/.").c_str(), GetDalvikCache(".").c_str());
+}
+
+
+TEST_F(FileUtilsTest, GetSystemImageFilename) {
+ EXPECT_STREQ("/system/framework/arm/boot.art",
+ GetSystemImageFilename("/system/framework/boot.art", InstructionSet::kArm).c_str());
+}
+
+TEST_F(FileUtilsTest, GetAndroidRootSafe) {
+ std::string error_msg;
+
+ // We don't expect null returns for most cases, so don't check and let std::string crash.
+
+ // CommonRuntimeTest sets ANDROID_ROOT, so expect this to be the same.
+ std::string android_root = GetAndroidRootSafe(&error_msg);
+ std::string android_root_env = getenv("ANDROID_ROOT");
+ EXPECT_EQ(android_root, android_root_env);
+
+ // Set ANDROID_ROOT to something else (but the directory must exist). So use dirname.
+ char* root_dup = strdup(android_root_env.c_str());
+ char* dir = dirname(root_dup);
+ ASSERT_EQ(0, setenv("ANDROID_ROOT", dir, 1 /* overwrite */));
+ std::string android_root2 = GetAndroidRootSafe(&error_msg);
+ EXPECT_STREQ(dir, android_root2.c_str());
+ free(root_dup);
+
+ // Set a bogus value for ANDROID_ROOT. This should be an error.
+ ASSERT_EQ(0, setenv("ANDROID_ROOT", "/this/is/obviously/bogus", 1 /* overwrite */));
+ EXPECT_TRUE(GetAndroidRootSafe(&error_msg) == nullptr);
+
+ // Unset ANDROID_ROOT and see that it still returns something (as libart code is running).
+ ASSERT_EQ(0, unsetenv("ANDROID_ROOT"));
+ std::string android_root3 = GetAndroidRootSafe(&error_msg);
+ // This should be the same as the other root (modulo realpath), otherwise the test setup is
+ // broken.
+ UniqueCPtr<char> real_root(realpath(android_root.c_str(), nullptr));
+ UniqueCPtr<char> real_root3(realpath(android_root3.c_str(), nullptr));
+ EXPECT_STREQ(real_root.get(), real_root3.get());
+
+
+ // Reset ANDROID_ROOT, as other things may depend on it.
+ ASSERT_EQ(0, setenv("ANDROID_ROOT", android_root_env.c_str(), 1 /* overwrite */));
+}
+
+} // namespace art
diff --git a/runtime/base/logging.cc b/runtime/base/logging.cc
index 90eb74c..78d5429 100644
--- a/runtime/base/logging.cc
+++ b/runtime/base/logging.cc
@@ -22,7 +22,6 @@
#include "aborting.h"
#include "mutex.h"
-#include "thread-current-inl.h"
#include "utils.h"
// Headers for LogMessage::LogLine.
diff --git a/runtime/check_jni.cc b/runtime/check_jni.cc
index 02580cc..900ce0e 100644
--- a/runtime/check_jni.cc
+++ b/runtime/check_jni.cc
@@ -31,6 +31,7 @@
#include "base/time_utils.h"
#include "class_linker-inl.h"
#include "class_linker.h"
+#include "dex/descriptors_names.h"
#include "dex/dex_file-inl.h"
#include "gc/space/space.h"
#include "java_vm_ext.h"
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 63d47e6..9c0ccee 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -50,6 +50,7 @@
#include "class_table-inl.h"
#include "compiler_callbacks.h"
#include "debugger.h"
+#include "dex/descriptors_names.h"
#include "dex/dex_file-inl.h"
#include "dex/dex_file_exception_helpers.h"
#include "dex/dex_file_loader.h"
diff --git a/runtime/debugger.cc b/runtime/debugger.cc
index 61ad725..602e094 100644
--- a/runtime/debugger.cc
+++ b/runtime/debugger.cc
@@ -33,6 +33,7 @@
#include "base/time_utils.h"
#include "class_linker-inl.h"
#include "class_linker.h"
+#include "dex/descriptors_names.h"
#include "dex/dex_file-inl.h"
#include "dex/dex_file_annotations.h"
#include "dex/dex_file_types.h"
diff --git a/runtime/exec_utils_test.cc b/runtime/exec_utils_test.cc
new file mode 100644
index 0000000..68edfa8
--- /dev/null
+++ b/runtime/exec_utils_test.cc
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "exec_utils.h"
+
+#include "base/file_utils.h"
+#include "base/memory_tool.h"
+#include "common_runtime_test.h"
+
+namespace art {
+
+std::string PrettyArguments(const char* signature);
+std::string PrettyReturnType(const char* signature);
+
+class ExecUtilsTest : public CommonRuntimeTest {};
+
+TEST_F(ExecUtilsTest, ExecSuccess) {
+ std::vector<std::string> command;
+ if (kIsTargetBuild) {
+ std::string android_root(GetAndroidRoot());
+ command.push_back(android_root + "/bin/id");
+ } else {
+ command.push_back("/usr/bin/id");
+ }
+ std::string error_msg;
+ if (!(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) {
+ // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks.
+ EXPECT_TRUE(Exec(command, &error_msg));
+ }
+ EXPECT_EQ(0U, error_msg.size()) << error_msg;
+}
+
+TEST_F(ExecUtilsTest, ExecError) {
+ // This will lead to error messages in the log.
+ ScopedLogSeverity sls(LogSeverity::FATAL);
+
+ std::vector<std::string> command;
+ command.push_back("bogus");
+ std::string error_msg;
+ if (!(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) {
+ // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks.
+ EXPECT_FALSE(Exec(command, &error_msg));
+ EXPECT_FALSE(error_msg.empty());
+ }
+}
+
+TEST_F(ExecUtilsTest, EnvSnapshotAdditionsAreNotVisible) {
+ static constexpr const char* kModifiedVariable = "EXEC_SHOULD_NOT_EXPORT_THIS";
+ static constexpr int kOverwrite = 1;
+ // Set an variable in the current environment.
+ EXPECT_EQ(setenv(kModifiedVariable, "NEVER", kOverwrite), 0);
+ // Test that it is not exported.
+ std::vector<std::string> command;
+ if (kIsTargetBuild) {
+ std::string android_root(GetAndroidRoot());
+ command.push_back(android_root + "/bin/printenv");
+ } else {
+ command.push_back("/usr/bin/printenv");
+ }
+ command.push_back(kModifiedVariable);
+ std::string error_msg;
+ if (!(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) {
+ // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks.
+ EXPECT_FALSE(Exec(command, &error_msg));
+ EXPECT_NE(0U, error_msg.size()) << error_msg;
+ }
+}
+
+TEST_F(ExecUtilsTest, EnvSnapshotDeletionsAreNotVisible) {
+ static constexpr const char* kDeletedVariable = "PATH";
+ static constexpr int kOverwrite = 1;
+ // Save the variable's value.
+ const char* save_value = getenv(kDeletedVariable);
+ EXPECT_NE(save_value, nullptr);
+ // Delete the variable.
+ EXPECT_EQ(unsetenv(kDeletedVariable), 0);
+ // Test that it is not exported.
+ std::vector<std::string> command;
+ if (kIsTargetBuild) {
+ std::string android_root(GetAndroidRoot());
+ command.push_back(android_root + "/bin/printenv");
+ } else {
+ command.push_back("/usr/bin/printenv");
+ }
+ command.push_back(kDeletedVariable);
+ std::string error_msg;
+ if (!(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) {
+ // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks.
+ EXPECT_TRUE(Exec(command, &error_msg));
+ EXPECT_EQ(0U, error_msg.size()) << error_msg;
+ }
+ // Restore the variable's value.
+ EXPECT_EQ(setenv(kDeletedVariable, save_value, kOverwrite), 0);
+}
+
+} // namespace art
diff --git a/runtime/interpreter/unstarted_runtime.cc b/runtime/interpreter/unstarted_runtime.cc
index f8dd829..a0b58ef 100644
--- a/runtime/interpreter/unstarted_runtime.cc
+++ b/runtime/interpreter/unstarted_runtime.cc
@@ -35,6 +35,7 @@
#include "base/macros.h"
#include "class_linker.h"
#include "common_throws.h"
+#include "dex/descriptors_names.h"
#include "entrypoints/entrypoint_utils-inl.h"
#include "gc/reference_processor.h"
#include "handle_scope-inl.h"
diff --git a/runtime/interpreter/unstarted_runtime_test.cc b/runtime/interpreter/unstarted_runtime_test.cc
index 0986005..fd43562 100644
--- a/runtime/interpreter/unstarted_runtime_test.cc
+++ b/runtime/interpreter/unstarted_runtime_test.cc
@@ -24,6 +24,7 @@
#include "base/memory_tool.h"
#include "class_linker.h"
#include "common_runtime_test.h"
+#include "dex/descriptors_names.h"
#include "dex/dex_instruction.h"
#include "handle.h"
#include "handle_scope-inl.h"
diff --git a/runtime/mirror/class.cc b/runtime/mirror/class.cc
index 5d730ce..7a09391 100644
--- a/runtime/mirror/class.cc
+++ b/runtime/mirror/class.cc
@@ -25,6 +25,7 @@
#include "class_ext.h"
#include "class_linker-inl.h"
#include "class_loader.h"
+#include "dex/descriptors_names.h"
#include "dex/dex_file-inl.h"
#include "dex/dex_file_annotations.h"
#include "dex_cache.h"
diff --git a/runtime/mirror/object.cc b/runtime/mirror/object.cc
index 3765d0a..f274cfc 100644
--- a/runtime/mirror/object.cc
+++ b/runtime/mirror/object.cc
@@ -24,6 +24,7 @@
#include "class-inl.h"
#include "class.h"
#include "class_linker-inl.h"
+#include "dex/descriptors_names.h"
#include "dex/dex_file-inl.h"
#include "gc/accounting/card_table-inl.h"
#include "gc/heap.h"
diff --git a/runtime/mirror/string.cc b/runtime/mirror/string.cc
index cad84ce..6208a96 100644
--- a/runtime/mirror/string.cc
+++ b/runtime/mirror/string.cc
@@ -21,6 +21,7 @@
#include "base/array_ref.h"
#include "base/stl_util.h"
#include "class-inl.h"
+#include "dex/descriptors_names.h"
#include "dex/utf-inl.h"
#include "gc/accounting/card_table-inl.h"
#include "gc_root-inl.h"
diff --git a/runtime/native/dalvik_system_DexFile.cc b/runtime/native/dalvik_system_DexFile.cc
index b49209c..dd7b34a 100644
--- a/runtime/native/dalvik_system_DexFile.cc
+++ b/runtime/native/dalvik_system_DexFile.cc
@@ -28,6 +28,7 @@
#include "common_throws.h"
#include "compiler_filter.h"
#include "dex/art_dex_file_loader.h"
+#include "dex/descriptors_names.h"
#include "dex/dex_file-inl.h"
#include "dex/dex_file_loader.h"
#include "jit/debugger_interface.h"
diff --git a/runtime/native/java_lang_Class.cc b/runtime/native/java_lang_Class.cc
index e518553..38a4a3b 100644
--- a/runtime/native/java_lang_Class.cc
+++ b/runtime/native/java_lang_Class.cc
@@ -23,6 +23,7 @@
#include "base/enums.h"
#include "class_linker-inl.h"
#include "common_throws.h"
+#include "dex/descriptors_names.h"
#include "dex/dex_file-inl.h"
#include "dex/dex_file_annotations.h"
#include "dex/utf.h"
diff --git a/runtime/native/java_lang_VMClassLoader.cc b/runtime/native/java_lang_VMClassLoader.cc
index 6eebff4..3a0d760 100644
--- a/runtime/native/java_lang_VMClassLoader.cc
+++ b/runtime/native/java_lang_VMClassLoader.cc
@@ -17,6 +17,7 @@
#include "java_lang_VMClassLoader.h"
#include "class_linker.h"
+#include "dex/descriptors_names.h"
#include "dex/dex_file_loader.h"
#include "jni_internal.h"
#include "mirror/class_loader.h"
diff --git a/runtime/reflection-inl.h b/runtime/reflection-inl.h
index 62ce9e9..6edb12f 100644
--- a/runtime/reflection-inl.h
+++ b/runtime/reflection-inl.h
@@ -22,6 +22,7 @@
#include "android-base/stringprintf.h"
#include "common_throws.h"
+#include "dex/descriptors_names.h"
#include "jvalue-inl.h"
#include "mirror/object-inl.h"
#include "obj_ptr-inl.h"
diff --git a/runtime/reflection_test.cc b/runtime/reflection_test.cc
index 7794872..7b36c73 100644
--- a/runtime/reflection_test.cc
+++ b/runtime/reflection_test.cc
@@ -22,6 +22,7 @@
#include "art_method-inl.h"
#include "base/enums.h"
#include "common_compiler_test.h"
+#include "dex/descriptors_names.h"
#include "java_vm_ext.h"
#include "jni_internal.h"
#include "nativehelper/scoped_local_ref.h"
diff --git a/runtime/thread.cc b/runtime/thread.cc
index 1de7b20..4cdf015 100644
--- a/runtime/thread.cc
+++ b/runtime/thread.cc
@@ -47,6 +47,7 @@
#include "base/to_str.h"
#include "class_linker-inl.h"
#include "debugger.h"
+#include "dex/descriptors_names.h"
#include "dex/dex_file-inl.h"
#include "dex/dex_file_annotations.h"
#include "dex/dex_file_types.h"
diff --git a/runtime/trace.cc b/runtime/trace.cc
index f9d22df..bdc6757 100644
--- a/runtime/trace.cc
+++ b/runtime/trace.cc
@@ -31,6 +31,7 @@
#include "class_linker.h"
#include "common_throws.h"
#include "debugger.h"
+#include "dex/descriptors_names.h"
#include "dex/dex_file-inl.h"
#include "entrypoints/quick/quick_entrypoints.h"
#include "gc/scoped_gc_critical_section.h"
diff --git a/runtime/utils.cc b/runtime/utils.cc
index 393b18e..7246c3d 100644
--- a/runtime/utils.cc
+++ b/runtime/utils.cc
@@ -72,59 +72,6 @@
return result;
}
-void AppendPrettyDescriptor(const char* descriptor, std::string* result) {
- // Count the number of '['s to get the dimensionality.
- const char* c = descriptor;
- size_t dim = 0;
- while (*c == '[') {
- dim++;
- c++;
- }
-
- // Reference or primitive?
- if (*c == 'L') {
- // "[[La/b/C;" -> "a.b.C[][]".
- c++; // Skip the 'L'.
- } else {
- // "[[B" -> "byte[][]".
- // To make life easier, we make primitives look like unqualified
- // reference types.
- switch (*c) {
- case 'B': c = "byte;"; break;
- case 'C': c = "char;"; break;
- case 'D': c = "double;"; break;
- case 'F': c = "float;"; break;
- case 'I': c = "int;"; break;
- case 'J': c = "long;"; break;
- case 'S': c = "short;"; break;
- case 'Z': c = "boolean;"; break;
- case 'V': c = "void;"; break; // Used when decoding return types.
- default: result->append(descriptor); return;
- }
- }
-
- // At this point, 'c' is a string of the form "fully/qualified/Type;"
- // or "primitive;". Rewrite the type with '.' instead of '/':
- const char* p = c;
- while (*p != ';') {
- char ch = *p++;
- if (ch == '/') {
- ch = '.';
- }
- result->push_back(ch);
- }
- // ...and replace the semicolon with 'dim' "[]" pairs:
- for (size_t i = 0; i < dim; ++i) {
- result->append("[]");
- }
-}
-
-std::string PrettyDescriptor(const char* descriptor) {
- std::string result;
- AppendPrettyDescriptor(descriptor, &result);
- return result;
-}
-
std::string PrettySize(int64_t byte_count) {
// The byte thresholds at which we display amounts. A byte count is displayed
// in unit U when kUnitThresholds[U] <= bytes < kUnitThresholds[U+1].
@@ -151,330 +98,6 @@
negative_str, byte_count / kBytesPerUnit[i], kUnitStrings[i]);
}
-std::string GetJniShortName(const std::string& class_descriptor, const std::string& method) {
- // Remove the leading 'L' and trailing ';'...
- std::string class_name(class_descriptor);
- CHECK_EQ(class_name[0], 'L') << class_name;
- CHECK_EQ(class_name[class_name.size() - 1], ';') << class_name;
- class_name.erase(0, 1);
- class_name.erase(class_name.size() - 1, 1);
-
- std::string short_name;
- short_name += "Java_";
- short_name += MangleForJni(class_name);
- short_name += "_";
- short_name += MangleForJni(method);
- return short_name;
-}
-
-// See http://java.sun.com/j2se/1.5.0/docs/guide/jni/spec/design.html#wp615 for the full rules.
-std::string MangleForJni(const std::string& s) {
- std::string result;
- size_t char_count = CountModifiedUtf8Chars(s.c_str());
- const char* cp = &s[0];
- for (size_t i = 0; i < char_count; ++i) {
- uint32_t ch = GetUtf16FromUtf8(&cp);
- if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9')) {
- result.push_back(ch);
- } else if (ch == '.' || ch == '/') {
- result += "_";
- } else if (ch == '_') {
- result += "_1";
- } else if (ch == ';') {
- result += "_2";
- } else if (ch == '[') {
- result += "_3";
- } else {
- const uint16_t leading = GetLeadingUtf16Char(ch);
- const uint32_t trailing = GetTrailingUtf16Char(ch);
-
- StringAppendF(&result, "_0%04x", leading);
- if (trailing != 0) {
- StringAppendF(&result, "_0%04x", trailing);
- }
- }
- }
- return result;
-}
-
-std::string DotToDescriptor(const char* class_name) {
- std::string descriptor(class_name);
- std::replace(descriptor.begin(), descriptor.end(), '.', '/');
- if (descriptor.length() > 0 && descriptor[0] != '[') {
- descriptor = "L" + descriptor + ";";
- }
- return descriptor;
-}
-
-std::string DescriptorToDot(const char* descriptor) {
- size_t length = strlen(descriptor);
- if (length > 1) {
- if (descriptor[0] == 'L' && descriptor[length - 1] == ';') {
- // Descriptors have the leading 'L' and trailing ';' stripped.
- std::string result(descriptor + 1, length - 2);
- std::replace(result.begin(), result.end(), '/', '.');
- return result;
- } else {
- // For arrays the 'L' and ';' remain intact.
- std::string result(descriptor);
- std::replace(result.begin(), result.end(), '/', '.');
- return result;
- }
- }
- // Do nothing for non-class/array descriptors.
- return descriptor;
-}
-
-std::string DescriptorToName(const char* descriptor) {
- size_t length = strlen(descriptor);
- if (descriptor[0] == 'L' && descriptor[length - 1] == ';') {
- std::string result(descriptor + 1, length - 2);
- return result;
- }
- return descriptor;
-}
-
-// Helper for IsValidPartOfMemberNameUtf8(), a bit vector indicating valid low ascii.
-uint32_t DEX_MEMBER_VALID_LOW_ASCII[4] = {
- 0x00000000, // 00..1f low control characters; nothing valid
- 0x03ff2010, // 20..3f digits and symbols; valid: '0'..'9', '$', '-'
- 0x87fffffe, // 40..5f uppercase etc.; valid: 'A'..'Z', '_'
- 0x07fffffe // 60..7f lowercase etc.; valid: 'a'..'z'
-};
-
-// Helper for IsValidPartOfMemberNameUtf8(); do not call directly.
-bool IsValidPartOfMemberNameUtf8Slow(const char** pUtf8Ptr) {
- /*
- * It's a multibyte encoded character. Decode it and analyze. We
- * accept anything that isn't (a) an improperly encoded low value,
- * (b) an improper surrogate pair, (c) an encoded '\0', (d) a high
- * control character, or (e) a high space, layout, or special
- * character (U+00a0, U+2000..U+200f, U+2028..U+202f,
- * U+fff0..U+ffff). This is all specified in the dex format
- * document.
- */
-
- const uint32_t pair = GetUtf16FromUtf8(pUtf8Ptr);
- const uint16_t leading = GetLeadingUtf16Char(pair);
-
- // We have a surrogate pair resulting from a valid 4 byte UTF sequence.
- // No further checks are necessary because 4 byte sequences span code
- // points [U+10000, U+1FFFFF], which are valid codepoints in a dex
- // identifier. Furthermore, GetUtf16FromUtf8 guarantees that each of
- // the surrogate halves are valid and well formed in this instance.
- if (GetTrailingUtf16Char(pair) != 0) {
- return true;
- }
-
-
- // We've encountered a one, two or three byte UTF-8 sequence. The
- // three byte UTF-8 sequence could be one half of a surrogate pair.
- switch (leading >> 8) {
- case 0x00:
- // It's only valid if it's above the ISO-8859-1 high space (0xa0).
- return (leading > 0x00a0);
- case 0xd8:
- case 0xd9:
- case 0xda:
- case 0xdb:
- {
- // We found a three byte sequence encoding one half of a surrogate.
- // Look for the other half.
- const uint32_t pair2 = GetUtf16FromUtf8(pUtf8Ptr);
- const uint16_t trailing = GetLeadingUtf16Char(pair2);
-
- return (GetTrailingUtf16Char(pair2) == 0) && (0xdc00 <= trailing && trailing <= 0xdfff);
- }
- case 0xdc:
- case 0xdd:
- case 0xde:
- case 0xdf:
- // It's a trailing surrogate, which is not valid at this point.
- return false;
- case 0x20:
- case 0xff:
- // It's in the range that has spaces, controls, and specials.
- switch (leading & 0xfff8) {
- case 0x2000:
- case 0x2008:
- case 0x2028:
- case 0xfff0:
- case 0xfff8:
- return false;
- }
- return true;
- default:
- return true;
- }
-
- UNREACHABLE();
-}
-
-/* Return whether the pointed-at modified-UTF-8 encoded character is
- * valid as part of a member name, updating the pointer to point past
- * the consumed character. This will consume two encoded UTF-16 code
- * points if the character is encoded as a surrogate pair. Also, if
- * this function returns false, then the given pointer may only have
- * been partially advanced.
- */
-static bool IsValidPartOfMemberNameUtf8(const char** pUtf8Ptr) {
- uint8_t c = (uint8_t) **pUtf8Ptr;
- if (LIKELY(c <= 0x7f)) {
- // It's low-ascii, so check the table.
- uint32_t wordIdx = c >> 5;
- uint32_t bitIdx = c & 0x1f;
- (*pUtf8Ptr)++;
- return (DEX_MEMBER_VALID_LOW_ASCII[wordIdx] & (1 << bitIdx)) != 0;
- }
-
- // It's a multibyte encoded character. Call a non-inline function
- // for the heavy lifting.
- return IsValidPartOfMemberNameUtf8Slow(pUtf8Ptr);
-}
-
-bool IsValidMemberName(const char* s) {
- bool angle_name = false;
-
- switch (*s) {
- case '\0':
- // The empty string is not a valid name.
- return false;
- case '<':
- angle_name = true;
- s++;
- break;
- }
-
- while (true) {
- switch (*s) {
- case '\0':
- return !angle_name;
- case '>':
- return angle_name && s[1] == '\0';
- }
-
- if (!IsValidPartOfMemberNameUtf8(&s)) {
- return false;
- }
- }
-}
-
-enum ClassNameType { kName, kDescriptor };
-template<ClassNameType kType, char kSeparator>
-static bool IsValidClassName(const char* s) {
- int arrayCount = 0;
- while (*s == '[') {
- arrayCount++;
- s++;
- }
-
- if (arrayCount > 255) {
- // Arrays may have no more than 255 dimensions.
- return false;
- }
-
- ClassNameType type = kType;
- if (type != kDescriptor && arrayCount != 0) {
- /*
- * If we're looking at an array of some sort, then it doesn't
- * matter if what is being asked for is a class name; the
- * format looks the same as a type descriptor in that case, so
- * treat it as such.
- */
- type = kDescriptor;
- }
-
- if (type == kDescriptor) {
- /*
- * We are looking for a descriptor. Either validate it as a
- * single-character primitive type, or continue on to check the
- * embedded class name (bracketed by "L" and ";").
- */
- switch (*(s++)) {
- case 'B':
- case 'C':
- case 'D':
- case 'F':
- case 'I':
- case 'J':
- case 'S':
- case 'Z':
- // These are all single-character descriptors for primitive types.
- return (*s == '\0');
- case 'V':
- // Non-array void is valid, but you can't have an array of void.
- return (arrayCount == 0) && (*s == '\0');
- case 'L':
- // Class name: Break out and continue below.
- break;
- default:
- // Oddball descriptor character.
- return false;
- }
- }
-
- /*
- * We just consumed the 'L' that introduces a class name as part
- * of a type descriptor, or we are looking for an unadorned class
- * name.
- */
-
- bool sepOrFirst = true; // first character or just encountered a separator.
- for (;;) {
- uint8_t c = (uint8_t) *s;
- switch (c) {
- case '\0':
- /*
- * Premature end for a type descriptor, but valid for
- * a class name as long as we haven't encountered an
- * empty component (including the degenerate case of
- * the empty string "").
- */
- return (type == kName) && !sepOrFirst;
- case ';':
- /*
- * Invalid character for a class name, but the
- * legitimate end of a type descriptor. In the latter
- * case, make sure that this is the end of the string
- * and that it doesn't end with an empty component
- * (including the degenerate case of "L;").
- */
- return (type == kDescriptor) && !sepOrFirst && (s[1] == '\0');
- case '/':
- case '.':
- if (c != kSeparator) {
- // The wrong separator character.
- return false;
- }
- if (sepOrFirst) {
- // Separator at start or two separators in a row.
- return false;
- }
- sepOrFirst = true;
- s++;
- break;
- default:
- if (!IsValidPartOfMemberNameUtf8(&s)) {
- return false;
- }
- sepOrFirst = false;
- break;
- }
- }
-}
-
-bool IsValidBinaryClassName(const char* s) {
- return IsValidClassName<kName, '.'>(s);
-}
-
-bool IsValidJniClassName(const char* s) {
- return IsValidClassName<kName, '/'>(s);
-}
-
-bool IsValidDescriptor(const char* s) {
- return IsValidClassName<kDescriptor, '/'>(s);
-}
-
void Split(const std::string& s, char separator, std::vector<std::string>* result) {
const char* p = s.data();
const char* end = p + s.size();
@@ -541,10 +164,6 @@
*task_cpu = strtoull(fields[36].c_str(), nullptr, 10);
}
-std::string PrettyDescriptor(Primitive::Type type) {
- return PrettyDescriptor(Primitive::Descriptor(type));
-}
-
static void ParseStringAfterChar(const std::string& s,
char c,
std::string* parsed_value,
diff --git a/runtime/utils.h b/runtime/utils.h
index 443b0cc..7dc8f35 100644
--- a/runtime/utils.h
+++ b/runtime/utils.h
@@ -67,44 +67,9 @@
return intp & 0xFFFFFFFFU;
}
-// Used to implement PrettyClass, PrettyField, PrettyMethod, and PrettyTypeOf,
-// one of which is probably more useful to you.
-// Returns a human-readable equivalent of 'descriptor'. So "I" would be "int",
-// "[[I" would be "int[][]", "[Ljava/lang/String;" would be
-// "java.lang.String[]", and so forth.
-void AppendPrettyDescriptor(const char* descriptor, std::string* result);
-std::string PrettyDescriptor(const char* descriptor);
-std::string PrettyDescriptor(Primitive::Type type);
-
// Returns a human-readable size string such as "1MB".
std::string PrettySize(int64_t size_in_bytes);
-// Performs JNI name mangling as described in section 11.3 "Linking Native Methods"
-// of the JNI spec.
-std::string MangleForJni(const std::string& s);
-
-std::string GetJniShortName(const std::string& class_name, const std::string& method_name);
-
-// Turn "java.lang.String" into "Ljava/lang/String;".
-std::string DotToDescriptor(const char* class_name);
-
-// Turn "Ljava/lang/String;" into "java.lang.String" using the conventions of
-// java.lang.Class.getName().
-std::string DescriptorToDot(const char* descriptor);
-
-// Turn "Ljava/lang/String;" into "java/lang/String" using the opposite conventions of
-// java.lang.Class.getName().
-std::string DescriptorToName(const char* descriptor);
-
-// Tests for whether 's' is a valid class name in the three common forms:
-bool IsValidBinaryClassName(const char* s); // "java.lang.String"
-bool IsValidJniClassName(const char* s); // "java/lang/String"
-bool IsValidDescriptor(const char* s); // "Ljava/lang/String;"
-
-// Returns whether the given string is a valid field or method name,
-// additionally allowing names that begin with '<' and end with '>'.
-bool IsValidMemberName(const char* s);
-
// Splits a string using the given separator character into a vector of
// strings. Empty strings will be omitted.
void Split(const std::string& s, char separator, std::vector<std::string>* result);
diff --git a/runtime/utils_test.cc b/runtime/utils_test.cc
index 1dc4687..e67e93f 100644
--- a/runtime/utils_test.cc
+++ b/runtime/utils_test.cc
@@ -37,63 +37,8 @@
namespace art {
-std::string PrettyArguments(const char* signature);
-std::string PrettyReturnType(const char* signature);
-
class UtilsTest : public CommonRuntimeTest {};
-TEST_F(UtilsTest, PrettyDescriptor_ArrayReferences) {
- EXPECT_EQ("java.lang.Class[]", PrettyDescriptor("[Ljava/lang/Class;"));
- EXPECT_EQ("java.lang.Class[][]", PrettyDescriptor("[[Ljava/lang/Class;"));
-}
-
-TEST_F(UtilsTest, PrettyDescriptor_ScalarReferences) {
- EXPECT_EQ("java.lang.String", PrettyDescriptor("Ljava.lang.String;"));
- EXPECT_EQ("java.lang.String", PrettyDescriptor("Ljava/lang/String;"));
-}
-
-TEST_F(UtilsTest, PrettyDescriptor_Primitive) {
- EXPECT_EQ("boolean", PrettyDescriptor(Primitive::kPrimBoolean));
- EXPECT_EQ("byte", PrettyDescriptor(Primitive::kPrimByte));
- EXPECT_EQ("char", PrettyDescriptor(Primitive::kPrimChar));
- EXPECT_EQ("short", PrettyDescriptor(Primitive::kPrimShort));
- EXPECT_EQ("int", PrettyDescriptor(Primitive::kPrimInt));
- EXPECT_EQ("float", PrettyDescriptor(Primitive::kPrimFloat));
- EXPECT_EQ("long", PrettyDescriptor(Primitive::kPrimLong));
- EXPECT_EQ("double", PrettyDescriptor(Primitive::kPrimDouble));
- EXPECT_EQ("void", PrettyDescriptor(Primitive::kPrimVoid));
-}
-
-TEST_F(UtilsTest, PrettyDescriptor_PrimitiveArrays) {
- EXPECT_EQ("boolean[]", PrettyDescriptor("[Z"));
- EXPECT_EQ("boolean[][]", PrettyDescriptor("[[Z"));
- EXPECT_EQ("byte[]", PrettyDescriptor("[B"));
- EXPECT_EQ("byte[][]", PrettyDescriptor("[[B"));
- EXPECT_EQ("char[]", PrettyDescriptor("[C"));
- EXPECT_EQ("char[][]", PrettyDescriptor("[[C"));
- EXPECT_EQ("double[]", PrettyDescriptor("[D"));
- EXPECT_EQ("double[][]", PrettyDescriptor("[[D"));
- EXPECT_EQ("float[]", PrettyDescriptor("[F"));
- EXPECT_EQ("float[][]", PrettyDescriptor("[[F"));
- EXPECT_EQ("int[]", PrettyDescriptor("[I"));
- EXPECT_EQ("int[][]", PrettyDescriptor("[[I"));
- EXPECT_EQ("long[]", PrettyDescriptor("[J"));
- EXPECT_EQ("long[][]", PrettyDescriptor("[[J"));
- EXPECT_EQ("short[]", PrettyDescriptor("[S"));
- EXPECT_EQ("short[][]", PrettyDescriptor("[[S"));
-}
-
-TEST_F(UtilsTest, PrettyDescriptor_PrimitiveScalars) {
- EXPECT_EQ("boolean", PrettyDescriptor("Z"));
- EXPECT_EQ("byte", PrettyDescriptor("B"));
- EXPECT_EQ("char", PrettyDescriptor("C"));
- EXPECT_EQ("double", PrettyDescriptor("D"));
- EXPECT_EQ("float", PrettyDescriptor("F"));
- EXPECT_EQ("int", PrettyDescriptor("I"));
- EXPECT_EQ("long", PrettyDescriptor("J"));
- EXPECT_EQ("short", PrettyDescriptor("S"));
-}
-
TEST_F(UtilsTest, PrettyTypeOf) {
ScopedObjectAccess soa(Thread::Current());
EXPECT_EQ("null", mirror::Object::PrettyTypeOf(nullptr));
@@ -163,15 +108,6 @@
EXPECT_EQ("512B", PrettySize(512));
}
-TEST_F(UtilsTest, MangleForJni) {
- ScopedObjectAccess soa(Thread::Current());
- EXPECT_EQ("hello_00024world", MangleForJni("hello$world"));
- EXPECT_EQ("hello_000a9world", MangleForJni("hello\xc2\xa9world"));
- EXPECT_EQ("hello_1world", MangleForJni("hello_world"));
- EXPECT_EQ("Ljava_lang_String_2", MangleForJni("Ljava/lang/String;"));
- EXPECT_EQ("_3C", MangleForJni("[C"));
-}
-
TEST_F(UtilsTest, JniShortName_JniLongName) {
ScopedObjectAccess soa(Thread::Current());
mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/String;");
@@ -263,140 +199,6 @@
EXPECT_EQ(expected, actual);
}
-TEST_F(UtilsTest, GetDalvikCacheFilename) {
- std::string name;
- std::string error;
-
- EXPECT_TRUE(GetDalvikCacheFilename("/system/app/Foo.apk", "/foo", &name, &error)) << error;
- EXPECT_EQ("/foo/system@app@Foo.apk@classes.dex", name);
-
- EXPECT_TRUE(GetDalvikCacheFilename("/data/app/foo-1.apk", "/foo", &name, &error)) << error;
- EXPECT_EQ("/foo/data@app@foo-1.apk@classes.dex", name);
-
- EXPECT_TRUE(GetDalvikCacheFilename("/system/framework/core.jar", "/foo", &name, &error)) << error;
- EXPECT_EQ("/foo/system@framework@core.jar@classes.dex", name);
-
- EXPECT_TRUE(GetDalvikCacheFilename("/system/framework/boot.art", "/foo", &name, &error)) << error;
- EXPECT_EQ("/foo/system@framework@boot.art", name);
-
- EXPECT_TRUE(GetDalvikCacheFilename("/system/framework/boot.oat", "/foo", &name, &error)) << error;
- EXPECT_EQ("/foo/system@framework@boot.oat", name);
-}
-
-TEST_F(UtilsTest, GetDalvikCache) {
- EXPECT_STREQ("", GetDalvikCache("should-not-exist123").c_str());
-
- EXPECT_STREQ((android_data_ + "/dalvik-cache/.").c_str(), GetDalvikCache(".").c_str());
-}
-
-
-TEST_F(UtilsTest, GetSystemImageFilename) {
- EXPECT_STREQ("/system/framework/arm/boot.art",
- GetSystemImageFilename("/system/framework/boot.art", InstructionSet::kArm).c_str());
-}
-
-TEST_F(UtilsTest, ExecSuccess) {
- std::vector<std::string> command;
- if (kIsTargetBuild) {
- std::string android_root(GetAndroidRoot());
- command.push_back(android_root + "/bin/id");
- } else {
- command.push_back("/usr/bin/id");
- }
- std::string error_msg;
- if (!(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) {
- // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks.
- EXPECT_TRUE(Exec(command, &error_msg));
- }
- EXPECT_EQ(0U, error_msg.size()) << error_msg;
-}
-
-TEST_F(UtilsTest, ExecError) {
- // This will lead to error messages in the log.
- ScopedLogSeverity sls(LogSeverity::FATAL);
-
- std::vector<std::string> command;
- command.push_back("bogus");
- std::string error_msg;
- if (!(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) {
- // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks.
- EXPECT_FALSE(Exec(command, &error_msg));
- EXPECT_FALSE(error_msg.empty());
- }
-}
-
-TEST_F(UtilsTest, EnvSnapshotAdditionsAreNotVisible) {
- static constexpr const char* kModifiedVariable = "EXEC_SHOULD_NOT_EXPORT_THIS";
- static constexpr int kOverwrite = 1;
- // Set an variable in the current environment.
- EXPECT_EQ(setenv(kModifiedVariable, "NEVER", kOverwrite), 0);
- // Test that it is not exported.
- std::vector<std::string> command;
- if (kIsTargetBuild) {
- std::string android_root(GetAndroidRoot());
- command.push_back(android_root + "/bin/printenv");
- } else {
- command.push_back("/usr/bin/printenv");
- }
- command.push_back(kModifiedVariable);
- std::string error_msg;
- if (!(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) {
- // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks.
- EXPECT_FALSE(Exec(command, &error_msg));
- EXPECT_NE(0U, error_msg.size()) << error_msg;
- }
-}
-
-TEST_F(UtilsTest, EnvSnapshotDeletionsAreNotVisible) {
- static constexpr const char* kDeletedVariable = "PATH";
- static constexpr int kOverwrite = 1;
- // Save the variable's value.
- const char* save_value = getenv(kDeletedVariable);
- EXPECT_NE(save_value, nullptr);
- // Delete the variable.
- EXPECT_EQ(unsetenv(kDeletedVariable), 0);
- // Test that it is not exported.
- std::vector<std::string> command;
- if (kIsTargetBuild) {
- std::string android_root(GetAndroidRoot());
- command.push_back(android_root + "/bin/printenv");
- } else {
- command.push_back("/usr/bin/printenv");
- }
- command.push_back(kDeletedVariable);
- std::string error_msg;
- if (!(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) {
- // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks.
- EXPECT_TRUE(Exec(command, &error_msg));
- EXPECT_EQ(0U, error_msg.size()) << error_msg;
- }
- // Restore the variable's value.
- EXPECT_EQ(setenv(kDeletedVariable, save_value, kOverwrite), 0);
-}
-
-TEST_F(UtilsTest, IsValidDescriptor) {
- std::vector<uint8_t> descriptor(
- { 'L', 'a', '/', 'b', '$', 0xed, 0xa0, 0x80, 0xed, 0xb0, 0x80, ';', 0x00 });
- EXPECT_TRUE(IsValidDescriptor(reinterpret_cast<char*>(&descriptor[0])));
-
- std::vector<uint8_t> unpaired_surrogate(
- { 'L', 'a', '/', 'b', '$', 0xed, 0xa0, 0x80, ';', 0x00 });
- EXPECT_FALSE(IsValidDescriptor(reinterpret_cast<char*>(&unpaired_surrogate[0])));
-
- std::vector<uint8_t> unpaired_surrogate_at_end(
- { 'L', 'a', '/', 'b', '$', 0xed, 0xa0, 0x80, 0x00 });
- EXPECT_FALSE(IsValidDescriptor(reinterpret_cast<char*>(&unpaired_surrogate_at_end[0])));
-
- std::vector<uint8_t> invalid_surrogate(
- { 'L', 'a', '/', 'b', '$', 0xed, 0xb0, 0x80, ';', 0x00 });
- EXPECT_FALSE(IsValidDescriptor(reinterpret_cast<char*>(&invalid_surrogate[0])));
-
- std::vector<uint8_t> unpaired_surrogate_with_multibyte_sequence(
- { 'L', 'a', '/', 'b', '$', 0xed, 0xb0, 0x80, 0xf0, 0x9f, 0x8f, 0xa0, ';', 0x00 });
- EXPECT_FALSE(
- IsValidDescriptor(reinterpret_cast<char*>(&unpaired_surrogate_with_multibyte_sequence[0])));
-}
-
TEST_F(UtilsTest, ArrayCount) {
int i[64];
EXPECT_EQ(ArrayCount(i), 64u);
@@ -416,40 +218,4 @@
EXPECT_EQ(BoundsCheckedCast<const uint64_t*>(buffer + 57, buffer, buffer_end), nullptr);
}
-TEST_F(UtilsTest, GetAndroidRootSafe) {
- std::string error_msg;
-
- // We don't expect null returns for most cases, so don't check and let std::string crash.
-
- // CommonRuntimeTest sets ANDROID_ROOT, so expect this to be the same.
- std::string android_root = GetAndroidRootSafe(&error_msg);
- std::string android_root_env = getenv("ANDROID_ROOT");
- EXPECT_EQ(android_root, android_root_env);
-
- // Set ANDROID_ROOT to something else (but the directory must exist). So use dirname.
- char* root_dup = strdup(android_root_env.c_str());
- char* dir = dirname(root_dup);
- ASSERT_EQ(0, setenv("ANDROID_ROOT", dir, 1 /* overwrite */));
- std::string android_root2 = GetAndroidRootSafe(&error_msg);
- EXPECT_STREQ(dir, android_root2.c_str());
- free(root_dup);
-
- // Set a bogus value for ANDROID_ROOT. This should be an error.
- ASSERT_EQ(0, setenv("ANDROID_ROOT", "/this/is/obviously/bogus", 1 /* overwrite */));
- EXPECT_TRUE(GetAndroidRootSafe(&error_msg) == nullptr);
-
- // Unset ANDROID_ROOT and see that it still returns something (as libart code is running).
- ASSERT_EQ(0, unsetenv("ANDROID_ROOT"));
- std::string android_root3 = GetAndroidRootSafe(&error_msg);
- // This should be the same as the other root (modulo realpath), otherwise the test setup is
- // broken.
- UniqueCPtr<char> real_root(realpath(android_root.c_str(), nullptr));
- UniqueCPtr<char> real_root3(realpath(android_root3.c_str(), nullptr));
- EXPECT_STREQ(real_root.get(), real_root3.get());
-
-
- // Reset ANDROID_ROOT, as other things may depend on it.
- ASSERT_EQ(0, setenv("ANDROID_ROOT", android_root_env.c_str(), 1 /* overwrite */));
-}
-
} // namespace art
diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc
index 66e578f..9a393ea 100644
--- a/runtime/verifier/method_verifier.cc
+++ b/runtime/verifier/method_verifier.cc
@@ -31,6 +31,7 @@
#include "base/time_utils.h"
#include "class_linker.h"
#include "compiler_callbacks.h"
+#include "dex/descriptors_names.h"
#include "dex/dex_file-inl.h"
#include "dex/dex_file_exception_helpers.h"
#include "dex/dex_instruction-inl.h"
diff --git a/runtime/verifier/reg_type.cc b/runtime/verifier/reg_type.cc
index 7ebdd90..e7864a2 100644
--- a/runtime/verifier/reg_type.cc
+++ b/runtime/verifier/reg_type.cc
@@ -22,6 +22,7 @@
#include "base/bit_vector-inl.h"
#include "base/casts.h"
#include "class_linker-inl.h"
+#include "dex/descriptors_names.h"
#include "dex/dex_file-inl.h"
#include "method_verifier.h"
#include "mirror/class-inl.h"
diff --git a/runtime/verifier/reg_type_cache.cc b/runtime/verifier/reg_type_cache.cc
index 30aefed..87fc60b 100644
--- a/runtime/verifier/reg_type_cache.cc
+++ b/runtime/verifier/reg_type_cache.cc
@@ -25,6 +25,7 @@
#include "base/scoped_arena_allocator.h"
#include "base/stl_util.h"
#include "class_linker-inl.h"
+#include "dex/descriptors_names.h"
#include "dex/dex_file-inl.h"
#include "mirror/class-inl.h"
#include "mirror/object-inl.h"