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 |