blob: f3f8b5c72c42dea53fab16bcf438958724f6d331 [file] [log] [blame]
// Copyright 2008 Google Inc.
// Author: Lincoln Smith
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <config.h>
#include "google/vcdecoder.h"
#include <stdlib.h> // free, posix_memalign
#include <string.h> // memcpy
#include <string>
#include "testing.h"
#include "varint_bigendian.h"
#include "vcdecoder_test.h"
#include "vcdiff_defs.h" // VCD_SOURCE
#ifdef HAVE_MALLOC_H
#include <malloc.h>
#endif // HAVE_MALLOC_H
#ifdef HAVE_SYS_MMAN_H
#define _XOPEN_SOURCE 600 // posix_memalign
#include <sys/mman.h> // mprotect
#endif // HAVE_SYS_MMAN_H
#ifdef HAVE_UNISTD_H
#include <unistd.h> // getpagesize
#endif // HAVE_UNISTD_H
namespace open_vcdiff {
// Test headers, valid and invalid.
TEST_F(VCDiffInterleavedDecoderTest, DecodeHeaderOnly) {
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_TRUE(decoder_.DecodeChunk(delta_file_header_.data(),
delta_file_header_.size(),
&output_));
EXPECT_TRUE(decoder_.FinishDecoding());
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, PartialHeaderNotEnough) {
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_TRUE(decoder_.DecodeChunk(delta_file_header_.data(),
delta_file_header_.size() - 2,
&output_));
EXPECT_FALSE(decoder_.FinishDecoding());
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, BadMagicNumber) {
delta_file_[1] = 'Q' | 0x80;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, BadVersionNumber) {
delta_file_[3] = 0x01;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, SecondaryCompressionNotSupported) {
delta_file_[4] = 0x01;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, Decode) {
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_TRUE(decoder_.FinishDecoding());
EXPECT_EQ(expected_target_, output_);
}
TEST_F(VCDiffInterleavedDecoderTest, DecodeWithChecksum) {
ComputeAndAddChecksum();
InitializeDeltaFile();
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_TRUE(decoder_.FinishDecoding());
EXPECT_EQ(expected_target_, output_);
}
TEST_F(VCDiffInterleavedDecoderTest, ChecksumDoesNotMatch) {
AddChecksum(0xBADBAD);
InitializeDeltaFile();
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, ChecksumIsInvalid64BitVarint) {
static const char kInvalidVarint[] = { 0x81, 0x80, 0x80, 0x80, 0x80, 0x80,
0x80, 0x80, 0x80, 0x00 };
delta_window_header_[0] |= VCD_CHECKSUM;
delta_window_header_.append(kInvalidVarint, sizeof(kInvalidVarint));
// Adjust delta window size to include size of invalid Varint.
string size_of_invalid_varint;
VarintBE<int32_t>::AppendToString(
static_cast<int32_t>(delta_window_header_[4] + sizeof(kInvalidVarint)),
&size_of_invalid_varint);
delta_window_header_.replace(4, 1, size_of_invalid_varint);
InitializeDeltaFile();
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
// Remove one byte from the length of the chunk to process, and
// verify that an error is returned for FinishDecoding().
TEST_F(VCDiffInterleavedDecoderTest, FinishAfterDecodingPartialWindow) {
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size() - 1,
&output_));
EXPECT_FALSE(decoder_.FinishDecoding());
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTest, FinishAfterDecodingPartialWindowHeader) {
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_header_.size()
+ delta_window_header_.size() - 1,
&output_));
EXPECT_FALSE(decoder_.FinishDecoding());
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTest, TargetMatchesWindowSizeLimit) {
decoder_.SetMaximumTargetWindowSize(expected_target_.size());
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_TRUE(decoder_.FinishDecoding());
EXPECT_EQ(expected_target_, output_);
}
TEST_F(VCDiffInterleavedDecoderTest, TargetMatchesFileSizeLimit) {
decoder_.SetMaximumTargetFileSize(expected_target_.size());
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_TRUE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_TRUE(decoder_.FinishDecoding());
EXPECT_EQ(expected_target_, output_);
}
TEST_F(VCDiffInterleavedDecoderTest, TargetExceedsWindowSizeLimit) {
decoder_.SetMaximumTargetWindowSize(expected_target_.size() - 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, TargetExceedsFileSizeLimit) {
decoder_.SetMaximumTargetFileSize(expected_target_.size() - 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
// Fuzz bits to make sure decoder does not violently crash.
// This test has no expected behavior except that no crashes should occur.
// In some cases, changing bits will still decode to the correct target;
// for example, changing unused bits within a bitfield.
TEST_F(VCDiffInterleavedDecoderTest, FuzzBits) {
while (FuzzOneByteInDeltaFile()) {
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
if (decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_)) {
decoder_.FinishDecoding();
}
InitializeDeltaFile();
output_.clear();
}
}
// If a checksum is present, then fuzzing any of the bits may produce an error,
// but it should not result in an incorrect target being produced without
// an error.
TEST_F(VCDiffInterleavedDecoderTest, FuzzBitsWithChecksum) {
ComputeAndAddChecksum();
InitializeDeltaFile();
while (FuzzOneByteInDeltaFile()) {
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
if (decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_)) {
if (decoder_.FinishDecoding()) {
// Decoding succeeded. Make sure the correct target was produced.
EXPECT_EQ(expected_target_, output_);
}
} else {
EXPECT_EQ("", output_);
}
InitializeDeltaFile();
output_.clear();
}
}
TEST_F(VCDiffInterleavedDecoderTest, CopyMoreThanExpectedTarget) {
delta_file_[delta_file_header_.size() + 0x0C] =
FirstByteOfStringLength(kExpectedTarget);
delta_file_[delta_file_header_.size() + 0x0D] =
SecondByteOfStringLength(kExpectedTarget) + 1;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, CopySizeZero) {
delta_file_[delta_file_header_.size() + 0x0C] = 0;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, CopySizeTooLargeByOne) {
++delta_file_[delta_file_header_.size() + 0x0C];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, CopySizeTooSmallByOne) {
--delta_file_[delta_file_header_.size() + 0x0C];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, CopySizeMaxInt) {
WriteMaxVarintAtOffset(0x0C, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, CopySizeNegative) {
WriteNegativeVarintAtOffset(0x0C, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, CopySizeInvalid) {
WriteInvalidVarintAtOffset(0x0C, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, CopyAddressBeyondHereAddress) {
delta_file_[delta_file_header_.size() + 0x0D] =
FirstByteOfStringLength(kDictionary);
delta_file_[delta_file_header_.size() + 0x0E] =
SecondByteOfStringLength(kDictionary);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, CopyAddressMaxInt) {
WriteMaxVarintAtOffset(0x0D, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, CopyAddressNegative) {
WriteNegativeVarintAtOffset(0x0D, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, CopyAddressInvalid) {
WriteInvalidVarintAtOffset(0x0D, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, AddMoreThanExpectedTarget) {
delta_file_[delta_file_header_.size() + 0x0F] =
FirstByteOfStringLength(kExpectedTarget);
delta_file_[delta_file_header_.size() + 0x10] =
SecondByteOfStringLength(kExpectedTarget) + 1;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, AddSizeZero) {
delta_file_[delta_file_header_.size() + 0x0F] = 0;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, AddSizeTooLargeByOne) {
++delta_file_[delta_file_header_.size() + 0x0F];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, AddSizeTooSmallByOne) {
--delta_file_[delta_file_header_.size() + 0x0F];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, AddSizeMaxInt) {
WriteMaxVarintAtOffset(0x0F, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, AddSizeNegative) {
WriteNegativeVarintAtOffset(0x0F, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, AddSizeInvalid) {
WriteInvalidVarintAtOffset(0x0F, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, RunMoreThanExpectedTarget) {
delta_file_[delta_file_header_.size() + 0x5F] =
FirstByteOfStringLength(kExpectedTarget);
delta_file_[delta_file_header_.size() + 0x60] =
SecondByteOfStringLength(kExpectedTarget) + 1;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, RunSizeZero) {
delta_file_[delta_file_header_.size() + 0x5F] = 0;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, RunSizeTooLargeByOne) {
++delta_file_[delta_file_header_.size() + 0x5F];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, RunSizeTooSmallByOne) {
--delta_file_[delta_file_header_.size() + 0x5F];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, RunSizeMaxInt) {
WriteMaxVarintAtOffset(0x5F, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, RunSizeNegative) {
WriteNegativeVarintAtOffset(0x5F, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTest, RunSizeInvalid) {
WriteInvalidVarintAtOffset(0x5F, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
#if defined(HAVE_MPROTECT) && \
(defined(HAVE_MEMALIGN) || defined(HAVE_POSIX_MEMALIGN))
TEST_F(VCDiffInterleavedDecoderTest, ShouldNotReadPastEndOfBuffer) {
// Allocate two memory pages.
const int page_size = getpagesize();
void* two_pages = NULL;
#ifdef HAVE_POSIX_MEMALIGN
posix_memalign(&two_pages, page_size, 2 * page_size);
#else // !HAVE_POSIX_MEMALIGN
two_pages = memalign(page_size, 2 * page_size);
#endif // HAVE_POSIX_MEMALIGN
char* const first_page = reinterpret_cast<char*>(two_pages);
char* const second_page = first_page + page_size;
// Place the delta string at the end of the first page.
char* delta_with_guard = second_page - delta_file_.size();
memcpy(delta_with_guard, delta_file_.data(), delta_file_.size());
// Make the second page unreadable.
mprotect(second_page, page_size, PROT_NONE);
// Now perform the decode operation, which will cause a segmentation fault
// if it reads past the end of the buffer.
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_TRUE(decoder_.DecodeChunk(delta_with_guard,
delta_file_.size(),
&output_));
EXPECT_TRUE(decoder_.FinishDecoding());
EXPECT_EQ(expected_target_, output_);
// Undo the mprotect.
mprotect(second_page, page_size, PROT_READ|PROT_WRITE);
free(two_pages);
}
TEST_F(VCDiffInterleavedDecoderTest, ShouldNotReadPastBeginningOfBuffer) {
// Allocate two memory pages.
const int page_size = getpagesize();
void* two_pages = NULL;
#ifdef HAVE_POSIX_MEMALIGN
posix_memalign(&two_pages, page_size, 2 * page_size);
#else // !HAVE_POSIX_MEMALIGN
two_pages = memalign(page_size, 2 * page_size);
#endif // HAVE_POSIX_MEMALIGN
char* const first_page = reinterpret_cast<char*>(two_pages);
char* const second_page = first_page + page_size;
// Make the first page unreadable.
mprotect(first_page, page_size, PROT_NONE);
// Place the delta string at the beginning of the second page.
char* delta_with_guard = second_page;
memcpy(delta_with_guard, delta_file_.data(), delta_file_.size());
// Now perform the decode operation, which will cause a segmentation fault
// if it reads past the beginning of the buffer.
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_TRUE(decoder_.DecodeChunk(delta_with_guard,
delta_file_.size(),
&output_));
EXPECT_TRUE(decoder_.FinishDecoding());
EXPECT_EQ(expected_target_, output_);
// Undo the mprotect.
mprotect(first_page, page_size, PROT_READ|PROT_WRITE);
free(two_pages);
}
#endif // HAVE_MPROTECT && (HAVE_MEMALIGN || HAVE_POSIX_MEMALIGN)
// These are the same tests as for VCDiffInterleavedDecoderTest, with the added
// complication that instead of calling DecodeChunk() once with the entire data
// set, DecodeChunk() is called once for each byte of input. This is intended
// to shake out any bugs with rewind and resume while parsing chunked data.
typedef VCDiffInterleavedDecoderTest VCDiffInterleavedDecoderTestByteByByte;
// Test headers, valid and invalid.
TEST_F(VCDiffInterleavedDecoderTestByteByByte, DecodeHeaderOnly) {
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
for (size_t i = 0; i < delta_file_header_.size(); ++i) {
EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_header_[i], 1, &output_));
}
EXPECT_TRUE(decoder_.FinishDecoding());
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, PartialHeaderNotEnough) {
delta_file_.resize(delta_file_header_.size() - 2);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
for (size_t i = 0; i < delta_file_.size(); ++i) {
EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
}
EXPECT_FALSE(decoder_.FinishDecoding());
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, BadMagicNumber) {
delta_file_[1] = 'Q' | 0x80;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
// It should fail at the position that was altered
EXPECT_EQ(1U, i);
failed = true;
break;
}
}
EXPECT_TRUE(failed);
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, BadVersionNumber) {
delta_file_[3] = 0x01;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(3U, i);
break;
}
}
EXPECT_TRUE(failed);
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte,
SecondaryCompressionNotSupported) {
delta_file_[4] = 0x01;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(4U, i);
break;
}
}
EXPECT_TRUE(failed);
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, Decode) {
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
for (size_t i = 0; i < delta_file_.size(); ++i) {
EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
}
EXPECT_TRUE(decoder_.FinishDecoding());
EXPECT_EQ(expected_target_, output_);
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, DecodeWithChecksum) {
ComputeAndAddChecksum();
InitializeDeltaFile();
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
for (size_t i = 0; i < delta_file_.size(); ++i) {
EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
}
EXPECT_TRUE(decoder_.FinishDecoding());
EXPECT_EQ(expected_target_, output_);
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, ChecksumDoesNotMatch) {
AddChecksum(0xBADBAD);
InitializeDeltaFile();
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail after decoding the entire delta file
EXPECT_EQ(delta_file_.size() - 1, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, ChecksumIsInvalid64BitVarint) {
static const char kInvalidVarint[] = { 0x81, 0x80, 0x80, 0x80, 0x80, 0x80,
0x80, 0x80, 0x80, 0x00 };
delta_window_header_[0] |= VCD_CHECKSUM;
delta_window_header_.append(kInvalidVarint, sizeof(kInvalidVarint));
// Adjust delta window size to include size of invalid Varint.
string size_of_invalid_varint;
VarintBE<int32_t>::AppendToString(
static_cast<int32_t>(delta_window_header_[4] + sizeof(kInvalidVarint)),
&size_of_invalid_varint);
delta_window_header_.replace(4, 1, size_of_invalid_varint);
InitializeDeltaFile();
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail while trying to interpret the checksum.
EXPECT_EQ(delta_file_header_.size() + delta_window_header_.size() - 2, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, TargetMatchesWindowSizeLimit) {
decoder_.SetMaximumTargetWindowSize(expected_target_.size());
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
for (size_t i = 0; i < delta_file_.size(); ++i) {
EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
}
EXPECT_TRUE(decoder_.FinishDecoding());
EXPECT_EQ(expected_target_, output_);
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, TargetMatchesFileSizeLimit) {
decoder_.SetMaximumTargetFileSize(expected_target_.size());
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
for (size_t i = 0; i < delta_file_.size(); ++i) {
EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
}
EXPECT_TRUE(decoder_.FinishDecoding());
EXPECT_EQ(expected_target_, output_);
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, TargetExceedsWindowSizeLimit) {
decoder_.SetMaximumTargetWindowSize(expected_target_.size() - 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
break;
}
}
EXPECT_TRUE(failed);
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, TargetExceedsFileSizeLimit) {
decoder_.SetMaximumTargetFileSize(expected_target_.size() - 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
break;
}
}
EXPECT_TRUE(failed);
EXPECT_EQ("", output_);
}
// Fuzz bits to make sure decoder does not violently crash.
// This test has no expected behavior except that no crashes should occur.
// In some cases, changing bits will still decode to the correct target;
// for example, changing unused bits within a bitfield.
TEST_F(VCDiffInterleavedDecoderTestByteByByte, FuzzBits) {
while (FuzzOneByteInDeltaFile()) {
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
break;
}
}
if (!failed) {
decoder_.FinishDecoding();
}
InitializeDeltaFile();
output_.clear();
}
}
// If a checksum is present, then fuzzing any of the bits may produce an error,
// but it should not result in an incorrect target being produced without
// an error.
TEST_F(VCDiffInterleavedDecoderTestByteByByte, FuzzBitsWithChecksum) {
ComputeAndAddChecksum();
InitializeDeltaFile();
while (FuzzOneByteInDeltaFile()) {
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
break;
}
}
if (!failed) {
if (decoder_.FinishDecoding()) {
// Decoding succeeded. Make sure the correct target was produced.
EXPECT_EQ(expected_target_, output_);
}
}
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
InitializeDeltaFile();
output_.clear();
}
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte,
CopyInstructionsShouldFailIfNoSourceSegment) {
// Replace the Win_Indicator and the source size and source offset with a
// single 0 byte (a Win_Indicator for a window with no source segment.)
delta_window_header_.replace(0, 4, "\0", 1);
InitializeDeltaFile();
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// The first COPY instruction should fail.
EXPECT_EQ(delta_file_header_.size() + delta_window_header_.size() + 2, i);
break;
}
}
EXPECT_TRUE(failed);
EXPECT_EQ("", output_);
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopyMoreThanExpectedTarget) {
delta_file_[delta_file_header_.size() + 0x0C] =
FirstByteOfStringLength(kExpectedTarget);
delta_file_[delta_file_header_.size() + 0x0D] =
SecondByteOfStringLength(kExpectedTarget) + 1;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(delta_file_header_.size() + 0x0D, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
// A COPY instruction with an explicit size of 0 is not illegal according to the
// standard, although it is inefficient and should not be generated by any
// reasonable encoder. Changing the size of a COPY instruction to zero will
// cause a failure because the generated target window size will not match the
// expected target size.
TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopySizeZero) {
delta_file_[delta_file_header_.size() + 0x0C] = 0;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopySizeTooLargeByOne) {
++delta_file_[delta_file_header_.size() + 0x0C];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopySizeTooSmallByOne) {
--delta_file_[delta_file_header_.size() + 0x0C];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopySizeMaxInt) {
WriteMaxVarintAtOffset(0x0C, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(delta_file_header_.size() + 0x10, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopySizeNegative) {
WriteNegativeVarintAtOffset(0x0C, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(delta_file_header_.size() + 0x0F, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopySizeInvalid) {
WriteInvalidVarintAtOffset(0x0C, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(delta_file_header_.size() + 0x10, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopyAddressBeyondHereAddress) {
delta_file_[delta_file_header_.size() + 0x0D] =
FirstByteOfStringLength(kDictionary);
delta_file_[delta_file_header_.size() + 0x0E] =
SecondByteOfStringLength(kDictionary);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(delta_file_header_.size() + 0x0E, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopyAddressMaxInt) {
WriteMaxVarintAtOffset(0x0D, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(delta_file_header_.size() + 0x11, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopyAddressNegative) {
WriteNegativeVarintAtOffset(0x0D, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(delta_file_header_.size() + 0x10, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, CopyAddressInvalid) {
WriteInvalidVarintAtOffset(0x0D, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(delta_file_header_.size() + 0x11, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, AddMoreThanExpectedTarget) {
delta_file_[delta_file_header_.size() + 0x0F] =
FirstByteOfStringLength(kExpectedTarget);
delta_file_[delta_file_header_.size() + 0x10] =
SecondByteOfStringLength(kExpectedTarget) + 1;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(delta_file_header_.size() + 0x10, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
// An ADD instruction with an explicit size of 0 is not illegal according to the
// standard, although it is inefficient and should not be generated by any
// reasonable encoder. Changing the size of an ADD instruction to zero will
// cause a failure because the generated target window size will not match the
// expected target size.
TEST_F(VCDiffInterleavedDecoderTestByteByByte, AddSizeZero) {
delta_file_[delta_file_header_.size() + 0x0F] = 0;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, AddSizeTooLargeByOne) {
++delta_file_[delta_file_header_.size() + 0x0F];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, AddSizeTooSmallByOne) {
--delta_file_[delta_file_header_.size() + 0x0F];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, AddSizeMaxInt) {
WriteMaxVarintAtOffset(0x0F, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(delta_file_header_.size() + 0x13, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, AddSizeNegative) {
WriteNegativeVarintAtOffset(0x0F, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(delta_file_header_.size() + 0x12, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, AddSizeInvalid) {
WriteInvalidVarintAtOffset(0x0F, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(delta_file_header_.size() + 0x13, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, RunMoreThanExpectedTarget) {
delta_file_[delta_file_header_.size() + 0x5F] =
FirstByteOfStringLength(kExpectedTarget);
delta_file_[delta_file_header_.size() + 0x60] =
SecondByteOfStringLength(kExpectedTarget) + 1;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(delta_file_header_.size() + 0x60, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
// A RUN instruction with an explicit size of 0 is not illegal according to the
// standard, although it is inefficient and should not be generated by any
// reasonable encoder. Changing the size of a RUN instruction to zero will
// cause a failure because the generated target window size will not match the
// expected target size.
TEST_F(VCDiffInterleavedDecoderTestByteByByte, RunSizeZero) {
delta_file_[delta_file_header_.size() + 0x5F] = 0;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, RunSizeTooLargeByOne) {
++delta_file_[delta_file_header_.size() + 0x5F];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, RunSizeTooSmallByOne) {
--delta_file_[delta_file_header_.size() + 0x5F];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, RunSizeMaxInt) {
WriteMaxVarintAtOffset(0x5F, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(delta_file_header_.size() + 0x63, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, RunSizeNegative) {
WriteNegativeVarintAtOffset(0x5F, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(delta_file_header_.size() + 0x62, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
TEST_F(VCDiffInterleavedDecoderTestByteByByte, RunSizeInvalid) {
WriteInvalidVarintAtOffset(0x5F, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
bool failed = false;
for (size_t i = 0; i < delta_file_.size(); ++i) {
if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
failed = true;
// It should fail at the position that was altered
EXPECT_EQ(delta_file_header_.size() + 0x63, i);
break;
}
}
EXPECT_TRUE(failed);
// The decoder should not create more target bytes than were expected.
EXPECT_GE(expected_target_.size(), output_.size());
}
} // namespace open_vcdiff