| OLD | NEW |
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/files/file.h" | |
| 6 #include "base/files/file_path.h" | |
| 7 #include "base/files/file_util.h" | |
| 8 #include "base/files/scoped_temp_dir.h" | |
| 9 #include "base/path_service.h" | |
| 10 #include "base/strings/string_piece.h" | |
| 11 #include "testing/gtest/include/gtest/gtest.h" | |
| 12 #include "ui/base/resource/data_pack.h" | |
| 13 #include "ui/base/ui_base_paths.h" | |
| 14 | |
| 15 namespace ui { | |
| 16 | |
| 17 class DataPackTest | |
| 18 : public testing::TestWithParam<DataPack::TextEncodingType> { | |
| 19 public: | |
| 20 DataPackTest() {} | |
| 21 }; | |
| 22 | |
| 23 extern const char kSamplePakContents[]; | |
| 24 extern const char kSampleCorruptPakContents[]; | |
| 25 extern const size_t kSamplePakSize; | |
| 26 extern const size_t kSampleCorruptPakSize; | |
| 27 | |
| 28 TEST(DataPackTest, LoadFromPath) { | |
| 29 base::ScopedTempDir dir; | |
| 30 ASSERT_TRUE(dir.CreateUniqueTempDir()); | |
| 31 base::FilePath data_path = dir.path().Append(FILE_PATH_LITERAL("sample.pak")); | |
| 32 | |
| 33 // Dump contents into the pak file. | |
| 34 ASSERT_EQ(base::WriteFile(data_path, kSamplePakContents, kSamplePakSize), | |
| 35 static_cast<int>(kSamplePakSize)); | |
| 36 | |
| 37 // Load the file through the data pack API. | |
| 38 DataPack pack(SCALE_FACTOR_100P); | |
| 39 ASSERT_TRUE(pack.LoadFromPath(data_path)); | |
| 40 | |
| 41 base::StringPiece data; | |
| 42 ASSERT_TRUE(pack.HasResource(4)); | |
| 43 ASSERT_TRUE(pack.GetStringPiece(4, &data)); | |
| 44 EXPECT_EQ("this is id 4", data); | |
| 45 ASSERT_TRUE(pack.HasResource(6)); | |
| 46 ASSERT_TRUE(pack.GetStringPiece(6, &data)); | |
| 47 EXPECT_EQ("this is id 6", data); | |
| 48 | |
| 49 // Try reading zero-length data blobs, just in case. | |
| 50 ASSERT_TRUE(pack.GetStringPiece(1, &data)); | |
| 51 EXPECT_EQ(0U, data.length()); | |
| 52 ASSERT_TRUE(pack.GetStringPiece(10, &data)); | |
| 53 EXPECT_EQ(0U, data.length()); | |
| 54 | |
| 55 // Try looking up an invalid key. | |
| 56 ASSERT_FALSE(pack.HasResource(140)); | |
| 57 ASSERT_FALSE(pack.GetStringPiece(140, &data)); | |
| 58 } | |
| 59 | |
| 60 TEST(DataPackTest, LoadFromFile) { | |
| 61 base::ScopedTempDir dir; | |
| 62 ASSERT_TRUE(dir.CreateUniqueTempDir()); | |
| 63 base::FilePath data_path = dir.path().Append(FILE_PATH_LITERAL("sample.pak")); | |
| 64 | |
| 65 // Dump contents into the pak file. | |
| 66 ASSERT_EQ(base::WriteFile(data_path, kSamplePakContents, kSamplePakSize), | |
| 67 static_cast<int>(kSamplePakSize)); | |
| 68 | |
| 69 base::File file(data_path, base::File::FLAG_OPEN | base::File::FLAG_READ); | |
| 70 ASSERT_TRUE(file.IsValid()); | |
| 71 | |
| 72 // Load the file through the data pack API. | |
| 73 DataPack pack(SCALE_FACTOR_100P); | |
| 74 ASSERT_TRUE(pack.LoadFromFile(file.Pass())); | |
| 75 | |
| 76 base::StringPiece data; | |
| 77 ASSERT_TRUE(pack.HasResource(4)); | |
| 78 ASSERT_TRUE(pack.GetStringPiece(4, &data)); | |
| 79 EXPECT_EQ("this is id 4", data); | |
| 80 ASSERT_TRUE(pack.HasResource(6)); | |
| 81 ASSERT_TRUE(pack.GetStringPiece(6, &data)); | |
| 82 EXPECT_EQ("this is id 6", data); | |
| 83 | |
| 84 // Try reading zero-length data blobs, just in case. | |
| 85 ASSERT_TRUE(pack.GetStringPiece(1, &data)); | |
| 86 EXPECT_EQ(0U, data.length()); | |
| 87 ASSERT_TRUE(pack.GetStringPiece(10, &data)); | |
| 88 EXPECT_EQ(0U, data.length()); | |
| 89 | |
| 90 // Try looking up an invalid key. | |
| 91 ASSERT_FALSE(pack.HasResource(140)); | |
| 92 ASSERT_FALSE(pack.GetStringPiece(140, &data)); | |
| 93 } | |
| 94 | |
| 95 TEST(DataPackTest, LoadFromFileRegion) { | |
| 96 base::ScopedTempDir dir; | |
| 97 ASSERT_TRUE(dir.CreateUniqueTempDir()); | |
| 98 base::FilePath data_path = dir.path().Append(FILE_PATH_LITERAL("sample.pak")); | |
| 99 | |
| 100 // Construct a file which has a non page-aligned zero-filled header followed | |
| 101 // by the actual pak file content. | |
| 102 const char kPadding[5678] = {0}; | |
| 103 ASSERT_EQ(static_cast<int>(sizeof(kPadding)), | |
| 104 base::WriteFile(data_path, kPadding, sizeof(kPadding))); | |
| 105 ASSERT_TRUE(base::AppendToFile( | |
| 106 data_path, kSamplePakContents, kSamplePakSize)); | |
| 107 | |
| 108 base::File file(data_path, base::File::FLAG_OPEN | base::File::FLAG_READ); | |
| 109 ASSERT_TRUE(file.IsValid()); | |
| 110 | |
| 111 // Load the file through the data pack API. | |
| 112 DataPack pack(SCALE_FACTOR_100P); | |
| 113 base::MemoryMappedFile::Region region(sizeof(kPadding), kSamplePakSize); | |
| 114 ASSERT_TRUE(pack.LoadFromFileRegion(file.Pass(), region)); | |
| 115 | |
| 116 base::StringPiece data; | |
| 117 ASSERT_TRUE(pack.HasResource(4)); | |
| 118 ASSERT_TRUE(pack.GetStringPiece(4, &data)); | |
| 119 EXPECT_EQ("this is id 4", data); | |
| 120 ASSERT_TRUE(pack.HasResource(6)); | |
| 121 ASSERT_TRUE(pack.GetStringPiece(6, &data)); | |
| 122 EXPECT_EQ("this is id 6", data); | |
| 123 | |
| 124 // Try reading zero-length data blobs, just in case. | |
| 125 ASSERT_TRUE(pack.GetStringPiece(1, &data)); | |
| 126 EXPECT_EQ(0U, data.length()); | |
| 127 ASSERT_TRUE(pack.GetStringPiece(10, &data)); | |
| 128 EXPECT_EQ(0U, data.length()); | |
| 129 | |
| 130 // Try looking up an invalid key. | |
| 131 ASSERT_FALSE(pack.HasResource(140)); | |
| 132 ASSERT_FALSE(pack.GetStringPiece(140, &data)); | |
| 133 } | |
| 134 | |
| 135 INSTANTIATE_TEST_CASE_P(WriteBINARY, DataPackTest, ::testing::Values( | |
| 136 DataPack::BINARY)); | |
| 137 INSTANTIATE_TEST_CASE_P(WriteUTF8, DataPackTest, ::testing::Values( | |
| 138 DataPack::UTF8)); | |
| 139 INSTANTIATE_TEST_CASE_P(WriteUTF16, DataPackTest, ::testing::Values( | |
| 140 DataPack::UTF16)); | |
| 141 | |
| 142 TEST(DataPackTest, LoadFileWithTruncatedHeader) { | |
| 143 base::FilePath data_path; | |
| 144 ASSERT_TRUE(PathService::Get(UI_DIR_TEST_DATA, &data_path)); | |
| 145 data_path = data_path.AppendASCII("data_pack_unittest/truncated-header.pak"); | |
| 146 | |
| 147 DataPack pack(SCALE_FACTOR_100P); | |
| 148 ASSERT_FALSE(pack.LoadFromPath(data_path)); | |
| 149 } | |
| 150 | |
| 151 TEST_P(DataPackTest, Write) { | |
| 152 base::ScopedTempDir dir; | |
| 153 ASSERT_TRUE(dir.CreateUniqueTempDir()); | |
| 154 base::FilePath file = dir.path().Append(FILE_PATH_LITERAL("data.pak")); | |
| 155 | |
| 156 std::string one("one"); | |
| 157 std::string two("two"); | |
| 158 std::string three("three"); | |
| 159 std::string four("four"); | |
| 160 std::string fifteen("fifteen"); | |
| 161 | |
| 162 std::map<uint16, base::StringPiece> resources; | |
| 163 resources.insert(std::make_pair(1, base::StringPiece(one))); | |
| 164 resources.insert(std::make_pair(2, base::StringPiece(two))); | |
| 165 resources.insert(std::make_pair(15, base::StringPiece(fifteen))); | |
| 166 resources.insert(std::make_pair(3, base::StringPiece(three))); | |
| 167 resources.insert(std::make_pair(4, base::StringPiece(four))); | |
| 168 ASSERT_TRUE(DataPack::WritePack(file, resources, GetParam())); | |
| 169 | |
| 170 // Now try to read the data back in. | |
| 171 DataPack pack(SCALE_FACTOR_100P); | |
| 172 ASSERT_TRUE(pack.LoadFromPath(file)); | |
| 173 EXPECT_EQ(pack.GetTextEncodingType(), GetParam()); | |
| 174 | |
| 175 base::StringPiece data; | |
| 176 ASSERT_TRUE(pack.GetStringPiece(1, &data)); | |
| 177 EXPECT_EQ(one, data); | |
| 178 ASSERT_TRUE(pack.GetStringPiece(2, &data)); | |
| 179 EXPECT_EQ(two, data); | |
| 180 ASSERT_TRUE(pack.GetStringPiece(3, &data)); | |
| 181 EXPECT_EQ(three, data); | |
| 182 ASSERT_TRUE(pack.GetStringPiece(4, &data)); | |
| 183 EXPECT_EQ(four, data); | |
| 184 ASSERT_TRUE(pack.GetStringPiece(15, &data)); | |
| 185 EXPECT_EQ(fifteen, data); | |
| 186 } | |
| 187 | |
| 188 #if defined(OS_POSIX) | |
| 189 TEST(DataPackTest, ModifiedWhileUsed) { | |
| 190 base::ScopedTempDir dir; | |
| 191 ASSERT_TRUE(dir.CreateUniqueTempDir()); | |
| 192 base::FilePath data_path = dir.path().Append(FILE_PATH_LITERAL("sample.pak")); | |
| 193 | |
| 194 // Dump contents into the pak file. | |
| 195 ASSERT_EQ(base::WriteFile(data_path, kSamplePakContents, kSamplePakSize), | |
| 196 static_cast<int>(kSamplePakSize)); | |
| 197 | |
| 198 base::File file(data_path, base::File::FLAG_OPEN | base::File::FLAG_READ); | |
| 199 ASSERT_TRUE(file.IsValid()); | |
| 200 | |
| 201 // Load the file through the data pack API. | |
| 202 DataPack pack(SCALE_FACTOR_100P); | |
| 203 ASSERT_TRUE(pack.LoadFromFile(file.Pass())); | |
| 204 | |
| 205 base::StringPiece data; | |
| 206 ASSERT_TRUE(pack.HasResource(10)); | |
| 207 ASSERT_TRUE(pack.GetStringPiece(10, &data)); | |
| 208 | |
| 209 ASSERT_EQ(base::WriteFile(data_path, kSampleCorruptPakContents, | |
| 210 kSampleCorruptPakSize), | |
| 211 static_cast<int>(kSampleCorruptPakSize)); | |
| 212 | |
| 213 // Reading asset #10 should now fail as it extends past the end of the file. | |
| 214 ASSERT_TRUE(pack.HasResource(10)); | |
| 215 ASSERT_FALSE(pack.GetStringPiece(10, &data)); | |
| 216 } | |
| 217 #endif | |
| 218 | |
| 219 } // namespace ui | |
| OLD | NEW |