Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2018 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 <stdint.h> |
| 18 | #include <sys/types.h> |
| 19 | #include <unistd.h> |
| 20 | |
| 21 | #include <unordered_map> |
| 22 | |
Mark Salyzyn | 9f1cf25 | 2018-11-12 12:45:59 -0800 | [diff] [blame] | 23 | #include <android-base/file.h> |
Martin Stjernholm | bb4f2b4 | 2018-12-19 14:28:33 +0000 | [diff] [blame] | 24 | #include <gtest/gtest.h> |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 25 | #include <unwindstack/MapInfo.h> |
| 26 | #include <unwindstack/Memory.h> |
| 27 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 28 | #include "DexFile.h" |
Christopher Ferris | 7747b60 | 2018-01-31 19:05:19 -0800 | [diff] [blame] | 29 | #include "DexFileData.h" |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 30 | #include "MemoryFake.h" |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 31 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 32 | namespace unwindstack { |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 33 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 34 | TEST(DexFileTest, from_file_open_non_exist) { |
Martin Stjernholm | bb4f2b4 | 2018-12-19 14:28:33 +0000 | [diff] [blame] | 35 | EXPECT_TRUE(DexFileFromFile::Create(0, "/file/does/not/exist") == nullptr); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 36 | } |
| 37 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 38 | TEST(DexFileTest, from_file_open_too_small) { |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 39 | TemporaryFile tf; |
| 40 | ASSERT_TRUE(tf.fd != -1); |
| 41 | |
Martin Stjernholm | 2677b80 | 2019-01-09 23:26:33 +0000 | [diff] [blame] | 42 | ASSERT_EQ(size_t{10}, static_cast<size_t>(TEMP_FAILURE_RETRY(write(tf.fd, kDexData, 10)))); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 43 | |
| 44 | // Header too small. |
Martin Stjernholm | bb4f2b4 | 2018-12-19 14:28:33 +0000 | [diff] [blame] | 45 | EXPECT_TRUE(DexFileFromFile::Create(0, tf.path) == nullptr); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 46 | |
| 47 | // Header correct, file too small. |
| 48 | ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)); |
Martin Stjernholm | 2677b80 | 2019-01-09 23:26:33 +0000 | [diff] [blame] | 49 | ASSERT_EQ(sizeof(kDexData) - 1, |
| 50 | static_cast<size_t>(TEMP_FAILURE_RETRY(write(tf.fd, kDexData, sizeof(kDexData) - 1)))); |
Martin Stjernholm | bb4f2b4 | 2018-12-19 14:28:33 +0000 | [diff] [blame] | 51 | EXPECT_TRUE(DexFileFromFile::Create(0, tf.path) == nullptr); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 52 | } |
| 53 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 54 | TEST(DexFileTest, from_file_open) { |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 55 | TemporaryFile tf; |
| 56 | ASSERT_TRUE(tf.fd != -1); |
| 57 | |
| 58 | ASSERT_EQ(sizeof(kDexData), |
| 59 | static_cast<size_t>(TEMP_FAILURE_RETRY(write(tf.fd, kDexData, sizeof(kDexData))))); |
| 60 | |
Martin Stjernholm | bb4f2b4 | 2018-12-19 14:28:33 +0000 | [diff] [blame] | 61 | EXPECT_TRUE(DexFileFromFile::Create(0, tf.path) != nullptr); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 62 | } |
| 63 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 64 | TEST(DexFileTest, from_file_open_non_zero_offset) { |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 65 | TemporaryFile tf; |
| 66 | ASSERT_TRUE(tf.fd != -1); |
| 67 | |
| 68 | ASSERT_EQ(0x100, lseek(tf.fd, 0x100, SEEK_SET)); |
| 69 | ASSERT_EQ(sizeof(kDexData), |
| 70 | static_cast<size_t>(TEMP_FAILURE_RETRY(write(tf.fd, kDexData, sizeof(kDexData))))); |
| 71 | |
Martin Stjernholm | bb4f2b4 | 2018-12-19 14:28:33 +0000 | [diff] [blame] | 72 | EXPECT_TRUE(DexFileFromFile::Create(0x100, tf.path) != nullptr); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 73 | } |
| 74 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 75 | TEST(DexFileTest, from_memory_fail_too_small_for_header) { |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 76 | MemoryFake memory; |
| 77 | |
Martin Stjernholm | 2677b80 | 2019-01-09 23:26:33 +0000 | [diff] [blame] | 78 | memory.SetMemory(0x1000, kDexData, 10); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 79 | |
Martin Stjernholm | bb4f2b4 | 2018-12-19 14:28:33 +0000 | [diff] [blame] | 80 | EXPECT_TRUE(DexFileFromMemory::Create(0x1000, &memory, "") == nullptr); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 81 | } |
| 82 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 83 | TEST(DexFileTest, from_memory_fail_too_small_for_data) { |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 84 | MemoryFake memory; |
| 85 | |
| 86 | memory.SetMemory(0x1000, kDexData, sizeof(kDexData) - 2); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 87 | |
Martin Stjernholm | bb4f2b4 | 2018-12-19 14:28:33 +0000 | [diff] [blame] | 88 | EXPECT_TRUE(DexFileFromMemory::Create(0x1000, &memory, "") == nullptr); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 89 | } |
| 90 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 91 | TEST(DexFileTest, from_memory_open) { |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 92 | MemoryFake memory; |
| 93 | |
| 94 | memory.SetMemory(0x1000, kDexData, sizeof(kDexData)); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 95 | |
Martin Stjernholm | bb4f2b4 | 2018-12-19 14:28:33 +0000 | [diff] [blame] | 96 | EXPECT_TRUE(DexFileFromMemory::Create(0x1000, &memory, "") != nullptr); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 97 | } |
| 98 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 99 | TEST(DexFileTest, create_using_file) { |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 100 | TemporaryFile tf; |
| 101 | ASSERT_TRUE(tf.fd != -1); |
| 102 | |
| 103 | ASSERT_EQ(0x500, lseek(tf.fd, 0x500, SEEK_SET)); |
| 104 | ASSERT_EQ(sizeof(kDexData), |
| 105 | static_cast<size_t>(TEMP_FAILURE_RETRY(write(tf.fd, kDexData, sizeof(kDexData))))); |
| 106 | |
| 107 | MemoryFake memory; |
Christopher Ferris | 9d5712c | 2018-10-01 21:01:09 -0700 | [diff] [blame] | 108 | MapInfo info(nullptr, 0, 0x10000, 0, 0x5, tf.path); |
Martin Stjernholm | bb4f2b4 | 2018-12-19 14:28:33 +0000 | [diff] [blame] | 109 | EXPECT_TRUE(DexFile::Create(0x500, &memory, &info) != nullptr); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 110 | } |
| 111 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 112 | TEST(DexFileTest, create_using_file_non_zero_start) { |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 113 | TemporaryFile tf; |
| 114 | ASSERT_TRUE(tf.fd != -1); |
| 115 | |
| 116 | ASSERT_EQ(0x500, lseek(tf.fd, 0x500, SEEK_SET)); |
| 117 | ASSERT_EQ(sizeof(kDexData), |
| 118 | static_cast<size_t>(TEMP_FAILURE_RETRY(write(tf.fd, kDexData, sizeof(kDexData))))); |
| 119 | |
| 120 | MemoryFake memory; |
Christopher Ferris | 9d5712c | 2018-10-01 21:01:09 -0700 | [diff] [blame] | 121 | MapInfo info(nullptr, 0x100, 0x10000, 0, 0x5, tf.path); |
Martin Stjernholm | bb4f2b4 | 2018-12-19 14:28:33 +0000 | [diff] [blame] | 122 | EXPECT_TRUE(DexFile::Create(0x600, &memory, &info) != nullptr); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 123 | } |
| 124 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 125 | TEST(DexFileTest, create_using_file_non_zero_offset) { |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 126 | TemporaryFile tf; |
| 127 | ASSERT_TRUE(tf.fd != -1); |
| 128 | |
| 129 | ASSERT_EQ(0x500, lseek(tf.fd, 0x500, SEEK_SET)); |
| 130 | ASSERT_EQ(sizeof(kDexData), |
| 131 | static_cast<size_t>(TEMP_FAILURE_RETRY(write(tf.fd, kDexData, sizeof(kDexData))))); |
| 132 | |
| 133 | MemoryFake memory; |
Christopher Ferris | 9d5712c | 2018-10-01 21:01:09 -0700 | [diff] [blame] | 134 | MapInfo info(nullptr, 0x100, 0x10000, 0x200, 0x5, tf.path); |
Martin Stjernholm | bb4f2b4 | 2018-12-19 14:28:33 +0000 | [diff] [blame] | 135 | EXPECT_TRUE(DexFile::Create(0x400, &memory, &info) != nullptr); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 136 | } |
| 137 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 138 | TEST(DexFileTest, create_using_memory_empty_file) { |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 139 | MemoryFake memory; |
| 140 | memory.SetMemory(0x4000, kDexData, sizeof(kDexData)); |
Christopher Ferris | 9d5712c | 2018-10-01 21:01:09 -0700 | [diff] [blame] | 141 | MapInfo info(nullptr, 0x100, 0x10000, 0x200, 0x5, ""); |
Martin Stjernholm | bb4f2b4 | 2018-12-19 14:28:33 +0000 | [diff] [blame] | 142 | EXPECT_TRUE(DexFile::Create(0x4000, &memory, &info) != nullptr); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 143 | } |
| 144 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 145 | TEST(DexFileTest, create_using_memory_file_does_not_exist) { |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 146 | MemoryFake memory; |
| 147 | memory.SetMemory(0x4000, kDexData, sizeof(kDexData)); |
Christopher Ferris | 9d5712c | 2018-10-01 21:01:09 -0700 | [diff] [blame] | 148 | MapInfo info(nullptr, 0x100, 0x10000, 0x200, 0x5, "/does/not/exist"); |
Martin Stjernholm | bb4f2b4 | 2018-12-19 14:28:33 +0000 | [diff] [blame] | 149 | EXPECT_TRUE(DexFile::Create(0x4000, &memory, &info) != nullptr); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 150 | } |
| 151 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 152 | TEST(DexFileTest, create_using_memory_file_is_malformed) { |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 153 | TemporaryFile tf; |
| 154 | ASSERT_TRUE(tf.fd != -1); |
| 155 | |
| 156 | ASSERT_EQ(sizeof(kDexData) - 10, |
| 157 | static_cast<size_t>(TEMP_FAILURE_RETRY(write(tf.fd, kDexData, sizeof(kDexData) - 10)))); |
| 158 | |
| 159 | MemoryFake memory; |
| 160 | memory.SetMemory(0x4000, kDexData, sizeof(kDexData)); |
Christopher Ferris | 9d5712c | 2018-10-01 21:01:09 -0700 | [diff] [blame] | 161 | MapInfo info(nullptr, 0x4000, 0x10000, 0x200, 0x5, "/does/not/exist"); |
Martin Stjernholm | bb4f2b4 | 2018-12-19 14:28:33 +0000 | [diff] [blame] | 162 | std::unique_ptr<DexFile> dex_file = DexFile::Create(0x4000, &memory, &info); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 163 | ASSERT_TRUE(dex_file != nullptr); |
| 164 | |
| 165 | // Check it came from memory by clearing memory and verifying it fails. |
| 166 | memory.Clear(); |
Martin Stjernholm | bb4f2b4 | 2018-12-19 14:28:33 +0000 | [diff] [blame] | 167 | dex_file = DexFile::Create(0x4000, &memory, &info); |
| 168 | EXPECT_TRUE(dex_file == nullptr); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 169 | } |
| 170 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 171 | TEST(DexFileTest, get_method) { |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 172 | MemoryFake memory; |
| 173 | memory.SetMemory(0x4000, kDexData, sizeof(kDexData)); |
Christopher Ferris | 9d5712c | 2018-10-01 21:01:09 -0700 | [diff] [blame] | 174 | MapInfo info(nullptr, 0x100, 0x10000, 0x200, 0x5, ""); |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 175 | std::unique_ptr<DexFile> dex_file(DexFile::Create(0x4000, &memory, &info)); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 176 | ASSERT_TRUE(dex_file != nullptr); |
| 177 | |
| 178 | std::string method; |
| 179 | uint64_t method_offset; |
David Srbecky | b9cc4fb | 2019-04-05 18:23:32 +0000 | [diff] [blame] | 180 | ASSERT_TRUE(dex_file->GetMethodInformation(0x102, &method, &method_offset)); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 181 | EXPECT_EQ("Main.<init>", method); |
| 182 | EXPECT_EQ(2U, method_offset); |
| 183 | |
David Srbecky | b9cc4fb | 2019-04-05 18:23:32 +0000 | [diff] [blame] | 184 | ASSERT_TRUE(dex_file->GetMethodInformation(0x118, &method, &method_offset)); |
David Srbecky | 02d0f79 | 2018-03-24 00:29:14 +0000 | [diff] [blame] | 185 | EXPECT_EQ("Main.main", method); |
| 186 | EXPECT_EQ(0U, method_offset); |
David Srbecky | 02d0f79 | 2018-03-24 00:29:14 +0000 | [diff] [blame] | 187 | } |
| 188 | |
| 189 | TEST(DexFileTest, get_method_empty) { |
| 190 | MemoryFake memory; |
| 191 | memory.SetMemory(0x4000, kDexData, sizeof(kDexData)); |
Christopher Ferris | 9d5712c | 2018-10-01 21:01:09 -0700 | [diff] [blame] | 192 | MapInfo info(nullptr, 0x100, 0x10000, 0x200, 0x5, ""); |
David Srbecky | 02d0f79 | 2018-03-24 00:29:14 +0000 | [diff] [blame] | 193 | std::unique_ptr<DexFile> dex_file(DexFile::Create(0x4000, &memory, &info)); |
| 194 | ASSERT_TRUE(dex_file != nullptr); |
| 195 | |
| 196 | std::string method; |
| 197 | uint64_t method_offset; |
David Srbecky | b9cc4fb | 2019-04-05 18:23:32 +0000 | [diff] [blame] | 198 | EXPECT_FALSE(dex_file->GetMethodInformation(0x100000, &method, &method_offset)); |
David Srbecky | 02d0f79 | 2018-03-24 00:29:14 +0000 | [diff] [blame] | 199 | |
David Srbecky | b9cc4fb | 2019-04-05 18:23:32 +0000 | [diff] [blame] | 200 | EXPECT_FALSE(dex_file->GetMethodInformation(0x98, &method, &method_offset)); |
Christopher Ferris | 0b06a59 | 2018-01-19 10:26:36 -0800 | [diff] [blame] | 201 | } |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 202 | |
| 203 | } // namespace unwindstack |