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