diff options
Diffstat (limited to 'src/vcdecoder1_test.cc')
| -rw-r--r-- | src/vcdecoder1_test.cc | 801 |
1 files changed, 801 insertions, 0 deletions
diff --git a/src/vcdecoder1_test.cc b/src/vcdecoder1_test.cc new file mode 100644 index 0000000..65bff91 --- /dev/null +++ b/src/vcdecoder1_test.cc @@ -0,0 +1,801 @@ +// 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_.c_str(), 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_.c_str(), 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_.c_str(), 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_.c_str(), 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_.c_str(), 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 |