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: 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 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 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 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