diff options
Diffstat (limited to 'runtime/dex_file_test.cc')
| -rw-r--r-- | runtime/dex_file_test.cc | 270 |
1 files changed, 270 insertions, 0 deletions
diff --git a/runtime/dex_file_test.cc b/runtime/dex_file_test.cc new file mode 100644 index 0000000000..e7899ecf31 --- /dev/null +++ b/runtime/dex_file_test.cc @@ -0,0 +1,270 @@ +/* + * 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 "dex_file.h" + +#include "UniquePtr.h" +#include "common_test.h" + +namespace art { + +class DexFileTest : public CommonTest {}; + +TEST_F(DexFileTest, Open) { + ScopedObjectAccess soa(Thread::Current()); + const DexFile* dex(OpenTestDexFile("Nested")); + ASSERT_TRUE(dex != NULL); +} + +// Although this is the same content logically as the Nested test dex, +// the DexFileHeader test is sensitive to subtle changes in the +// contents due to the checksum etc, so we embed the exact input here. +// +// class Nested { +// class Inner { +// } +// } +static const char kRawDex[] = + "ZGV4CjAzNQAQedgAe7gM1B/WHsWJ6L7lGAISGC7yjD2IAwAAcAAAAHhWNBIAAAAAAAAAAMQCAAAP" + "AAAAcAAAAAcAAACsAAAAAgAAAMgAAAABAAAA4AAAAAMAAADoAAAAAgAAAAABAABIAgAAQAEAAK4B" + "AAC2AQAAvQEAAM0BAADXAQAA+wEAABsCAAA+AgAAUgIAAF8CAABiAgAAZgIAAHMCAAB5AgAAgQIA" + "AAIAAAADAAAABAAAAAUAAAAGAAAABwAAAAkAAAAJAAAABgAAAAAAAAAKAAAABgAAAKgBAAAAAAEA" + "DQAAAAAAAQAAAAAAAQAAAAAAAAAFAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAIAAAAiAEAAKsCAAAA" + "AAAAAQAAAAAAAAAFAAAAAAAAAAgAAACYAQAAuAIAAAAAAAACAAAAlAIAAJoCAAABAAAAowIAAAIA" + "AgABAAAAiAIAAAYAAABbAQAAcBACAAAADgABAAEAAQAAAI4CAAAEAAAAcBACAAAADgBAAQAAAAAA" + "AAAAAAAAAAAATAEAAAAAAAAAAAAAAAAAAAEAAAABAAY8aW5pdD4ABUlubmVyAA5MTmVzdGVkJElu" + "bmVyOwAITE5lc3RlZDsAIkxkYWx2aWsvYW5ub3RhdGlvbi9FbmNsb3NpbmdDbGFzczsAHkxkYWx2" + "aWsvYW5ub3RhdGlvbi9Jbm5lckNsYXNzOwAhTGRhbHZpay9hbm5vdGF0aW9uL01lbWJlckNsYXNz" + "ZXM7ABJMamF2YS9sYW5nL09iamVjdDsAC05lc3RlZC5qYXZhAAFWAAJWTAALYWNjZXNzRmxhZ3MA" + "BG5hbWUABnRoaXMkMAAFdmFsdWUAAgEABw4AAQAHDjwAAgIBDhgBAgMCCwQADBcBAgQBDhwBGAAA" + "AQEAAJAgAICABNQCAAABAAGAgATwAgAAEAAAAAAAAAABAAAAAAAAAAEAAAAPAAAAcAAAAAIAAAAH" + "AAAArAAAAAMAAAACAAAAyAAAAAQAAAABAAAA4AAAAAUAAAADAAAA6AAAAAYAAAACAAAAAAEAAAMQ" + "AAACAAAAQAEAAAEgAAACAAAAVAEAAAYgAAACAAAAiAEAAAEQAAABAAAAqAEAAAIgAAAPAAAArgEA" + "AAMgAAACAAAAiAIAAAQgAAADAAAAlAIAAAAgAAACAAAAqwIAAAAQAAABAAAAxAIAAA=="; + +static const DexFile* OpenDexFileBase64(const char* base64, + const std::string& location) { + // decode base64 + CHECK(base64 != NULL); + size_t length; + UniquePtr<byte[]> dex_bytes(DecodeBase64(base64, &length)); + CHECK(dex_bytes.get() != NULL); + + // write to provided file + UniquePtr<File> file(OS::OpenFile(location.c_str(), true)); + CHECK(file.get() != NULL); + if (!file->WriteFully(dex_bytes.get(), length)) { + PLOG(FATAL) << "Failed to write base64 as dex file"; + } + file.reset(); + + // read dex file + ScopedObjectAccess soa(Thread::Current()); + const DexFile* dex_file = DexFile::Open(location, location); + CHECK(dex_file != NULL); + return dex_file; +} + +TEST_F(DexFileTest, Header) { + ScratchFile tmp; + UniquePtr<const DexFile> raw(OpenDexFileBase64(kRawDex, tmp.GetFilename())); + ASSERT_TRUE(raw.get() != NULL); + + const DexFile::Header& header = raw->GetHeader(); + // TODO: header.magic_ + EXPECT_EQ(0x00d87910U, header.checksum_); + // TODO: header.signature_ + EXPECT_EQ(904U, header.file_size_); + EXPECT_EQ(112U, header.header_size_); + EXPECT_EQ(0U, header.link_size_); + EXPECT_EQ(0U, header.link_off_); + EXPECT_EQ(15U, header.string_ids_size_); + EXPECT_EQ(112U, header.string_ids_off_); + EXPECT_EQ(7U, header.type_ids_size_); + EXPECT_EQ(172U, header.type_ids_off_); + EXPECT_EQ(2U, header.proto_ids_size_); + EXPECT_EQ(200U, header.proto_ids_off_); + EXPECT_EQ(1U, header.field_ids_size_); + EXPECT_EQ(224U, header.field_ids_off_); + EXPECT_EQ(3U, header.method_ids_size_); + EXPECT_EQ(232U, header.method_ids_off_); + EXPECT_EQ(2U, header.class_defs_size_); + EXPECT_EQ(256U, header.class_defs_off_); + EXPECT_EQ(584U, header.data_size_); + EXPECT_EQ(320U, header.data_off_); + + EXPECT_EQ(header.checksum_, raw->GetLocationChecksum()); +} + +TEST_F(DexFileTest, GetLocationChecksum) { + ScopedObjectAccess soa(Thread::Current()); + const DexFile* raw(OpenTestDexFile("Main")); + EXPECT_NE(raw->GetHeader().checksum_, raw->GetLocationChecksum()); +} + +TEST_F(DexFileTest, GetChecksum) { + uint32_t checksum; + ScopedObjectAccess soa(Thread::Current()); + EXPECT_TRUE(DexFile::GetChecksum(GetLibCoreDexFileName(), checksum)); + EXPECT_EQ(java_lang_dex_file_->GetLocationChecksum(), checksum); +} + +TEST_F(DexFileTest, ClassDefs) { + ScopedObjectAccess soa(Thread::Current()); + const DexFile* raw(OpenTestDexFile("Nested")); + ASSERT_TRUE(raw != NULL); + EXPECT_EQ(2U, raw->NumClassDefs()); + + const DexFile::ClassDef& c0 = raw->GetClassDef(0); + EXPECT_STREQ("LNested$Inner;", raw->GetClassDescriptor(c0)); + + const DexFile::ClassDef& c1 = raw->GetClassDef(1); + EXPECT_STREQ("LNested;", raw->GetClassDescriptor(c1)); +} + +TEST_F(DexFileTest, CreateMethodSignature) { + ScopedObjectAccess soa(Thread::Current()); + const DexFile* raw(OpenTestDexFile("CreateMethodSignature")); + ASSERT_TRUE(raw != NULL); + EXPECT_EQ(1U, raw->NumClassDefs()); + + const DexFile::ClassDef& class_def = raw->GetClassDef(0); + ASSERT_STREQ("LCreateMethodSignature;", raw->GetClassDescriptor(class_def)); + + const byte* class_data = raw->GetClassData(class_def); + ASSERT_TRUE(class_data != NULL); + ClassDataItemIterator it(*raw, class_data); + + EXPECT_EQ(1u, it.NumDirectMethods()); + + // Check the signature for the static initializer. + { + ASSERT_EQ(1U, it.NumDirectMethods()); + const DexFile::MethodId& method_id = raw->GetMethodId(it.GetMemberIndex()); + uint32_t proto_idx = method_id.proto_idx_; + const char* name = raw->StringDataByIdx(method_id.name_idx_); + ASSERT_STREQ("<init>", name); + int32_t length; + std::string signature(raw->CreateMethodSignature(proto_idx, &length)); + ASSERT_EQ("()V", signature); + } + + // Check both virtual methods. + ASSERT_EQ(2U, it.NumVirtualMethods()); + { + it.Next(); + const DexFile::MethodId& method_id = raw->GetMethodId(it.GetMemberIndex()); + + const char* name = raw->StringDataByIdx(method_id.name_idx_); + ASSERT_STREQ("m1", name); + + uint32_t proto_idx = method_id.proto_idx_; + int32_t length; + std::string signature(raw->CreateMethodSignature(proto_idx, &length)); + ASSERT_EQ("(IDJLjava/lang/Object;)Ljava/lang/Float;", signature); + } + + { + it.Next(); + const DexFile::MethodId& method_id = raw->GetMethodId(it.GetMemberIndex()); + + const char* name = raw->StringDataByIdx(method_id.name_idx_); + ASSERT_STREQ("m2", name); + + uint32_t proto_idx = method_id.proto_idx_; + int32_t length; + std::string signature(raw->CreateMethodSignature(proto_idx, &length)); + ASSERT_EQ("(ZSC)LCreateMethodSignature;", signature); + } +} + +TEST_F(DexFileTest, FindStringId) { + ScopedObjectAccess soa(Thread::Current()); + const DexFile* raw(OpenTestDexFile("CreateMethodSignature")); + ASSERT_TRUE(raw != NULL); + EXPECT_EQ(1U, raw->NumClassDefs()); + + const char* strings[] = { "LCreateMethodSignature;", "Ljava/lang/Float;", "Ljava/lang/Object;", + "D", "I", "J", NULL }; + for (size_t i = 0; strings[i] != NULL; i++) { + const char* str = strings[i]; + const DexFile::StringId* str_id = raw->FindStringId(str); + const char* dex_str = raw->GetStringData(*str_id); + EXPECT_STREQ(dex_str, str); + } +} + +TEST_F(DexFileTest, FindTypeId) { + for (size_t i = 0; i < java_lang_dex_file_->NumTypeIds(); i++) { + const char* type_str = java_lang_dex_file_->StringByTypeIdx(i); + const DexFile::StringId* type_str_id = java_lang_dex_file_->FindStringId(type_str); + ASSERT_TRUE(type_str_id != NULL); + uint32_t type_str_idx = java_lang_dex_file_->GetIndexForStringId(*type_str_id); + const DexFile::TypeId* type_id = java_lang_dex_file_->FindTypeId(type_str_idx); + ASSERT_TRUE(type_id != NULL); + EXPECT_EQ(java_lang_dex_file_->GetIndexForTypeId(*type_id), i); + } +} + +TEST_F(DexFileTest, FindProtoId) { + for (size_t i = 0; i < java_lang_dex_file_->NumProtoIds(); i++) { + const DexFile::ProtoId& to_find = java_lang_dex_file_->GetProtoId(i); + const DexFile::TypeList* to_find_tl = java_lang_dex_file_->GetProtoParameters(to_find); + std::vector<uint16_t> to_find_types; + if (to_find_tl != NULL) { + for (size_t j = 0; j < to_find_tl->Size(); j++) { + to_find_types.push_back(to_find_tl->GetTypeItem(j).type_idx_); + } + } + const DexFile::ProtoId* found = + java_lang_dex_file_->FindProtoId(to_find.return_type_idx_, to_find_types); + ASSERT_TRUE(found != NULL); + EXPECT_EQ(java_lang_dex_file_->GetIndexForProtoId(*found), i); + } +} + +TEST_F(DexFileTest, FindMethodId) { + for (size_t i = 0; i < java_lang_dex_file_->NumMethodIds(); i++) { + const DexFile::MethodId& to_find = java_lang_dex_file_->GetMethodId(i); + const DexFile::TypeId& klass = java_lang_dex_file_->GetTypeId(to_find.class_idx_); + const DexFile::StringId& name = java_lang_dex_file_->GetStringId(to_find.name_idx_); + const DexFile::ProtoId& signature = java_lang_dex_file_->GetProtoId(to_find.proto_idx_); + const DexFile::MethodId* found = java_lang_dex_file_->FindMethodId(klass, name, signature); + int32_t length; + ASSERT_TRUE(found != NULL) << "Didn't find method " << i << ": " + << java_lang_dex_file_->StringByTypeIdx(to_find.class_idx_) << "." + << java_lang_dex_file_->GetStringData(name) + << java_lang_dex_file_->CreateMethodSignature(to_find.proto_idx_, &length); + EXPECT_EQ(java_lang_dex_file_->GetIndexForMethodId(*found), i); + } +} + +TEST_F(DexFileTest, FindFieldId) { + for (size_t i = 0; i < java_lang_dex_file_->NumFieldIds(); i++) { + const DexFile::FieldId& to_find = java_lang_dex_file_->GetFieldId(i); + const DexFile::TypeId& klass = java_lang_dex_file_->GetTypeId(to_find.class_idx_); + const DexFile::StringId& name = java_lang_dex_file_->GetStringId(to_find.name_idx_); + const DexFile::TypeId& type = java_lang_dex_file_->GetTypeId(to_find.type_idx_); + const DexFile::FieldId* found = java_lang_dex_file_->FindFieldId(klass, name, type); + ASSERT_TRUE(found != NULL) << "Didn't find field " << i << ": " + << java_lang_dex_file_->StringByTypeIdx(to_find.type_idx_) << " " + << java_lang_dex_file_->StringByTypeIdx(to_find.class_idx_) << "." + << java_lang_dex_file_->GetStringData(name); + EXPECT_EQ(java_lang_dex_file_->GetIndexForFieldId(*found), i); + } +} + +} // namespace art |