// 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 <string>
#include "testing.h"
#include "vcdecoder_test.h"
#include "vcdiff_defs.h"
namespace open_vcdiff {
TEST_F(VCDiffStandardDecoderTest, 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(VCDiffStandardDecoderTest, 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_);
}
// If we add a checksum to a standard-format delta file (without using format
// extensions), it will be interpreted as random bytes inserted into the middle
// of the file. The decode operation should fail, but where exactly it fails is
// not easy to predict.
TEST_F(VCDiffStandardDecoderTest, StandardFormatDoesNotSupportChecksum) {
ComputeAndAddChecksum();
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(VCDiffStandardDecoderTest, 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(VCDiffStandardDecoderTest, 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());
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, 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(VCDiffStandardDecoderTest, 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(VCDiffStandardDecoderTest, 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(VCDiffStandardDecoderTest, 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(VCDiffStandardDecoderTest, FuzzBits) {
while (FuzzOneByteInDeltaFile()) {
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
if (decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_)) {
decoder_.FinishDecoding();
}
InitializeDeltaFile();
output_.clear();
}
}
// Change each element of the delta file window to an erroneous value
// and make sure it's caught as an error.
TEST_F(VCDiffStandardDecoderTest, WinIndicatorHasBothSourceAndTarget) {
delta_file_[delta_file_header_.size()] = VCD_SOURCE + VCD_TARGET;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, OkayToSetUpperBitsOfWinIndicator) {
// It is not an error to set any of the other bits in Win_Indicator
// besides VCD_SOURCE and VCD_TARGET.
delta_file_[delta_file_header_.size()] = 0xFD;
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(VCDiffStandardDecoderTest, 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());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
// The first COPY instruction should fail, so there should be no output
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, SourceSegmentSizeExceedsDictionarySize) {
++delta_file_[delta_file_header_.size() + 2]; // increment size
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, SourceSegmentSizeMaxInt) {
WriteMaxVarintAtOffset(1, 2);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, SourceSegmentSizeNegative) {
WriteNegativeVarintAtOffset(1, 2);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, SourceSegmentSizeInvalid) {
WriteInvalidVarintAtOffset(1, 2);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, SourceSegmentEndExceedsDictionarySize) {
++delta_file_[delta_file_header_.size() + 3]; // increment start pos
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, SourceSegmentPosMaxInt) {
WriteMaxVarintAtOffset(3, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, SourceSegmentPosNegative) {
WriteNegativeVarintAtOffset(3, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, SourceSegmentPosInvalid) {
WriteInvalidVarintAtOffset(3, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, DeltaEncodingLengthZero) {
delta_file_[delta_file_header_.size() + 4] = 0;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, DeltaEncodingLengthTooLargeByOne) {
++delta_file_[delta_file_header_.size() + 4];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, DeltaEncodingLengthTooSmallByOne) {
--delta_file_[delta_file_header_.size() + 4];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, DeltaEncodingLengthMaxInt) {
WriteMaxVarintAtOffset(4, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, DeltaEncodingLengthNegative) {
WriteNegativeVarintAtOffset(4, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, DeltaEncodingLengthInvalid) {
WriteInvalidVarintAtOffset(4, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, TargetWindowSizeZero) {
static const char zero_size[] = { 0x00 };
delta_file_.replace(delta_file_header_.size() + 5, 2, zero_size, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, TargetWindowSizeTooLargeByOne) {
++delta_file_[delta_file_header_.size() + 6];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, TargetWindowSizeTooSmallByOne) {
--delta_file_[delta_file_header_.size() + 6];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, TargetWindowSizeMaxInt) {
WriteMaxVarintAtOffset(5, 2);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, TargetWindowSizeNegative) {
WriteNegativeVarintAtOffset(5, 2);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, TargetWindowSizeInvalid) {
WriteInvalidVarintAtOffset(5, 2);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, OkayToSetUpperBitsOfDeltaIndicator) {
delta_file_[delta_file_header_.size() + 7] = 0xF8;
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(VCDiffStandardDecoderTest, DataCompressionNotSupported) {
delta_file_[delta_file_header_.size() + 7] = 0x01;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, InstructionCompressionNotSupported) {
delta_file_[delta_file_header_.size() + 7] = 0x02;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, AddressCompressionNotSupported) {
delta_file_[delta_file_header_.size() + 7] = 0x04;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, AddRunDataSizeZero) {
delta_file_[delta_file_header_.size() + 8] = 0;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, AddRunDataSizeTooLargeByOne) {
++delta_file_[delta_file_header_.size() + 8];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, AddRunDataSizeTooSmallByOne) {
--delta_file_[delta_file_header_.size() + 8];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, AddRunDataSizeMaxInt) {
WriteMaxVarintAtOffset(8, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, AddRunDataSizeNegative) {
WriteNegativeVarintAtOffset(8, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, AddRunDataSizeInvalid) {
WriteInvalidVarintAtOffset(8, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, InstructionsSizeZero) {
delta_file_[delta_file_header_.size() + 9] = 0;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, InstructionsSizeTooLargeByOne) {
++delta_file_[delta_file_header_.size() + 9];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, InstructionsSizeTooSmallByOne) {
--delta_file_[delta_file_header_.size() + 9];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, InstructionsSizeMaxInt) {
WriteMaxVarintAtOffset(9, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, InstructionsSizeNegative) {
WriteNegativeVarintAtOffset(9, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, InstructionsSizeInvalid) {
WriteInvalidVarintAtOffset(9, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, CopyAddressSizeZero) {
delta_file_[delta_file_header_.size() + 10] = 0;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, CopyAddressSizeTooLargeByOne) {
++delta_file_[delta_file_header_.size() + 10];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, CopyAddressSizeTooSmallByOne) {
--delta_file_[delta_file_header_.size() + 10];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, CopyAddressSizeMaxInt) {
WriteMaxVarintAtOffset(10, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, CopyAddressSizeNegative) {
WriteNegativeVarintAtOffset(10, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, CopyAddressSizeInvalid) {
WriteInvalidVarintAtOffset(10, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, InstructionsEndEarly) {
--delta_file_[delta_file_header_.size() + 9];
++delta_file_[delta_file_header_.size() + 10];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
// From this point on, the tests should also be run against the interleaved
// format.
TEST_F(VCDiffStandardDecoderTest, CopyMoreThanExpectedTarget) {
delta_file_[delta_file_header_.size() + 0x70] =
FirstByteOfStringLength(kExpectedTarget);
delta_file_[delta_file_header_.size() + 0x71] =
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(VCDiffStandardDecoderTest, CopySizeZero) {
delta_file_[delta_file_header_.size() + 0x70] = 0;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, CopySizeTooLargeByOne) {
++delta_file_[delta_file_header_.size() + 0x70];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, CopySizeTooSmallByOne) {
--delta_file_[delta_file_header_.size() + 0x70];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, CopySizeMaxInt) {
WriteMaxVarintAtOffset(0x70, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, CopySizeNegative) {
WriteNegativeVarintAtOffset(0x70, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, CopySizeInvalid) {
WriteInvalidVarintAtOffset(0x70, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, CopyAddressBeyondHereAddress) {
delta_file_[delta_file_header_.size() + 0x7B] =
FirstByteOfStringLength(kDictionary);
delta_file_[delta_file_header_.size() + 0x7C] =
SecondByteOfStringLength(kDictionary);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, CopyAddressMaxInt) {
WriteMaxVarintAtOffset(0x7B, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, CopyAddressNegative) {
WriteNegativeVarintAtOffset(0x70, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, CopyAddressInvalid) {
WriteInvalidVarintAtOffset(0x70, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, AddMoreThanExpectedTarget) {
delta_file_[delta_file_header_.size() + 0x72] =
FirstByteOfStringLength(kExpectedTarget);
delta_file_[delta_file_header_.size() + 0x73] =
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(VCDiffStandardDecoderTest, AddSizeZero) {
delta_file_[delta_file_header_.size() + 0x72] = 0;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, AddSizeTooLargeByOne) {
++delta_file_[delta_file_header_.size() + 0x72];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, AddSizeTooSmallByOne) {
--delta_file_[delta_file_header_.size() + 0x72];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, AddSizeMaxInt) {
WriteMaxVarintAtOffset(0x72, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, AddSizeNegative) {
WriteNegativeVarintAtOffset(0x72, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, AddSizeInvalid) {
WriteInvalidVarintAtOffset(0x72, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, RunMoreThanExpectedTarget) {
delta_file_[delta_file_header_.size() + 0x78] =
FirstByteOfStringLength(kExpectedTarget);
delta_file_[delta_file_header_.size() + 0x79] =
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(VCDiffStandardDecoderTest, RunSizeZero) {
delta_file_[delta_file_header_.size() + 0x78] = 0;
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, RunSizeTooLargeByOne) {
++delta_file_[delta_file_header_.size() + 0x78];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, RunSizeTooSmallByOne) {
--delta_file_[delta_file_header_.size() + 0x78];
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, RunSizeMaxInt) {
WriteMaxVarintAtOffset(0x78, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, RunSizeNegative) {
WriteNegativeVarintAtOffset(0x78, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
TEST_F(VCDiffStandardDecoderTest, RunSizeInvalid) {
WriteInvalidVarintAtOffset(0x78, 1);
decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
EXPECT_FALSE(decoder_.DecodeChunk(delta_file_.data(),
delta_file_.size(),
&output_));
EXPECT_EQ("", output_);
}
} // namespace open_vcdiff