ui/base/resource/data_pack_unittest.cc

   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