OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <string> | 5 #include <string> |
6 | 6 |
7 #include "base/strings/stringprintf.h" | 7 #include "base/strings/stringprintf.h" |
8 #include "base/time/time.h" | 8 #include "base/time/time.h" |
9 #include "chrome/browser/safe_browsing/protocol_parser.h" | 9 #include "chrome/browser/safe_browsing/protocol_parser.h" |
10 #include "chrome/browser/safe_browsing/safe_browsing_util.h" | 10 #include "chrome/browser/safe_browsing/safe_browsing_util.h" |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
81 EXPECT_TRUE(safe_browsing::ParseChunk(kRawAddChunk, sizeof(kRawAddChunk), | 81 EXPECT_TRUE(safe_browsing::ParseChunk(kRawAddChunk, sizeof(kRawAddChunk), |
82 &chunks)); | 82 &chunks)); |
83 ASSERT_EQ(1U, chunks.size()); | 83 ASSERT_EQ(1U, chunks.size()); |
84 EXPECT_EQ(1, chunks[0]->ChunkNumber()); | 84 EXPECT_EQ(1, chunks[0]->ChunkNumber()); |
85 EXPECT_TRUE(chunks[0]->IsAdd()); | 85 EXPECT_TRUE(chunks[0]->IsAdd()); |
86 EXPECT_FALSE(chunks[0]->IsSub()); | 86 EXPECT_FALSE(chunks[0]->IsSub()); |
87 EXPECT_FALSE(chunks[0]->IsPrefix()); | 87 EXPECT_FALSE(chunks[0]->IsPrefix()); |
88 EXPECT_TRUE(chunks[0]->IsFullHash()); | 88 EXPECT_TRUE(chunks[0]->IsFullHash()); |
89 | 89 |
90 ASSERT_EQ(2U, chunks[0]->FullHashCount()); | 90 ASSERT_EQ(2U, chunks[0]->FullHashCount()); |
91 EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(0), full_hash1)); | 91 EXPECT_TRUE( |
92 EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(1), full_hash2)); | 92 safe_browsing::SBFullHashEqual(chunks[0]->FullHashAt(0), full_hash1)); |
| 93 EXPECT_TRUE( |
| 94 safe_browsing::SBFullHashEqual(chunks[0]->FullHashAt(1), full_hash2)); |
93 } | 95 } |
94 | 96 |
95 // Test parsing multiple add chunks. We'll use the same chunk as above, and add | 97 // Test parsing multiple add chunks. We'll use the same chunk as above, and add |
96 // one more after it. | 98 // one more after it. |
97 TEST(SafeBrowsingProtocolParsingTest, TestAddChunks) { | 99 TEST(SafeBrowsingProtocolParsingTest, TestAddChunks) { |
98 const char kRawAddChunk[] = { | 100 const char kRawAddChunk[] = { |
99 '\0', '\0', '\0', '\x1C', // 32-bit payload length in network byte order. | 101 '\0', '\0', '\0', '\x1C', // 32-bit payload length in network byte order. |
100 '\x08', // field 1, wire format varint | 102 '\x08', // field 1, wire format varint |
101 '\x01', // chunk_number varint 1 | 103 '\x01', // chunk_number varint 1 |
102 '\x22', // field 4, wire format length-delimited | 104 '\x22', // field 4, wire format length-delimited |
(...skipping 172 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
275 EXPECT_TRUE(safe_browsing::ParseChunk(kRawSubChunk, sizeof(kRawSubChunk), | 277 EXPECT_TRUE(safe_browsing::ParseChunk(kRawSubChunk, sizeof(kRawSubChunk), |
276 &chunks)); | 278 &chunks)); |
277 ASSERT_EQ(1U, chunks.size()); | 279 ASSERT_EQ(1U, chunks.size()); |
278 EXPECT_EQ(2, chunks[0]->ChunkNumber()); | 280 EXPECT_EQ(2, chunks[0]->ChunkNumber()); |
279 EXPECT_FALSE(chunks[0]->IsAdd()); | 281 EXPECT_FALSE(chunks[0]->IsAdd()); |
280 EXPECT_TRUE(chunks[0]->IsSub()); | 282 EXPECT_TRUE(chunks[0]->IsSub()); |
281 EXPECT_FALSE(chunks[0]->IsPrefix()); | 283 EXPECT_FALSE(chunks[0]->IsPrefix()); |
282 EXPECT_TRUE(chunks[0]->IsFullHash()); | 284 EXPECT_TRUE(chunks[0]->IsFullHash()); |
283 | 285 |
284 ASSERT_EQ(2U, chunks[0]->FullHashCount()); | 286 ASSERT_EQ(2U, chunks[0]->FullHashCount()); |
285 EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(0), full_hash1)); | 287 EXPECT_TRUE( |
| 288 safe_browsing::SBFullHashEqual(chunks[0]->FullHashAt(0), full_hash1)); |
286 EXPECT_EQ(7, chunks[0]->AddChunkNumberAt(0)); | 289 EXPECT_EQ(7, chunks[0]->AddChunkNumberAt(0)); |
287 EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(1), full_hash2)); | 290 EXPECT_TRUE( |
| 291 safe_browsing::SBFullHashEqual(chunks[0]->FullHashAt(1), full_hash2)); |
288 EXPECT_EQ(9, chunks[0]->AddChunkNumberAt(1)); | 292 EXPECT_EQ(9, chunks[0]->AddChunkNumberAt(1)); |
289 } | 293 } |
290 | 294 |
291 // Test parsing the SafeBrowsing update response. | 295 // Test parsing the SafeBrowsing update response. |
292 TEST(SafeBrowsingProtocolParsingTest, TestChunkDelete) { | 296 TEST(SafeBrowsingProtocolParsingTest, TestChunkDelete) { |
293 std::string add_del("n:1700\ni:phishy\nad:1-7,43-597,44444,99999\n" | 297 std::string add_del("n:1700\ni:phishy\nad:1-7,43-597,44444,99999\n" |
294 "i:malware\nsd:21-27,42,171717\n"); | 298 "i:malware\nsd:21-27,42,171717\n"); |
295 | 299 |
296 size_t next_query_sec = 0; | 300 size_t next_query_sec = 0; |
297 bool reset = false; | 301 bool reset = false; |
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
389 kDefaultPhishList)); | 393 kDefaultPhishList)); |
390 std::vector<SBFullHashResult> full_hashes; | 394 std::vector<SBFullHashResult> full_hashes; |
391 base::TimeDelta cache_lifetime; | 395 base::TimeDelta cache_lifetime; |
392 EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash.data(), get_hash.length(), | 396 EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash.data(), get_hash.length(), |
393 &cache_lifetime, &full_hashes)); | 397 &cache_lifetime, &full_hashes)); |
394 | 398 |
395 ASSERT_EQ(3U, full_hashes.size()); | 399 ASSERT_EQ(3U, full_hashes.size()); |
396 EXPECT_EQ(memcmp(&full_hashes[0].hash, | 400 EXPECT_EQ(memcmp(&full_hashes[0].hash, |
397 "00112233445566778899aabbccddeeff", | 401 "00112233445566778899aabbccddeeff", |
398 sizeof(SBFullHash)), 0); | 402 sizeof(SBFullHash)), 0); |
399 EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id); | 403 EXPECT_EQ(safe_browsing::PHISH, full_hashes[0].list_id); |
400 EXPECT_EQ(memcmp(&full_hashes[1].hash, | 404 EXPECT_EQ(memcmp(&full_hashes[1].hash, |
401 "00001111222233334444555566667777", | 405 "00001111222233334444555566667777", |
402 sizeof(SBFullHash)), 0); | 406 sizeof(SBFullHash)), 0); |
403 EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[1].list_id); | 407 EXPECT_EQ(safe_browsing::PHISH, full_hashes[1].list_id); |
404 EXPECT_EQ(memcmp(&full_hashes[2].hash, | 408 EXPECT_EQ(memcmp(&full_hashes[2].hash, |
405 "ffffeeeeddddccccbbbbaaaa99998888", | 409 "ffffeeeeddddccccbbbbaaaa99998888", |
406 sizeof(SBFullHash)), 0); | 410 sizeof(SBFullHash)), 0); |
407 EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[2].list_id); | 411 EXPECT_EQ(safe_browsing::PHISH, full_hashes[2].list_id); |
408 | 412 |
409 // Test multiple lists in the GetHash results. | 413 // Test multiple lists in the GetHash results. |
410 const std::string get_hash2(base::StringPrintf( | 414 const std::string get_hash2(base::StringPrintf( |
411 "45\n" | 415 "45\n" |
412 "%s:32:1\n" | 416 "%s:32:1\n" |
413 "00112233445566778899aabbccddeeff" | 417 "00112233445566778899aabbccddeeff" |
414 "%s:32:2\n" | 418 "%s:32:2\n" |
415 "cafebeefcafebeefdeaddeaddeaddead" | 419 "cafebeefcafebeefdeaddeaddeaddead" |
416 "zzzzyyyyxxxxwwwwvvvvuuuuttttssss", | 420 "zzzzyyyyxxxxwwwwvvvvuuuuttttssss", |
417 kDefaultPhishList, | 421 kDefaultPhishList, |
418 kDefaultMalwareList)); | 422 kDefaultMalwareList)); |
419 EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash2.data(), get_hash2.length(), | 423 EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash2.data(), get_hash2.length(), |
420 &cache_lifetime, &full_hashes)); | 424 &cache_lifetime, &full_hashes)); |
421 | 425 |
422 ASSERT_EQ(3U, full_hashes.size()); | 426 ASSERT_EQ(3U, full_hashes.size()); |
423 EXPECT_EQ(memcmp(&full_hashes[0].hash, | 427 EXPECT_EQ(memcmp(&full_hashes[0].hash, |
424 "00112233445566778899aabbccddeeff", | 428 "00112233445566778899aabbccddeeff", |
425 sizeof(SBFullHash)), 0); | 429 sizeof(SBFullHash)), 0); |
426 EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id); | 430 EXPECT_EQ(safe_browsing::PHISH, full_hashes[0].list_id); |
427 EXPECT_EQ(memcmp(&full_hashes[1].hash, | 431 EXPECT_EQ(memcmp(&full_hashes[1].hash, |
428 "cafebeefcafebeefdeaddeaddeaddead", | 432 "cafebeefcafebeefdeaddeaddeaddead", |
429 sizeof(SBFullHash)), 0); | 433 sizeof(SBFullHash)), 0); |
430 EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[1].list_id); | 434 EXPECT_EQ(safe_browsing::MALWARE, full_hashes[1].list_id); |
431 EXPECT_EQ(memcmp(&full_hashes[2].hash, | 435 EXPECT_EQ(memcmp(&full_hashes[2].hash, |
432 "zzzzyyyyxxxxwwwwvvvvuuuuttttssss", | 436 "zzzzyyyyxxxxwwwwvvvvuuuuttttssss", |
433 sizeof(SBFullHash)), 0); | 437 sizeof(SBFullHash)), 0); |
434 EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[2].list_id); | 438 EXPECT_EQ(safe_browsing::MALWARE, full_hashes[2].list_id); |
435 | 439 |
436 // Test metadata parsing. | 440 // Test metadata parsing. |
437 const std::string get_hash3(base::StringPrintf( | 441 const std::string get_hash3(base::StringPrintf( |
438 "45\n" | 442 "45\n" |
439 "%s:32:2:m\n" | 443 "%s:32:2:m\n" |
440 "zzzzyyyyxxxxwwwwvvvvuuuuttttssss" | 444 "zzzzyyyyxxxxwwwwvvvvuuuuttttssss" |
441 "00112233445566778899aabbccddeeff" | 445 "00112233445566778899aabbccddeeff" |
442 "2\nab2\nxy" | 446 "2\nab2\nxy" |
443 "%s:32:1\n" | 447 "%s:32:1\n" |
444 "cafebeefcafebeefdeaddeaddeaddead", | 448 "cafebeefcafebeefdeaddeaddeaddead", |
445 kDefaultMalwareList, | 449 kDefaultMalwareList, |
446 kDefaultPhishList)); | 450 kDefaultPhishList)); |
447 EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash3.data(), get_hash3.length(), | 451 EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash3.data(), get_hash3.length(), |
448 &cache_lifetime, &full_hashes)); | 452 &cache_lifetime, &full_hashes)); |
449 | 453 |
450 ASSERT_EQ(3U, full_hashes.size()); | 454 ASSERT_EQ(3U, full_hashes.size()); |
451 EXPECT_EQ(memcmp(&full_hashes[0].hash, | 455 EXPECT_EQ(memcmp(&full_hashes[0].hash, |
452 "zzzzyyyyxxxxwwwwvvvvuuuuttttssss", | 456 "zzzzyyyyxxxxwwwwvvvvuuuuttttssss", |
453 sizeof(SBFullHash)), 0); | 457 sizeof(SBFullHash)), 0); |
454 EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[0].list_id); | 458 EXPECT_EQ(safe_browsing::MALWARE, full_hashes[0].list_id); |
455 EXPECT_EQ(std::string("ab"), full_hashes[0].metadata); | 459 EXPECT_EQ(std::string("ab"), full_hashes[0].metadata); |
456 EXPECT_EQ(memcmp(&full_hashes[1].hash, | 460 EXPECT_EQ(memcmp(&full_hashes[1].hash, |
457 "00112233445566778899aabbccddeeff", | 461 "00112233445566778899aabbccddeeff", |
458 sizeof(SBFullHash)), 0); | 462 sizeof(SBFullHash)), 0); |
459 EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[1].list_id); | 463 EXPECT_EQ(safe_browsing::MALWARE, full_hashes[1].list_id); |
460 EXPECT_EQ(std::string("xy"), full_hashes[1].metadata); | 464 EXPECT_EQ(std::string("xy"), full_hashes[1].metadata); |
461 EXPECT_EQ(memcmp(&full_hashes[2].hash, | 465 EXPECT_EQ(memcmp(&full_hashes[2].hash, |
462 "cafebeefcafebeefdeaddeaddeaddead", | 466 "cafebeefcafebeefdeaddeaddeaddead", |
463 sizeof(SBFullHash)), 0); | 467 sizeof(SBFullHash)), 0); |
464 EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[2].list_id); | 468 EXPECT_EQ(safe_browsing::PHISH, full_hashes[2].list_id); |
465 EXPECT_EQ(std::string(), full_hashes[2].metadata); | 469 EXPECT_EQ(std::string(), full_hashes[2].metadata); |
466 } | 470 } |
467 | 471 |
468 TEST(SafeBrowsingProtocolParsingTest, TestGetHashWithUnknownList) { | 472 TEST(SafeBrowsingProtocolParsingTest, TestGetHashWithUnknownList) { |
469 std::string hash_response(base::StringPrintf( | 473 std::string hash_response(base::StringPrintf( |
470 "45\n" | 474 "45\n" |
471 "%s:32:1\n" | 475 "%s:32:1\n" |
472 "12345678901234567890123456789012" | 476 "12345678901234567890123456789012" |
473 "googpub-phish-shavar:32:1\n" | 477 "googpub-phish-shavar:32:1\n" |
474 "09876543210987654321098765432109", | 478 "09876543210987654321098765432109", |
475 kDefaultPhishList)); | 479 kDefaultPhishList)); |
476 std::vector<SBFullHashResult> full_hashes; | 480 std::vector<SBFullHashResult> full_hashes; |
477 base::TimeDelta cache_lifetime; | 481 base::TimeDelta cache_lifetime; |
478 EXPECT_TRUE(safe_browsing::ParseGetHash(hash_response.data(), | 482 EXPECT_TRUE(safe_browsing::ParseGetHash(hash_response.data(), |
479 hash_response.size(), | 483 hash_response.size(), |
480 &cache_lifetime, | 484 &cache_lifetime, |
481 &full_hashes)); | 485 &full_hashes)); |
482 | 486 |
483 ASSERT_EQ(1U, full_hashes.size()); | 487 ASSERT_EQ(1U, full_hashes.size()); |
484 EXPECT_EQ(memcmp("12345678901234567890123456789012", | 488 EXPECT_EQ(memcmp("12345678901234567890123456789012", |
485 &full_hashes[0].hash, sizeof(SBFullHash)), 0); | 489 &full_hashes[0].hash, sizeof(SBFullHash)), 0); |
486 EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id); | 490 EXPECT_EQ(safe_browsing::PHISH, full_hashes[0].list_id); |
487 | 491 |
488 hash_response += base::StringPrintf( | 492 hash_response += base::StringPrintf( |
489 "%s:32:1\n" | 493 "%s:32:1\n" |
490 "abcdefghijklmnopqrstuvwxyz123457", | 494 "abcdefghijklmnopqrstuvwxyz123457", |
491 kDefaultMalwareList); | 495 kDefaultMalwareList); |
492 full_hashes.clear(); | 496 full_hashes.clear(); |
493 EXPECT_TRUE(safe_browsing::ParseGetHash(hash_response.data(), | 497 EXPECT_TRUE(safe_browsing::ParseGetHash(hash_response.data(), |
494 hash_response.size(), | 498 hash_response.size(), |
495 &cache_lifetime, | 499 &cache_lifetime, |
496 &full_hashes)); | 500 &full_hashes)); |
497 | 501 |
498 EXPECT_EQ(2U, full_hashes.size()); | 502 EXPECT_EQ(2U, full_hashes.size()); |
499 EXPECT_EQ(memcmp("12345678901234567890123456789012", | 503 EXPECT_EQ(memcmp("12345678901234567890123456789012", |
500 &full_hashes[0].hash, sizeof(SBFullHash)), 0); | 504 &full_hashes[0].hash, sizeof(SBFullHash)), 0); |
501 EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id); | 505 EXPECT_EQ(safe_browsing::PHISH, full_hashes[0].list_id); |
502 EXPECT_EQ(memcmp("abcdefghijklmnopqrstuvwxyz123457", | 506 EXPECT_EQ(memcmp("abcdefghijklmnopqrstuvwxyz123457", |
503 &full_hashes[1].hash, sizeof(SBFullHash)), 0); | 507 &full_hashes[1].hash, sizeof(SBFullHash)), 0); |
504 EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[1].list_id); | 508 EXPECT_EQ(safe_browsing::MALWARE, full_hashes[1].list_id); |
505 } | 509 } |
506 | 510 |
507 TEST(SafeBrowsingProtocolParsingTest, TestGetHashWithUnknownListAndMetadata) { | 511 TEST(SafeBrowsingProtocolParsingTest, TestGetHashWithUnknownListAndMetadata) { |
508 std::vector<SBFullHashResult> full_hashes; | 512 std::vector<SBFullHashResult> full_hashes; |
509 base::TimeDelta cache_lifetime; | 513 base::TimeDelta cache_lifetime; |
510 // Test skipping over a hashentry with an unrecognized listname that also has | 514 // Test skipping over a hashentry with an unrecognized listname that also has |
511 // metadata. | 515 // metadata. |
512 const std::string get_hash3(base::StringPrintf( | 516 const std::string get_hash3(base::StringPrintf( |
513 "600\n" | 517 "600\n" |
514 "BADLISTNAME:32:1:m\n" | 518 "BADLISTNAME:32:1:m\n" |
515 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" | 519 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" |
516 "8\nMETADATA" | 520 "8\nMETADATA" |
517 "%s:32:1\n" | 521 "%s:32:1\n" |
518 "0123456789hashhashhashhashhashha", | 522 "0123456789hashhashhashhashhashha", |
519 kDefaultMalwareList)); | 523 kDefaultMalwareList)); |
520 EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash3.data(), get_hash3.length(), | 524 EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash3.data(), get_hash3.length(), |
521 &cache_lifetime, &full_hashes)); | 525 &cache_lifetime, &full_hashes)); |
522 ASSERT_EQ(1U, full_hashes.size()); | 526 ASSERT_EQ(1U, full_hashes.size()); |
523 EXPECT_EQ(memcmp(&full_hashes[0].hash, | 527 EXPECT_EQ(memcmp(&full_hashes[0].hash, |
524 "0123456789hashhashhashhashhashha", | 528 "0123456789hashhashhashhashhashha", |
525 sizeof(SBFullHash)), 0); | 529 sizeof(SBFullHash)), 0); |
526 EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[0].list_id); | 530 EXPECT_EQ(safe_browsing::MALWARE, full_hashes[0].list_id); |
527 EXPECT_EQ(std::string(), full_hashes[0].metadata); | 531 EXPECT_EQ(std::string(), full_hashes[0].metadata); |
528 } | 532 } |
529 | 533 |
530 TEST(SafeBrowsingProtocolParsingTest, TestFormatHash) { | 534 TEST(SafeBrowsingProtocolParsingTest, TestFormatHash) { |
531 std::vector<SBPrefix> prefixes; | 535 std::vector<SBPrefix> prefixes; |
532 prefixes.push_back(0x34333231); | 536 prefixes.push_back(0x34333231); |
533 prefixes.push_back(0x64636261); | 537 prefixes.push_back(0x64636261); |
534 prefixes.push_back(0x73727170); | 538 prefixes.push_back(0x73727170); |
535 | 539 |
536 EXPECT_EQ("4:12\n1234abcdpqrs", safe_browsing::FormatGetHash(prefixes)); | 540 EXPECT_EQ("4:12\n1234abcdpqrs", safe_browsing::FormatGetHash(prefixes)); |
(...skipping 167 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
704 EXPECT_FALSE(chunks[0]->IsAdd()); | 708 EXPECT_FALSE(chunks[0]->IsAdd()); |
705 EXPECT_TRUE(chunks[0]->IsSub()); | 709 EXPECT_TRUE(chunks[0]->IsSub()); |
706 EXPECT_TRUE(chunks[2]->IsPrefix()); | 710 EXPECT_TRUE(chunks[2]->IsPrefix()); |
707 EXPECT_FALSE(chunks[2]->IsFullHash()); | 711 EXPECT_FALSE(chunks[2]->IsFullHash()); |
708 ASSERT_EQ(1U, chunks[2]->PrefixCount()); | 712 ASSERT_EQ(1U, chunks[2]->PrefixCount()); |
709 EXPECT_EQ(0x70707070U, chunks[2]->PrefixAt(0)); // pppp | 713 EXPECT_EQ(0x70707070U, chunks[2]->PrefixAt(0)); // pppp |
710 EXPECT_EQ(11, chunks[2]->AddChunkNumberAt(0)); | 714 EXPECT_EQ(11, chunks[2]->AddChunkNumberAt(0)); |
711 } | 715 } |
712 | 716 |
713 } // namespace | 717 } // namespace |
OLD | NEW |