Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(9)

Unified Diff: sdch/open_vcdiff/depot/opensource/open-vcdiff/src/decodetable_test.cc

Issue 5203: Transition to pulling open-vcdiff from repository, instead of using snapshot... (Closed) Base URL: svn://chrome-svn/chrome/trunk/src/
Patch Set: Created 12 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: sdch/open_vcdiff/depot/opensource/open-vcdiff/src/decodetable_test.cc
===================================================================
--- sdch/open_vcdiff/depot/opensource/open-vcdiff/src/decodetable_test.cc (revision 2678)
+++ sdch/open_vcdiff/depot/opensource/open-vcdiff/src/decodetable_test.cc (working copy)
@@ -1,464 +0,0 @@
-// 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.
-//
-// Unit tests for the class VCDiffCodeTableReader, found in decodetable.h.
-
-#include <config.h>
-#include "decodetable.h"
-#include <stdint.h> // int32_t
-#include <vector>
-#include "addrcache.h"
-#include "codetable.h"
-#include "testing.h"
-#include "varint_bigendian.h"
-
-namespace open_vcdiff {
-namespace {
-
-class DecodeTableTest : public testing::Test {
- protected:
- DecodeTableTest()
- : instructions_and_sizes_(instruction_buffer_size),
- found_size_(0),
- found_mode_(0) {
- instructions_and_sizes_ptr_ = &instructions_and_sizes_[0];
- reader_.Init(&instructions_and_sizes_ptr_,
- instructions_and_sizes_ptr_ + instruction_buffer_size);
- }
-
- static void AddExerciseOpcode(unsigned char inst1,
- unsigned char mode1,
- unsigned char size1,
- unsigned char inst2,
- unsigned char mode2,
- unsigned char size2,
- int opcode) {
- g_exercise_code_table_->inst1[opcode] = inst1;
- g_exercise_code_table_->mode1[opcode] = mode1;
- g_exercise_code_table_->size1[opcode] = (inst1 == VCD_NOOP) ? 0 : size1;
- g_exercise_code_table_->inst2[opcode] = inst2;
- g_exercise_code_table_->mode2[opcode] = mode2;
- g_exercise_code_table_->size2[opcode] = (inst2 == VCD_NOOP) ? 0 : size2;
- }
-
- static void SetUpTestCase() {
- g_exercise_code_table_ = new VCDiffCodeTableData;
- int opcode = 0;
- for (unsigned char inst_mode1 = 0;
- inst_mode1 <= VCD_LAST_INSTRUCTION_TYPE + kLastExerciseMode;
- ++inst_mode1) {
- unsigned char inst1 = inst_mode1;
- unsigned char mode1 = 0;
- if (inst_mode1 > VCD_COPY) {
- inst1 = VCD_COPY;
- mode1 = inst_mode1 - VCD_COPY;
- }
- for (unsigned char inst_mode2 = 0;
- inst_mode2 <= VCD_LAST_INSTRUCTION_TYPE + kLastExerciseMode;
- ++inst_mode2) {
- unsigned char inst2 = inst_mode2;
- unsigned char mode2 = 0;
- if (inst_mode2 > VCD_COPY) {
- inst2 = VCD_COPY;
- mode2 = inst_mode2 - VCD_COPY;
- }
- AddExerciseOpcode(inst1, mode1, 0, inst2, mode2, 0, opcode++);
- AddExerciseOpcode(inst1, mode1, 0, inst2, mode2, 255, opcode++);
- AddExerciseOpcode(inst1, mode1, 255, inst2, mode2, 0, opcode++);
- AddExerciseOpcode(inst1, mode1, 255, inst2, mode2, 255, opcode++);
- }
- }
- if (VCDiffCodeTableData::kCodeTableSize != opcode) {
- LOG(FATAL) << "Internal error in test: The nested loops in "
- "DecodeTableTest::SetUpTestCase should iterate through "
- "exactly " << VCDiffCodeTableData::kCodeTableSize
- << " opcodes.";
- return;
- }
- EXPECT_TRUE(VCDiffCodeTableData::kDefaultCodeTableData.Validate());
- EXPECT_TRUE(g_exercise_code_table_->Validate(kLastExerciseMode));
- }
-
- static void TearDownTestCase() {
- delete g_exercise_code_table_;
- }
-
- void VerifyInstModeSize(unsigned char inst,
- unsigned char mode,
- unsigned char size,
- unsigned char opcode) {
- if (inst == VCD_NOOP) return; // GetNextInstruction skips NOOPs
- int32_t found_size = 0;
- unsigned char found_mode = 0;
- unsigned char found_inst = reader_.GetNextInstruction(&found_size,
- &found_mode);
- EXPECT_EQ(inst, found_inst);
- EXPECT_EQ(mode, found_mode);
- if (size == 0) {
- EXPECT_EQ(1000 + opcode, found_size);
- } else {
- EXPECT_EQ(size, found_size);
- }
- }
-
- void VerifyInstModeSize1(unsigned char inst,
- unsigned char mode,
- unsigned char size,
- unsigned char opcode) {
- if (inst == VCD_NOOP) size = 0;
- EXPECT_EQ(g_exercise_code_table_->inst1[opcode], inst);
- EXPECT_EQ(g_exercise_code_table_->mode1[opcode], mode);
- EXPECT_EQ(g_exercise_code_table_->size1[opcode], size);
- VerifyInstModeSize(inst, mode, size, opcode);
- }
-
- void VerifyInstModeSize2(unsigned char inst,
- unsigned char mode,
- unsigned char size,
- unsigned char opcode) {
- if (inst == VCD_NOOP) size = 0;
- EXPECT_EQ(g_exercise_code_table_->inst2[opcode], inst);
- EXPECT_EQ(g_exercise_code_table_->mode2[opcode], mode);
- EXPECT_EQ(g_exercise_code_table_->size2[opcode], size);
- VerifyInstModeSize(inst, mode, size, opcode);
- }
-
- // This value is designed so that the total number of inst values and modes
- // will equal 8 (VCD_NOOP, VCD_ADD, VCD_RUN, VCD_COPY modes 0 - 4).
- // Eight combinations of inst and mode, times two possible size values,
- // squared (because there are two instructions per opcode), makes
- // exactly 256 possible instruction combinations, which fits kCodeTableSize
- // (the number of opcodes in the table.)
- static const int kLastExerciseMode = 4;
-
- // The buffer size (in bytes) needed to store kCodeTableSize opcodes plus
- // up to kCodeTableSize VarintBE-encoded size values.
- static const int instruction_buffer_size;
-
- // A code table that exercises as many combinations as possible:
- // 2 instructions, each is a NOOP, ADD, RUN, or one of 5 copy modes
- // (== 8 total combinations of inst and mode), and each has
- // size == 0 or 255 (2 possibilities.)
- static VCDiffCodeTableData* g_exercise_code_table_;
-
- VCDiffCodeTableReader reader_;
-
- // A buffer to which instructions and sizes will be added manually
- // in order to exercise VCDiffCodeTableReader.
- std::vector<char> instructions_and_sizes_;
-
- // The buffer pointer used by the VCDiffCodeTableReader.
- const char* instructions_and_sizes_ptr_;
-
- // The size and mode returned by GetNextInstruction().
- int32_t found_size_;
- unsigned char found_mode_;
-};
-
-VCDiffCodeTableData* DecodeTableTest::g_exercise_code_table_ = NULL;
-
-const int DecodeTableTest::instruction_buffer_size =
- VCDiffCodeTableData::kCodeTableSize *
- (1 + (VarintBE<VCDAddress>::kMaxBytes));
-
-TEST_F(DecodeTableTest, ReadAdd) {
- instructions_and_sizes_[0] = 1;
- VarintBE<VCDAddress>::Encode(257, &instructions_and_sizes_[1]);
- unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
- &found_mode_);
- EXPECT_EQ(VCD_ADD, found_inst);
- EXPECT_EQ(257, found_size_);
- EXPECT_EQ(0, found_mode_);
-}
-
-TEST_F(DecodeTableTest, ReadRun) {
- instructions_and_sizes_[0] = 0;
- VarintBE<VCDAddress>::Encode(111, &instructions_and_sizes_[1]);
- unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
- &found_mode_);
- EXPECT_EQ(VCD_RUN, found_inst);
- EXPECT_EQ(111, found_size_);
- EXPECT_EQ(0, found_mode_);
-}
-
-TEST_F(DecodeTableTest, ReadCopy) {
- instructions_and_sizes_[0] = 58;
- instructions_and_sizes_[1] = 0;
- unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
- &found_mode_);
- EXPECT_EQ(VCD_COPY, found_inst);
- EXPECT_EQ(10, found_size_);
- EXPECT_EQ(2, found_mode_);
-}
-
-TEST_F(DecodeTableTest, ReadAddCopy) {
- instructions_and_sizes_[0] = 175;
- instructions_and_sizes_[1] = 0;
- unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
- &found_mode_);
- EXPECT_EQ(VCD_ADD, found_inst);
- EXPECT_EQ(1, found_size_);
- EXPECT_EQ(0, found_mode_);
- found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
- EXPECT_EQ(VCD_COPY, found_inst);
- EXPECT_EQ(4, found_size_);
- EXPECT_EQ(1, found_mode_);
-}
-
-TEST_F(DecodeTableTest, ReadCopyAdd) {
- instructions_and_sizes_[0] = 255;
- instructions_and_sizes_[1] = 0;
- unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
- &found_mode_);
- EXPECT_EQ(VCD_COPY, found_inst);
- EXPECT_EQ(4, found_size_);
- EXPECT_EQ(8, found_mode_);
- found_mode_ = 0;
- found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
- EXPECT_EQ(VCD_ADD, found_inst);
- EXPECT_EQ(1, found_size_);
- EXPECT_EQ(0, found_mode_);
-}
-
-TEST_F(DecodeTableTest, UnGetAdd) {
- instructions_and_sizes_[0] = 1;
- instructions_and_sizes_[1] = 255;
- VarintBE<VCDAddress>::Encode(257, &instructions_and_sizes_[1]);
- unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
- &found_mode_);
- EXPECT_EQ(VCD_ADD, found_inst);
- EXPECT_EQ(257, found_size_);
- EXPECT_EQ(0, found_mode_);
- reader_.UnGetInstruction();
- found_size_ = 0;
- found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
- EXPECT_EQ(VCD_ADD, found_inst);
- EXPECT_EQ(257, found_size_);
- EXPECT_EQ(0, found_mode_);
-}
-
-TEST_F(DecodeTableTest, UnGetCopy) {
- instructions_and_sizes_[0] = 58;
- instructions_and_sizes_[1] = 0;
- instructions_and_sizes_[2] = 255;
- unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
- &found_mode_);
- EXPECT_EQ(VCD_COPY, found_inst);
- EXPECT_EQ(10, found_size_);
- EXPECT_EQ(2, found_mode_);
- reader_.UnGetInstruction();
- found_size_ = 0;
- found_mode_ = 0;
- found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
- EXPECT_EQ(VCD_COPY, found_inst);
- EXPECT_EQ(10, found_size_);
- EXPECT_EQ(2, found_mode_);
-}
-
-TEST_F(DecodeTableTest, UnGetCopyAdd) {
- instructions_and_sizes_[0] = 255;
- instructions_and_sizes_[1] = 0;
- unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
- &found_mode_);
- EXPECT_EQ(VCD_COPY, found_inst);
- EXPECT_EQ(4, found_size_);
- EXPECT_EQ(8, found_mode_);
- reader_.UnGetInstruction();
- found_mode_ = 0;
- found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
- EXPECT_EQ(VCD_COPY, found_inst);
- EXPECT_EQ(4, found_size_);
- EXPECT_EQ(8, found_mode_);
- found_mode_ = 0;
- found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
- EXPECT_EQ(VCD_ADD, found_inst);
- EXPECT_EQ(1, found_size_);
- EXPECT_EQ(0, found_mode_);
-}
-
-TEST_F(DecodeTableTest, UnGetTwice) {
- instructions_and_sizes_[0] = 255;
- instructions_and_sizes_[1] = 0;
- unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
- &found_mode_);
- EXPECT_EQ(VCD_COPY, found_inst);
- EXPECT_EQ(4, found_size_);
- EXPECT_EQ(8, found_mode_);
- reader_.UnGetInstruction();
- reader_.UnGetInstruction();
- found_mode_ = 0;
- found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
- EXPECT_EQ(VCD_COPY, found_inst);
- EXPECT_EQ(4, found_size_);
- EXPECT_EQ(8, found_mode_);
- found_mode_ = 0;
- found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
- EXPECT_EQ(VCD_ADD, found_inst);
- EXPECT_EQ(1, found_size_);
- EXPECT_EQ(0, found_mode_);
-}
-
-TEST_F(DecodeTableTest, UnGetBeforeGet) {
- instructions_and_sizes_[0] = 255;
- instructions_and_sizes_[1] = 0;
- reader_.UnGetInstruction();
- unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
- &found_mode_);
- EXPECT_EQ(VCD_COPY, found_inst);
- EXPECT_EQ(4, found_size_);
- EXPECT_EQ(8, found_mode_);
-}
-
-TEST_F(DecodeTableTest, UnGetAddCopy) {
- instructions_and_sizes_[0] = 175;
- instructions_and_sizes_[1] = 0;
- unsigned char found_inst = reader_.GetNextInstruction(&found_size_,
- &found_mode_);
- EXPECT_EQ(VCD_ADD, found_inst);
- EXPECT_EQ(1, found_size_);
- EXPECT_EQ(0, found_mode_);
- reader_.UnGetInstruction();
- found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
- EXPECT_EQ(VCD_ADD, found_inst);
- EXPECT_EQ(1, found_size_);
- EXPECT_EQ(0, found_mode_);
- found_inst = reader_.GetNextInstruction(&found_size_, &found_mode_);
- EXPECT_EQ(VCD_COPY, found_inst);
- EXPECT_EQ(4, found_size_);
- EXPECT_EQ(1, found_mode_);
-}
-
-TEST_F(DecodeTableTest, ReReadIncomplete) {
- instructions_and_sizes_[0] = 175; // Add(1) + Copy1(4)
- instructions_and_sizes_[1] = 1; // Add(0)
- instructions_and_sizes_[2] = 111; // with size 111
- instructions_and_sizes_[3] = 255; // Copy8(4) + Add(1)
-
- reader_.Init(&instructions_and_sizes_ptr_,
- instructions_and_sizes_ptr_ + 0); // 0 bytes available
- EXPECT_EQ(VCD_INSTRUCTION_END_OF_DATA,
- reader_.GetNextInstruction(&found_size_, &found_mode_));
- EXPECT_EQ(&instructions_and_sizes_[0], instructions_and_sizes_ptr_);
-
- reader_.Init(&instructions_and_sizes_ptr_,
- instructions_and_sizes_ptr_ + 1); // 1 more byte available
- EXPECT_EQ(VCD_ADD, reader_.GetNextInstruction(&found_size_, &found_mode_));
- EXPECT_EQ(1, found_size_);
- EXPECT_EQ(0, found_mode_);
- EXPECT_EQ(VCD_COPY, reader_.GetNextInstruction(&found_size_, &found_mode_));
- EXPECT_EQ(4, found_size_);
- EXPECT_EQ(1, found_mode_);
- EXPECT_EQ(VCD_INSTRUCTION_END_OF_DATA,
- reader_.GetNextInstruction(&found_size_, &found_mode_));
- EXPECT_EQ(&instructions_and_sizes_[1], instructions_and_sizes_ptr_);
-
- reader_.Init(&instructions_and_sizes_ptr_,
- instructions_and_sizes_ptr_ + 1); // 1 more byte available
- // The opcode is available, but the separately encoded size is not
- EXPECT_EQ(VCD_INSTRUCTION_END_OF_DATA,
- reader_.GetNextInstruction(&found_size_, &found_mode_));
- EXPECT_EQ(&instructions_and_sizes_[1], instructions_and_sizes_ptr_);
-
- reader_.Init(&instructions_and_sizes_ptr_,
- instructions_and_sizes_ptr_ + 2); // 2 more bytes available
- EXPECT_EQ(VCD_ADD, reader_.GetNextInstruction(&found_size_, &found_mode_));
- EXPECT_EQ(111, found_size_);
- EXPECT_EQ(0, found_mode_);
- EXPECT_EQ(VCD_INSTRUCTION_END_OF_DATA,
- reader_.GetNextInstruction(&found_size_, &found_mode_));
- EXPECT_EQ(&instructions_and_sizes_[3], instructions_and_sizes_ptr_);
-
- reader_.Init(&instructions_and_sizes_ptr_,
- instructions_and_sizes_ptr_ + 1); // 1 more byte available
- EXPECT_EQ(VCD_COPY, reader_.GetNextInstruction(&found_size_, &found_mode_));
- EXPECT_EQ(4, found_size_);
- EXPECT_EQ(8, found_mode_);
- EXPECT_EQ(VCD_ADD, reader_.GetNextInstruction(&found_size_, &found_mode_));
- EXPECT_EQ(1, found_size_);
- EXPECT_EQ(0, found_mode_);
- EXPECT_EQ(VCD_INSTRUCTION_END_OF_DATA,
- reader_.GetNextInstruction(&found_size_, &found_mode_));
- EXPECT_EQ(&instructions_and_sizes_[4], instructions_and_sizes_ptr_);
-}
-
-TEST_F(DecodeTableTest, ExerciseCodeTableReader) {
- char* instruction_ptr = &instructions_and_sizes_[0];
- for (int opcode = 0; opcode < VCDiffCodeTableData::kCodeTableSize; ++opcode) {
- *instruction_ptr = opcode;
- ++instruction_ptr;
- if ((g_exercise_code_table_->inst1[opcode] != VCD_NOOP) &&
- (g_exercise_code_table_->size1[opcode] == 0)) {
- // A separately-encoded size value
- int encoded_size = VarintBE<VCDAddress>::Encode(1000 + opcode,
- instruction_ptr);
- EXPECT_LT(0, encoded_size);
- instruction_ptr += encoded_size;
- }
- if ((g_exercise_code_table_->inst2[opcode] != VCD_NOOP) &&
- (g_exercise_code_table_->size2[opcode] == 0)) {
- int encoded_size = VarintBE<VCDAddress>::Encode(1000 + opcode,
- instruction_ptr);
- EXPECT_LT(0, encoded_size);
- instruction_ptr += encoded_size;
- }
- }
- EXPECT_TRUE(reader_.UseCodeTable(*g_exercise_code_table_, kLastExerciseMode));
- int opcode = 0;
- // This loop has the same bounds as the one in SetUpTestCase.
- // Iterate over the instruction types and make sure that the opcodes,
- // interpreted in order, return exactly those instruction types.
- for (unsigned char inst_mode1 = 0;
- inst_mode1 <= VCD_LAST_INSTRUCTION_TYPE + kLastExerciseMode;
- ++inst_mode1) {
- unsigned char inst1 = inst_mode1;
- unsigned char mode1 = 0;
- if (inst_mode1 > VCD_COPY) {
- inst1 = VCD_COPY;
- mode1 = inst_mode1 - VCD_COPY;
- }
- for (unsigned char inst_mode2 = 0;
- inst_mode2 <= VCD_LAST_INSTRUCTION_TYPE + kLastExerciseMode;
- ++inst_mode2) {
- unsigned char inst2 = inst_mode2;
- unsigned char mode2 = 0;
- if (inst_mode2 > VCD_COPY) {
- inst2 = VCD_COPY;
- mode2 = inst_mode2 - VCD_COPY;
- }
- VerifyInstModeSize1(inst1, mode1, 0, opcode);
- VerifyInstModeSize2(inst2, mode2, 0, opcode);
- ++opcode;
- VerifyInstModeSize1(inst1, mode1, 0, opcode);
- VerifyInstModeSize2(inst2, mode2, 255, opcode);
- ++opcode;
- VerifyInstModeSize1(inst1, mode1, 255, opcode);
- VerifyInstModeSize2(inst2, mode2, 0, opcode);
- ++opcode;
- VerifyInstModeSize1(inst1, mode1, 255, opcode);
- VerifyInstModeSize2(inst2, mode2, 255, opcode);
- ++opcode;
- }
- }
- if (VCDiffCodeTableData::kCodeTableSize != opcode) {
- LOG(FATAL) << "Internal error in test: The nested loops in "
- "DecodeTableTest::ExerciseCodeTableReader should iterate "
- "through exactly " << VCDiffCodeTableData::kCodeTableSize
- << " opcodes.";
- return;
- }
-}
-
-} // unnamed namespace
-} // namespace open_vcdiff

Powered by Google App Engine
This is Rietveld 408576698