From 3684a151e76991bc67dd397cba66b0620cc38bae Mon Sep 17 00:00:00 2001 From: Lei Zhang Date: Mon, 24 Apr 2017 16:22:54 -0700 Subject: Add tests for BC_OnedCode128Writer encoding functions. Make encoding functions return pattern indices instead of pattern pointers for easier testing. Also remove some dead code. Change-Id: Ib80d84b2e6828bbc8920b931d77bbcd82427f01a Reviewed-on: https://pdfium-review.googlesource.com/4474 Commit-Queue: Lei Zhang Reviewed-by: Tom Sepez --- BUILD.gn | 1 + fxbarcode/oned/BC_OnedCode128Writer.cpp | 65 +++++++----------- fxbarcode/oned/BC_OnedCode128Writer.h | 15 ++--- fxbarcode/oned/BC_OnedCode128Writer_unittest.cpp | 84 ++++++++++++++++++++++++ 4 files changed, 117 insertions(+), 48 deletions(-) create mode 100644 fxbarcode/oned/BC_OnedCode128Writer_unittest.cpp diff --git a/BUILD.gn b/BUILD.gn index 3e5eafbe1a..ba36cfbc74 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -1892,6 +1892,7 @@ test("pdfium_unittests") { sources += [ "core/fxcrt/xml/cfx_saxreader_unittest.cpp", "core/fxcrt/xml/cfx_xmlsyntaxparser_unittest.cpp", + "fxbarcode/oned/BC_OnedCode128Writer_unittest.cpp", "fxbarcode/pdf417/BC_PDF417HighLevelEncoder_unittest.cpp", "xfa/fde/cfde_txtedtbuf_unittest.cpp", "xfa/fde/css/cfde_cssdeclaration_unittest.cpp", diff --git a/fxbarcode/oned/BC_OnedCode128Writer.cpp b/fxbarcode/oned/BC_OnedCode128Writer.cpp index 9cdebfd112..818b4bc79e 100644 --- a/fxbarcode/oned/BC_OnedCode128Writer.cpp +++ b/fxbarcode/oned/BC_OnedCode128Writer.cpp @@ -29,7 +29,9 @@ namespace { -const int8_t CODE_PATTERNS[107][7] = { +constexpr size_t kPatternSize = 7; + +const int8_t CODE_PATTERNS[107][kPatternSize] = { {2, 1, 2, 2, 2, 2, 0}, {2, 2, 2, 1, 2, 2, 0}, {2, 2, 2, 2, 2, 1, 0}, {1, 2, 1, 2, 2, 3, 0}, {1, 2, 1, 3, 2, 2, 0}, {1, 3, 1, 2, 2, 2, 0}, {1, 2, 2, 2, 1, 3, 0}, {1, 2, 2, 3, 1, 2, 0}, {1, 3, 2, 2, 1, 2, 0}, @@ -73,16 +75,12 @@ const int32_t CODE_STOP = 106; } // namespace -CBC_OnedCode128Writer::CBC_OnedCode128Writer() { - m_codeFormat = BC_CODE128_B; -} CBC_OnedCode128Writer::CBC_OnedCode128Writer(BC_TYPE type) { m_codeFormat = type; } + CBC_OnedCode128Writer::~CBC_OnedCode128Writer() {} -BC_TYPE CBC_OnedCode128Writer::GetType() { - return m_codeFormat; -} + bool CBC_OnedCode128Writer::CheckContentValidity( const CFX_WideStringC& contents) { if (m_codeFormat != BC_CODE128_B && m_codeFormat != BC_CODE128_C) @@ -146,24 +144,12 @@ uint8_t* CBC_OnedCode128Writer::EncodeWithHint(const CFX_ByteString& contents, hints); } -bool CBC_OnedCode128Writer::IsDigits(const CFX_ByteString& contents, - int32_t start, - int32_t length) { - int32_t end = start + length; - for (int32_t i = start; i < end; i++) { - if (contents[i] < '0' || contents[i] > '9') { - return false; - } - } - return true; -} - uint8_t* CBC_OnedCode128Writer::EncodeImpl(const CFX_ByteString& contents, int32_t& outLength) { if (contents.GetLength() < 1 || contents.GetLength() > 80) return nullptr; - std::vector patterns; + std::vector patterns; int32_t checkSum = 0; if (m_codeFormat == BC_CODE128_B) { checkSum = Encode128B(contents, &patterns); @@ -173,42 +159,41 @@ uint8_t* CBC_OnedCode128Writer::EncodeImpl(const CFX_ByteString& contents, return nullptr; } checkSum %= 103; - patterns.push_back(CODE_PATTERNS[checkSum]); - patterns.push_back(CODE_PATTERNS[CODE_STOP]); + patterns.push_back(checkSum); + patterns.push_back(CODE_STOP); m_iContentLen = contents.GetLength() + 3; int32_t codeWidth = 0; - for (size_t k = 0; k < patterns.size(); k++) { - const int8_t* pattern = patterns[k]; - for (size_t j = 0; j < 7; j++) { - codeWidth += pattern[j]; - } + for (const auto& patternIndex : patterns) { + const int8_t* pattern = CODE_PATTERNS[patternIndex]; + for (size_t i = 0; i < kPatternSize; ++i) + codeWidth += pattern[i]; } outLength = codeWidth; std::unique_ptr result(FX_Alloc(uint8_t, outLength)); int32_t pos = 0; - for (size_t j = 0; j < patterns.size(); j++) { - const int8_t* pattern = patterns[j]; + for (size_t i = 0; i < patterns.size(); ++i) { + const int8_t* pattern = CODE_PATTERNS[patterns[i]]; int32_t e = BCExceptionNO; - pos += AppendPattern(result.get(), pos, pattern, 7, 1, e); + pos += AppendPattern(result.get(), pos, pattern, kPatternSize, 1, e); if (e != BCExceptionNO) return nullptr; } return result.release(); } -int32_t CBC_OnedCode128Writer::Encode128B( - const CFX_ByteString& contents, - std::vector* patterns) { +// static +int32_t CBC_OnedCode128Writer::Encode128B(const CFX_ByteString& contents, + std::vector* patterns) { int32_t checkSum = 0; int32_t checkWeight = 1; int32_t position = 0; - patterns->push_back(CODE_PATTERNS[CODE_START_B]); + patterns->push_back(CODE_START_B); checkSum += CODE_START_B * checkWeight; while (position < contents.GetLength()) { int32_t patternIndex = 0; patternIndex = contents[position] - ' '; position += 1; - patterns->push_back(CODE_PATTERNS[patternIndex]); + patterns->push_back(patternIndex); checkSum += patternIndex * checkWeight; if (position != 0) { checkWeight++; @@ -217,13 +202,13 @@ int32_t CBC_OnedCode128Writer::Encode128B( return checkSum; } -int32_t CBC_OnedCode128Writer::Encode128C( - const CFX_ByteString& contents, - std::vector* patterns) { +// static +int32_t CBC_OnedCode128Writer::Encode128C(const CFX_ByteString& contents, + std::vector* patterns) { int32_t checkSum = 0; int32_t checkWeight = 1; int32_t position = 0; - patterns->push_back(CODE_PATTERNS[CODE_START_C]); + patterns->push_back(CODE_START_C); checkSum += CODE_START_C * checkWeight; while (position < contents.GetLength()) { int32_t patternIndex = 0; @@ -240,7 +225,7 @@ int32_t CBC_OnedCode128Writer::Encode128C( position += 2; } } - patterns->push_back(CODE_PATTERNS[patternIndex]); + patterns->push_back(patternIndex); checkSum += patternIndex * checkWeight; if (position != 0) { checkWeight++; diff --git a/fxbarcode/oned/BC_OnedCode128Writer.h b/fxbarcode/oned/BC_OnedCode128Writer.h index c4c0bf0037..f1b346ddbd 100644 --- a/fxbarcode/oned/BC_OnedCode128Writer.h +++ b/fxbarcode/oned/BC_OnedCode128Writer.h @@ -15,10 +15,15 @@ class CBC_OnedCode128Writer : public CBC_OneDimWriter { public: - CBC_OnedCode128Writer(); explicit CBC_OnedCode128Writer(BC_TYPE type); ~CBC_OnedCode128Writer() override; + // Exposed for testing. + static int32_t Encode128B(const CFX_ByteString& contents, + std::vector* patterns); + static int32_t Encode128C(const CFX_ByteString& contents, + std::vector* patterns); + // CBC_OneDimWriter uint8_t* EncodeWithHint(const CFX_ByteString& contents, BCFORMAT format, @@ -32,15 +37,9 @@ class CBC_OnedCode128Writer : public CBC_OneDimWriter { bool SetTextLocation(BC_TEXT_LOC location); - BC_TYPE GetType(); + BC_TYPE GetType() const { return m_codeFormat; } private: - bool IsDigits(const CFX_ByteString& contents, int32_t start, int32_t length); - int32_t Encode128B(const CFX_ByteString& contents, - std::vector* patterns); - int32_t Encode128C(const CFX_ByteString& contents, - std::vector* patterns); - BC_TYPE m_codeFormat; }; diff --git a/fxbarcode/oned/BC_OnedCode128Writer_unittest.cpp b/fxbarcode/oned/BC_OnedCode128Writer_unittest.cpp new file mode 100644 index 0000000000..add4696a18 --- /dev/null +++ b/fxbarcode/oned/BC_OnedCode128Writer_unittest.cpp @@ -0,0 +1,84 @@ +// Copyright 2017 PDFium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "fxbarcode/oned/BC_OnedCode128Writer.h" +#include "core/fxcrt/fx_basic.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace { + +struct TestCase { + const char* input; + int32_t checksum; + int32_t patterns[7]; + size_t num_patterns; +}; + +TEST(OnedCode128WriterTest, Encode128B) { + char buf[100]; + TestCase kTestCases[] = { + {"", 104, {104}, 1}, + {"a", 169, {104, 65}, 2}, + {"1", 121, {104, 17}, 2}, + {"a1", 203, {104, 65, 17}, 3}, + {"ab", 301, {104, 65, 66}, 3}, + {"12", 157, {104, 17, 18}, 3}, + {"abc", 502, {104, 65, 66, 67}, 4}, + {"123", 214, {104, 17, 18, 19}, 4}, + {"abc123", 774, {104, 65, 66, 67, 17, 18, 19}, 7}, + {"ABC123", 582, {104, 33, 34, 35, 17, 18, 19}, 7}, + {"321ABC", 722, {104, 19, 18, 17, 33, 34, 35}, 7}, + {"XYZ", 448, {104, 56, 57, 58}, 4}, + }; + for (size_t i = 0; i < FX_ArraySize(kTestCases); ++i) { + FXSYS_snprintf(buf, sizeof(buf) - 1, "Test case %zu", i); + SCOPED_TRACE(buf); + const TestCase& test_case = kTestCases[i]; + std::vector patterns; + int32_t checksum = + CBC_OnedCode128Writer::Encode128B(test_case.input, &patterns); + EXPECT_EQ(test_case.checksum, checksum); + ASSERT_EQ(test_case.num_patterns, patterns.size()); + for (size_t j = 0; j < patterns.size(); ++j) { + FXSYS_snprintf(buf, sizeof(buf) - 1, "Comparison %zu", j); + SCOPED_TRACE(buf); + EXPECT_EQ(test_case.patterns[j], patterns[j]); + } + } +} + +TEST(OnedCode128WriterTest, Encode128C) { + char buf[100]; + TestCase kTestCases[] = { + {"", 105, {105}, 1}, + {"a", 202, {105, 97}, 2}, + {"1", 106, {105, 1}, 2}, + {"a1", 204, {105, 97, 1}, 3}, + {"ab", 398, {105, 97, 98}, 3}, + {"12", 117, {105, 12}, 2}, + {"abc", 695, {105, 97, 98, 99}, 4}, + {"123", 123, {105, 12, 3}, 3}, + {"abc123", 758, {105, 97, 98, 99, 12, 3}, 6}, + {"ABC123", 566, {105, 65, 66, 67, 12, 3}, 6}, + {"321ABC", 933, {105, 32, 1, 65, 66, 67}, 6}, + {"XYZ", 641, {105, 88, 89, 90}, 4}, + }; + for (size_t i = 0; i < FX_ArraySize(kTestCases); ++i) { + FXSYS_snprintf(buf, sizeof(buf) - 1, "Test case %zu", i); + SCOPED_TRACE(buf); + const TestCase& test_case = kTestCases[i]; + std::vector patterns; + int32_t checksum = + CBC_OnedCode128Writer::Encode128C(test_case.input, &patterns); + EXPECT_EQ(test_case.checksum, checksum); + ASSERT_EQ(test_case.num_patterns, patterns.size()); + for (size_t j = 0; j < patterns.size(); ++j) { + FXSYS_snprintf(buf, sizeof(buf) - 1, "Comparison %zu", j); + SCOPED_TRACE(buf); + EXPECT_EQ(test_case.patterns[j], patterns[j]); + } + } +} + +} // namespace -- cgit v1.2.3