1 //
2 // Copyright (C) 2015 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 "update_engine/payload_generator/block_mapping.h"
18
19 #include <fcntl.h>
20 #include <sys/stat.h>
21 #include <sys/types.h>
22
23 #include <string>
24 #include <vector>
25
26 #include <gtest/gtest.h>
27
28 #include "update_engine/common/test_utils.h"
29 #include "update_engine/common/utils.h"
30
31 using std::string;
32 using std::vector;
33
34 namespace chromeos_update_engine {
35
36 namespace {
37
38 } // namespace
39
40 class BlockMappingTest : public ::testing::Test {
41 protected:
SetUp()42 void SetUp() override {
43 EXPECT_TRUE(utils::MakeTempFile("BlockMappingTest_old.XXXXXX",
44 &old_part_path_,
45 nullptr));
46 EXPECT_TRUE(utils::MakeTempFile("BlockMappingTest_new.XXXXXX",
47 &new_part_path_,
48 nullptr));
49
50 old_part_unlinker_.reset(new ScopedPathUnlinker(old_part_path_));
51 new_part_unlinker_.reset(new ScopedPathUnlinker(new_part_path_));
52 }
53
54 // Old new partition files used in testing.
55 string old_part_path_;
56 string new_part_path_;
57 std::unique_ptr<ScopedPathUnlinker> old_part_unlinker_;
58 std::unique_ptr<ScopedPathUnlinker> new_part_unlinker_;
59
60 size_t block_size_{1024};
61 BlockMapping bm_{block_size_}; // BlockMapping under test.
62 };
63
TEST_F(BlockMappingTest,FirstAddedBlockIsZero)64 TEST_F(BlockMappingTest, FirstAddedBlockIsZero) {
65 brillo::Blob blob(block_size_);
66 // The BlockMapping just assigns the block ids in order, so it doesn't matter
67 // what are the contents of the first block.
68 blob[0] = 42;
69 EXPECT_EQ(0, bm_.AddBlock(blob));
70 blob[0] = 5;
71 EXPECT_EQ(1, bm_.AddBlock(blob));
72 }
73
TEST_F(BlockMappingTest,BlocksAreNotKeptInMemory)74 TEST_F(BlockMappingTest, BlocksAreNotKeptInMemory) {
75 test_utils::WriteFileString(old_part_path_, string(block_size_, 'a'));
76 int old_fd = HANDLE_EINTR(open(old_part_path_.c_str(), O_RDONLY));
77 ScopedFdCloser old_fd_closer(&old_fd);
78
79 EXPECT_EQ(0, bm_.AddDiskBlock(old_fd, 0));
80
81 // Check that the block_data is not stored on memory if we just used the block
82 // once.
83 for (const auto& it : bm_.mapping_) {
84 for (const BlockMapping::UniqueBlock& ublock : it.second) {
85 EXPECT_TRUE(ublock.block_data.empty());
86 }
87 }
88
89 brillo::Blob block(block_size_, 'a');
90 for (int i = 0; i < 5; ++i) {
91 // Re-add the same block 5 times.
92 EXPECT_EQ(0, bm_.AddBlock(block));
93 }
94
95 for (const auto& it : bm_.mapping_) {
96 for (const BlockMapping::UniqueBlock& ublock : it.second) {
97 EXPECT_FALSE(ublock.block_data.empty());
98 // The block was loaded from disk only 4 times, and after that the counter
99 // is not updated anymore.
100 EXPECT_EQ(4U, ublock.times_read);
101 }
102 }
103 }
104
TEST_F(BlockMappingTest,MapPartitionBlocks)105 TEST_F(BlockMappingTest, MapPartitionBlocks) {
106 // A string with 10 blocks where all the blocks are different.
107 string old_contents(10 * block_size_, '\0');
108 for (size_t i = 0; i < old_contents.size(); ++i)
109 old_contents[i] = 4 + i / block_size_;
110 test_utils::WriteFileString(old_part_path_, old_contents);
111
112 // A string including the block with all zeros and overlapping some of the
113 // other blocks in old_contents.
114 string new_contents(6 * block_size_, '\0');
115 for (size_t i = 0; i < new_contents.size(); ++i)
116 new_contents[i] = i / block_size_;
117 test_utils::WriteFileString(new_part_path_, new_contents);
118
119 vector<BlockMapping::BlockId> old_ids, new_ids;
120 EXPECT_TRUE(MapPartitionBlocks(old_part_path_,
121 new_part_path_,
122 old_contents.size(),
123 new_contents.size(),
124 block_size_,
125 &old_ids,
126 &new_ids));
127
128 EXPECT_EQ((vector<BlockMapping::BlockId>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}),
129 old_ids);
130 EXPECT_EQ((vector<BlockMapping::BlockId>{0, 11, 12, 13, 1, 2}),
131 new_ids);
132 }
133
134 } // namespace chromeos_update_engine
135