OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2009 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 <sys/types.h> |
| 6 #include <sys/stat.h> |
| 7 #include <fcntl.h> |
| 8 #include <unistd.h> |
| 9 #include <string> |
| 10 #include <vector> |
| 11 #include "base/string_util.h" |
| 12 #include <gtest/gtest.h> |
| 13 #include "chromeos/obsolete_logging.h" |
| 14 #include "update_engine/decompressing_file_writer.h" |
| 15 #include "update_engine/delta_diff_generator.h" |
| 16 #include "update_engine/delta_diff_parser.h" |
| 17 #include "update_engine/gzip.h" |
| 18 #include "update_engine/mock_file_writer.h" |
| 19 #include "update_engine/subprocess.h" |
| 20 #include "update_engine/test_utils.h" |
| 21 #include "update_engine/utils.h" |
| 22 |
| 23 namespace chromeos_update_engine { |
| 24 |
| 25 using std::string; |
| 26 using std::vector; |
| 27 |
| 28 class DeltaDiffGeneratorTest : public ::testing::Test {}; |
| 29 |
| 30 namespace { |
| 31 void DumpProto(const DeltaArchiveManifest* archive) { |
| 32 for (int i = 0; i < archive->files_size(); i++) { |
| 33 printf("Node %d\n", i); |
| 34 const DeltaArchiveManifest_File& file = archive->files(i); |
| 35 for (int j = 0; j < file.children_size(); j++) { |
| 36 const DeltaArchiveManifest_File_Child& child = file.children(j); |
| 37 printf(" %d %s\n", child.index(), child.name().c_str()); |
| 38 } |
| 39 } |
| 40 } |
| 41 |
| 42 // The following files are generated at the path 'base': |
| 43 // / |
| 44 // cdev (c 2 1) |
| 45 // dir/ |
| 46 // bdev (b 3 1) |
| 47 // emptydir/ (owner:group = 501:503) |
| 48 // hello ("hello") |
| 49 // newempty ("") |
| 50 // subdir/ |
| 51 // fifo |
| 52 // link -> /target |
| 53 // encoding/ |
| 54 // long_new |
| 55 // long_small_change |
| 56 // nochange |
| 57 // onebyte |
| 58 // hi ("hi") |
| 59 void GenerateFilesAtPath(const string& base) { |
| 60 const char* base_c = base.c_str(); |
| 61 EXPECT_EQ(0, System(StringPrintf("echo hi > '%s/hi'", base_c))); |
| 62 EXPECT_EQ(0, System(StringPrintf("mkdir -p '%s/dir'", base_c))); |
| 63 EXPECT_EQ(0, System(StringPrintf("rm -f '%s/dir/bdev'", base_c))); |
| 64 EXPECT_EQ(0, System(StringPrintf("mknod '%s/dir/bdev' b 3 1", base_c))); |
| 65 EXPECT_EQ(0, System(StringPrintf("rm -f '%s/cdev'", base_c))); |
| 66 EXPECT_EQ(0, System(StringPrintf("mknod '%s/cdev' c 2 1", base_c))); |
| 67 EXPECT_EQ(0, System(StringPrintf("mkdir -p '%s/dir/subdir'", base_c))); |
| 68 EXPECT_EQ(0, System(StringPrintf("mkdir -p '%s/dir/emptydir'", base_c))); |
| 69 EXPECT_EQ(0, System(StringPrintf("chown 501:503 '%s/dir/emptydir'", base_c))); |
| 70 EXPECT_EQ(0, System(StringPrintf("rm -f '%s/dir/subdir/fifo'", base_c))); |
| 71 EXPECT_EQ(0, System(StringPrintf("mkfifo '%s/dir/subdir/fifo'", base_c))); |
| 72 EXPECT_EQ(0, System(StringPrintf("ln -f -s /target '%s/dir/subdir/link'", |
| 73 base_c))); |
| 74 |
| 75 // Things that will encode differently: |
| 76 EXPECT_EQ(0, System(StringPrintf("mkdir -p '%s/encoding'", base_c))); |
| 77 EXPECT_EQ(0, System(StringPrintf("echo nochange > '%s/encoding/nochange'", |
| 78 base_c))); |
| 79 EXPECT_EQ(0, System(StringPrintf("echo -n > '%s/encoding/onebyte'", base_c))); |
| 80 EXPECT_EQ(0, System(StringPrintf("echo -n > '%s/encoding/long_new'", |
| 81 base_c))); |
| 82 // Random 1 MiB byte length file |
| 83 EXPECT_TRUE(WriteFile((base + |
| 84 "/encoding/long_small_change").c_str(), |
| 85 reinterpret_cast<const char*>(kRandomString), |
| 86 sizeof(kRandomString))); |
| 87 } |
| 88 // base points to a folder that was passed to GenerateFilesAtPath(). |
| 89 // This edits some, so that one can make a diff from the original data |
| 90 // and the edited data. |
| 91 void EditFilesAtPath(const string& base) { |
| 92 CHECK_EQ(0, System(string("echo hello > ") + base + "/dir/hello")); |
| 93 CHECK_EQ(0, System(string("echo -n > ") + base + "/dir/newempty")); |
| 94 CHECK_EQ(0, System(string("echo newhi > ") + base + "/hi")); |
| 95 CHECK_EQ(0, System(string("echo -n h >> ") + base + |
| 96 "/encoding/onebyte")); |
| 97 CHECK_EQ(0, System(string("echo -n h >> ") + base + |
| 98 "/encoding/long_small_change")); |
| 99 CHECK_EQ(0, System(string("echo -n This is a pice of text that should " |
| 100 "compress well since it is just ascii and it " |
| 101 "has repetition xxxxxxxxxxxxxxxxxxxxx" |
| 102 "xxxxxxxxxxxxxxxxxxxx > ") + base + |
| 103 "/encoding/long_new")); |
| 104 } |
| 105 |
| 106 } // namespace {} |
| 107 |
| 108 TEST_F(DeltaDiffGeneratorTest, FakerootEncodeMetadataToProtoBufferTest) { |
| 109 char cwd[1000]; |
| 110 ASSERT_EQ(cwd, getcwd(cwd, sizeof(cwd))) << "cwd buf possibly too small"; |
| 111 ASSERT_EQ(0, System(string("mkdir -p ") + cwd + "/diff-gen-test")); |
| 112 ASSERT_EQ(0, System(string("mkdir -p ") + cwd + "/diff-gen-test/old")); |
| 113 ASSERT_EQ(0, System(string("mkdir -p ") + cwd + "/diff-gen-test/new")); |
| 114 GenerateFilesAtPath(string(cwd) + "/diff-gen-test/old"); |
| 115 GenerateFilesAtPath(string(cwd) + "/diff-gen-test/new"); |
| 116 EditFilesAtPath(string(cwd) + "/diff-gen-test/new"); |
| 117 |
| 118 DeltaArchiveManifest* archive = |
| 119 DeltaDiffGenerator::EncodeMetadataToProtoBuffer( |
| 120 (string(cwd) + "/diff-gen-test/new").c_str()); |
| 121 EXPECT_TRUE(NULL != archive); |
| 122 |
| 123 EXPECT_EQ(16, archive->files_size()); |
| 124 //DumpProto(archive); |
| 125 const DeltaArchiveManifest_File& root = archive->files(0); |
| 126 EXPECT_TRUE(S_ISDIR(root.mode())); |
| 127 EXPECT_EQ(0, root.uid()); |
| 128 EXPECT_EQ(0, root.gid()); |
| 129 ASSERT_EQ(4, root.children_size()); |
| 130 EXPECT_EQ("cdev", root.children(0).name()); |
| 131 EXPECT_EQ("dir", root.children(1).name()); |
| 132 EXPECT_EQ("encoding", root.children(2).name()); |
| 133 EXPECT_EQ("hi", root.children(3).name()); |
| 134 EXPECT_FALSE(root.has_data_format()); |
| 135 EXPECT_FALSE(root.has_data_offset()); |
| 136 EXPECT_FALSE(root.has_data_length()); |
| 137 |
| 138 const DeltaArchiveManifest_File& cdev = |
| 139 archive->files(root.children(0).index()); |
| 140 EXPECT_EQ(0, cdev.children_size()); |
| 141 EXPECT_TRUE(S_ISCHR(cdev.mode())); |
| 142 EXPECT_EQ(0, cdev.uid()); |
| 143 EXPECT_EQ(0, cdev.gid()); |
| 144 EXPECT_FALSE(cdev.has_data_format()); |
| 145 EXPECT_FALSE(cdev.has_data_offset()); |
| 146 EXPECT_FALSE(cdev.has_data_length()); |
| 147 |
| 148 const DeltaArchiveManifest_File& hi = |
| 149 archive->files(root.children(3).index()); |
| 150 EXPECT_EQ(0, hi.children_size()); |
| 151 EXPECT_TRUE(S_ISREG(hi.mode())); |
| 152 EXPECT_EQ(0, hi.uid()); |
| 153 EXPECT_EQ(0, hi.gid()); |
| 154 EXPECT_FALSE(hi.has_data_format()); |
| 155 EXPECT_FALSE(hi.has_data_offset()); |
| 156 EXPECT_FALSE(hi.has_data_length()); |
| 157 |
| 158 const DeltaArchiveManifest_File& encoding = |
| 159 archive->files(root.children(2).index()); |
| 160 EXPECT_TRUE(S_ISDIR(encoding.mode())); |
| 161 EXPECT_EQ(0, encoding.uid()); |
| 162 EXPECT_EQ(0, encoding.gid()); |
| 163 EXPECT_EQ(4, encoding.children_size()); |
| 164 EXPECT_EQ("long_new", encoding.children(0).name()); |
| 165 EXPECT_EQ("long_small_change", encoding.children(1).name()); |
| 166 EXPECT_EQ("nochange", encoding.children(2).name()); |
| 167 EXPECT_EQ("onebyte", encoding.children(3).name()); |
| 168 EXPECT_FALSE(encoding.has_data_format()); |
| 169 EXPECT_FALSE(encoding.has_data_offset()); |
| 170 EXPECT_FALSE(encoding.has_data_length()); |
| 171 |
| 172 const DeltaArchiveManifest_File& long_new = |
| 173 archive->files(encoding.children(0).index()); |
| 174 EXPECT_EQ(0, long_new.children_size()); |
| 175 EXPECT_TRUE(S_ISREG(long_new.mode())); |
| 176 EXPECT_EQ(0, long_new.uid()); |
| 177 EXPECT_EQ(0, long_new.gid()); |
| 178 EXPECT_FALSE(long_new.has_data_format()); |
| 179 EXPECT_FALSE(long_new.has_data_offset()); |
| 180 EXPECT_FALSE(long_new.has_data_length()); |
| 181 |
| 182 const DeltaArchiveManifest_File& long_small_change = |
| 183 archive->files(encoding.children(1).index()); |
| 184 EXPECT_EQ(0, long_small_change.children_size()); |
| 185 EXPECT_TRUE(S_ISREG(long_small_change.mode())); |
| 186 EXPECT_EQ(0, long_small_change.uid()); |
| 187 EXPECT_EQ(0, long_small_change.gid()); |
| 188 EXPECT_FALSE(long_small_change.has_data_format()); |
| 189 EXPECT_FALSE(long_small_change.has_data_offset()); |
| 190 EXPECT_FALSE(long_small_change.has_data_length()); |
| 191 |
| 192 const DeltaArchiveManifest_File& nochange = |
| 193 archive->files(encoding.children(2).index()); |
| 194 EXPECT_EQ(0, nochange.children_size()); |
| 195 EXPECT_TRUE(S_ISREG(nochange.mode())); |
| 196 EXPECT_EQ(0, nochange.uid()); |
| 197 EXPECT_EQ(0, nochange.gid()); |
| 198 EXPECT_FALSE(nochange.has_data_format()); |
| 199 EXPECT_FALSE(nochange.has_data_offset()); |
| 200 EXPECT_FALSE(nochange.has_data_length()); |
| 201 |
| 202 const DeltaArchiveManifest_File& onebyte = |
| 203 archive->files(encoding.children(3).index()); |
| 204 EXPECT_EQ(0, onebyte.children_size()); |
| 205 EXPECT_TRUE(S_ISREG(onebyte.mode())); |
| 206 EXPECT_EQ(0, onebyte.uid()); |
| 207 EXPECT_EQ(0, onebyte.gid()); |
| 208 EXPECT_FALSE(onebyte.has_data_format()); |
| 209 EXPECT_FALSE(onebyte.has_data_offset()); |
| 210 EXPECT_FALSE(onebyte.has_data_length()); |
| 211 |
| 212 const DeltaArchiveManifest_File& dir = |
| 213 archive->files(root.children(1).index()); |
| 214 EXPECT_TRUE(S_ISDIR(dir.mode())); |
| 215 EXPECT_EQ(0, dir.uid()); |
| 216 EXPECT_EQ(0, dir.gid()); |
| 217 ASSERT_EQ(5, dir.children_size()); |
| 218 EXPECT_EQ("bdev", dir.children(0).name()); |
| 219 EXPECT_EQ("emptydir", dir.children(1).name()); |
| 220 EXPECT_EQ("hello", dir.children(2).name()); |
| 221 EXPECT_EQ("newempty", dir.children(3).name()); |
| 222 EXPECT_EQ("subdir", dir.children(4).name()); |
| 223 EXPECT_FALSE(dir.has_data_format()); |
| 224 EXPECT_FALSE(dir.has_data_offset()); |
| 225 EXPECT_FALSE(dir.has_data_length()); |
| 226 |
| 227 const DeltaArchiveManifest_File& bdev = |
| 228 archive->files(dir.children(0).index()); |
| 229 EXPECT_EQ(0, bdev.children_size()); |
| 230 EXPECT_TRUE(S_ISBLK(bdev.mode())); |
| 231 EXPECT_EQ(0, bdev.uid()); |
| 232 EXPECT_EQ(0, bdev.gid()); |
| 233 EXPECT_FALSE(bdev.has_data_format()); |
| 234 EXPECT_FALSE(bdev.has_data_offset()); |
| 235 EXPECT_FALSE(bdev.has_data_length()); |
| 236 |
| 237 const DeltaArchiveManifest_File& emptydir = |
| 238 archive->files(dir.children(1).index()); |
| 239 EXPECT_EQ(0, emptydir.children_size()); |
| 240 EXPECT_TRUE(S_ISDIR(emptydir.mode())); |
| 241 EXPECT_EQ(501, emptydir.uid()); |
| 242 EXPECT_EQ(503, emptydir.gid()); |
| 243 EXPECT_FALSE(emptydir.has_data_format()); |
| 244 EXPECT_FALSE(emptydir.has_data_offset()); |
| 245 EXPECT_FALSE(emptydir.has_data_length()); |
| 246 |
| 247 const DeltaArchiveManifest_File& hello = |
| 248 archive->files(dir.children(2).index()); |
| 249 EXPECT_EQ(0, hello.children_size()); |
| 250 EXPECT_TRUE(S_ISREG(hello.mode())); |
| 251 EXPECT_EQ(0, hello.uid()); |
| 252 EXPECT_EQ(0, hello.gid()); |
| 253 EXPECT_FALSE(hello.has_data_format()); |
| 254 EXPECT_FALSE(hello.has_data_offset()); |
| 255 EXPECT_FALSE(hello.has_data_length()); |
| 256 |
| 257 const DeltaArchiveManifest_File& newempty = |
| 258 archive->files(dir.children(3).index()); |
| 259 EXPECT_EQ(0, newempty.children_size()); |
| 260 EXPECT_TRUE(S_ISREG(newempty.mode())); |
| 261 EXPECT_EQ(0, newempty.uid()); |
| 262 EXPECT_EQ(0, newempty.gid()); |
| 263 EXPECT_FALSE(newempty.has_data_format()); |
| 264 EXPECT_FALSE(newempty.has_data_offset()); |
| 265 EXPECT_FALSE(newempty.has_data_length()); |
| 266 |
| 267 const DeltaArchiveManifest_File& subdir = |
| 268 archive->files(dir.children(4).index()); |
| 269 EXPECT_EQ(2, subdir.children_size()); |
| 270 EXPECT_EQ("fifo", subdir.children(0).name()); |
| 271 EXPECT_EQ("link", subdir.children(1).name()); |
| 272 EXPECT_TRUE(S_ISDIR(subdir.mode())); |
| 273 EXPECT_EQ(0, subdir.uid()); |
| 274 EXPECT_EQ(0, subdir.gid()); |
| 275 EXPECT_FALSE(subdir.has_data_format()); |
| 276 EXPECT_FALSE(subdir.has_data_offset()); |
| 277 EXPECT_FALSE(subdir.has_data_length()); |
| 278 |
| 279 const DeltaArchiveManifest_File& fifo = |
| 280 archive->files(subdir.children(0).index()); |
| 281 EXPECT_EQ(0, fifo.children_size()); |
| 282 EXPECT_TRUE(S_ISFIFO(fifo.mode())); |
| 283 EXPECT_EQ(0, fifo.uid()); |
| 284 EXPECT_EQ(0, fifo.gid()); |
| 285 EXPECT_FALSE(fifo.has_data_format()); |
| 286 EXPECT_FALSE(fifo.has_data_offset()); |
| 287 EXPECT_FALSE(fifo.has_data_length()); |
| 288 |
| 289 const DeltaArchiveManifest_File& link = |
| 290 archive->files(subdir.children(1).index()); |
| 291 EXPECT_EQ(0, link.children_size()); |
| 292 EXPECT_TRUE(S_ISLNK(link.mode())); |
| 293 EXPECT_EQ(0, link.uid()); |
| 294 EXPECT_EQ(0, link.gid()); |
| 295 EXPECT_FALSE(link.has_data_format()); |
| 296 EXPECT_FALSE(link.has_data_offset()); |
| 297 EXPECT_FALSE(link.has_data_length()); |
| 298 } |
| 299 |
| 300 TEST_F(DeltaDiffGeneratorTest, FakerootEncodeDataToDeltaFileTest) { |
| 301 char cwd[1000]; |
| 302 ASSERT_EQ(cwd, getcwd(cwd, sizeof(cwd))) << "cwd buf possibly too small"; |
| 303 ASSERT_EQ(0, System(string("mkdir -p ") + cwd + "/diff-gen-test")); |
| 304 ASSERT_EQ(0, System(string("mkdir -p ") + cwd + "/diff-gen-test/old")); |
| 305 ASSERT_EQ(0, System(string("mkdir -p ") + cwd + "/diff-gen-test/new")); |
| 306 GenerateFilesAtPath(string(cwd) + "/diff-gen-test/old"); |
| 307 GenerateFilesAtPath(string(cwd) + "/diff-gen-test/new"); |
| 308 EditFilesAtPath(string(cwd) + "/diff-gen-test/new"); |
| 309 |
| 310 DeltaArchiveManifest* archive = |
| 311 DeltaDiffGenerator::EncodeMetadataToProtoBuffer( |
| 312 (string(cwd) + "/diff-gen-test/new").c_str()); |
| 313 EXPECT_TRUE(NULL != archive); |
| 314 |
| 315 EXPECT_TRUE(DeltaDiffGenerator::EncodeDataToDeltaFile( |
| 316 archive, |
| 317 string(cwd) + "/diff-gen-test/old", |
| 318 string(cwd) + "/diff-gen-test/new", |
| 319 string(cwd) + "/diff-gen-test/out.dat")); |
| 320 |
| 321 EXPECT_EQ(16, archive->files_size()); |
| 322 |
| 323 const DeltaArchiveManifest_File& root = archive->files(0); |
| 324 EXPECT_TRUE(S_ISDIR(root.mode())); |
| 325 EXPECT_EQ(0, root.uid()); |
| 326 EXPECT_EQ(0, root.gid()); |
| 327 ASSERT_EQ(4, root.children_size()); |
| 328 EXPECT_EQ("cdev", root.children(0).name()); |
| 329 EXPECT_EQ("dir", root.children(1).name()); |
| 330 EXPECT_EQ("encoding", root.children(2).name()); |
| 331 EXPECT_EQ("hi", root.children(3).name()); |
| 332 EXPECT_FALSE(root.has_data_format()); |
| 333 EXPECT_FALSE(root.has_data_offset()); |
| 334 EXPECT_FALSE(root.has_data_length()); |
| 335 |
| 336 const DeltaArchiveManifest_File& cdev = |
| 337 archive->files(root.children(0).index()); |
| 338 EXPECT_EQ(0, cdev.children_size()); |
| 339 EXPECT_TRUE(S_ISCHR(cdev.mode())); |
| 340 EXPECT_EQ(0, cdev.uid()); |
| 341 EXPECT_EQ(0, cdev.gid()); |
| 342 ASSERT_TRUE(cdev.has_data_format()); |
| 343 EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, cdev.data_format()); |
| 344 EXPECT_TRUE(cdev.has_data_offset()); |
| 345 ASSERT_TRUE(cdev.has_data_length()); |
| 346 EXPECT_GT(cdev.data_length(), 0); |
| 347 |
| 348 const DeltaArchiveManifest_File& hi = |
| 349 archive->files(root.children(3).index()); |
| 350 EXPECT_EQ(0, hi.children_size()); |
| 351 EXPECT_TRUE(S_ISREG(hi.mode())); |
| 352 EXPECT_EQ(0, hi.uid()); |
| 353 EXPECT_EQ(0, hi.gid()); |
| 354 ASSERT_TRUE(hi.has_data_format()); |
| 355 EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, hi.data_format()); |
| 356 EXPECT_TRUE(hi.has_data_offset()); |
| 357 ASSERT_TRUE(hi.has_data_length()); |
| 358 EXPECT_GT(hi.data_length(), 0); |
| 359 |
| 360 const DeltaArchiveManifest_File& encoding = |
| 361 archive->files(root.children(2).index()); |
| 362 EXPECT_TRUE(S_ISDIR(encoding.mode())); |
| 363 EXPECT_EQ(0, encoding.uid()); |
| 364 EXPECT_EQ(0, encoding.gid()); |
| 365 EXPECT_EQ(4, encoding.children_size()); |
| 366 EXPECT_EQ("long_new", encoding.children(0).name()); |
| 367 EXPECT_EQ("long_small_change", encoding.children(1).name()); |
| 368 EXPECT_EQ("nochange", encoding.children(2).name()); |
| 369 EXPECT_EQ("onebyte", encoding.children(3).name()); |
| 370 EXPECT_FALSE(encoding.has_data_format()); |
| 371 EXPECT_FALSE(encoding.has_data_offset()); |
| 372 EXPECT_FALSE(encoding.has_data_length()); |
| 373 |
| 374 const DeltaArchiveManifest_File& long_new = |
| 375 archive->files(encoding.children(0).index()); |
| 376 EXPECT_EQ(0, long_new.children_size()); |
| 377 EXPECT_TRUE(S_ISREG(long_new.mode())); |
| 378 EXPECT_EQ(0, long_new.uid()); |
| 379 EXPECT_EQ(0, long_new.gid()); |
| 380 EXPECT_TRUE(long_new.has_data_format()); |
| 381 EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL_GZ, |
| 382 long_new.data_format()); |
| 383 EXPECT_TRUE(long_new.has_data_offset()); |
| 384 EXPECT_TRUE(long_new.has_data_length()); |
| 385 |
| 386 const DeltaArchiveManifest_File& long_small_change = |
| 387 archive->files(encoding.children(1).index()); |
| 388 EXPECT_EQ(0, long_small_change.children_size()); |
| 389 EXPECT_TRUE(S_ISREG(long_small_change.mode())); |
| 390 EXPECT_EQ(0, long_small_change.uid()); |
| 391 EXPECT_EQ(0, long_small_change.gid()); |
| 392 EXPECT_TRUE(long_small_change.has_data_format()); |
| 393 EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_BSDIFF, |
| 394 long_small_change.data_format()); |
| 395 EXPECT_TRUE(long_small_change.has_data_offset()); |
| 396 EXPECT_TRUE(long_small_change.has_data_length()); |
| 397 |
| 398 const DeltaArchiveManifest_File& nochange = |
| 399 archive->files(encoding.children(2).index()); |
| 400 EXPECT_EQ(0, nochange.children_size()); |
| 401 EXPECT_TRUE(S_ISREG(nochange.mode())); |
| 402 EXPECT_EQ(0, nochange.uid()); |
| 403 EXPECT_EQ(0, nochange.gid()); |
| 404 EXPECT_TRUE(nochange.has_data_format()); |
| 405 EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, nochange.data_format()); |
| 406 EXPECT_TRUE(nochange.has_data_offset()); |
| 407 EXPECT_TRUE(nochange.has_data_length()); |
| 408 |
| 409 const DeltaArchiveManifest_File& onebyte = |
| 410 archive->files(encoding.children(3).index()); |
| 411 EXPECT_EQ(0, onebyte.children_size()); |
| 412 EXPECT_TRUE(S_ISREG(onebyte.mode())); |
| 413 EXPECT_EQ(0, onebyte.uid()); |
| 414 EXPECT_EQ(0, onebyte.gid()); |
| 415 EXPECT_TRUE(onebyte.has_data_format()); |
| 416 EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, onebyte.data_format()); |
| 417 EXPECT_TRUE(onebyte.has_data_offset()); |
| 418 EXPECT_TRUE(onebyte.has_data_length()); |
| 419 EXPECT_EQ(1, onebyte.data_length()); |
| 420 |
| 421 const DeltaArchiveManifest_File& dir = |
| 422 archive->files(root.children(1).index()); |
| 423 EXPECT_TRUE(S_ISDIR(dir.mode())); |
| 424 EXPECT_EQ(0, dir.uid()); |
| 425 EXPECT_EQ(0, dir.gid()); |
| 426 ASSERT_EQ(5, dir.children_size()); |
| 427 EXPECT_EQ("bdev", dir.children(0).name()); |
| 428 EXPECT_EQ("emptydir", dir.children(1).name()); |
| 429 EXPECT_EQ("hello", dir.children(2).name()); |
| 430 EXPECT_EQ("newempty", dir.children(3).name()); |
| 431 EXPECT_EQ("subdir", dir.children(4).name()); |
| 432 EXPECT_FALSE(dir.has_data_format()); |
| 433 EXPECT_FALSE(dir.has_data_offset()); |
| 434 EXPECT_FALSE(dir.has_data_length()); |
| 435 |
| 436 const DeltaArchiveManifest_File& bdev = |
| 437 archive->files(dir.children(0).index()); |
| 438 EXPECT_EQ(0, bdev.children_size()); |
| 439 EXPECT_TRUE(S_ISBLK(bdev.mode())); |
| 440 EXPECT_EQ(0, bdev.uid()); |
| 441 EXPECT_EQ(0, bdev.gid()); |
| 442 ASSERT_TRUE(bdev.has_data_format()); |
| 443 EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, bdev.data_format()); |
| 444 EXPECT_TRUE(bdev.has_data_offset()); |
| 445 ASSERT_TRUE(bdev.has_data_length()); |
| 446 EXPECT_GT(bdev.data_length(), 0); |
| 447 |
| 448 const DeltaArchiveManifest_File& emptydir = |
| 449 archive->files(dir.children(1).index()); |
| 450 EXPECT_EQ(0, emptydir.children_size()); |
| 451 EXPECT_TRUE(S_ISDIR(emptydir.mode())); |
| 452 EXPECT_EQ(501, emptydir.uid()); |
| 453 EXPECT_EQ(503, emptydir.gid()); |
| 454 EXPECT_FALSE(emptydir.has_data_format()); |
| 455 EXPECT_FALSE(emptydir.has_data_offset()); |
| 456 EXPECT_FALSE(emptydir.has_data_length()); |
| 457 |
| 458 const DeltaArchiveManifest_File& hello = |
| 459 archive->files(dir.children(2).index()); |
| 460 EXPECT_EQ(0, hello.children_size()); |
| 461 EXPECT_TRUE(S_ISREG(hello.mode())); |
| 462 EXPECT_EQ(0, hello.uid()); |
| 463 EXPECT_EQ(0, hello.gid()); |
| 464 ASSERT_TRUE(hello.has_data_format()); |
| 465 EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, hello.data_format()); |
| 466 EXPECT_TRUE(hello.has_data_offset()); |
| 467 ASSERT_TRUE(hello.has_data_length()); |
| 468 EXPECT_GT(hello.data_length(), 0); |
| 469 |
| 470 const DeltaArchiveManifest_File& newempty = |
| 471 archive->files(dir.children(3).index()); |
| 472 EXPECT_EQ(0, newempty.children_size()); |
| 473 EXPECT_TRUE(S_ISREG(newempty.mode())); |
| 474 EXPECT_EQ(0, newempty.uid()); |
| 475 EXPECT_EQ(0, newempty.gid()); |
| 476 EXPECT_FALSE(newempty.has_data_format()); |
| 477 EXPECT_FALSE(newempty.has_data_offset()); |
| 478 EXPECT_FALSE(newempty.has_data_length()); |
| 479 |
| 480 const DeltaArchiveManifest_File& subdir = |
| 481 archive->files(dir.children(4).index()); |
| 482 EXPECT_EQ(2, subdir.children_size()); |
| 483 EXPECT_EQ("fifo", subdir.children(0).name()); |
| 484 EXPECT_EQ("link", subdir.children(1).name()); |
| 485 EXPECT_TRUE(S_ISDIR(subdir.mode())); |
| 486 EXPECT_EQ(0, subdir.uid()); |
| 487 EXPECT_EQ(0, subdir.gid()); |
| 488 EXPECT_FALSE(subdir.has_data_format()); |
| 489 EXPECT_FALSE(subdir.has_data_offset()); |
| 490 EXPECT_FALSE(subdir.has_data_length()); |
| 491 |
| 492 const DeltaArchiveManifest_File& fifo = |
| 493 archive->files(subdir.children(0).index()); |
| 494 EXPECT_EQ(0, fifo.children_size()); |
| 495 EXPECT_TRUE(S_ISFIFO(fifo.mode())); |
| 496 EXPECT_EQ(0, fifo.uid()); |
| 497 EXPECT_EQ(0, fifo.gid()); |
| 498 EXPECT_FALSE(fifo.has_data_format()); |
| 499 EXPECT_FALSE(fifo.has_data_offset()); |
| 500 EXPECT_FALSE(fifo.has_data_length()); |
| 501 |
| 502 const DeltaArchiveManifest_File& link = |
| 503 archive->files(subdir.children(1).index()); |
| 504 EXPECT_EQ(0, link.children_size()); |
| 505 EXPECT_TRUE(S_ISLNK(link.mode())); |
| 506 EXPECT_EQ(0, link.uid()); |
| 507 EXPECT_EQ(0, link.gid()); |
| 508 ASSERT_TRUE(link.has_data_format()); |
| 509 EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, link.data_format()); |
| 510 EXPECT_TRUE(link.has_data_offset()); |
| 511 ASSERT_TRUE(link.has_data_length()); |
| 512 EXPECT_GT(link.data_length(), 0); |
| 513 } |
| 514 |
| 515 class DeltaDiffParserTest : public ::testing::Test { |
| 516 virtual void TearDown() { |
| 517 EXPECT_EQ(0, system("rm -rf diff-gen-test")); |
| 518 } |
| 519 }; |
| 520 |
| 521 namespace { |
| 522 // Reads part of a file into memory |
| 523 vector<char> ReadFilePart(const string& path, off_t start, off_t size) { |
| 524 vector<char> ret; |
| 525 int fd = open(path.c_str(), O_RDONLY, 0); |
| 526 if (fd < 0) |
| 527 return ret; |
| 528 ret.resize(size); |
| 529 EXPECT_EQ(size, pread(fd, &ret[0], size, start)); |
| 530 close(fd); |
| 531 return ret; |
| 532 } |
| 533 |
| 534 string ReadFilePartToString(const string& path, off_t start, off_t size) { |
| 535 vector<char> bytes = ReadFilePart(path, start, size); |
| 536 string ret; |
| 537 ret.append(&bytes[0], bytes.size()); |
| 538 return ret; |
| 539 } |
| 540 |
| 541 string StringFromVectorChar(const vector<char>& in) { |
| 542 return string(&in[0], in.size()); |
| 543 } |
| 544 |
| 545 string GzipDecompressToString(const vector<char>& in) { |
| 546 vector<char> out; |
| 547 EXPECT_TRUE(GzipDecompress(in, &out)); |
| 548 return StringFromVectorChar(out); |
| 549 } |
| 550 |
| 551 } |
| 552 |
| 553 TEST_F(DeltaDiffParserTest, FakerootDecodeDataFromDeltaFileTest) { |
| 554 char cwd[1000]; |
| 555 ASSERT_EQ(cwd, getcwd(cwd, sizeof(cwd))) << "cwd buf possibly too small"; |
| 556 ASSERT_EQ(0, System(string("mkdir -p ") + cwd + "/diff-gen-test")); |
| 557 ASSERT_EQ(0, System(string("mkdir -p ") + cwd + "/diff-gen-test/old")); |
| 558 ASSERT_EQ(0, System(string("mkdir -p ") + cwd + "/diff-gen-test/new")); |
| 559 GenerateFilesAtPath(string(cwd) + "/diff-gen-test/old"); |
| 560 GenerateFilesAtPath(string(cwd) + "/diff-gen-test/new"); |
| 561 EditFilesAtPath(string(cwd) + "/diff-gen-test/new"); |
| 562 |
| 563 DeltaArchiveManifest* archive = |
| 564 DeltaDiffGenerator::EncodeMetadataToProtoBuffer( |
| 565 (string(cwd) + "/diff-gen-test/new").c_str()); |
| 566 EXPECT_TRUE(NULL != archive); |
| 567 |
| 568 EXPECT_TRUE(DeltaDiffGenerator::EncodeDataToDeltaFile( |
| 569 archive, |
| 570 string(cwd) + "/diff-gen-test/old", |
| 571 string(cwd) + "/diff-gen-test/new", |
| 572 string(cwd) + "/diff-gen-test/out.dat")); |
| 573 // parse the file |
| 574 |
| 575 DeltaDiffParser parser(string(cwd) + "/diff-gen-test/out.dat"); |
| 576 ASSERT_TRUE(parser.valid()); |
| 577 DeltaDiffParser::Iterator it = parser.Begin(); |
| 578 string expected_paths[] = { |
| 579 "", |
| 580 "/cdev", |
| 581 "/dir", |
| 582 "/dir/bdev", |
| 583 "/dir/emptydir", |
| 584 "/dir/hello", |
| 585 "/dir/newempty", |
| 586 "/dir/subdir", |
| 587 "/dir/subdir/fifo", |
| 588 "/dir/subdir/link", |
| 589 "/encoding", |
| 590 "/encoding/long_new", |
| 591 "/encoding/long_small_change", |
| 592 "/encoding/nochange", |
| 593 "/encoding/onebyte", |
| 594 "/hi" |
| 595 }; |
| 596 for (unsigned int i = 0; |
| 597 i < (sizeof(expected_paths)/sizeof(expected_paths[0])); i++) { |
| 598 ASSERT_TRUE(it != parser.End()); |
| 599 ASSERT_TRUE(parser.ContainsPath(expected_paths[i])); |
| 600 EXPECT_EQ(expected_paths[i], it.path()); |
| 601 EXPECT_EQ(expected_paths[i].substr(expected_paths[i].find_last_of('/') + 1), |
| 602 it.GetName()); |
| 603 DeltaArchiveManifest_File f1 = parser.GetFileAtPath(expected_paths[i]); |
| 604 DeltaArchiveManifest_File f2 = it.GetFile(); |
| 605 EXPECT_EQ(f1.mode(), f2.mode()) << it.path(); |
| 606 EXPECT_EQ(f1.uid(), f2.uid()); |
| 607 EXPECT_EQ(f1.gid(), f2.gid()); |
| 608 EXPECT_EQ(f1.has_data_format(), f2.has_data_format()); |
| 609 if (f1.has_data_format()) { |
| 610 EXPECT_EQ(f1.data_format(), f2.data_format()); |
| 611 EXPECT_TRUE(f1.has_data_offset()); |
| 612 EXPECT_TRUE(f2.has_data_offset()); |
| 613 EXPECT_EQ(f1.data_offset(), f2.data_offset()); |
| 614 } else { |
| 615 EXPECT_FALSE(f2.has_data_format()); |
| 616 EXPECT_FALSE(f1.has_data_offset()); |
| 617 EXPECT_FALSE(f2.has_data_offset()); |
| 618 } |
| 619 EXPECT_EQ(f1.children_size(), f2.children_size()); |
| 620 for (int j = 0; j < f1.children_size(); j++) { |
| 621 EXPECT_EQ(f1.children(j).name(), f2.children(j).name()); |
| 622 EXPECT_EQ(f1.children(j).index(), f2.children(j).index()); |
| 623 } |
| 624 it.Increment(); |
| 625 } |
| 626 EXPECT_TRUE(it == parser.End()); |
| 627 EXPECT_FALSE(parser.ContainsPath("/cdew")); |
| 628 EXPECT_FALSE(parser.ContainsPath("/hi/hi")); |
| 629 EXPECT_FALSE(parser.ContainsPath("/dir/newempty/hi")); |
| 630 EXPECT_TRUE(parser.ContainsPath("/dir/")); |
| 631 |
| 632 // Check the data |
| 633 // root |
| 634 DeltaArchiveManifest_File file = parser.GetFileAtPath(""); |
| 635 EXPECT_TRUE(S_ISDIR(file.mode())); |
| 636 EXPECT_FALSE(file.has_data_format()); |
| 637 |
| 638 // cdev |
| 639 file = parser.GetFileAtPath("/cdev"); |
| 640 EXPECT_TRUE(S_ISCHR(file.mode())); |
| 641 EXPECT_TRUE(file.has_data_format()); |
| 642 vector<char> data = ReadFilePart(string(cwd) + "/diff-gen-test/out.dat", |
| 643 file.data_offset(), file.data_length()); |
| 644 LinuxDevice linux_device; |
| 645 linux_device.ParseFromArray(&data[0], data.size()); |
| 646 EXPECT_EQ(linux_device.major(), 2); |
| 647 EXPECT_EQ(linux_device.minor(), 1); |
| 648 |
| 649 // dir |
| 650 file = parser.GetFileAtPath("/dir"); |
| 651 EXPECT_TRUE(S_ISDIR(file.mode())); |
| 652 EXPECT_FALSE(file.has_data_format()); |
| 653 |
| 654 // bdev |
| 655 file = parser.GetFileAtPath("/dir/bdev"); |
| 656 EXPECT_TRUE(S_ISBLK(file.mode())); |
| 657 EXPECT_TRUE(file.has_data_format()); |
| 658 data = ReadFilePart(string(cwd) + "/diff-gen-test/out.dat", |
| 659 file.data_offset(), file.data_length()); |
| 660 linux_device.ParseFromArray(&data[0], data.size()); |
| 661 EXPECT_EQ(linux_device.major(), 3); |
| 662 EXPECT_EQ(linux_device.minor(), 1); |
| 663 |
| 664 // emptydir |
| 665 file = parser.GetFileAtPath("/dir/emptydir"); |
| 666 EXPECT_TRUE(S_ISDIR(file.mode())); |
| 667 EXPECT_FALSE(file.has_data_format()); |
| 668 |
| 669 // hello |
| 670 file = parser.GetFileAtPath("/dir/hello"); |
| 671 EXPECT_TRUE(S_ISREG(file.mode())); |
| 672 EXPECT_TRUE(file.has_data_format()); |
| 673 EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, file.data_format()); |
| 674 EXPECT_EQ("hello\n", ReadFilePartToString(string(cwd) + |
| 675 "/diff-gen-test/out.dat", |
| 676 file.data_offset(), |
| 677 file.data_length())); |
| 678 |
| 679 // newempty |
| 680 file = parser.GetFileAtPath("/dir/newempty"); |
| 681 EXPECT_TRUE(S_ISREG(file.mode())); |
| 682 EXPECT_FALSE(file.has_data_format()); |
| 683 |
| 684 // subdir |
| 685 file = parser.GetFileAtPath("/dir/subdir"); |
| 686 EXPECT_TRUE(S_ISDIR(file.mode())); |
| 687 EXPECT_FALSE(file.has_data_format()); |
| 688 |
| 689 // fifo |
| 690 file = parser.GetFileAtPath("/dir/subdir/fifo"); |
| 691 EXPECT_TRUE(S_ISFIFO(file.mode())); |
| 692 EXPECT_FALSE(file.has_data_format()); |
| 693 |
| 694 // link |
| 695 file = parser.GetFileAtPath("/dir/subdir/link"); |
| 696 EXPECT_TRUE(S_ISLNK(file.mode())); |
| 697 EXPECT_TRUE(file.has_data_format()); |
| 698 EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, file.data_format()); |
| 699 EXPECT_EQ("/target", ReadFilePartToString(string(cwd) + |
| 700 "/diff-gen-test/out.dat", |
| 701 file.data_offset(), |
| 702 file.data_length())); |
| 703 |
| 704 // encoding |
| 705 file = parser.GetFileAtPath("/encoding"); |
| 706 EXPECT_TRUE(S_ISDIR(file.mode())); |
| 707 EXPECT_FALSE(file.has_data_format()); |
| 708 |
| 709 // long_new |
| 710 file = parser.GetFileAtPath("/encoding/long_new"); |
| 711 EXPECT_TRUE(S_ISREG(file.mode())); |
| 712 EXPECT_TRUE(file.has_data_format()); |
| 713 EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL_GZ, file.data_format()); |
| 714 EXPECT_EQ("This is a pice of text that should " |
| 715 "compress well since it is just ascii and it " |
| 716 "has repetition xxxxxxxxxxxxxxxxxxxxx" |
| 717 "xxxxxxxxxxxxxxxxxxxx", |
| 718 GzipDecompressToString(ReadFilePart(string(cwd) + |
| 719 "/diff-gen-test/out.dat", |
| 720 file.data_offset(), |
| 721 file.data_length()))); |
| 722 |
| 723 // long_small_change |
| 724 file = parser.GetFileAtPath("/encoding/long_small_change"); |
| 725 EXPECT_TRUE(S_ISREG(file.mode())); |
| 726 EXPECT_TRUE(file.has_data_format()); |
| 727 EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_BSDIFF, file.data_format()); |
| 728 data = ReadFilePart(string(cwd) + "/diff-gen-test/out.dat", |
| 729 file.data_offset(), file.data_length()); |
| 730 WriteFileVector(string(cwd) + "/diff-gen-test/patch", data); |
| 731 int rc = 1; |
| 732 vector<string> cmd; |
| 733 cmd.push_back("/usr/bin/bspatch"); |
| 734 cmd.push_back(string(cwd) + "/diff-gen-test/old/encoding/long_small_change"); |
| 735 cmd.push_back(string(cwd) + "/diff-gen-test/patch_result"); |
| 736 cmd.push_back(string(cwd) + "/diff-gen-test/patch"); |
| 737 Subprocess::SynchronousExec(cmd, &rc); |
| 738 EXPECT_EQ(0, rc); |
| 739 vector<char> patch_result; |
| 740 EXPECT_TRUE(utils::ReadFile(string(cwd) + "/diff-gen-test/patch_result", |
| 741 &patch_result)); |
| 742 vector<char> expected_data(sizeof(kRandomString) + 1); |
| 743 memcpy(&expected_data[0], kRandomString, sizeof(kRandomString)); |
| 744 expected_data[expected_data.size() - 1] = 'h'; |
| 745 ExpectVectorsEq(expected_data, patch_result); |
| 746 |
| 747 // nochange |
| 748 file = parser.GetFileAtPath("/encoding/nochange"); |
| 749 EXPECT_TRUE(S_ISREG(file.mode())); |
| 750 EXPECT_TRUE(file.has_data_format()); |
| 751 EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, file.data_format()); |
| 752 EXPECT_EQ("nochange\n", ReadFilePartToString(string(cwd) + |
| 753 "/diff-gen-test/out.dat", |
| 754 file.data_offset(), |
| 755 file.data_length())); |
| 756 |
| 757 // onebyte |
| 758 file = parser.GetFileAtPath("/encoding/onebyte"); |
| 759 EXPECT_TRUE(S_ISREG(file.mode())); |
| 760 EXPECT_TRUE(file.has_data_format()); |
| 761 EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, file.data_format()); |
| 762 EXPECT_EQ("h", ReadFilePartToString(string(cwd) + |
| 763 "/diff-gen-test/out.dat", |
| 764 file.data_offset(), |
| 765 file.data_length())); |
| 766 |
| 767 // hi |
| 768 file = parser.GetFileAtPath("/hi"); |
| 769 EXPECT_TRUE(S_ISREG(file.mode())); |
| 770 EXPECT_TRUE(file.has_data_format()); |
| 771 EXPECT_EQ(DeltaArchiveManifest_File_DataFormat_FULL, file.data_format()); |
| 772 EXPECT_EQ("newhi\n", ReadFilePartToString(string(cwd) + |
| 773 "/diff-gen-test/out.dat", |
| 774 file.data_offset(), |
| 775 file.data_length())); |
| 776 } |
| 777 |
| 778 TEST_F(DeltaDiffParserTest, FakerootInvalidTest) { |
| 779 ASSERT_EQ(0, mkdir("diff-gen-test", 0777)); |
| 780 { |
| 781 DeltaDiffParser parser("/no/such/file"); |
| 782 EXPECT_FALSE(parser.valid()); |
| 783 } |
| 784 { |
| 785 vector<char> data(3); |
| 786 memcpy(&data[0], "CrA", 3); |
| 787 WriteFileVector("diff-gen-test/baddelta", data); |
| 788 DeltaDiffParser parser("diff-gen-test/baddelta"); |
| 789 EXPECT_FALSE(parser.valid()); |
| 790 } |
| 791 { |
| 792 vector<char> data(5); |
| 793 memcpy(&data[0], "CrAPx", 5); |
| 794 WriteFileVector("diff-gen-test/baddelta", data); |
| 795 DeltaDiffParser parser("diff-gen-test/baddelta"); |
| 796 EXPECT_FALSE(parser.valid()); |
| 797 } |
| 798 { |
| 799 vector<char> data(5); |
| 800 memcpy(&data[0], "CrAU\0", 5); |
| 801 WriteFileVector("diff-gen-test/baddelta", data); |
| 802 DeltaDiffParser parser("diff-gen-test/baddelta"); |
| 803 EXPECT_FALSE(parser.valid()); |
| 804 } |
| 805 { |
| 806 vector<char> data(14); |
| 807 memcpy(&data[0], "CrAU\0\0\0\0\0\0\0\x0cxx", 12); |
| 808 WriteFileVector("diff-gen-test/baddelta", data); |
| 809 DeltaDiffParser parser("diff-gen-test/baddelta"); |
| 810 EXPECT_FALSE(parser.valid()); |
| 811 } |
| 812 } |
| 813 |
| 814 } // namespace chromeos_update_engine |
OLD | NEW |