Elliott Hughes | 2faa5f1 | 2012-01-30 14:42:07 -0800 | [diff] [blame] | 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 | */ |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 16 | |
Brian Carlstrom | a1ce1fe | 2014-02-24 23:23:58 -0800 | [diff] [blame] | 17 | #include "utils.h" |
| 18 | |
Vladimir Marko | 3481ba2 | 2015-04-13 12:22:36 +0100 | [diff] [blame] | 19 | #include "class_linker-inl.h" |
Brian Carlstrom | a1ce1fe | 2014-02-24 23:23:58 -0800 | [diff] [blame] | 20 | #include "common_runtime_test.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 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" |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 26 | #include "scoped_thread_state_change.h" |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 27 | #include "handle_scope-inl.h" |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 28 | |
Mathieu Chartier | 661974a | 2014-01-09 11:23:53 -0800 | [diff] [blame] | 29 | #include <valgrind.h> |
| 30 | |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 31 | namespace art { |
| 32 | |
Elliott Hughes | 9058f2b | 2012-03-22 18:06:48 -0700 | [diff] [blame] | 33 | std::string PrettyArguments(const char* signature); |
| 34 | std::string PrettyReturnType(const char* signature); |
| 35 | |
Brian Carlstrom | a1ce1fe | 2014-02-24 23:23:58 -0800 | [diff] [blame] | 36 | class UtilsTest : public CommonRuntimeTest {}; |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 37 | |
Elliott Hughes | 5174fe6 | 2011-08-23 15:12:35 -0700 | [diff] [blame] | 38 | TEST_F(UtilsTest, PrettyDescriptor_ArrayReferences) { |
Elliott Hughes | 9058f2b | 2012-03-22 18:06:48 -0700 | [diff] [blame] | 39 | EXPECT_EQ("java.lang.Class[]", PrettyDescriptor("[Ljava/lang/Class;")); |
| 40 | EXPECT_EQ("java.lang.Class[][]", PrettyDescriptor("[[Ljava/lang/Class;")); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 41 | } |
| 42 | |
Elliott Hughes | 5174fe6 | 2011-08-23 15:12:35 -0700 | [diff] [blame] | 43 | TEST_F(UtilsTest, PrettyDescriptor_ScalarReferences) { |
Elliott Hughes | 9058f2b | 2012-03-22 18:06:48 -0700 | [diff] [blame] | 44 | EXPECT_EQ("java.lang.String", PrettyDescriptor("Ljava.lang.String;")); |
| 45 | EXPECT_EQ("java.lang.String", PrettyDescriptor("Ljava/lang/String;")); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 46 | } |
| 47 | |
Mathieu Chartier | 7643327 | 2014-09-26 14:32:37 -0700 | [diff] [blame] | 48 | TEST_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 | |
Elliott Hughes | 5174fe6 | 2011-08-23 15:12:35 -0700 | [diff] [blame] | 60 | TEST_F(UtilsTest, PrettyDescriptor_PrimitiveArrays) { |
Elliott Hughes | 9058f2b | 2012-03-22 18:06:48 -0700 | [diff] [blame] | 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")); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 77 | } |
| 78 | |
Elliott Hughes | 5174fe6 | 2011-08-23 15:12:35 -0700 | [diff] [blame] | 79 | TEST_F(UtilsTest, PrettyDescriptor_PrimitiveScalars) { |
Elliott Hughes | 9058f2b | 2012-03-22 18:06:48 -0700 | [diff] [blame] | 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 | |
| 90 | TEST_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 | |
| 99 | TEST_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;")); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 105 | } |
| 106 | |
Elliott Hughes | 54e7df1 | 2011-09-16 11:47:04 -0700 | [diff] [blame] | 107 | TEST_F(UtilsTest, PrettyTypeOf) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 108 | ScopedObjectAccess soa(Thread::Current()); |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame^] | 109 | EXPECT_EQ("null", PrettyTypeOf(nullptr)); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 110 | |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 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())); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 114 | |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 115 | Handle<mirror::ShortArray> a(hs.NewHandle(mirror::ShortArray::Alloc(soa.Self(), 2))); |
| 116 | EXPECT_EQ("short[]", PrettyTypeOf(a.Get())); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 117 | |
Ian Rogers | 9837939 | 2014-02-24 16:53:16 -0800 | [diff] [blame] | 118 | mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;"); |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame^] | 119 | ASSERT_TRUE(c != nullptr); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 120 | mirror::Object* o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0); |
Elliott Hughes | 54e7df1 | 2011-09-16 11:47:04 -0700 | [diff] [blame] | 121 | EXPECT_EQ("java.lang.String[]", PrettyTypeOf(o)); |
| 122 | EXPECT_EQ("java.lang.Class<java.lang.String[]>", PrettyTypeOf(o->GetClass())); |
| 123 | } |
| 124 | |
| 125 | TEST_F(UtilsTest, PrettyClass) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 126 | ScopedObjectAccess soa(Thread::Current()); |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame^] | 127 | EXPECT_EQ("null", PrettyClass(nullptr)); |
Ian Rogers | 9837939 | 2014-02-24 16:53:16 -0800 | [diff] [blame] | 128 | mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;"); |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame^] | 129 | ASSERT_TRUE(c != nullptr); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 130 | mirror::Object* o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0); |
Elliott Hughes | 54e7df1 | 2011-09-16 11:47:04 -0700 | [diff] [blame] | 131 | EXPECT_EQ("java.lang.Class<java.lang.String[]>", PrettyClass(o->GetClass())); |
| 132 | } |
| 133 | |
Ian Rogers | d81871c | 2011-10-03 13:57:23 -0700 | [diff] [blame] | 134 | TEST_F(UtilsTest, PrettyClassAndClassLoader) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 135 | ScopedObjectAccess soa(Thread::Current()); |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame^] | 136 | EXPECT_EQ("null", PrettyClassAndClassLoader(nullptr)); |
Ian Rogers | 9837939 | 2014-02-24 16:53:16 -0800 | [diff] [blame] | 137 | mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;"); |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame^] | 138 | ASSERT_TRUE(c != nullptr); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 139 | mirror::Object* o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0); |
Ian Rogers | d81871c | 2011-10-03 13:57:23 -0700 | [diff] [blame] | 140 | EXPECT_EQ("java.lang.Class<java.lang.String[],null>", PrettyClassAndClassLoader(o->GetClass())); |
| 141 | } |
| 142 | |
Elliott Hughes | 54e7df1 | 2011-09-16 11:47:04 -0700 | [diff] [blame] | 143 | TEST_F(UtilsTest, PrettyField) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 144 | ScopedObjectAccess soa(Thread::Current()); |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame^] | 145 | EXPECT_EQ("null", PrettyField(nullptr)); |
Elliott Hughes | 54e7df1 | 2011-09-16 11:47:04 -0700 | [diff] [blame] | 146 | |
Ian Rogers | 9837939 | 2014-02-24 16:53:16 -0800 | [diff] [blame] | 147 | mirror::Class* java_lang_String = class_linker_->FindSystemClass(soa.Self(), |
| 148 | "Ljava/lang/String;"); |
Elliott Hughes | 54e7df1 | 2011-09-16 11:47:04 -0700 | [diff] [blame] | 149 | |
Mathieu Chartier | c785344 | 2015-03-27 14:35:38 -0700 | [diff] [blame] | 150 | ArtField* f; |
Brian Carlstrom | 6b4ef02 | 2011-10-23 14:59:04 -0700 | [diff] [blame] | 151 | f = java_lang_String->FindDeclaredInstanceField("count", "I"); |
Elliott Hughes | 54e7df1 | 2011-09-16 11:47:04 -0700 | [diff] [blame] | 152 | EXPECT_EQ("int java.lang.String.count", PrettyField(f)); |
| 153 | EXPECT_EQ("java.lang.String.count", PrettyField(f, false)); |
Brian Carlstrom | 6b4ef02 | 2011-10-23 14:59:04 -0700 | [diff] [blame] | 154 | f = java_lang_String->FindDeclaredInstanceField("value", "[C"); |
Elliott Hughes | 54e7df1 | 2011-09-16 11:47:04 -0700 | [diff] [blame] | 155 | EXPECT_EQ("char[] java.lang.String.value", PrettyField(f)); |
| 156 | EXPECT_EQ("java.lang.String.value", PrettyField(f, false)); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 157 | } |
| 158 | |
Ian Rogers | 3bb17a6 | 2012-01-27 23:56:44 -0800 | [diff] [blame] | 159 | TEST_F(UtilsTest, PrettySize) { |
| 160 | EXPECT_EQ("1GB", PrettySize(1 * GB)); |
| 161 | EXPECT_EQ("2GB", PrettySize(2 * GB)); |
| 162 | if (sizeof(size_t) > sizeof(uint32_t)) { |
| 163 | EXPECT_EQ("100GB", PrettySize(100 * GB)); |
| 164 | } |
Elliott Hughes | c967f78 | 2012-04-16 10:23:15 -0700 | [diff] [blame] | 165 | EXPECT_EQ("1024KB", PrettySize(1 * MB)); |
Ian Rogers | 3bb17a6 | 2012-01-27 23:56:44 -0800 | [diff] [blame] | 166 | EXPECT_EQ("10MB", PrettySize(10 * MB)); |
| 167 | EXPECT_EQ("100MB", PrettySize(100 * MB)); |
Elliott Hughes | c967f78 | 2012-04-16 10:23:15 -0700 | [diff] [blame] | 168 | EXPECT_EQ("1024B", PrettySize(1 * KB)); |
Elliott Hughes | 409d273 | 2012-04-03 13:34:44 -0700 | [diff] [blame] | 169 | EXPECT_EQ("10KB", PrettySize(10 * KB)); |
| 170 | EXPECT_EQ("100KB", PrettySize(100 * KB)); |
Elliott Hughes | c967f78 | 2012-04-16 10:23:15 -0700 | [diff] [blame] | 171 | EXPECT_EQ("0B", PrettySize(0)); |
Ian Rogers | 3bb17a6 | 2012-01-27 23:56:44 -0800 | [diff] [blame] | 172 | EXPECT_EQ("1B", PrettySize(1)); |
| 173 | EXPECT_EQ("10B", PrettySize(10)); |
| 174 | EXPECT_EQ("100B", PrettySize(100)); |
Elliott Hughes | c967f78 | 2012-04-16 10:23:15 -0700 | [diff] [blame] | 175 | EXPECT_EQ("512B", PrettySize(512)); |
Ian Rogers | 3bb17a6 | 2012-01-27 23:56:44 -0800 | [diff] [blame] | 176 | } |
| 177 | |
| 178 | TEST_F(UtilsTest, PrettyDuration) { |
| 179 | const uint64_t one_sec = 1000000000; |
| 180 | const uint64_t one_ms = 1000000; |
| 181 | const uint64_t one_us = 1000; |
| 182 | |
| 183 | EXPECT_EQ("1s", PrettyDuration(1 * one_sec)); |
| 184 | EXPECT_EQ("10s", PrettyDuration(10 * one_sec)); |
| 185 | EXPECT_EQ("100s", PrettyDuration(100 * one_sec)); |
| 186 | EXPECT_EQ("1.001s", PrettyDuration(1 * one_sec + one_ms)); |
Mathieu Chartier | f5997b4 | 2014-06-20 10:37:54 -0700 | [diff] [blame] | 187 | EXPECT_EQ("1.000001s", PrettyDuration(1 * one_sec + one_us, 6)); |
| 188 | EXPECT_EQ("1.000000001s", PrettyDuration(1 * one_sec + 1, 9)); |
| 189 | EXPECT_EQ("1.000s", PrettyDuration(1 * one_sec + one_us, 3)); |
Ian Rogers | 3bb17a6 | 2012-01-27 23:56:44 -0800 | [diff] [blame] | 190 | |
| 191 | EXPECT_EQ("1ms", PrettyDuration(1 * one_ms)); |
| 192 | EXPECT_EQ("10ms", PrettyDuration(10 * one_ms)); |
| 193 | EXPECT_EQ("100ms", PrettyDuration(100 * one_ms)); |
| 194 | EXPECT_EQ("1.001ms", PrettyDuration(1 * one_ms + one_us)); |
Mathieu Chartier | f5997b4 | 2014-06-20 10:37:54 -0700 | [diff] [blame] | 195 | EXPECT_EQ("1.000001ms", PrettyDuration(1 * one_ms + 1, 6)); |
Ian Rogers | 3bb17a6 | 2012-01-27 23:56:44 -0800 | [diff] [blame] | 196 | |
| 197 | EXPECT_EQ("1us", PrettyDuration(1 * one_us)); |
| 198 | EXPECT_EQ("10us", PrettyDuration(10 * one_us)); |
| 199 | EXPECT_EQ("100us", PrettyDuration(100 * one_us)); |
| 200 | EXPECT_EQ("1.001us", PrettyDuration(1 * one_us + 1)); |
| 201 | |
| 202 | EXPECT_EQ("1ns", PrettyDuration(1)); |
| 203 | EXPECT_EQ("10ns", PrettyDuration(10)); |
| 204 | EXPECT_EQ("100ns", PrettyDuration(100)); |
| 205 | } |
| 206 | |
Elliott Hughes | 79082e3 | 2011-08-25 12:07:32 -0700 | [diff] [blame] | 207 | TEST_F(UtilsTest, MangleForJni) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 208 | ScopedObjectAccess soa(Thread::Current()); |
Elliott Hughes | 79082e3 | 2011-08-25 12:07:32 -0700 | [diff] [blame] | 209 | EXPECT_EQ("hello_00024world", MangleForJni("hello$world")); |
| 210 | EXPECT_EQ("hello_000a9world", MangleForJni("hello\xc2\xa9world")); |
| 211 | EXPECT_EQ("hello_1world", MangleForJni("hello_world")); |
| 212 | EXPECT_EQ("Ljava_lang_String_2", MangleForJni("Ljava/lang/String;")); |
| 213 | EXPECT_EQ("_3C", MangleForJni("[C")); |
| 214 | } |
| 215 | |
| 216 | TEST_F(UtilsTest, JniShortName_JniLongName) { |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 217 | ScopedObjectAccess soa(Thread::Current()); |
Ian Rogers | 9837939 | 2014-02-24 16:53:16 -0800 | [diff] [blame] | 218 | mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/String;"); |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame^] | 219 | ASSERT_TRUE(c != nullptr); |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 220 | mirror::ArtMethod* m; |
Elliott Hughes | 79082e3 | 2011-08-25 12:07:32 -0700 | [diff] [blame] | 221 | |
| 222 | m = c->FindVirtualMethod("charAt", "(I)C"); |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame^] | 223 | ASSERT_TRUE(m != nullptr); |
Elliott Hughes | 79082e3 | 2011-08-25 12:07:32 -0700 | [diff] [blame] | 224 | EXPECT_EQ("Java_java_lang_String_charAt", JniShortName(m)); |
| 225 | EXPECT_EQ("Java_java_lang_String_charAt__I", JniLongName(m)); |
| 226 | |
| 227 | m = c->FindVirtualMethod("indexOf", "(Ljava/lang/String;I)I"); |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame^] | 228 | ASSERT_TRUE(m != nullptr); |
Elliott Hughes | 79082e3 | 2011-08-25 12:07:32 -0700 | [diff] [blame] | 229 | EXPECT_EQ("Java_java_lang_String_indexOf", JniShortName(m)); |
| 230 | EXPECT_EQ("Java_java_lang_String_indexOf__Ljava_lang_String_2I", JniLongName(m)); |
| 231 | |
| 232 | m = c->FindDirectMethod("copyValueOf", "([CII)Ljava/lang/String;"); |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame^] | 233 | ASSERT_TRUE(m != nullptr); |
Elliott Hughes | 79082e3 | 2011-08-25 12:07:32 -0700 | [diff] [blame] | 234 | EXPECT_EQ("Java_java_lang_String_copyValueOf", JniShortName(m)); |
| 235 | EXPECT_EQ("Java_java_lang_String_copyValueOf___3CII", JniLongName(m)); |
| 236 | } |
| 237 | |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 238 | TEST_F(UtilsTest, Split) { |
| 239 | std::vector<std::string> actual; |
| 240 | std::vector<std::string> expected; |
| 241 | |
| 242 | expected.clear(); |
| 243 | |
| 244 | actual.clear(); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 245 | Split("", ':', &actual); |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 246 | EXPECT_EQ(expected, actual); |
| 247 | |
| 248 | actual.clear(); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 249 | Split(":", ':', &actual); |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 250 | EXPECT_EQ(expected, actual); |
| 251 | |
| 252 | expected.clear(); |
| 253 | expected.push_back("foo"); |
| 254 | |
| 255 | actual.clear(); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 256 | Split(":foo", ':', &actual); |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 257 | EXPECT_EQ(expected, actual); |
| 258 | |
| 259 | actual.clear(); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 260 | Split("foo:", ':', &actual); |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 261 | EXPECT_EQ(expected, actual); |
| 262 | |
| 263 | actual.clear(); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 264 | Split(":foo:", ':', &actual); |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 265 | EXPECT_EQ(expected, actual); |
| 266 | |
| 267 | expected.push_back("bar"); |
| 268 | |
| 269 | actual.clear(); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 270 | Split("foo:bar", ':', &actual); |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 271 | EXPECT_EQ(expected, actual); |
| 272 | |
| 273 | actual.clear(); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 274 | Split(":foo:bar", ':', &actual); |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 275 | EXPECT_EQ(expected, actual); |
| 276 | |
| 277 | actual.clear(); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 278 | Split("foo:bar:", ':', &actual); |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 279 | EXPECT_EQ(expected, actual); |
| 280 | |
| 281 | actual.clear(); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 282 | Split(":foo:bar:", ':', &actual); |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 283 | EXPECT_EQ(expected, actual); |
| 284 | |
| 285 | expected.push_back("baz"); |
| 286 | |
| 287 | actual.clear(); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 288 | Split("foo:bar:baz", ':', &actual); |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 289 | EXPECT_EQ(expected, actual); |
| 290 | |
| 291 | actual.clear(); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 292 | Split(":foo:bar:baz", ':', &actual); |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 293 | EXPECT_EQ(expected, actual); |
| 294 | |
| 295 | actual.clear(); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 296 | Split("foo:bar:baz:", ':', &actual); |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 297 | EXPECT_EQ(expected, actual); |
| 298 | |
| 299 | actual.clear(); |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 300 | Split(":foo:bar:baz:", ':', &actual); |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 301 | EXPECT_EQ(expected, actual); |
| 302 | } |
| 303 | |
Elliott Hughes | 48436bb | 2012-02-07 15:23:28 -0800 | [diff] [blame] | 304 | TEST_F(UtilsTest, Join) { |
| 305 | std::vector<std::string> strings; |
| 306 | |
| 307 | strings.clear(); |
| 308 | EXPECT_EQ("", Join(strings, ':')); |
| 309 | |
| 310 | strings.clear(); |
| 311 | strings.push_back("foo"); |
| 312 | EXPECT_EQ("foo", Join(strings, ':')); |
| 313 | |
| 314 | strings.clear(); |
| 315 | strings.push_back(""); |
| 316 | strings.push_back("foo"); |
| 317 | EXPECT_EQ(":foo", Join(strings, ':')); |
| 318 | |
| 319 | strings.clear(); |
| 320 | strings.push_back("foo"); |
| 321 | strings.push_back(""); |
| 322 | EXPECT_EQ("foo:", Join(strings, ':')); |
| 323 | |
| 324 | strings.clear(); |
| 325 | strings.push_back(""); |
| 326 | strings.push_back("foo"); |
| 327 | strings.push_back(""); |
| 328 | EXPECT_EQ(":foo:", Join(strings, ':')); |
| 329 | |
| 330 | strings.clear(); |
| 331 | strings.push_back("foo"); |
| 332 | strings.push_back("bar"); |
| 333 | EXPECT_EQ("foo:bar", Join(strings, ':')); |
| 334 | |
| 335 | strings.clear(); |
| 336 | strings.push_back("foo"); |
| 337 | strings.push_back("bar"); |
| 338 | strings.push_back("baz"); |
| 339 | EXPECT_EQ("foo:bar:baz", Join(strings, ':')); |
| 340 | } |
| 341 | |
Brian Carlstrom | 7a967b3 | 2012-03-28 15:23:10 -0700 | [diff] [blame] | 342 | TEST_F(UtilsTest, StartsWith) { |
| 343 | EXPECT_FALSE(StartsWith("foo", "bar")); |
| 344 | EXPECT_TRUE(StartsWith("foo", "foo")); |
| 345 | EXPECT_TRUE(StartsWith("food", "foo")); |
| 346 | EXPECT_FALSE(StartsWith("fo", "foo")); |
| 347 | } |
| 348 | |
| 349 | TEST_F(UtilsTest, EndsWith) { |
| 350 | EXPECT_FALSE(EndsWith("foo", "bar")); |
| 351 | EXPECT_TRUE(EndsWith("foo", "foo")); |
| 352 | EXPECT_TRUE(EndsWith("foofoo", "foo")); |
| 353 | EXPECT_FALSE(EndsWith("oo", "foo")); |
| 354 | } |
| 355 | |
Brian Carlstrom | 19a0836 | 2013-10-16 14:37:22 -0700 | [diff] [blame] | 356 | TEST_F(UtilsTest, GetDalvikCacheFilenameOrDie) { |
Narayan Kamath | 11d9f06 | 2014-04-23 20:24:57 +0100 | [diff] [blame] | 357 | EXPECT_STREQ("/foo/system@app@Foo.apk@classes.dex", |
| 358 | GetDalvikCacheFilenameOrDie("/system/app/Foo.apk", "/foo").c_str()); |
| 359 | |
| 360 | EXPECT_STREQ("/foo/data@app@foo-1.apk@classes.dex", |
| 361 | GetDalvikCacheFilenameOrDie("/data/app/foo-1.apk", "/foo").c_str()); |
| 362 | EXPECT_STREQ("/foo/system@framework@core.jar@classes.dex", |
| 363 | GetDalvikCacheFilenameOrDie("/system/framework/core.jar", "/foo").c_str()); |
| 364 | EXPECT_STREQ("/foo/system@framework@boot.art", |
| 365 | GetDalvikCacheFilenameOrDie("/system/framework/boot.art", "/foo").c_str()); |
Alex Light | 6e183f2 | 2014-07-18 14:57:04 -0700 | [diff] [blame] | 366 | EXPECT_STREQ("/foo/system@framework@boot.oat", |
| 367 | GetDalvikCacheFilenameOrDie("/system/framework/boot.oat", "/foo").c_str()); |
Brian Carlstrom | 19a0836 | 2013-10-16 14:37:22 -0700 | [diff] [blame] | 368 | } |
| 369 | |
Andreas Gampe | 40da286 | 2015-02-27 12:49:04 -0800 | [diff] [blame] | 370 | TEST_F(UtilsTest, GetDalvikCache) { |
| 371 | EXPECT_STREQ("", GetDalvikCache("should-not-exist123", false).c_str()); |
| 372 | |
| 373 | EXPECT_STREQ((android_data_ + "/dalvik-cache/.").c_str(), GetDalvikCache(".", false).c_str()); |
| 374 | EXPECT_STREQ((android_data_ + "/dalvik-cache/should-not-be-there").c_str(), |
| 375 | GetDalvikCache("should-not-be-there", true).c_str()); |
| 376 | } |
| 377 | |
| 378 | |
Brian Carlstrom | 0e12bdc | 2014-05-14 17:44:28 -0700 | [diff] [blame] | 379 | TEST_F(UtilsTest, GetSystemImageFilename) { |
| 380 | EXPECT_STREQ("/system/framework/arm/boot.art", |
| 381 | GetSystemImageFilename("/system/framework/boot.art", kArm).c_str()); |
| 382 | } |
| 383 | |
Brian Carlstrom | 6449c62 | 2014-02-10 23:48:36 -0800 | [diff] [blame] | 384 | TEST_F(UtilsTest, ExecSuccess) { |
| 385 | std::vector<std::string> command; |
| 386 | if (kIsTargetBuild) { |
| 387 | command.push_back("/system/bin/id"); |
| 388 | } else { |
| 389 | command.push_back("/usr/bin/id"); |
| 390 | } |
| 391 | std::string error_msg; |
Mathieu Chartier | 661974a | 2014-01-09 11:23:53 -0800 | [diff] [blame] | 392 | if (RUNNING_ON_VALGRIND == 0) { |
| 393 | // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks. |
| 394 | EXPECT_TRUE(Exec(command, &error_msg)); |
| 395 | } |
Brian Carlstrom | 6449c62 | 2014-02-10 23:48:36 -0800 | [diff] [blame] | 396 | EXPECT_EQ(0U, error_msg.size()) << error_msg; |
| 397 | } |
| 398 | |
Brian Carlstrom | a1ce1fe | 2014-02-24 23:23:58 -0800 | [diff] [blame] | 399 | TEST_F(UtilsTest, ExecError) { |
Andreas Gampe | 369810a | 2015-01-14 19:53:31 -0800 | [diff] [blame] | 400 | // This will lead to error messages in the log. |
| 401 | ScopedLogSeverity sls(LogSeverity::FATAL); |
| 402 | |
Brian Carlstrom | 6449c62 | 2014-02-10 23:48:36 -0800 | [diff] [blame] | 403 | std::vector<std::string> command; |
| 404 | command.push_back("bogus"); |
| 405 | std::string error_msg; |
Mathieu Chartier | 661974a | 2014-01-09 11:23:53 -0800 | [diff] [blame] | 406 | if (RUNNING_ON_VALGRIND == 0) { |
| 407 | // Running on valgrind fails due to some memory that leaks in thread alternate signal stacks. |
| 408 | EXPECT_FALSE(Exec(command, &error_msg)); |
| 409 | EXPECT_NE(0U, error_msg.size()); |
| 410 | } |
Brian Carlstrom | 6449c62 | 2014-02-10 23:48:36 -0800 | [diff] [blame] | 411 | } |
| 412 | |
Igor Murashkin | f5b4c50 | 2014-11-14 15:01:59 -0800 | [diff] [blame] | 413 | TEST_F(UtilsTest, RoundUpToPowerOfTwo) { |
| 414 | // Tests the constexpr variant since all the parameters are constexpr |
| 415 | EXPECT_EQ(0, RoundUpToPowerOfTwo(0)); |
| 416 | EXPECT_EQ(1, RoundUpToPowerOfTwo(1)); |
| 417 | EXPECT_EQ(2, RoundUpToPowerOfTwo(2)); |
| 418 | EXPECT_EQ(4, RoundUpToPowerOfTwo(3)); |
| 419 | EXPECT_EQ(8, RoundUpToPowerOfTwo(7)); |
| 420 | |
| 421 | EXPECT_EQ(0b10000L, RoundUpToPowerOfTwo(0b01101L)); |
| 422 | EXPECT_EQ(1ULL << 63, RoundUpToPowerOfTwo(1ULL << 62 | 1ULL)); |
| 423 | } |
| 424 | |
| 425 | TEST_F(UtilsTest, MostSignificantBit) { |
| 426 | EXPECT_EQ(-1, MostSignificantBit(0)); |
| 427 | EXPECT_EQ(0, MostSignificantBit(1)); |
| 428 | EXPECT_EQ(31, MostSignificantBit(~static_cast<uint32_t>(0))); |
| 429 | EXPECT_EQ(2, MostSignificantBit(0b110)); |
| 430 | EXPECT_EQ(2, MostSignificantBit(0b100)); |
| 431 | } |
| 432 | |
| 433 | TEST_F(UtilsTest, MinimumBitsToStore) { |
| 434 | EXPECT_EQ(0u, MinimumBitsToStore(0)); |
| 435 | EXPECT_EQ(1u, MinimumBitsToStore(1)); |
| 436 | EXPECT_EQ(2u, MinimumBitsToStore(0b10)); |
| 437 | EXPECT_EQ(2u, MinimumBitsToStore(0b11)); |
| 438 | EXPECT_EQ(3u, MinimumBitsToStore(0b100)); |
| 439 | EXPECT_EQ(3u, MinimumBitsToStore(0b110)); |
| 440 | EXPECT_EQ(3u, MinimumBitsToStore(0b101)); |
| 441 | EXPECT_EQ(8u, MinimumBitsToStore(0xFF)); |
| 442 | EXPECT_EQ(32u, MinimumBitsToStore(~static_cast<uint32_t>(0))); |
| 443 | } |
| 444 | |
David Brazdil | f646810 | 2015-03-27 10:31:38 +0000 | [diff] [blame] | 445 | static constexpr int64_t INT_MIN_minus1 = static_cast<int64_t>(INT_MIN) - 1; |
| 446 | static constexpr int64_t INT_MAX_plus1 = static_cast<int64_t>(INT_MAX) + 1; |
| 447 | static constexpr int64_t UINT_MAX_plus1 = static_cast<int64_t>(UINT_MAX) + 1; |
| 448 | |
| 449 | TEST_F(UtilsTest, IsInt) { |
| 450 | EXPECT_FALSE(IsInt(1, -2)); |
| 451 | EXPECT_TRUE(IsInt(1, -1)); |
| 452 | EXPECT_TRUE(IsInt(1, 0)); |
| 453 | EXPECT_FALSE(IsInt(1, 1)); |
| 454 | |
| 455 | EXPECT_FALSE(IsInt(4, -9)); |
| 456 | EXPECT_TRUE(IsInt(4, -8)); |
| 457 | EXPECT_TRUE(IsInt(4, 7)); |
| 458 | EXPECT_FALSE(IsInt(4, 8)); |
| 459 | |
| 460 | EXPECT_FALSE(IsInt(32, INT_MIN_minus1)); |
| 461 | EXPECT_TRUE(IsInt(32, INT_MIN)); |
| 462 | EXPECT_TRUE(IsInt(32, INT_MAX)); |
| 463 | EXPECT_FALSE(IsInt(32, INT_MAX_plus1)); |
| 464 | } |
| 465 | |
| 466 | TEST_F(UtilsTest, IsInt_Static) { |
| 467 | EXPECT_FALSE(IsInt<1>(-2)); |
| 468 | EXPECT_TRUE(IsInt<1>(-1)); |
| 469 | EXPECT_TRUE(IsInt<1>(0)); |
| 470 | EXPECT_FALSE(IsInt<1>(1)); |
| 471 | |
| 472 | EXPECT_FALSE(IsInt<4>(-9)); |
| 473 | EXPECT_TRUE(IsInt<4>(-8)); |
| 474 | EXPECT_TRUE(IsInt<4>(7)); |
| 475 | EXPECT_FALSE(IsInt<4>(8)); |
| 476 | |
| 477 | EXPECT_FALSE(IsInt<32>(INT_MIN_minus1)); |
| 478 | EXPECT_TRUE(IsInt<32>(INT_MIN)); |
| 479 | EXPECT_TRUE(IsInt<32>(INT_MAX)); |
| 480 | EXPECT_FALSE(IsInt<32>(INT_MAX_plus1)); |
| 481 | } |
| 482 | |
| 483 | TEST_F(UtilsTest, IsUint) { |
| 484 | EXPECT_FALSE(IsUint<1>(-1)); |
| 485 | EXPECT_TRUE(IsUint<1>(0)); |
| 486 | EXPECT_TRUE(IsUint<1>(1)); |
| 487 | EXPECT_FALSE(IsUint<1>(2)); |
| 488 | |
| 489 | EXPECT_FALSE(IsUint<4>(-1)); |
| 490 | EXPECT_TRUE(IsUint<4>(0)); |
| 491 | EXPECT_TRUE(IsUint<4>(15)); |
| 492 | EXPECT_FALSE(IsUint<4>(16)); |
| 493 | |
| 494 | EXPECT_FALSE(IsUint<32>(-1)); |
| 495 | EXPECT_TRUE(IsUint<32>(0)); |
| 496 | EXPECT_TRUE(IsUint<32>(UINT_MAX)); |
| 497 | EXPECT_FALSE(IsUint<32>(UINT_MAX_plus1)); |
| 498 | } |
| 499 | |
| 500 | TEST_F(UtilsTest, IsAbsoluteUint) { |
| 501 | EXPECT_FALSE(IsAbsoluteUint<1>(-2)); |
| 502 | EXPECT_TRUE(IsAbsoluteUint<1>(-1)); |
| 503 | EXPECT_TRUE(IsAbsoluteUint<32>(0)); |
| 504 | EXPECT_TRUE(IsAbsoluteUint<1>(1)); |
| 505 | EXPECT_FALSE(IsAbsoluteUint<1>(2)); |
| 506 | |
| 507 | EXPECT_FALSE(IsAbsoluteUint<4>(-16)); |
| 508 | EXPECT_TRUE(IsAbsoluteUint<4>(-15)); |
| 509 | EXPECT_TRUE(IsAbsoluteUint<32>(0)); |
| 510 | EXPECT_TRUE(IsAbsoluteUint<4>(15)); |
| 511 | EXPECT_FALSE(IsAbsoluteUint<4>(16)); |
| 512 | |
| 513 | EXPECT_FALSE(IsAbsoluteUint<32>(-UINT_MAX_plus1)); |
| 514 | EXPECT_TRUE(IsAbsoluteUint<32>(-UINT_MAX)); |
| 515 | EXPECT_TRUE(IsAbsoluteUint<32>(0)); |
| 516 | EXPECT_TRUE(IsAbsoluteUint<32>(UINT_MAX)); |
| 517 | EXPECT_FALSE(IsAbsoluteUint<32>(UINT_MAX_plus1)); |
| 518 | } |
| 519 | |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 520 | } // namespace art |