zxing_cpp_no_cmake 0.1.1

data/ext/zxing/zxing-cpp/core/tests/src/common/reedsolomon/ReedSolomonTest.cpp

@@ -0,0 +1,129 @@
+/*
+ *  ReedSolomonTest.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 06/05/2008.
+ *  Copyright 2008 Google UK. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ReedSolomonTest.h"
+#include <zxing/common/reedsolomon/ReedSolomonDecoder.h>
+#include <zxing/common/reedsolomon/ReedSolomonException.h>
+#include <zxing/common/IllegalArgumentException.h>
+#include <vector>
+#include <cmath>
+#include <cstdlib>
+
+namespace zxing {
+using namespace std;
+
+CPPUNIT_TEST_SUITE_REGISTRATION(ReedSolomonTest);
+
+static inline ArrayRef<int> makeVector(int n, int *items) {
+  ArrayRef<int> v(new Array<int>(items, n));
+  return v;
+}
+
+static int QR_CODE_TEST[] = { 0x10, 0x20, 0x0C, 0x56, 0x61, 0x80, 0xEC, 0x11, 0xEC,
+                              0x11, 0xEC, 0x11, 0xEC, 0x11, 0xEC, 0x11, 0xA5
+                            };
+static int QR_CODE_TEST_WITH_EC[] = { 0x10, 0x20, 0x0C, 0x56, 0x61, 0x80, 0xEC, 0x11, 0xEC,
+                                      0x11, 0xEC, 0x11, 0xEC, 0x11, 0xEC, 0x11, 0xA5, 0x24,
+                                      0xD4, 0xC1, 0xED, 0x36, 0xC7, 0x87, 0x2C, 0x55
+                                    };
+
+void ReedSolomonTest::setUp() {
+  qrCodeTest_ =
+    makeVector(sizeof(QR_CODE_TEST) / sizeof(QR_CODE_TEST[0]),
+               QR_CODE_TEST);
+  qrCodeTestWithEc_ =
+    makeVector(sizeof(QR_CODE_TEST_WITH_EC) / sizeof(QR_CODE_TEST_WITH_EC[0]),
+               QR_CODE_TEST_WITH_EC);
+  qrCodeCorrectable_ =
+    (qrCodeTestWithEc_->size() - qrCodeTest_->size()) / 2;
+
+  qrRSDecoder_ = new ReedSolomonDecoder(GenericGF::QR_CODE_FIELD_256);
+}
+
+void ReedSolomonTest::tearDown() {
+  delete qrRSDecoder_;
+}
+
+void ReedSolomonTest::testNoError() {
+  ArrayRef<int> received(new Array<int>(qrCodeTestWithEc_->size()));
+  *received = *qrCodeTestWithEc_;
+  checkQRRSDecode(received);
+}
+
+void ReedSolomonTest::testOneError() {
+  ArrayRef<int> received(new Array<int>(qrCodeTestWithEc_->size()));
+  srandom(0xDEADBEEFL);
+  for (int i = 0; i < received->size(); i++) {
+    *received = *qrCodeTestWithEc_;
+    received[i] = random() % 256;
+    checkQRRSDecode(received);
+  }
+}
+
+void ReedSolomonTest::testMaxErrors() {
+  ArrayRef<int> received(new Array<int>(qrCodeTestWithEc_->size()));
+  srandom(0xDEADBEEFL);
+  for (int i = 0; i < qrCodeTest_->size(); i++) {
+    *received = *qrCodeTestWithEc_;
+    corrupt(received, qrCodeCorrectable_);
+    checkQRRSDecode(received);
+  }
+}
+
+void ReedSolomonTest::testTooManyErrors() {
+  ArrayRef<int> received(new Array<int>(qrCodeTestWithEc_->size()));
+  srandom(0xDEADBEEFL);
+  *received = *qrCodeTestWithEc_;
+  try {
+    corrupt(received, qrCodeCorrectable_ + 1);
+    checkQRRSDecode(received);
+    cout << "expected exception!\n";
+    CPPUNIT_FAIL("should not happen!");
+  } catch (ReedSolomonException const& e) {
+    // expected
+  } catch (...) {
+    CPPUNIT_FAIL("unexpected exception!");
+  }
+}
+
+
+void ReedSolomonTest::checkQRRSDecode(ArrayRef<int> &received) {
+  int twoS = 2 * qrCodeCorrectable_;
+  qrRSDecoder_->decode(received, twoS);
+  for (int i = 0; i < qrCodeTest_->size(); i++) {
+    CPPUNIT_ASSERT_EQUAL(qrCodeTest_[i], received[i]);
+  }
+}
+
+void ReedSolomonTest::corrupt(ArrayRef<int> &received, int howMany) {
+  vector<bool> corrupted(received->size());
+  for (int j = 0; j < howMany; j++) {
+    int location = floor(received->size() * ((double)(random() >> 1) / (double)((RAND_MAX >> 1) + 1)));
+    if (corrupted[location]) {
+      j--;
+    } else {
+      corrupted[location] = true;
+      int newByte = random() % 256;
+      received[location] = newByte;
+    }
+  }
+}
+
+}

data/ext/zxing/zxing-cpp/core/tests/src/common/reedsolomon/ReedSolomonTest.h

@@ -0,0 +1,62 @@
+#ifndef __REED_SOLOMON_TEST_H__
+#define __REED_SOLOMON_TEST_H__
+
+/*
+ *  ReedSolomonTest.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <vector>
+#include <memory>
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+#include <zxing/common/Counted.h>
+#include <zxing/common/Array.h>
+
+
+namespace zxing {
+class ReedSolomonDecoder;
+
+class ReedSolomonTest : public CppUnit::TestFixture {
+  CPPUNIT_TEST_SUITE(ReedSolomonTest);
+  CPPUNIT_TEST(testNoError);
+  CPPUNIT_TEST(testOneError);
+  CPPUNIT_TEST(testMaxErrors);
+  CPPUNIT_TEST(testTooManyErrors);
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+  void setUp();
+  void tearDown();
+
+protected:
+  void testNoError();
+  void testOneError();
+  void testMaxErrors();
+  void testTooManyErrors();
+
+private:
+  ArrayRef<int> qrCodeTest_;
+  ArrayRef<int> qrCodeTestWithEc_;
+  int qrCodeCorrectable_;
+  ReedSolomonDecoder *qrRSDecoder_;
+  void checkQRRSDecode(ArrayRef<int> &received);
+  static void corrupt(ArrayRef<int> &received, int howMany);
+};
+}
+
+#endif // __REED_SOLOMON_TEST_H__

data/ext/zxing/zxing-cpp/core/tests/src/qrcode/ErrorCorrectionLevelTest.cpp

@@ -0,0 +1,47 @@
+/*
+ *  ErrorCorrectionLevelTest.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 19/05/2008.
+ *  Copyright 2008 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ErrorCorrectionLevelTest.h"
+#include <zxing/ReaderException.h>
+#include <zxing/qrcode/ErrorCorrectionLevel.h>
+
+namespace zxing {
+namespace qrcode {
+
+CPPUNIT_TEST_SUITE_REGISTRATION(ErrorCorrectionLevelTest);
+
+void ErrorCorrectionLevelTest::testForBits() {
+  CPPUNIT_ASSERT_EQUAL(&ErrorCorrectionLevel::M,
+                       &ErrorCorrectionLevel::forBits(0));
+  CPPUNIT_ASSERT_EQUAL(&ErrorCorrectionLevel::L,
+                       &ErrorCorrectionLevel::forBits(1));
+  CPPUNIT_ASSERT_EQUAL(&ErrorCorrectionLevel::H,
+                       &ErrorCorrectionLevel::forBits(2));
+  CPPUNIT_ASSERT_EQUAL(&ErrorCorrectionLevel::Q,
+                       &ErrorCorrectionLevel::forBits(3));
+  try {
+    ErrorCorrectionLevel::forBits(4);
+    CPPUNIT_FAIL("should have thrown an exception");
+  } catch (zxing::ReaderException const& ex) {
+    // expected
+  }
+}
+}
+}

data/ext/zxing/zxing-cpp/core/tests/src/qrcode/ErrorCorrectionLevelTest.h

@@ -0,0 +1,45 @@
+#ifndef __ERROR_CORRECTION_LEVEL_TEST_H__
+#define __ERROR_CORRECTION_LEVEL_TEST_H__
+
+/*
+ *  ErrorCorrectionLevelTest.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+#include <zxing/qrcode/ErrorCorrectionLevel.h>
+
+namespace zxing {
+namespace qrcode {
+
+class ErrorCorrectionLevelTest : public CPPUNIT_NS::TestFixture {
+  CPPUNIT_TEST_SUITE(ErrorCorrectionLevelTest);
+  CPPUNIT_TEST(testForBits);
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+
+protected:
+  void testForBits();
+
+private:
+};
+}
+}
+
+#endif // __ERROR_CORRECTION_LEVEL_TEST_H__

data/ext/zxing/zxing-cpp/core/tests/src/qrcode/FormatInformationTest.cpp

@@ -0,0 +1,88 @@
+/*
+ *  FormatInformationTest.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 19/05/2008.
+ *  Copyright 2008 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "FormatInformationTest.h"
+
+#include "ErrorCorrectionLevelTest.h"
+#include <zxing/ReaderException.h>
+#include <zxing/qrcode/FormatInformation.h>
+#include <zxing/qrcode/ErrorCorrectionLevel.h>
+
+namespace zxing {
+namespace qrcode {
+
+CPPUNIT_TEST_SUITE_REGISTRATION(FormatInformationTest);
+
+static const int MASKED_TEST_FORMAT_INFO = 0x2BED;
+static const int UNMASKED_TEST_FORMAT_INFO = MASKED_TEST_FORMAT_INFO ^ 0x5412;
+
+static void assertEquals(Ref<FormatInformation> a,
+                         Ref<FormatInformation> b) {
+  if (a == NULL || b == NULL)
+  {
+	CPPUNIT_ASSERT_EQUAL(a, b);
+  }
+  else
+  {
+	FormatInformation &aa = *a;
+	FormatInformation &bb = *b;
+	CPPUNIT_ASSERT_EQUAL(aa, bb);
+  }
+}
+
+void FormatInformationTest::testBitsDiffering() {
+  CPPUNIT_ASSERT_EQUAL(0, FormatInformation::numBitsDiffering(1, 1));
+  CPPUNIT_ASSERT_EQUAL(1, FormatInformation::numBitsDiffering(0, 2));
+  CPPUNIT_ASSERT_EQUAL(2, FormatInformation::numBitsDiffering(1, 2));
+  CPPUNIT_ASSERT_EQUAL(32, FormatInformation::numBitsDiffering(0xffffffff,
+                       0));
+}
+
+void FormatInformationTest::testDecode() {
+  // Normal case
+  Ref<FormatInformation> expected =
+    FormatInformation::decodeFormatInformation(MASKED_TEST_FORMAT_INFO, MASKED_TEST_FORMAT_INFO);
+  CPPUNIT_ASSERT_EQUAL((char)0x07, expected->getDataMask());
+  CPPUNIT_ASSERT_EQUAL(&ErrorCorrectionLevel::Q,
+                       &expected->getErrorCorrectionLevel());
+  // where the code forgot the mask!
+  assertEquals(expected,
+               FormatInformation::decodeFormatInformation(UNMASKED_TEST_FORMAT_INFO, MASKED_TEST_FORMAT_INFO));
+
+  //TODO separate tests as in Java?
+
+  // 1,2,3,4 bits difference
+  assertEquals(expected, FormatInformation::decodeFormatInformation(
+	MASKED_TEST_FORMAT_INFO ^ 0x01, MASKED_TEST_FORMAT_INFO ^ 0x01));
+  assertEquals(expected, FormatInformation::decodeFormatInformation(
+	MASKED_TEST_FORMAT_INFO ^ 0x03, MASKED_TEST_FORMAT_INFO ^ 0x03));
+  assertEquals(expected, FormatInformation::decodeFormatInformation(
+	MASKED_TEST_FORMAT_INFO ^ 0x07, MASKED_TEST_FORMAT_INFO ^ 0x07));
+
+  Ref<FormatInformation> expectedNull(NULL);
+  assertEquals(expectedNull, FormatInformation::decodeFormatInformation(
+	MASKED_TEST_FORMAT_INFO ^ 0x0F, MASKED_TEST_FORMAT_INFO ^ 0x0F));
+
+  // WithMisread
+  assertEquals(expected, FormatInformation::decodeFormatInformation(
+	MASKED_TEST_FORMAT_INFO ^ 0x03, MASKED_TEST_FORMAT_INFO ^ 0x0F));
+}
+}
+}

data/ext/zxing/zxing-cpp/core/tests/src/qrcode/FormatInformationTest.h

@@ -0,0 +1,47 @@
+#ifndef __FORMAT_INFORMATION_TEST_H__
+#define __FORMAT_INFORMATION_TEST_H__
+
+/*
+ *  FormatInformationTest.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+#include <zxing/qrcode/FormatInformation.h>
+
+namespace zxing {
+namespace qrcode {
+
+class FormatInformationTest : public CPPUNIT_NS::TestFixture {
+  CPPUNIT_TEST_SUITE(FormatInformationTest);
+  CPPUNIT_TEST(testBitsDiffering);
+  CPPUNIT_TEST(testDecode);
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+
+protected:
+  void testBitsDiffering();
+  void testDecode();
+
+private:
+};
+}
+}
+
+#endif // __FORMAT_INFORMATION_TEST_H__

data/ext/zxing/zxing-cpp/core/tests/src/qrcode/VersionTest.cpp

@@ -0,0 +1,88 @@
+/*
+ *  VersionTest.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 19/05/2008.
+ *  Copyright 2008 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "VersionTest.h"
+#include <zxing/ReaderException.h>
+#include <zxing/qrcode/Version.h>
+
+namespace zxing {
+namespace qrcode {
+
+static void assertNotNull(ECBlocks *blocks) {
+  CPPUNIT_ASSERT_EQUAL(false, blocks == 0);
+}
+
+static void checkVersion(Version *version, int number, int dimension) {
+  CPPUNIT_ASSERT_EQUAL(false, version == 0);
+  CPPUNIT_ASSERT_EQUAL(number, version->getVersionNumber());
+  if (number > 1) {
+    CPPUNIT_ASSERT_EQUAL(true,
+                         version->getAlignmentPatternCenters().size() > 0);
+  }
+  CPPUNIT_ASSERT_EQUAL(dimension, version->getDimensionForVersion());
+  assertNotNull(&version->getECBlocksForLevel(ErrorCorrectionLevel::H));
+  assertNotNull(&version->getECBlocksForLevel(ErrorCorrectionLevel::L));
+  assertNotNull(&version->getECBlocksForLevel(ErrorCorrectionLevel::M));
+  assertNotNull(&version->getECBlocksForLevel(ErrorCorrectionLevel::Q));
+  CPPUNIT_ASSERT_EQUAL(false, version->buildFunctionPattern() == 0);
+}
+
+
+CPPUNIT_TEST_SUITE_REGISTRATION(VersionTest);
+
+void VersionTest::testVersionForNumber() {
+  for (int i = 1; i <= (int)Version::VERSIONS.size(); i++) {
+    Version *v = Version::VERSIONS[i-1];
+    CPPUNIT_ASSERT_EQUAL((int)i, v->getVersionNumber());
+  }
+
+  try {
+    Version::getVersionForNumber(0);
+    CPPUNIT_FAIL("Should have thrown an exception");
+  } catch (zxing::ReaderException const& re) {
+    // good
+  }
+  for (int i = 1; i <= 40; i++) {
+    checkVersion(Version::getVersionForNumber(i), i, 4*i + 17);
+  }
+}
+
+void VersionTest::testGetProvisionalVersionForDimension() {
+  for (int i = 1; i <= 40; i++) {
+    int dimension = 4 * i + 17;
+    Version *v = Version::getProvisionalVersionForDimension(dimension);
+    int vi = v->getVersionNumber();
+    CPPUNIT_ASSERT_EQUAL(i, vi);
+  }
+}
+
+void VersionTest::testDecodeVersionInformation() {
+  // Spot check
+  CPPUNIT_ASSERT_EQUAL(7, Version::decodeVersionInformation(0x07C94)->getVersionNumber());
+  CPPUNIT_ASSERT_EQUAL(12, Version::decodeVersionInformation(0x0C762)->getVersionNumber());
+  CPPUNIT_ASSERT_EQUAL(17, Version::decodeVersionInformation(0x1145D)->getVersionNumber());
+  CPPUNIT_ASSERT_EQUAL(22, Version::decodeVersionInformation(0x168C9)->getVersionNumber());
+  CPPUNIT_ASSERT_EQUAL(27, Version::decodeVersionInformation(0x1B08E)->getVersionNumber());
+  CPPUNIT_ASSERT_EQUAL(32, Version::decodeVersionInformation(0x209D5)->getVersionNumber());
+}
+
+}
+}
+