zxing_cpp 0.1.0

data/ext/zxing/zxing-cpp/core/tests/src/common/BitMatrixTest.cpp

@@ -0,0 +1,106 @@
+/*
+ *  BitMatrixTest.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 12/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 "BitMatrixTest.h"
+#include <limits>
+#include <stdlib.h>
+#include <unistd.h>
+
+namespace zxing {
+using namespace std;
+
+CPPUNIT_TEST_SUITE_REGISTRATION(BitMatrixTest);
+
+BitMatrixTest::BitMatrixTest() {
+  srand(getpid());
+}
+
+void BitMatrixTest::testGetSet() {
+  const int bits = BitMatrix::bitsPerWord;
+  BitMatrix matrix(bits + 1);
+  CPPUNIT_ASSERT_EQUAL(bits + 1, matrix.getHeight());
+  for (int i = 0; i < bits + 1; i++) {
+    for (int j = 0; j < bits + 1; j++) {
+      if (i * j % 3 == 0) {
+        matrix.set(i, j);
+      }
+    }
+  }
+  for (int i = 0; i < bits + 1; i++) {
+    for (int j = 0; j < bits + 1; j++) {
+      CPPUNIT_ASSERT_EQUAL(i * j % 3 == 0, matrix.get(i, j));
+    }
+  }
+}
+
+void BitMatrixTest::testSetRegion() {
+  BitMatrix matrix(5);
+  matrix.setRegion(1, 1, 3, 3);
+  for (int i = 0; i < 5; i++) {
+    for (int j = 0; j < 5; j++) {
+      CPPUNIT_ASSERT_EQUAL(i >= 1 && i <= 3 && j >= 1 && j <= 3,
+                           matrix.get(i, j));
+    }
+  }
+}
+
+void BitMatrixTest::testGetRow0() {
+  const int width = 2;
+  const int height = 2;
+  runBitMatrixGetRowTest(width, height);
+}
+
+void BitMatrixTest::testGetRow1() {
+  const int width = 98;
+  const int height = 76;
+  runBitMatrixGetRowTest(width, height);
+}
+
+void BitMatrixTest::testGetRow2() {
+  const int width = 320;
+  const int height = 320;
+  runBitMatrixGetRowTest(width, height);
+}
+
+void BitMatrixTest::testGetRow3() {
+  const int width = 17;
+  const int height = 23;
+  runBitMatrixGetRowTest(width, height);
+}
+
+void BitMatrixTest::runBitMatrixGetRowTest(int width, int height) {
+  BitMatrix mat(width, height);
+  for (int y = 0; y < height; y++) {
+    for (int x = 0; x < width; x++) {
+      bool v = ((rand() & 0x01) != 0);
+      if (v) {
+        mat.set(x, y);
+      }
+    }
+  }
+  Ref<BitArray> row(new BitArray(width));
+  for (int y = 0; y < height; y++) {
+    row = mat.getRow(y, row);
+    for (int x = 0; x < width; x++) {
+      CPPUNIT_ASSERT_EQUAL(row->get(x), mat.get(x,y));
+    }
+  }
+}
+}

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

@@ -0,0 +1,55 @@
+#ifndef __BIT_MATRIX_TEST_H__
+#define __BIT_MATRIX_TEST_H__
+
+/*
+ *  BitMatrixTest.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/common/BitMatrix.h>
+
+namespace zxing {
+class BitMatrixTest : public CPPUNIT_NS::TestFixture {
+  CPPUNIT_TEST_SUITE(BitMatrixTest);
+  CPPUNIT_TEST(testGetSet);
+  CPPUNIT_TEST(testSetRegion);
+  CPPUNIT_TEST(testGetRow0);
+  CPPUNIT_TEST(testGetRow1);
+  CPPUNIT_TEST(testGetRow2);
+  CPPUNIT_TEST(testGetRow3);
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+  BitMatrixTest();
+
+protected:
+  void testGetSet();
+  void testSetRegion();
+  void testGetRow0();
+  void testGetRow1();
+  void testGetRow2();
+  void testGetRow3();
+
+private:
+  void runBitMatrixGetRowTest(int width, int height);
+};
+}
+
+
+#endif // __BIT_MATRIX_TEST_H__

data/ext/zxing/zxing-cpp/core/tests/src/common/BitSourceTest.cpp

@@ -0,0 +1,49 @@
+/*
+ *  BitSourceTest.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 09/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 "BitSourceTest.h"
+
+namespace zxing {
+
+CPPUNIT_TEST_SUITE_REGISTRATION(BitSourceTest);
+
+typedef char byte;
+
+void BitSourceTest::testSource() {
+  byte rawBytes[] = {(byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5};
+  ArrayRef<byte> bytes(rawBytes, 5);
+  BitSource source(bytes);
+  CPPUNIT_ASSERT_EQUAL(40, source.available());
+  CPPUNIT_ASSERT_EQUAL(0, source.readBits(1));
+  CPPUNIT_ASSERT_EQUAL(39, source.available());
+  CPPUNIT_ASSERT_EQUAL(0, source.readBits(6));
+  CPPUNIT_ASSERT_EQUAL(33, source.available());
+  CPPUNIT_ASSERT_EQUAL(1, source.readBits(1));
+  CPPUNIT_ASSERT_EQUAL(32, source.available());
+  CPPUNIT_ASSERT_EQUAL(2, source.readBits(8));
+  CPPUNIT_ASSERT_EQUAL(24, source.available());
+  CPPUNIT_ASSERT_EQUAL(12, source.readBits(10));
+  CPPUNIT_ASSERT_EQUAL(14, source.available());
+  CPPUNIT_ASSERT_EQUAL(16, source.readBits(8));
+  CPPUNIT_ASSERT_EQUAL(6, source.available());
+  CPPUNIT_ASSERT_EQUAL(5, source.readBits(6));
+  CPPUNIT_ASSERT_EQUAL(0, source.available());
+}
+}

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

@@ -0,0 +1,42 @@
+#ifndef __BIT_SOURCE_TEST_H__
+#define __BIT_SOURCE_TEST_H__
+
+/*
+ *  BitSourceTest.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/common/BitSource.h>
+
+namespace zxing {
+class BitSourceTest : public CPPUNIT_NS::TestFixture {
+  CPPUNIT_TEST_SUITE(BitSourceTest);
+  CPPUNIT_TEST(testSource);
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+
+protected:
+  void testSource();
+
+private:
+};
+}
+
+#endif // __BIT_SOURCE_TEST_H__

data/ext/zxing/zxing-cpp/core/tests/src/common/CountedTest.cpp

@@ -0,0 +1,58 @@
+/*
+ *  CountedTest.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 08/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 "CountedTest.h"
+#include <zxing/common/Counted.h>
+#include <iostream>
+
+using namespace std;
+using namespace CPPUNIT_NS;
+
+namespace zxing {
+
+class Foo : public Counted {
+public:
+  void foo() {
+    cout << "foo!\n";
+  }
+};
+
+//CPPUNIT_TEST_SUITE_REGISTRATION(CountedTest);
+
+void CountedTest::setUp() {}
+void CountedTest::tearDown() {}
+
+void CountedTest::test() {
+  Foo foo;
+  CPPUNIT_ASSERT_EQUAL(0, foo.count());
+  foo.retain();
+  CPPUNIT_ASSERT_EQUAL(1, foo.count());
+  Ref<Foo> foobar(new Foo);
+  CPPUNIT_ASSERT_EQUAL(1, foobar->count());
+  {
+    Ref<Foo> secondRef(foobar);
+    CPPUNIT_ASSERT_EQUAL(1, foo.count());
+    CPPUNIT_ASSERT_EQUAL(2, foobar->count());
+  }
+  CPPUNIT_ASSERT_EQUAL(1, foo.count());
+  CPPUNIT_ASSERT_EQUAL(1, foobar->count());
+}
+
+}

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

@@ -0,0 +1,46 @@
+#ifndef __COUNTED_TEST_H__
+#define __COUNTED_TEST_H__
+
+/*
+ *  CountedTest.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>
+
+using namespace std;
+
+namespace zxing {
+
+class CountedTest : public CppUnit::TestFixture {
+  CPPUNIT_TEST_SUITE(CountedTest);
+  CPPUNIT_TEST(test);
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+  void setUp();
+  void tearDown();
+
+protected:
+  void test();
+
+private:
+};
+}
+
+#endif // __COUNTED_TEST_H__

data/ext/zxing/zxing-cpp/core/tests/src/common/PerspectiveTransformTest.cpp

@@ -0,0 +1,69 @@
+/*
+ *  PerspectiveTransformTest.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 12/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 "PerspectiveTransformTest.h"
+
+namespace zxing {
+using namespace std;
+
+static float EPSILON = 0.0001f;
+
+CPPUNIT_TEST_SUITE_REGISTRATION(PerspectiveTransformTest);
+
+void PerspectiveTransformTest::testSquareToQuadrilateral() {
+  Ref<PerspectiveTransform> pt
+  (PerspectiveTransform::squareToQuadrilateral
+   (2.0f, 3.0f, 10.0f, 4.0f, 16.0f, 15.0f, 4.0f, 9.0f));
+  assertPointEquals(2.0f, 3.0f, 0.0f, 0.0f, pt);
+  assertPointEquals(10.0f, 4.0f, 1.0f, 0.0f, pt);
+  assertPointEquals(4.0f, 9.0f, 0.0f, 1.0f, pt);
+  assertPointEquals(16.0f, 15.0f, 1.0f, 1.0f, pt);
+  assertPointEquals(6.535211f, 6.8873234f, 0.5f, 0.5f, pt);
+  assertPointEquals(48.0f, 42.42857f, 1.5f, 1.5f, pt);
+}
+
+void PerspectiveTransformTest::testQuadrilateralToQuadrilateral() {
+  Ref<PerspectiveTransform> pt
+  (PerspectiveTransform::quadrilateralToQuadrilateral
+   (2.0f, 3.0f, 10.0f, 4.0f, 16.0f, 15.0f, 4.0f, 9.0f,
+    103.0f, 110.0f, 300.0f, 120.0f, 290.0f, 270.0f, 150.0f, 280.0f));
+  assertPointEquals(103.0f, 110.0f, 2.0f, 3.0f, pt);
+  assertPointEquals(300.0f, 120.0f, 10.0f, 4.0f, pt);
+  assertPointEquals(290.0f, 270.0f, 16.0f, 15.0f, pt);
+  assertPointEquals(150.0f, 280.0f, 4.0f, 9.0f, pt);
+  assertPointEquals(7.1516876f, -64.60185f, 0.5f, 0.5f, pt);
+  assertPointEquals(328.09116f, 334.16385f, 50.0f, 50.0f, pt);
+}
+
+void PerspectiveTransformTest::assertPointEquals(float expectedX,
+    float expectedY,
+    float sourceX,
+    float sourceY,
+    Ref<PerspectiveTransform> pt) {
+  vector<float> points(2);
+  points[0] = sourceX;
+  points[1] = sourceY;
+  pt->transformPoints(points);
+  CPPUNIT_ASSERT_DOUBLES_EQUAL(expectedX, points[0], EPSILON);
+  CPPUNIT_ASSERT_DOUBLES_EQUAL(expectedY, points[1], EPSILON);
+
+}
+
+}

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

@@ -0,0 +1,47 @@
+#ifndef __PERSPECTIVE_TRANSFORM_TEST_H__
+#define __PERSPECTIVE_TRANSFORM_TEST_H__
+
+/*
+ *  PerspectiveTransformTest.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/common/PerspectiveTransform.h>
+
+namespace zxing {
+class PerspectiveTransformTest : public CPPUNIT_NS::TestFixture {
+  CPPUNIT_TEST_SUITE(PerspectiveTransformTest);
+  CPPUNIT_TEST(testSquareToQuadrilateral);
+  CPPUNIT_TEST(testQuadrilateralToQuadrilateral);
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+
+protected:
+  void testSquareToQuadrilateral();
+  void testQuadrilateralToQuadrilateral();
+
+private:
+  static void assertPointEquals(float expectedX, float expectedY,
+                                float sourceX, float sourceY,
+                                Ref<PerspectiveTransform> pt);
+};
+}
+
+#endif // __PERSPECTIVE_TRANSFORM_TEST_H__