1 // Copyright 2017 The Chromium OS 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 "bsdiff/patch_reader.h"
6
7 #include <unistd.h>
8
9 #include <algorithm>
10 #include <string>
11 #include <vector>
12
13 #include <gtest/gtest.h>
14
15 #include "bsdiff/brotli_compressor.h"
16 #include "bsdiff/bz2_compressor.h"
17 #include "bsdiff/utils.h"
18
19 namespace {
20
EncodeInt64(int64_t x,uint8_t * buf)21 void EncodeInt64(int64_t x, uint8_t* buf) {
22 uint64_t y = x < 0 ? (1ULL << 63ULL) - x : x;
23 for (int i = 0; i < 8; ++i) {
24 buf[i] = y & 0xff;
25 y /= 256;
26 }
27 }
28
29 } // namespace
30
31 namespace bsdiff {
32
33 class PatchReaderTest : public testing::Test {
34 protected:
CompressData()35 void CompressData() {
36 for (size_t i = 0; i < diff_data_.size(); i++) {
37 uint8_t buf[24];
38 EncodeInt64(diff_data_[i].size(), buf);
39 EncodeInt64(extra_data_[i].size(), buf + 8);
40 EncodeInt64(offset_increment_[i], buf + 16);
41 EXPECT_TRUE(ctrl_stream_->Write(buf, sizeof(buf)));
42 EXPECT_TRUE(diff_stream_->Write(
43 reinterpret_cast<const uint8_t*>(diff_data_[i].data()),
44 diff_data_[i].size()));
45 EXPECT_TRUE(extra_stream_->Write(
46 reinterpret_cast<const uint8_t*>(extra_data_[i].data()),
47 extra_data_[i].size()));
48 }
49 EXPECT_TRUE(ctrl_stream_->Finish());
50 EXPECT_TRUE(diff_stream_->Finish());
51 EXPECT_TRUE(extra_stream_->Finish());
52 }
53
ConstructPatchData(std::vector<uint8_t> * patch_data)54 void ConstructPatchData(std::vector<uint8_t>* patch_data) {
55 EXPECT_EQ(static_cast<size_t>(8), patch_data->size());
56 // Encode the header
57 uint8_t buf[24];
58 EncodeInt64(ctrl_stream_->GetCompressedData().size(), buf);
59 EncodeInt64(diff_stream_->GetCompressedData().size(), buf + 8);
60 EncodeInt64(new_file_size_, buf + 16);
61 std::copy(buf, buf + sizeof(buf), std::back_inserter(*patch_data));
62
63 // Concatenate the three streams into one patch.
64 std::copy(ctrl_stream_->GetCompressedData().begin(),
65 ctrl_stream_->GetCompressedData().end(),
66 std::back_inserter(*patch_data));
67 std::copy(diff_stream_->GetCompressedData().begin(),
68 diff_stream_->GetCompressedData().end(),
69 std::back_inserter(*patch_data));
70 std::copy(extra_stream_->GetCompressedData().begin(),
71 extra_stream_->GetCompressedData().end(),
72 std::back_inserter(*patch_data));
73 }
74
VerifyPatch(const std::vector<uint8_t> & patch_data)75 void VerifyPatch(const std::vector<uint8_t>& patch_data) {
76 BsdiffPatchReader patch_reader;
77 EXPECT_TRUE(patch_reader.Init(patch_data.data(), patch_data.size()));
78 EXPECT_EQ(new_file_size_, patch_reader.new_file_size());
79 // Check that the decompressed data matches what we wrote.
80 for (size_t i = 0; i < diff_data_.size(); i++) {
81 ControlEntry control_entry(0, 0, 0);
82 EXPECT_TRUE(patch_reader.ParseControlEntry(&control_entry));
83 EXPECT_EQ(diff_data_[i].size(), control_entry.diff_size);
84 EXPECT_EQ(extra_data_[i].size(), control_entry.extra_size);
85 EXPECT_EQ(offset_increment_[i], control_entry.offset_increment);
86
87 uint8_t buffer[128] = {};
88 EXPECT_TRUE(patch_reader.ReadDiffStream(buffer, diff_data_[i].size()));
89 EXPECT_EQ(0, memcmp(buffer, diff_data_[i].data(), diff_data_[i].size()));
90 EXPECT_TRUE(patch_reader.ReadExtraStream(buffer, extra_data_[i].size()));
91 EXPECT_EQ(0,
92 memcmp(buffer, extra_data_[i].data(), extra_data_[i].size()));
93 }
94 EXPECT_TRUE(patch_reader.Finish());
95 }
96
97 size_t new_file_size_{500};
98 std::vector<std::string> diff_data_{"HelloWorld", "BspatchPatchTest",
99 "BspatchDiffData"};
100 std::vector<std::string> extra_data_{"HelloWorld!", "BZ2PatchReaderSmoke",
101 "BspatchExtraData"};
102 std::vector<int64_t> offset_increment_{100, 200, 300};
103
104 // The compressor streams.
105 std::unique_ptr<CompressorInterface> ctrl_stream_{nullptr};
106 std::unique_ptr<CompressorInterface> diff_stream_{nullptr};
107 std::unique_ptr<CompressorInterface> extra_stream_{nullptr};
108 };
109
TEST_F(PatchReaderTest,PatchReaderLegacyFormatSmoke)110 TEST_F(PatchReaderTest, PatchReaderLegacyFormatSmoke) {
111 ctrl_stream_.reset(new BZ2Compressor());
112 diff_stream_.reset(new BZ2Compressor());
113 extra_stream_.reset(new BZ2Compressor());
114
115 CompressData();
116
117 std::vector<uint8_t> patch_data;
118 std::copy(kLegacyMagicHeader, kLegacyMagicHeader + 8,
119 std::back_inserter(patch_data));
120 ConstructPatchData(&patch_data);
121
122 VerifyPatch(patch_data);
123 }
124
TEST_F(PatchReaderTest,PatchReaderNewFormatSmoke)125 TEST_F(PatchReaderTest, PatchReaderNewFormatSmoke) {
126 // Compress the data with one bz2 and two brotli compressors.
127 ctrl_stream_.reset(new BZ2Compressor());
128 diff_stream_.reset(new BrotliCompressor(11));
129 extra_stream_.reset(new BrotliCompressor(11));
130
131 CompressData();
132
133 std::vector<uint8_t> patch_data;
134 std::copy(kBSDF2MagicHeader, kBSDF2MagicHeader + 5,
135 std::back_inserter(patch_data));
136 patch_data.push_back(static_cast<uint8_t>(CompressorType::kBZ2));
137 patch_data.push_back(static_cast<uint8_t>(CompressorType::kBrotli));
138 patch_data.push_back(static_cast<uint8_t>(CompressorType::kBrotli));
139 ConstructPatchData(&patch_data);
140
141 VerifyPatch(patch_data);
142 }
143
144 } // namespace bsdiff
145