• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2008 Google Inc.
2 // Author: Lincoln Smith
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //      http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 
16 #include <config.h>
17 #include "google/vcdecoder.h"
18 #include "testing.h"
19 #include "vcdecoder_test.h"
20 #include "vcdiff_defs.h"  // VCD_SOURCE
21 
22 namespace open_vcdiff {
23 
24 // These are the same tests as for VCDiffStandardDecoderTest, with the added
25 // complication that instead of calling DecodeChunk() once with the entire data
26 // set, DecodeChunk() is called once for each byte of input.  This is intended
27 // to shake out any bugs with rewind and resume while parsing chunked data.
28 
29 typedef VCDiffStandardDecoderTest VCDiffStandardDecoderTestByteByByte;
30 
TEST_F(VCDiffStandardDecoderTestByteByByte,DecodeHeaderOnly)31 TEST_F(VCDiffStandardDecoderTestByteByByte, DecodeHeaderOnly) {
32   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
33   for (size_t i = 0; i < delta_file_header_.size(); ++i) {
34     EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_header_[i], 1, &output_));
35   }
36   EXPECT_TRUE(decoder_.FinishDecoding());
37   EXPECT_EQ("", output_);
38 }
39 
TEST_F(VCDiffStandardDecoderTestByteByByte,Decode)40 TEST_F(VCDiffStandardDecoderTestByteByByte, Decode) {
41   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
42   for (size_t i = 0; i < delta_file_.size(); ++i) {
43     EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
44   }
45   EXPECT_TRUE(decoder_.FinishDecoding());
46   EXPECT_EQ(expected_target_.c_str(), output_);
47 }
48 
TEST_F(VCDiffStandardDecoderTestByteByByte,DecodeNoVcdTarget)49 TEST_F(VCDiffStandardDecoderTestByteByByte, DecodeNoVcdTarget) {
50   decoder_.SetAllowVcdTarget(false);
51   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
52   for (size_t i = 0; i < delta_file_.size(); ++i) {
53     EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
54   }
55   EXPECT_TRUE(decoder_.FinishDecoding());
56   EXPECT_EQ(expected_target_.c_str(), output_);
57 }
58 
59 // Remove one byte from the length of the chunk to process, and
60 // verify that an error is returned for FinishDecoding().
TEST_F(VCDiffStandardDecoderTestByteByByte,FinishAfterDecodingPartialWindow)61 TEST_F(VCDiffStandardDecoderTestByteByByte, FinishAfterDecodingPartialWindow) {
62   delta_file_.resize(delta_file_.size() - 1);
63   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
64   for (size_t i = 0; i < delta_file_.size(); ++i) {
65     EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
66   }
67   EXPECT_FALSE(decoder_.FinishDecoding());
68   // The decoder should not create more target bytes than were expected.
69   EXPECT_GE(expected_target_.size(), output_.size());
70 }
71 
TEST_F(VCDiffStandardDecoderTestByteByByte,FinishAfterDecodingPartialWindowHeader)72 TEST_F(VCDiffStandardDecoderTestByteByByte,
73        FinishAfterDecodingPartialWindowHeader) {
74   delta_file_.resize(delta_file_header_.size()
75                        + delta_window_header_.size() - 1);
76   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
77   for (size_t i = 0; i < delta_file_.size(); ++i) {
78     EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
79   }
80   EXPECT_FALSE(decoder_.FinishDecoding());
81   EXPECT_EQ("", output_);
82 }
83 
84 // If we add a checksum to a standard-format delta file (without using format
85 // extensions), it will be interpreted as random bytes inserted into the middle
86 // of the file.  The decode operation should fail, but where exactly it fails is
87 // undefined.
TEST_F(VCDiffStandardDecoderTestByteByByte,StandardFormatDoesNotSupportChecksum)88 TEST_F(VCDiffStandardDecoderTestByteByByte,
89        StandardFormatDoesNotSupportChecksum) {
90   ComputeAndAddChecksum();
91   InitializeDeltaFile();
92   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
93   bool failed = false;
94   for (size_t i = 0; i < delta_file_.size(); ++i) {
95     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
96       failed = true;
97       break;
98     }
99   }
100   EXPECT_TRUE(failed);
101   // The decoder should not create more target bytes than were expected.
102   EXPECT_GE(expected_target_.size(), output_.size());
103 }
104 
TEST_F(VCDiffStandardDecoderTestByteByByte,TargetMatchesWindowSizeLimit)105 TEST_F(VCDiffStandardDecoderTestByteByByte, TargetMatchesWindowSizeLimit) {
106   decoder_.SetMaximumTargetWindowSize(expected_target_.size());
107   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
108   for (size_t i = 0; i < delta_file_.size(); ++i) {
109     EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
110   }
111   EXPECT_TRUE(decoder_.FinishDecoding());
112   EXPECT_EQ(expected_target_.c_str(), output_);
113 }
114 
TEST_F(VCDiffStandardDecoderTestByteByByte,TargetMatchesFileSizeLimit)115 TEST_F(VCDiffStandardDecoderTestByteByByte, TargetMatchesFileSizeLimit) {
116   decoder_.SetMaximumTargetFileSize(expected_target_.size());
117   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
118   for (size_t i = 0; i < delta_file_.size(); ++i) {
119     EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
120   }
121   EXPECT_TRUE(decoder_.FinishDecoding());
122   EXPECT_EQ(expected_target_.c_str(), output_);
123 }
124 
TEST_F(VCDiffStandardDecoderTestByteByByte,TargetExceedsWindowSizeLimit)125 TEST_F(VCDiffStandardDecoderTestByteByByte, TargetExceedsWindowSizeLimit) {
126   decoder_.SetMaximumTargetWindowSize(expected_target_.size() - 1);
127   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
128   bool failed = false;
129   for (size_t i = 0; i < delta_file_.size(); ++i) {
130     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
131       failed = true;
132       break;
133     }
134   }
135   EXPECT_TRUE(failed);
136   EXPECT_EQ("", output_);
137 }
138 
TEST_F(VCDiffStandardDecoderTestByteByByte,TargetExceedsFileSizeLimit)139 TEST_F(VCDiffStandardDecoderTestByteByByte, TargetExceedsFileSizeLimit) {
140   decoder_.SetMaximumTargetFileSize(expected_target_.size() - 1);
141   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
142   bool failed = false;
143   for (size_t i = 0; i < delta_file_.size(); ++i) {
144     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
145       failed = true;
146       break;
147     }
148   }
149   EXPECT_TRUE(failed);
150   EXPECT_EQ("", output_);
151 }
152 
153 // Fuzz bits to make sure decoder does not violently crash.
154 // This test has no expected behavior except that no crashes should occur.
155 // In some cases, changing bits will still decode to the correct target;
156 // for example, changing unused bits within a bitfield.
TEST_F(VCDiffStandardDecoderTestByteByByte,FuzzBits)157 TEST_F(VCDiffStandardDecoderTestByteByByte, FuzzBits) {
158   while (FuzzOneByteInDeltaFile()) {
159     decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
160     bool failed = false;
161     for (size_t i = 0; i < delta_file_.size(); ++i) {
162       if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
163         failed = true;
164         break;
165       }
166     }
167     if (!failed) {
168       decoder_.FinishDecoding();
169     }
170     // The decoder should not create more target bytes than were expected.
171     EXPECT_GE(expected_target_.size(), output_.size());
172     InitializeDeltaFile();
173     output_.clear();
174   }
175 }
176 
177 // Change each element of the delta file window to an erroneous value
178 // and make sure it's caught as an error.
179 
TEST_F(VCDiffStandardDecoderTestByteByByte,WinIndicatorHasBothSourceAndTarget)180 TEST_F(VCDiffStandardDecoderTestByteByByte,
181        WinIndicatorHasBothSourceAndTarget) {
182   delta_file_[delta_file_header_.size()] = VCD_SOURCE + VCD_TARGET;
183   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
184   bool failed = false;
185   for (size_t i = 0; i < delta_file_.size(); ++i) {
186     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
187       failed = true;
188       // It should fail at the position that was altered
189       EXPECT_EQ(delta_file_header_.size(), i);
190       break;
191     }
192   }
193   EXPECT_TRUE(failed);
194   EXPECT_EQ("", output_);
195 }
196 
TEST_F(VCDiffStandardDecoderTestByteByByte,OkayToSetUpperBitsOfWinIndicator)197 TEST_F(VCDiffStandardDecoderTestByteByByte, OkayToSetUpperBitsOfWinIndicator) {
198   // It is not an error to set any of the other bits in Win_Indicator
199   // besides VCD_SOURCE and VCD_TARGET.
200   delta_file_[delta_file_header_.size()] = 0xFD;
201   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
202   for (size_t i = 0; i < delta_file_.size(); ++i) {
203     EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
204   }
205   EXPECT_TRUE(decoder_.FinishDecoding());
206   EXPECT_EQ(expected_target_.c_str(), output_);
207 }
208 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopyInstructionsShouldFailIfNoSourceSegment)209 TEST_F(VCDiffStandardDecoderTestByteByByte,
210        CopyInstructionsShouldFailIfNoSourceSegment) {
211   // Replace the Win_Indicator and the source size and source offset with a
212   // single 0 byte (a Win_Indicator for a window with no source segment.)
213   delta_window_header_.replace(0, 4, "\0", 1);
214   InitializeDeltaFile();
215   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
216   bool failed = false;
217   for (size_t i = 0; i < delta_file_.size(); ++i) {
218     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
219       failed = true;
220       // The first COPY instruction should fail.  With the standard format,
221       // it may need to see the whole delta window before knowing that it is
222       // invalid.
223       break;
224     }
225   }
226   EXPECT_TRUE(failed);
227   EXPECT_EQ("", output_);
228 }
229 
TEST_F(VCDiffStandardDecoderTestByteByByte,SourceSegmentSizeExceedsDictionarySize)230 TEST_F(VCDiffStandardDecoderTestByteByByte,
231        SourceSegmentSizeExceedsDictionarySize) {
232   ++delta_file_[delta_file_header_.size() + 2];  // increment size
233   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
234   bool failed = false;
235   for (size_t i = 0; i < delta_file_.size(); ++i) {
236     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
237       failed = true;
238       // It should fail after decoding the source segment size
239       EXPECT_EQ(delta_file_header_.size() + 2, i);
240       break;
241     }
242   }
243   EXPECT_TRUE(failed);
244   EXPECT_EQ("", output_);
245 }
246 
TEST_F(VCDiffStandardDecoderTestByteByByte,SourceSegmentSizeMaxInt)247 TEST_F(VCDiffStandardDecoderTestByteByByte, SourceSegmentSizeMaxInt) {
248   WriteMaxVarintAtOffset(1, 2);
249   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
250   bool failed = false;
251   for (size_t i = 0; i < delta_file_.size(); ++i) {
252     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
253       failed = true;
254       // It should fail after decoding the source segment size
255       EXPECT_EQ(delta_file_header_.size() + 5, i);
256       break;
257     }
258   }
259   EXPECT_TRUE(failed);
260   EXPECT_EQ("", output_);
261 }
262 
TEST_F(VCDiffStandardDecoderTestByteByByte,SourceSegmentSizeNegative)263 TEST_F(VCDiffStandardDecoderTestByteByByte, SourceSegmentSizeNegative) {
264   WriteNegativeVarintAtOffset(1, 2);
265   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
266   bool failed = false;
267   for (size_t i = 0; i < delta_file_.size(); ++i) {
268     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
269       failed = true;
270       // It should fail after decoding the source segment size
271       EXPECT_EQ(delta_file_header_.size() + 4, i);
272       break;
273     }
274   }
275   EXPECT_TRUE(failed);
276   EXPECT_EQ("", output_);
277 }
278 
TEST_F(VCDiffStandardDecoderTestByteByByte,SourceSegmentSizeInvalid)279 TEST_F(VCDiffStandardDecoderTestByteByByte, SourceSegmentSizeInvalid) {
280   WriteInvalidVarintAtOffset(1, 2);
281   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
282   bool failed = false;
283   for (size_t i = 0; i < delta_file_.size(); ++i) {
284     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
285       failed = true;
286       // It should fail after decoding the source segment size
287       EXPECT_GE(delta_file_header_.size() + 6, i);
288       break;
289     }
290   }
291   EXPECT_TRUE(failed);
292   EXPECT_EQ("", output_);
293 }
294 
TEST_F(VCDiffStandardDecoderTestByteByByte,SourceSegmentEndExceedsDictionarySize)295 TEST_F(VCDiffStandardDecoderTestByteByByte,
296        SourceSegmentEndExceedsDictionarySize) {
297   ++delta_file_[delta_file_header_.size() + 3];  // increment start pos
298   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
299   bool failed = false;
300   for (size_t i = 0; i < delta_file_.size(); ++i) {
301     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
302       failed = true;
303       // It should fail after decoding the source segment end
304       EXPECT_EQ(delta_file_header_.size() + 3, i);
305       break;
306     }
307   }
308   EXPECT_TRUE(failed);
309   EXPECT_EQ("", output_);
310 }
311 
TEST_F(VCDiffStandardDecoderTestByteByByte,SourceSegmentPosMaxInt)312 TEST_F(VCDiffStandardDecoderTestByteByByte, SourceSegmentPosMaxInt) {
313   WriteMaxVarintAtOffset(3, 1);
314   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
315   bool failed = false;
316   for (size_t i = 0; i < delta_file_.size(); ++i) {
317     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
318       failed = true;
319       // It should fail after decoding the source segment pos
320       EXPECT_EQ(delta_file_header_.size() + 7, i);
321       break;
322     }
323   }
324   EXPECT_TRUE(failed);
325   EXPECT_EQ("", output_);
326 }
327 
TEST_F(VCDiffStandardDecoderTestByteByByte,SourceSegmentPosNegative)328 TEST_F(VCDiffStandardDecoderTestByteByByte, SourceSegmentPosNegative) {
329   WriteNegativeVarintAtOffset(3, 1);
330   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
331   bool failed = false;
332   for (size_t i = 0; i < delta_file_.size(); ++i) {
333     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
334       failed = true;
335       // It should fail after decoding the source segment pos
336       EXPECT_EQ(delta_file_header_.size() + 6, i);
337       break;
338     }
339   }
340   EXPECT_TRUE(failed);
341   EXPECT_EQ("", output_);
342 }
343 
TEST_F(VCDiffStandardDecoderTestByteByByte,SourceSegmentPosInvalid)344 TEST_F(VCDiffStandardDecoderTestByteByByte, SourceSegmentPosInvalid) {
345   WriteInvalidVarintAtOffset(3, 1);
346   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
347   bool failed = false;
348   for (size_t i = 0; i < delta_file_.size(); ++i) {
349     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
350       failed = true;
351       // It should fail after decoding the source segment pos
352       EXPECT_GE(delta_file_header_.size() + 8, i);
353       break;
354     }
355   }
356   EXPECT_TRUE(failed);
357   EXPECT_EQ("", output_);
358 }
359 
TEST_F(VCDiffStandardDecoderTestByteByByte,DeltaEncodingLengthZero)360 TEST_F(VCDiffStandardDecoderTestByteByByte, DeltaEncodingLengthZero) {
361   delta_file_[delta_file_header_.size() + 4] = 0;
362   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
363   bool failed = false;
364   for (size_t i = 0; i < delta_file_.size(); ++i) {
365     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
366       failed = true;
367       // It should fail after decoding the copy address segment size
368       EXPECT_EQ(delta_file_header_.size() + 10, i);
369       break;
370     }
371   }
372   EXPECT_TRUE(failed);
373   EXPECT_EQ("", output_);
374 }
375 
TEST_F(VCDiffStandardDecoderTestByteByByte,DeltaEncodingLengthTooLargeByOne)376 TEST_F(VCDiffStandardDecoderTestByteByByte, DeltaEncodingLengthTooLargeByOne) {
377   ++delta_file_[delta_file_header_.size() + 4];
378   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
379   bool failed = false;
380   for (size_t i = 0; i < delta_file_.size(); ++i) {
381     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
382       failed = true;
383       // It should fail after decoding the copy address segment size
384       EXPECT_EQ(delta_file_header_.size() + 10, i);
385       break;
386     }
387   }
388   EXPECT_TRUE(failed);
389   EXPECT_EQ("", output_);
390 }
391 
TEST_F(VCDiffStandardDecoderTestByteByByte,DeltaEncodingLengthTooSmallByOne)392 TEST_F(VCDiffStandardDecoderTestByteByByte, DeltaEncodingLengthTooSmallByOne) {
393   --delta_file_[delta_file_header_.size() + 4];
394   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
395   bool failed = false;
396   for (size_t i = 0; i < delta_file_.size(); ++i) {
397     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
398       failed = true;
399       // It should fail after decoding the copy address segment size
400       EXPECT_EQ(delta_file_header_.size() + 10, i);
401       break;
402     }
403   }
404   EXPECT_TRUE(failed);
405   EXPECT_EQ("", output_);
406 }
407 
TEST_F(VCDiffStandardDecoderTestByteByByte,DeltaEncodingLengthMaxInt)408 TEST_F(VCDiffStandardDecoderTestByteByByte, DeltaEncodingLengthMaxInt) {
409   WriteMaxVarintAtOffset(4, 1);
410   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
411   bool failed = false;
412   for (size_t i = 0; i < delta_file_.size(); ++i) {
413     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
414       failed = true;
415       // It should fail before finishing the window header
416       EXPECT_GE(delta_file_header_.size() + delta_window_header_.size() + 4,
417                 i);
418       break;
419     }
420   }
421   EXPECT_TRUE(failed);
422   EXPECT_EQ("", output_);
423 }
424 
TEST_F(VCDiffStandardDecoderTestByteByByte,DeltaEncodingLengthNegative)425 TEST_F(VCDiffStandardDecoderTestByteByByte, DeltaEncodingLengthNegative) {
426   WriteNegativeVarintAtOffset(4, 1);
427   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
428   bool failed = false;
429   for (size_t i = 0; i < delta_file_.size(); ++i) {
430     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
431       failed = true;
432       // It should fail after decoding the delta encoding length
433       EXPECT_EQ(delta_file_header_.size() + 7, i);
434       break;
435     }
436   }
437   EXPECT_TRUE(failed);
438   EXPECT_EQ("", output_);
439 }
440 
TEST_F(VCDiffStandardDecoderTestByteByByte,DeltaEncodingLengthInvalid)441 TEST_F(VCDiffStandardDecoderTestByteByByte, DeltaEncodingLengthInvalid) {
442   WriteInvalidVarintAtOffset(4, 1);
443   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
444   bool failed = false;
445   for (size_t i = 0; i < delta_file_.size(); ++i) {
446     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
447       failed = true;
448       // It should fail after decoding the delta encoding length
449       EXPECT_GE(delta_file_header_.size() + 9, i);
450       break;
451     }
452   }
453   EXPECT_TRUE(failed);
454   EXPECT_EQ("", output_);
455 }
456 
TEST_F(VCDiffStandardDecoderTestByteByByte,TargetWindowSizeZero)457 TEST_F(VCDiffStandardDecoderTestByteByByte, TargetWindowSizeZero) {
458   static const char zero_size[] = { 0x00 };
459   delta_file_.replace(delta_file_header_.size() + 5, 2, zero_size, 1);
460   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
461   bool failed = false;
462   for (size_t i = 0; i < delta_file_.size(); ++i) {
463     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
464       failed = true;
465       break;
466     }
467   }
468   EXPECT_TRUE(failed);
469   EXPECT_EQ("", output_);
470 }
471 
TEST_F(VCDiffStandardDecoderTestByteByByte,TargetWindowSizeTooLargeByOne)472 TEST_F(VCDiffStandardDecoderTestByteByByte, TargetWindowSizeTooLargeByOne) {
473   ++delta_file_[delta_file_header_.size() + 6];
474   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
475   bool failed = false;
476   for (size_t i = 0; i < delta_file_.size(); ++i) {
477     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
478       failed = true;
479       break;
480     }
481   }
482   EXPECT_TRUE(failed);
483   // The decoder should not create more target bytes than were expected.
484   EXPECT_GE(expected_target_.size(), output_.size());
485 }
486 
TEST_F(VCDiffStandardDecoderTestByteByByte,TargetWindowSizeTooSmallByOne)487 TEST_F(VCDiffStandardDecoderTestByteByByte, TargetWindowSizeTooSmallByOne) {
488   --delta_file_[delta_file_header_.size() + 6];
489   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
490   bool failed = false;
491   for (size_t i = 0; i < delta_file_.size(); ++i) {
492     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
493       failed = true;
494       break;
495     }
496   }
497   EXPECT_TRUE(failed);
498   // The decoder should not create more target bytes than were expected.
499   EXPECT_GE(expected_target_.size(), output_.size());
500 }
501 
TEST_F(VCDiffStandardDecoderTestByteByByte,TargetWindowSizeMaxInt)502 TEST_F(VCDiffStandardDecoderTestByteByByte, TargetWindowSizeMaxInt) {
503   WriteMaxVarintAtOffset(5, 2);
504   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
505   bool failed = false;
506   for (size_t i = 0; i < delta_file_.size(); ++i) {
507     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
508       failed = true;
509       // It should fail after decoding the target window size
510       EXPECT_EQ(delta_file_header_.size() + 9, i);
511       break;
512     }
513   }
514   EXPECT_TRUE(failed);
515   EXPECT_EQ("", output_);
516 }
517 
TEST_F(VCDiffStandardDecoderTestByteByByte,TargetWindowSizeNegative)518 TEST_F(VCDiffStandardDecoderTestByteByByte, TargetWindowSizeNegative) {
519   WriteNegativeVarintAtOffset(5, 2);
520   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
521   bool failed = false;
522   for (size_t i = 0; i < delta_file_.size(); ++i) {
523     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
524       failed = true;
525       // It should fail after decoding the target window size
526       EXPECT_EQ(delta_file_header_.size() + 8, i);
527       break;
528     }
529   }
530   EXPECT_TRUE(failed);
531   EXPECT_EQ("", output_);
532 }
533 
TEST_F(VCDiffStandardDecoderTestByteByByte,TargetWindowSizeInvalid)534 TEST_F(VCDiffStandardDecoderTestByteByByte, TargetWindowSizeInvalid) {
535   WriteInvalidVarintAtOffset(5, 2);
536   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
537   bool failed = false;
538   for (size_t i = 0; i < delta_file_.size(); ++i) {
539     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
540       failed = true;
541       // It should fail after decoding the target window size
542       EXPECT_GE(delta_file_header_.size() + 10, i);
543       break;
544     }
545   }
546   EXPECT_TRUE(failed);
547   EXPECT_EQ("", output_);
548 }
549 
TEST_F(VCDiffStandardDecoderTestByteByByte,OkayToSetUpperBitsOfDeltaIndicator)550 TEST_F(VCDiffStandardDecoderTestByteByByte,
551        OkayToSetUpperBitsOfDeltaIndicator) {
552   delta_file_[delta_file_header_.size() + 7] = 0xF8;
553   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
554   for (size_t i = 0; i < delta_file_.size(); ++i) {
555     EXPECT_TRUE(decoder_.DecodeChunk(&delta_file_[i], 1, &output_));
556   }
557   EXPECT_TRUE(decoder_.FinishDecoding());
558   EXPECT_EQ(expected_target_.c_str(), output_);
559 }
560 
TEST_F(VCDiffStandardDecoderTestByteByByte,DataCompressionNotSupported)561 TEST_F(VCDiffStandardDecoderTestByteByByte, DataCompressionNotSupported) {
562   delta_file_[delta_file_header_.size() + 7] = 0x01;
563   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
564   bool failed = false;
565   for (size_t i = 0; i < delta_file_.size(); ++i) {
566     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
567       failed = true;
568       // It should fail after decoding the delta indicator
569       EXPECT_EQ(delta_file_header_.size() + 7, i);
570       break;
571     }
572   }
573   EXPECT_TRUE(failed);
574   EXPECT_EQ("", output_);
575 }
576 
TEST_F(VCDiffStandardDecoderTestByteByByte,InstructionCompressionNotSupported)577 TEST_F(VCDiffStandardDecoderTestByteByByte,
578        InstructionCompressionNotSupported) {
579   delta_file_[delta_file_header_.size() + 7] = 0x02;
580   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
581   bool failed = false;
582   for (size_t i = 0; i < delta_file_.size(); ++i) {
583     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
584       failed = true;
585       // It should fail after decoding the delta indicator
586       EXPECT_EQ(delta_file_header_.size() + 7, i);
587       break;
588     }
589   }
590   EXPECT_TRUE(failed);
591   EXPECT_EQ("", output_);
592 }
593 
TEST_F(VCDiffStandardDecoderTestByteByByte,AddressCompressionNotSupported)594 TEST_F(VCDiffStandardDecoderTestByteByByte, AddressCompressionNotSupported) {
595   delta_file_[delta_file_header_.size() + 7] = 0x04;
596   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
597   bool failed = false;
598   for (size_t i = 0; i < delta_file_.size(); ++i) {
599     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
600       failed = true;
601       // It should fail after decoding the delta indicator
602       EXPECT_EQ(delta_file_header_.size() + 7, i);
603       break;
604     }
605   }
606   EXPECT_TRUE(failed);
607   EXPECT_EQ("", output_);
608 }
609 
TEST_F(VCDiffStandardDecoderTestByteByByte,AddRunDataSizeZero)610 TEST_F(VCDiffStandardDecoderTestByteByByte, AddRunDataSizeZero) {
611   delta_file_[delta_file_header_.size() + 8] = 0;
612   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
613   bool failed = false;
614   for (size_t i = 0; i < delta_file_.size(); ++i) {
615     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
616       failed = true;
617       // It should fail after decoding the copy address segment size
618       EXPECT_EQ(delta_file_header_.size() + 10, i);
619       break;
620     }
621   }
622   EXPECT_TRUE(failed);
623   EXPECT_EQ("", output_);
624 }
625 
TEST_F(VCDiffStandardDecoderTestByteByByte,AddRunDataSizeTooLargeByOne)626 TEST_F(VCDiffStandardDecoderTestByteByByte, AddRunDataSizeTooLargeByOne) {
627   ++delta_file_[delta_file_header_.size() + 8];
628   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
629   bool failed = false;
630   for (size_t i = 0; i < delta_file_.size(); ++i) {
631     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
632       failed = true;
633       // It should fail after decoding the copy address segment size
634       EXPECT_EQ(delta_file_header_.size() + 10, i);
635       break;
636     }
637   }
638   EXPECT_TRUE(failed);
639   EXPECT_EQ("", output_);
640 }
641 
TEST_F(VCDiffStandardDecoderTestByteByByte,AddRunDataSizeTooSmallByOne)642 TEST_F(VCDiffStandardDecoderTestByteByByte, AddRunDataSizeTooSmallByOne) {
643   --delta_file_[delta_file_header_.size() + 8];
644   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
645   bool failed = false;
646   for (size_t i = 0; i < delta_file_.size(); ++i) {
647     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
648       failed = true;
649       // It should fail after decoding the copy address segment size
650       EXPECT_EQ(delta_file_header_.size() + 10, i);
651       break;
652     }
653   }
654   EXPECT_TRUE(failed);
655   EXPECT_EQ("", output_);
656 }
657 
TEST_F(VCDiffStandardDecoderTestByteByByte,AddRunDataSizeMaxInt)658 TEST_F(VCDiffStandardDecoderTestByteByByte, AddRunDataSizeMaxInt) {
659   WriteMaxVarintAtOffset(8, 1);
660   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
661   bool failed = false;
662   for (size_t i = 0; i < delta_file_.size(); ++i) {
663     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
664       failed = true;
665       // It should fail before finishing the window header
666       EXPECT_GE(delta_file_header_.size() + delta_window_header_.size() + 4,
667                 i);
668       break;
669     }
670   }
671   EXPECT_TRUE(failed);
672   EXPECT_EQ("", output_);
673 }
674 
TEST_F(VCDiffStandardDecoderTestByteByByte,AddRunDataSizeNegative)675 TEST_F(VCDiffStandardDecoderTestByteByByte, AddRunDataSizeNegative) {
676   WriteNegativeVarintAtOffset(8, 1);
677   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
678   bool failed = false;
679   for (size_t i = 0; i < delta_file_.size(); ++i) {
680     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
681       failed = true;
682       // It should fail after decoding the add/run data segment size
683       EXPECT_EQ(delta_file_header_.size() + 11, i);
684       break;
685     }
686   }
687   EXPECT_TRUE(failed);
688   EXPECT_EQ("", output_);
689 }
690 
TEST_F(VCDiffStandardDecoderTestByteByByte,AddRunDataSizeInvalid)691 TEST_F(VCDiffStandardDecoderTestByteByByte, AddRunDataSizeInvalid) {
692   WriteInvalidVarintAtOffset(8, 1);
693   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
694   bool failed = false;
695   for (size_t i = 0; i < delta_file_.size(); ++i) {
696     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
697       failed = true;
698       // It should fail after decoding the add/run data segment size
699       EXPECT_GE(delta_file_header_.size() + 13, i);
700       break;
701     }
702   }
703   EXPECT_TRUE(failed);
704   EXPECT_EQ("", output_);
705 }
706 
TEST_F(VCDiffStandardDecoderTestByteByByte,InstructionsSizeZero)707 TEST_F(VCDiffStandardDecoderTestByteByByte, InstructionsSizeZero) {
708   delta_file_[delta_file_header_.size() + 9] = 0;
709   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
710   bool failed = false;
711   for (size_t i = 0; i < delta_file_.size(); ++i) {
712     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
713       failed = true;
714       // It should fail after decoding the copy address segment size
715       EXPECT_EQ(delta_file_header_.size() + 10, i);
716       break;
717     }
718   }
719   EXPECT_TRUE(failed);
720   EXPECT_EQ("", output_);
721 }
722 
TEST_F(VCDiffStandardDecoderTestByteByByte,InstructionsSizeTooLargeByOne)723 TEST_F(VCDiffStandardDecoderTestByteByByte, InstructionsSizeTooLargeByOne) {
724   ++delta_file_[delta_file_header_.size() + 9];
725   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
726   bool failed = false;
727   for (size_t i = 0; i < delta_file_.size(); ++i) {
728     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
729       failed = true;
730       // It should fail after decoding the copy address segment size
731       EXPECT_EQ(delta_file_header_.size() + 10, i);
732       break;
733     }
734   }
735   EXPECT_TRUE(failed);
736   EXPECT_EQ("", output_);
737 }
738 
TEST_F(VCDiffStandardDecoderTestByteByByte,InstructionsSizeTooSmallByOne)739 TEST_F(VCDiffStandardDecoderTestByteByByte, InstructionsSizeTooSmallByOne) {
740   --delta_file_[delta_file_header_.size() + 9];
741   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
742   bool failed = false;
743   for (size_t i = 0; i < delta_file_.size(); ++i) {
744     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
745       failed = true;
746       // It should fail after decoding the copy address segment size
747       EXPECT_EQ(delta_file_header_.size() + 10, i);
748       break;
749     }
750   }
751   EXPECT_TRUE(failed);
752   EXPECT_EQ("", output_);
753 }
754 
TEST_F(VCDiffStandardDecoderTestByteByByte,InstructionsSizeMaxInt)755 TEST_F(VCDiffStandardDecoderTestByteByByte, InstructionsSizeMaxInt) {
756   WriteMaxVarintAtOffset(9, 1);
757   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
758   bool failed = false;
759   for (size_t i = 0; i < delta_file_.size(); ++i) {
760     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
761       failed = true;
762       // It should fail before finishing the window header
763       EXPECT_GE(delta_file_header_.size() + delta_window_header_.size() + 4,
764                 i);
765       break;
766     }
767   }
768   EXPECT_TRUE(failed);
769   EXPECT_EQ("", output_);
770 }
771 
TEST_F(VCDiffStandardDecoderTestByteByByte,InstructionsSizeNegative)772 TEST_F(VCDiffStandardDecoderTestByteByByte, InstructionsSizeNegative) {
773   WriteNegativeVarintAtOffset(9, 1);
774   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
775   bool failed = false;
776   for (size_t i = 0; i < delta_file_.size(); ++i) {
777     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
778       failed = true;
779       // It should fail after decoding the instructions segment size
780       EXPECT_EQ(delta_file_header_.size() + 12, i);
781       break;
782     }
783   }
784   EXPECT_TRUE(failed);
785   EXPECT_EQ("", output_);
786 }
787 
TEST_F(VCDiffStandardDecoderTestByteByByte,InstructionsSizeInvalid)788 TEST_F(VCDiffStandardDecoderTestByteByByte, InstructionsSizeInvalid) {
789   WriteInvalidVarintAtOffset(9, 1);
790   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
791   bool failed = false;
792   for (size_t i = 0; i < delta_file_.size(); ++i) {
793     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
794       failed = true;
795       // It should fail after decoding the instructions segment size
796       EXPECT_GE(delta_file_header_.size() + 14, i);
797       break;
798     }
799   }
800   EXPECT_TRUE(failed);
801   EXPECT_EQ("", output_);
802 }
803 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopyAddressSizeZero)804 TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressSizeZero) {
805   delta_file_[delta_file_header_.size() + 10] = 0;
806   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
807   bool failed = false;
808   for (size_t i = 0; i < delta_file_.size(); ++i) {
809     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
810       failed = true;
811       // It should fail after decoding the copy address segment size
812       EXPECT_EQ(delta_file_header_.size() + 10, i);
813       break;
814     }
815   }
816   EXPECT_TRUE(failed);
817   EXPECT_EQ("", output_);
818 }
819 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopyAddressSizeTooLargeByOne)820 TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressSizeTooLargeByOne) {
821   ++delta_file_[delta_file_header_.size() + 10];
822   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
823   bool failed = false;
824   for (size_t i = 0; i < delta_file_.size(); ++i) {
825     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
826       failed = true;
827       // It should fail after decoding the copy address segment size
828       EXPECT_EQ(delta_file_header_.size() + 10, i);
829       break;
830     }
831   }
832   EXPECT_TRUE(failed);
833   EXPECT_EQ("", output_);
834 }
835 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopyAddressSizeTooSmallByOne)836 TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressSizeTooSmallByOne) {
837   --delta_file_[delta_file_header_.size() + 10];
838   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
839   bool failed = false;
840   for (size_t i = 0; i < delta_file_.size(); ++i) {
841     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
842       failed = true;
843       // It should fail after decoding the copy address segment size
844       EXPECT_EQ(delta_file_header_.size() + 10, i);
845       break;
846     }
847   }
848   EXPECT_TRUE(failed);
849   EXPECT_EQ("", output_);
850 }
851 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopyAddressSizeMaxInt)852 TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressSizeMaxInt) {
853   WriteMaxVarintAtOffset(10, 1);
854   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
855   bool failed = false;
856   for (size_t i = 0; i < delta_file_.size(); ++i) {
857     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
858       failed = true;
859       // It should fail after decoding the copy address segment size
860       EXPECT_EQ(delta_file_header_.size() + 14, i);
861       break;
862     }
863   }
864   EXPECT_TRUE(failed);
865   EXPECT_EQ("", output_);
866 }
867 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopyAddressSizeNegative)868 TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressSizeNegative) {
869   WriteNegativeVarintAtOffset(10, 1);
870   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
871   bool failed = false;
872   for (size_t i = 0; i < delta_file_.size(); ++i) {
873     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
874       failed = true;
875       // It should fail after decoding the copy address segment size
876       EXPECT_EQ(delta_file_header_.size() + 13, i);
877       break;
878     }
879   }
880   EXPECT_TRUE(failed);
881   EXPECT_EQ("", output_);
882 }
883 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopyAddressSizeInvalid)884 TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressSizeInvalid) {
885   WriteInvalidVarintAtOffset(10, 1);
886   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
887   bool failed = false;
888   for (size_t i = 0; i < delta_file_.size(); ++i) {
889     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
890       failed = true;
891       // It should fail after decoding the copy address segment size
892       EXPECT_GE(delta_file_header_.size() + 15, i);
893       break;
894     }
895   }
896   EXPECT_TRUE(failed);
897   EXPECT_EQ("", output_);
898 }
899 
TEST_F(VCDiffStandardDecoderTestByteByByte,InstructionsEndEarly)900 TEST_F(VCDiffStandardDecoderTestByteByByte, InstructionsEndEarly) {
901   --delta_file_[delta_file_header_.size() + 9];
902   ++delta_file_[delta_file_header_.size() + 10];
903   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
904   bool failed = false;
905   for (size_t i = 0; i < delta_file_.size(); ++i) {
906     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
907       failed = true;
908       break;
909     }
910   }
911   EXPECT_TRUE(failed);
912   // The decoder should not create more target bytes than were expected.
913   EXPECT_GE(expected_target_.size(), output_.size());
914 }
915 
916 // From this point on, the tests should also be run against the interleaved
917 // format.
918 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopyMoreThanExpectedTarget)919 TEST_F(VCDiffStandardDecoderTestByteByByte, CopyMoreThanExpectedTarget) {
920   delta_file_[delta_file_header_.size() + 0x70] =
921       FirstByteOfStringLength(kExpectedTarget);
922   delta_file_[delta_file_header_.size() + 0x71] =
923       SecondByteOfStringLength(kExpectedTarget) + 1;
924   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
925   bool failed = false;
926   for (size_t i = 0; i < delta_file_.size(); ++i) {
927     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
928       failed = true;
929       break;
930     }
931   }
932   EXPECT_TRUE(failed);
933   // The decoder should not create more target bytes than were expected.
934   EXPECT_GE(expected_target_.size(), output_.size());
935 }
936 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopySizeZero)937 TEST_F(VCDiffStandardDecoderTestByteByByte, CopySizeZero) {
938   delta_file_[delta_file_header_.size() + 0x70] = 0;
939   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
940   bool failed = false;
941   for (size_t i = 0; i < delta_file_.size(); ++i) {
942     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
943       failed = true;
944       break;
945     }
946   }
947   EXPECT_TRUE(failed);
948   // The decoder should not create more target bytes than were expected.
949   EXPECT_GE(expected_target_.size(), output_.size());
950 }
951 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopySizeTooLargeByOne)952 TEST_F(VCDiffStandardDecoderTestByteByByte, CopySizeTooLargeByOne) {
953   ++delta_file_[delta_file_header_.size() + 0x70];
954   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
955   bool failed = false;
956   for (size_t i = 0; i < delta_file_.size(); ++i) {
957     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
958       failed = true;
959       break;
960     }
961   }
962   EXPECT_TRUE(failed);
963   // The decoder should not create more target bytes than were expected.
964   EXPECT_GE(expected_target_.size(), output_.size());
965 }
966 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopySizeTooSmallByOne)967 TEST_F(VCDiffStandardDecoderTestByteByByte, CopySizeTooSmallByOne) {
968   --delta_file_[delta_file_header_.size() + 0x70];
969   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
970   bool failed = false;
971   for (size_t i = 0; i < delta_file_.size(); ++i) {
972     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
973       failed = true;
974       break;
975     }
976   }
977   EXPECT_TRUE(failed);
978   // The decoder should not create more target bytes than were expected.
979   EXPECT_GE(expected_target_.size(), output_.size());
980 }
981 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopySizeMaxInt)982 TEST_F(VCDiffStandardDecoderTestByteByByte, CopySizeMaxInt) {
983   WriteMaxVarintAtOffset(0x70, 1);
984   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
985   bool failed = false;
986   for (size_t i = 0; i < delta_file_.size(); ++i) {
987     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
988       failed = true;
989       break;
990     }
991   }
992   EXPECT_TRUE(failed);
993   // The decoder should not create more target bytes than were expected.
994   EXPECT_GE(expected_target_.size(), output_.size());
995 }
996 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopySizeNegative)997 TEST_F(VCDiffStandardDecoderTestByteByByte, CopySizeNegative) {
998   WriteNegativeVarintAtOffset(0x70, 1);
999   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1000   bool failed = false;
1001   for (size_t i = 0; i < delta_file_.size(); ++i) {
1002     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1003       failed = true;
1004       break;
1005     }
1006   }
1007   EXPECT_TRUE(failed);
1008   // The decoder should not create more target bytes than were expected.
1009   EXPECT_GE(expected_target_.size(), output_.size());
1010 }
1011 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopySizeInvalid)1012 TEST_F(VCDiffStandardDecoderTestByteByByte, CopySizeInvalid) {
1013   WriteInvalidVarintAtOffset(0x70, 1);
1014   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1015   bool failed = false;
1016   for (size_t i = 0; i < delta_file_.size(); ++i) {
1017     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1018       failed = true;
1019       break;
1020     }
1021   }
1022   EXPECT_TRUE(failed);
1023   // The decoder should not create more target bytes than were expected.
1024   EXPECT_GE(expected_target_.size(), output_.size());
1025 }
1026 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopyAddressBeyondHereAddress)1027 TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressBeyondHereAddress) {
1028   delta_file_[delta_file_header_.size() + 0x7B] =
1029       FirstByteOfStringLength(kDictionary);
1030   delta_file_[delta_file_header_.size() + 0x7C] =
1031       SecondByteOfStringLength(kDictionary);
1032   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1033   bool failed = false;
1034   for (size_t i = 0; i < delta_file_.size(); ++i) {
1035     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1036       failed = true;
1037       break;
1038     }
1039   }
1040   EXPECT_TRUE(failed);
1041   // The decoder should not create more target bytes than were expected.
1042   EXPECT_GE(expected_target_.size(), output_.size());
1043 }
1044 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopyAddressMaxInt)1045 TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressMaxInt) {
1046   WriteMaxVarintAtOffset(0x7B, 1);
1047   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1048   bool failed = false;
1049   for (size_t i = 0; i < delta_file_.size(); ++i) {
1050     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1051       failed = true;
1052       break;
1053     }
1054   }
1055   EXPECT_TRUE(failed);
1056   // The decoder should not create more target bytes than were expected.
1057   EXPECT_GE(expected_target_.size(), output_.size());
1058 }
1059 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopyAddressNegative)1060 TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressNegative) {
1061   WriteNegativeVarintAtOffset(0x70, 1);
1062   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1063   bool failed = false;
1064   for (size_t i = 0; i < delta_file_.size(); ++i) {
1065     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1066       failed = true;
1067       break;
1068     }
1069   }
1070   EXPECT_TRUE(failed);
1071   // The decoder should not create more target bytes than were expected.
1072   EXPECT_GE(expected_target_.size(), output_.size());
1073 }
1074 
TEST_F(VCDiffStandardDecoderTestByteByByte,CopyAddressInvalid)1075 TEST_F(VCDiffStandardDecoderTestByteByByte, CopyAddressInvalid) {
1076   WriteInvalidVarintAtOffset(0x70, 1);
1077   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1078   bool failed = false;
1079   for (size_t i = 0; i < delta_file_.size(); ++i) {
1080     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1081       failed = true;
1082       break;
1083     }
1084   }
1085   EXPECT_TRUE(failed);
1086   // The decoder should not create more target bytes than were expected.
1087   EXPECT_GE(expected_target_.size(), output_.size());
1088 }
1089 
TEST_F(VCDiffStandardDecoderTestByteByByte,AddMoreThanExpectedTarget)1090 TEST_F(VCDiffStandardDecoderTestByteByByte, AddMoreThanExpectedTarget) {
1091   delta_file_[delta_file_header_.size() + 0x72] =
1092       FirstByteOfStringLength(kExpectedTarget);
1093   delta_file_[delta_file_header_.size() + 0x73] =
1094       SecondByteOfStringLength(kExpectedTarget) + 1;
1095   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1096   bool failed = false;
1097   for (size_t i = 0; i < delta_file_.size(); ++i) {
1098     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1099       failed = true;
1100       break;
1101     }
1102   }
1103   EXPECT_TRUE(failed);
1104   // The decoder should not create more target bytes than were expected.
1105   EXPECT_GE(expected_target_.size(), output_.size());
1106 }
1107 
TEST_F(VCDiffStandardDecoderTestByteByByte,AddSizeZero)1108 TEST_F(VCDiffStandardDecoderTestByteByByte, AddSizeZero) {
1109   delta_file_[delta_file_header_.size() + 0x72] = 0;
1110   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1111   bool failed = false;
1112   for (size_t i = 0; i < delta_file_.size(); ++i) {
1113     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1114       failed = true;
1115       break;
1116     }
1117   }
1118   EXPECT_TRUE(failed);
1119   // The decoder should not create more target bytes than were expected.
1120   EXPECT_GE(expected_target_.size(), output_.size());
1121 }
1122 
TEST_F(VCDiffStandardDecoderTestByteByByte,AddSizeTooLargeByOne)1123 TEST_F(VCDiffStandardDecoderTestByteByByte, AddSizeTooLargeByOne) {
1124   ++delta_file_[delta_file_header_.size() + 0x72];
1125   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1126   bool failed = false;
1127   for (size_t i = 0; i < delta_file_.size(); ++i) {
1128     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1129       failed = true;
1130       break;
1131     }
1132   }
1133   EXPECT_TRUE(failed);
1134   // The decoder should not create more target bytes than were expected.
1135   EXPECT_GE(expected_target_.size(), output_.size());
1136 }
1137 
TEST_F(VCDiffStandardDecoderTestByteByByte,AddSizeTooSmallByOne)1138 TEST_F(VCDiffStandardDecoderTestByteByByte, AddSizeTooSmallByOne) {
1139   --delta_file_[delta_file_header_.size() + 0x72];
1140   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1141   bool failed = false;
1142   for (size_t i = 0; i < delta_file_.size(); ++i) {
1143     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1144       failed = true;
1145       break;
1146     }
1147   }
1148   EXPECT_TRUE(failed);
1149   // The decoder should not create more target bytes than were expected.
1150   EXPECT_GE(expected_target_.size(), output_.size());
1151 }
1152 
TEST_F(VCDiffStandardDecoderTestByteByByte,AddSizeMaxInt)1153 TEST_F(VCDiffStandardDecoderTestByteByByte, AddSizeMaxInt) {
1154   WriteMaxVarintAtOffset(0x72, 1);
1155   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1156   bool failed = false;
1157   for (size_t i = 0; i < delta_file_.size(); ++i) {
1158     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1159       failed = true;
1160       break;
1161     }
1162   }
1163   EXPECT_TRUE(failed);
1164   // The decoder should not create more target bytes than were expected.
1165   EXPECT_GE(expected_target_.size(), output_.size());
1166 }
1167 
TEST_F(VCDiffStandardDecoderTestByteByByte,AddSizeNegative)1168 TEST_F(VCDiffStandardDecoderTestByteByByte, AddSizeNegative) {
1169   WriteNegativeVarintAtOffset(0x72, 1);
1170   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1171   bool failed = false;
1172   for (size_t i = 0; i < delta_file_.size(); ++i) {
1173     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1174       failed = true;
1175       break;
1176     }
1177   }
1178   EXPECT_TRUE(failed);
1179   // The decoder should not create more target bytes than were expected.
1180   EXPECT_GE(expected_target_.size(), output_.size());
1181 }
1182 
TEST_F(VCDiffStandardDecoderTestByteByByte,AddSizeInvalid)1183 TEST_F(VCDiffStandardDecoderTestByteByByte, AddSizeInvalid) {
1184   WriteInvalidVarintAtOffset(0x72, 1);
1185   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1186   bool failed = false;
1187   for (size_t i = 0; i < delta_file_.size(); ++i) {
1188     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1189       failed = true;
1190       break;
1191     }
1192   }
1193   EXPECT_TRUE(failed);
1194   // The decoder should not create more target bytes than were expected.
1195   EXPECT_GE(expected_target_.size(), output_.size());
1196 }
1197 
TEST_F(VCDiffStandardDecoderTestByteByByte,RunMoreThanExpectedTarget)1198 TEST_F(VCDiffStandardDecoderTestByteByByte, RunMoreThanExpectedTarget) {
1199   delta_file_[delta_file_header_.size() + 0x78] =
1200       FirstByteOfStringLength(kExpectedTarget);
1201   delta_file_[delta_file_header_.size() + 0x79] =
1202       SecondByteOfStringLength(kExpectedTarget) + 1;
1203   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1204   bool failed = false;
1205   for (size_t i = 0; i < delta_file_.size(); ++i) {
1206     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1207       failed = true;
1208       break;
1209     }
1210   }
1211   EXPECT_TRUE(failed);
1212   // The decoder should not create more target bytes than were expected.
1213   EXPECT_GE(expected_target_.size(), output_.size());
1214 }
1215 
TEST_F(VCDiffStandardDecoderTestByteByByte,RunSizeZero)1216 TEST_F(VCDiffStandardDecoderTestByteByByte, RunSizeZero) {
1217   delta_file_[delta_file_header_.size() + 0x78] = 0;
1218   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1219   bool failed = false;
1220   for (size_t i = 0; i < delta_file_.size(); ++i) {
1221     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1222       failed = true;
1223       break;
1224     }
1225   }
1226   EXPECT_TRUE(failed);
1227   // The decoder should not create more target bytes than were expected.
1228   EXPECT_GE(expected_target_.size(), output_.size());
1229 }
1230 
TEST_F(VCDiffStandardDecoderTestByteByByte,RunSizeTooLargeByOne)1231 TEST_F(VCDiffStandardDecoderTestByteByByte, RunSizeTooLargeByOne) {
1232   ++delta_file_[delta_file_header_.size() + 0x78];
1233   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1234   bool failed = false;
1235   for (size_t i = 0; i < delta_file_.size(); ++i) {
1236     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1237       failed = true;
1238       break;
1239     }
1240   }
1241   EXPECT_TRUE(failed);
1242   // The decoder should not create more target bytes than were expected.
1243   EXPECT_GE(expected_target_.size(), output_.size());
1244 }
1245 
TEST_F(VCDiffStandardDecoderTestByteByByte,RunSizeTooSmallByOne)1246 TEST_F(VCDiffStandardDecoderTestByteByByte, RunSizeTooSmallByOne) {
1247   --delta_file_[delta_file_header_.size() + 0x78];
1248   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1249   bool failed = false;
1250   for (size_t i = 0; i < delta_file_.size(); ++i) {
1251     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1252       failed = true;
1253       break;
1254     }
1255   }
1256   EXPECT_TRUE(failed);
1257   // The decoder should not create more target bytes than were expected.
1258   EXPECT_GE(expected_target_.size(), output_.size());
1259 }
1260 
TEST_F(VCDiffStandardDecoderTestByteByByte,RunSizeMaxInt)1261 TEST_F(VCDiffStandardDecoderTestByteByByte, RunSizeMaxInt) {
1262   WriteMaxVarintAtOffset(0x78, 1);
1263   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1264   bool failed = false;
1265   for (size_t i = 0; i < delta_file_.size(); ++i) {
1266     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1267       failed = true;
1268       break;
1269     }
1270   }
1271   EXPECT_TRUE(failed);
1272   // The decoder should not create more target bytes than were expected.
1273   EXPECT_GE(expected_target_.size(), output_.size());
1274 }
1275 
TEST_F(VCDiffStandardDecoderTestByteByByte,RunSizeNegative)1276 TEST_F(VCDiffStandardDecoderTestByteByByte, RunSizeNegative) {
1277   WriteNegativeVarintAtOffset(0x78, 1);
1278   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1279   bool failed = false;
1280   for (size_t i = 0; i < delta_file_.size(); ++i) {
1281     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1282       failed = true;
1283       break;
1284     }
1285   }
1286   EXPECT_TRUE(failed);
1287   // The decoder should not create more target bytes than were expected.
1288   EXPECT_GE(expected_target_.size(), output_.size());
1289 }
1290 
TEST_F(VCDiffStandardDecoderTestByteByByte,RunSizeInvalid)1291 TEST_F(VCDiffStandardDecoderTestByteByByte, RunSizeInvalid) {
1292   WriteInvalidVarintAtOffset(0x78, 1);
1293   decoder_.StartDecoding(dictionary_.data(), dictionary_.size());
1294   bool failed = false;
1295   for (size_t i = 0; i < delta_file_.size(); ++i) {
1296     if (!decoder_.DecodeChunk(&delta_file_[i], 1, &output_)) {
1297       failed = true;
1298       break;
1299     }
1300   }
1301   EXPECT_TRUE(failed);
1302   // The decoder should not create more target bytes than were expected.
1303   EXPECT_GE(expected_target_.size(), output_.size());
1304 }
1305 
1306 }  // namespace open_vcdiff
1307