added stub java tests

modules/java/android_test/src/org/opencv/test/ConvertersTest.java

+package org.opencv.test;
+
+
+public class ConvertersTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testMat_to_vector_float() {
+		fail("Not yet implemented");
+	}
+
+	public void testMat_to_vector_int() {
+		fail("Not yet implemented");
+	}
+
+	public void testMat_to_vector_KeyPoint() {
+		fail("Not yet implemented");
+	}
+
+	public void testMat_to_vector_Mat() {
+		fail("Not yet implemented");
+	}
+
+	public void testMat_to_vector_Point() {
+		fail("Not yet implemented");
+	}
+
+	public void testMat_to_vector_Rect() {
+		fail("Not yet implemented");
+	}
+
+	public void testVector_double_to_Mat() {
+		fail("Not yet implemented");
+	}
+
+	public void testVector_float_to_Mat() {
+		fail("Not yet implemented");
+	}
+
+	public void testVector_int_to_Mat() {
+		fail("Not yet implemented");
+	}
+
+	public void testVector_Mat_to_Mat() {
+		fail("Not yet implemented");
+	}
+
+	public void testVector_Point_to_Mat() {
+		fail("Not yet implemented");
+	}
+
+	public void testVector_Rect_to_Mat() {
+		fail("Not yet implemented");
+	}
+
+	public void testVector_uchar_to_Mat() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/OpenCVTestCase.java

@@ -104,7 +104,7 @@ public class OpenCVTestCase extends TestCase {
         rgba128 = new Mat(matSize, matSize, CvType.CV_8UC4, Scalar.all(128));
         
         rgbLena = Highgui.imread(OpenCVTestRunner.LENA_PATH);
-        grayChess = Highgui.imread(OpenCVTestRunner.CHESS_PATH);
+        grayChess = Highgui.imread(OpenCVTestRunner.CHESS_PATH, 0);
         
 		v1 = new Mat(1, 3, CvType.CV_32F); v1.put(0, 0, 1.0, 3.0, 2.0);
 		v2 = new Mat(1, 3, CvType.CV_32F); v2.put(0, 0, 2.0, 1.0, 3.0);

modules/java/android_test/src/org/opencv/test/calib3d/StereoBMTest.java

+package org.opencv.test.calib3d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class StereoBMTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testComputeMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testComputeMatMatMatInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testStereoBM() {
+		fail("Not yet implemented");
+	}
+
+	public void testStereoBMInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testStereoBMIntInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testStereoBMIntIntInt() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/core/KDTreeTest.java

+package org.opencv.test.core;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class KDTreeTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testBuildMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testBuildMatBoolean() {
+		fail("Not yet implemented");
+	}
+
+	public void testBuildMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testBuildMatMatBoolean() {
+		fail("Not yet implemented");
+	}
+
+	public void testDims() {
+		fail("Not yet implemented");
+	}
+
+	public void testFindNearestMatIntIntMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testFindNearestMatIntIntMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testFindNearestMatIntIntMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testFindNearestMatIntIntMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testFindOrthoRangeMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testFindOrthoRangeMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testFindOrthoRangeMatMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_maxDepth() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_normType() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_points() {
+		fail("Not yet implemented");
+	}
+
+	public void testGetPointsMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testGetPointsMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testKDTree() {
+		fail("Not yet implemented");
+	}
+
+	public void testKDTreeMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testKDTreeMatBoolean() {
+		fail("Not yet implemented");
+	}
+
+	public void testKDTreeMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testKDTreeMatMatBoolean() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_normType() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/core/Point3Test.java

+package org.opencv.test.core;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class Point3Test extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testClone() {
+		fail("Not yet implemented");
+	}
+
+	public void testCross() {
+		fail("Not yet implemented");
+	}
+
+	public void testDot() {
+		fail("Not yet implemented");
+	}
+
+	public void testEqualsObject() {
+		fail("Not yet implemented");
+	}
+
+	public void testPoint3() {
+		fail("Not yet implemented");
+	}
+
+	public void testPoint3DoubleArray() {
+		fail("Not yet implemented");
+	}
+
+	public void testPoint3DoubleDoubleDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testPoint3Point() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/core/PointTest.java

+package org.opencv.test.core;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class PointTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testClone() {
+		fail("Not yet implemented");
+	}
+
+	public void testDot() {
+		fail("Not yet implemented");
+	}
+
+	public void testEqualsObject() {
+		fail("Not yet implemented");
+	}
+
+	public void testInside() {
+		fail("Not yet implemented");
+	}
+
+	public void testPoint() {
+		fail("Not yet implemented");
+	}
+
+	public void testPointDoubleArray() {
+		fail("Not yet implemented");
+	}
+
+	public void testPointDoubleDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet() {
+		fail("Not yet implemented");
+	}
+
+	public void testToString() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/core/RangeTest.java

+package org.opencv.test.core;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class RangeTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testAll() {
+		fail("Not yet implemented");
+	}
+
+	public void testClone() {
+		fail("Not yet implemented");
+	}
+
+	public void testEmpty() {
+		fail("Not yet implemented");
+	}
+
+	public void testEqualsObject() {
+		fail("Not yet implemented");
+	}
+
+	public void testIntersection() {
+		fail("Not yet implemented");
+	}
+
+	public void testRange() {
+		fail("Not yet implemented");
+	}
+
+	public void testRangeDoubleArray() {
+		fail("Not yet implemented");
+	}
+
+	public void testRangeIntInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet() {
+		fail("Not yet implemented");
+	}
+
+	public void testShift() {
+		fail("Not yet implemented");
+	}
+
+	public void testSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testToString() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/core/RectTest.java

+package org.opencv.test.core;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class RectTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testArea() {
+		fail("Not yet implemented");
+	}
+
+	public void testBr() {
+		fail("Not yet implemented");
+	}
+
+	public void testClone() {
+		fail("Not yet implemented");
+	}
+
+	public void testContains() {
+		fail("Not yet implemented");
+	}
+
+	public void testEqualsObject() {
+		fail("Not yet implemented");
+	}
+
+	public void testRect() {
+		fail("Not yet implemented");
+	}
+
+	public void testRectDoubleArray() {
+		fail("Not yet implemented");
+	}
+
+	public void testRectIntIntIntInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testRectPointPoint() {
+		fail("Not yet implemented");
+	}
+
+	public void testRectPointSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet() {
+		fail("Not yet implemented");
+	}
+
+	public void testSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testTl() {
+		fail("Not yet implemented");
+	}
+
+	public void testToString() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/core/ScalarTest.java

+package org.opencv.test.core;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class ScalarTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testAll() {
+		fail("Not yet implemented");
+	}
+
+	public void testClone() {
+		fail("Not yet implemented");
+	}
+
+	public void testConj() {
+		fail("Not yet implemented");
+	}
+
+	public void testEqualsObject() {
+		fail("Not yet implemented");
+	}
+
+	public void testIsReal() {
+		fail("Not yet implemented");
+	}
+
+	public void testMulScalar() {
+		fail("Not yet implemented");
+	}
+
+	public void testMulScalarDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testScalarDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testScalarDoubleArray() {
+		fail("Not yet implemented");
+	}
+
+	public void testScalarDoubleDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testScalarDoubleDoubleDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testScalarDoubleDoubleDoubleDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/core/SizeTest.java

+package org.opencv.test.core;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class SizeTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testArea() {
+		fail("Not yet implemented");
+	}
+
+	public void testClone() {
+		fail("Not yet implemented");
+	}
+
+	public void testEqualsObject() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet() {
+		fail("Not yet implemented");
+	}
+
+	public void testSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testSizeDoubleArray() {
+		fail("Not yet implemented");
+	}
+
+	public void testSizeDoubleDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testSizePoint() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/core/TermCriteriaTest.java

+package org.opencv.test.core;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class TermCriteriaTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testClone() {
+		fail("Not yet implemented");
+	}
+
+	public void testEqualsObject() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet() {
+		fail("Not yet implemented");
+	}
+
+	public void testTermCriteria() {
+		fail("Not yet implemented");
+	}
+
+	public void testTermCriteriaDoubleArray() {
+		fail("Not yet implemented");
+	}
+
+	public void testTermCriteriaIntIntDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testToString() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/core/coreTest.java

@@ -145,6 +145,26 @@ public class coreTest extends OpenCVTestCase {
 		assertMatEqual(angle, dst_angle);	
 	}
 
+	public void testCheckRangeMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCheckRangeMatBoolean() {
+		fail("Not yet implemented");
+	}
+
+	public void testCheckRangeMatBooleanPoint() {
+		fail("Not yet implemented");
+	}
+
+	public void testCheckRangeMatBooleanPointDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testCheckRangeMatBooleanPointDoubleDouble() {
+		fail("Not yet implemented");
+	}
+
 	public void testCircleMatPointIntScalar() {
 		Point center = new Point(gray0.cols() / 2, gray0.rows()/2);
 		int radius = Math.min(gray0.cols()/4, gray0.rows()/4);
@@ -213,6 +233,7 @@ public class coreTest extends OpenCVTestCase {
 		assertEquals(pt2Clipped, pt2);
 	}
 
+	
 	public void testCompare() {
         Core.compare(gray0, gray0, dst, Core.CMP_EQ);
         assertMatEqual(dst, gray255);
@@ -369,6 +390,10 @@ public class coreTest extends OpenCVTestCase {
 		assertMatEqual(gray3, dst);
 	}
 
+	public void testEigen() {
+		fail("Not yet implemented");
+	}
+
 	public void testEllipse2Poly() {
 		fail("Not yet implemented");
 	}
@@ -388,7 +413,7 @@ public class coreTest extends OpenCVTestCase {
 	public void testEllipseMatPointSizeDoubleDoubleDoubleScalarIntIntInt() {
 		fail("Not yet implemented");
 	}
-	
+
 	public void testEllipseMatRotatedRectScalar() {
 		fail("Not yet implemented");
 	}
@@ -421,6 +446,34 @@ public class coreTest extends OpenCVTestCase {
 		assertEquals(75.96, res2, delta);		
 	}
 
+	public void testFillConvexPolyMatMatScalar() {
+		fail("Not yet implemented");
+	}
+
+	public void testFillConvexPolyMatMatScalarInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testFillConvexPolyMatMatScalarIntInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testFillPolyMatListOfMatScalar() {
+		fail("Not yet implemented");
+	}
+
+	public void testFillPolyMatListOfMatScalarInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testFillPolyMatListOfMatScalarIntInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testFillPolyMatListOfMatScalarIntIntPoint() {
+		fail("Not yet implemented");
+	}
+
 	public void testFlip() {
 		Mat src = new Mat(2, 2, CvType.CV_32F);
 		Mat des_f0 = new Mat(2, 2, CvType.CV_32F);
@@ -489,6 +542,10 @@ public class coreTest extends OpenCVTestCase {
 		assertMatEqual(desired, dst);
 	}
 
+	public void testGetCPUTickCount() {
+		fail("Not yet implemented");
+	}
+
 	public void testGetOptimalDFTSize() {
 		int vecsize = Core.getOptimalDFTSize(0);
 		assertEquals(1, vecsize);
@@ -503,6 +560,10 @@ public class coreTest extends OpenCVTestCase {
 		fail("Not yet implemented");
 	}
 
+	public void testGetTickCount() {
+		fail("Not yet implemented");
+	}
+
 	public void testGetTickFrequency() {
 		double freq = 0.0;
 		freq = Core.getTickFrequency();
@@ -528,7 +589,7 @@ public class coreTest extends OpenCVTestCase {
 		Core.idct(in, dst);
 		assertMatEqual(truth, dst);
 	}
-
+	
 	public void testIdctMatMatInt() {		
 		Mat in = new Mat(1, 8, CvType.CV_32F);
 		in.put(0, 0, 1.0, 2.0, 1.0, 0.0, 1.0, 2.0, 3.0, 1.0);
@@ -619,11 +680,11 @@ public class coreTest extends OpenCVTestCase {
 		double det = Core.determinant(src);
 		assertTrue(det > 0.0);
 	}
-	
+
 	public void testKmeansMatIntMatTermCriteriaIntInt() {
 		fail("Not yet implemented");
 	}
-	
+
 	public void testKmeansMatIntMatTermCriteriaIntIntMat() {
 		fail("Not yet implemented");
 	}
@@ -655,7 +716,6 @@ public class coreTest extends OpenCVTestCase {
 	public void testLineMatPointPointScalarIntInt() {
 		fail("Not yet implemented");
 	}
-	
 
 	public void testLineMatPointPointScalarIntIntInt() {
 		fail("Not yet implemented");
@@ -747,7 +807,7 @@ public class coreTest extends OpenCVTestCase {
 	public void testMeanMatMat() {
 		fail("Not yet implemented");
 	}
-
+	
 	public void testMeanStdDevMatMatMat() {
 		Mat mean = new Mat();
 		Mat stddev = new Mat();
@@ -756,7 +816,7 @@ public class coreTest extends OpenCVTestCase {
 		assertEquals(0, Core.countNonZero(mean));
 		assertEquals(0, Core.countNonZero(stddev));
 	}
-
+	
 	public void testMeanStdDevMatMatMatMat() {
 		Mat mean = new Mat();
 		Mat stddev = new Mat();
@@ -806,6 +866,7 @@ public class coreTest extends OpenCVTestCase {
 		assertTrue(mmres.minLoc.equals(minLoc)); 
 		assertTrue(mmres.maxLoc.equals(maxLoc));		
 	}
+	
 
 	public void testMinMaxLocMat() {
 		fail("Not yet implemented");
@@ -815,6 +876,10 @@ public class coreTest extends OpenCVTestCase {
 		fail("Not yet implemented");
 	}
 
+	public void testMixChannels() {
+		fail("Not yet implemented");
+	}
+
 	public void testMulSpectrumsMatMatMatInt() {
 		Mat src1 = new Mat(1, 4, CvType.CV_32F);
 		Mat src2 = new Mat(1, 4, CvType.CV_32F);
@@ -968,6 +1033,22 @@ public class coreTest extends OpenCVTestCase {
 		assertEquals(0.0, n);
 	}
 
+	public void testPCABackProject() {
+		fail("Not yet implemented");
+	}
+
+	public void testPCAComputeMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testPCAComputeMatMatMatInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testPCAProject() {
+		fail("Not yet implemented");
+	}
+
 	public void testPerspectiveTransform() {
 		//nice example
 		fail("Not yet implemented");
@@ -1026,6 +1107,22 @@ public class coreTest extends OpenCVTestCase {
 		fail("Not yet implemented");
 	}
 
+	public void testPolylinesMatListOfMatBooleanScalar() {
+		fail("Not yet implemented");
+	}
+
+	public void testPolylinesMatListOfMatBooleanScalarInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testPolylinesMatListOfMatBooleanScalarIntInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testPolylinesMatListOfMatBooleanScalarIntIntInt() {
+		fail("Not yet implemented");
+	}
+
 	public void testPow() {
 		Core.pow(gray3, 2.0, dst);
 		assertMatEqual(gray9, dst);
@@ -1056,6 +1153,14 @@ public class coreTest extends OpenCVTestCase {
         assertTrue(0 != Core.countNonZero(gray0));	
 	}
 
+	public void testRandShuffleMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testRandShuffleMatDouble() {
+		fail("Not yet implemented");
+	}
+
 	public void testRandu() {
         Mat low  = new Mat(1, 1, CvType.CV_16UC1, new Scalar(0));
         Mat high = new Mat(1, 1, CvType.CV_16UC1, new Scalar(256));
@@ -1074,7 +1179,7 @@ public class coreTest extends OpenCVTestCase {
 		Core.rectangle(gray0, center, origin, color);
 		assertTrue(0 != Core.countNonZero(gray0));
 	}
-	
+
 	public void testRectangleMatPointPointScalarInt() {
 		 Point center = new Point(gray0.cols(), gray0.rows());
 		 Point origin = new Point(0,0);
@@ -1104,7 +1209,7 @@ public class coreTest extends OpenCVTestCase {
 		 Core.rectangle(gray0, center, origin, color, 2, 4, 2);
 		 assertTrue(0 != Core.countNonZero(gray0));
 	}
-
+	
 	public void testReduceMatMatIntInt() {
 		Mat src = new Mat(2, 2, CvType.CV_32F);
 		Mat out = new Mat(1, 2, CvType.CV_32F);
@@ -1298,6 +1403,18 @@ public class coreTest extends OpenCVTestCase {
 		fail("Not yet implemented");
 	}
 
+	public void testSVBackSubst() {
+		fail("Not yet implemented");
+	}
+
+	public void testSVDecompMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testSVDecompMatMatMatMatInt() {
+		fail("Not yet implemented");
+	}
+
 	public void testTrace() {
 		fail("Not yet implemented");
 	}

modules/java/android_test/src/org/opencv/test/features2d/KeyPointTest.java

@@ -6,11 +6,11 @@ import org.opencv.test.OpenCVTestCase;
 public class KeyPointTest extends OpenCVTestCase {
 	
 	private KeyPoint keyPoint;
+	private float size;
 	private float x;
 	private float y;
-	private float size;
-	
-    @Override
+
+	@Override
     protected void setUp() throws Exception {
         super.setUp();
         
@@ -19,39 +19,84 @@ public class KeyPointTest extends OpenCVTestCase {
     	y = 2.0f;
     	size = 3.0f;
     }
-	
+
 	public void test_1() {
-		super.test_1("FEATURES2D.KeyPoint");
+		super.test_1("features2d.KeyPoint");
+	}
+
+	public void testGet_angle() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_class_id() {
+		fail("Not yet implemented");
 	}
 
+	public void testGet_octave() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_pt() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_response() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_size() {
+		fail("Not yet implemented");
+	}
+	
 	public void testKeyPoint() {
 		keyPoint = new KeyPoint();
 		assertTrue(null != keyPoint);
 	}
-
 	public void testKeyPointFloatFloatFloat() {
 		keyPoint = new KeyPoint(x, y, size);
 		assertTrue(null != keyPoint);
 	}
-
 	public void testKeyPointFloatFloatFloatFloat() {
 		keyPoint = new KeyPoint(x, y, size, 10.0f);
 		assertTrue(null != keyPoint);
 	}
-
 	public void testKeyPointFloatFloatFloatFloatFloat() {
 		keyPoint = new KeyPoint(x, y, size, 1.0f, 1.0f);
 		assertTrue(null != keyPoint);
 	}
-
-	public void testKeyPointFloatFloatFloatFloatFloatInt() {
+	
+    public void testKeyPointFloatFloatFloatFloatFloatInt() {
 		keyPoint = new KeyPoint(x, y, size, 1.0f, 1.0f, 1);
 		assertTrue(null != keyPoint);
 	}
-
+	
 	public void testKeyPointFloatFloatFloatFloatFloatIntInt() {
 		keyPoint = new KeyPoint(x, y, size, 1.0f, 1.0f, 1, 1);
 		assertTrue(null != keyPoint);
 	}
 
+	public void testSet_angle() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_class_id() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_octave() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_pt() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_response() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_size() {
+		fail("Not yet implemented");
+	}
+
 }

modules/java/android_test/src/org/opencv/test/features2d/SURFTest.java

 package org.opencv.test.features2d;
 
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.opencv.core.Mat;
 import org.opencv.features2d.SURF;
+import org.opencv.features2d.KeyPoint;
 import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
 
 public class SURFTest extends OpenCVTestCase {
 	
 	private SURF surf;
-	
-    @Override
+
+	@Override
     protected void setUp() throws Exception {
         super.setUp();
         
         surf = null;
     }
-    
+
 	public void test_1() {
-		super.test_1("FEATURES2D.SURF");
+		super.test_1("features2d.SURF");
 	}
-
+	
 	public void testDescriptorSize() {
 		surf = new SURF(500.0, 4, 2, false);
 		assertEquals(64, surf.descriptorSize());
@@ -25,6 +32,23 @@ public class SURFTest extends OpenCVTestCase {
 		surf = new SURF(500.0, 4, 2, true);
 		assertEquals(128, surf.descriptorSize());
 	}
+	
+    public void testDetectMatMatListOfKeyPoint() {
+    	surf = new SURF();
+    	List<KeyPoint> keypoints = new LinkedList<KeyPoint>();
+    	
+    	surf.detect(grayChess, new Mat(), keypoints);    	
+    	OpenCVTestRunner.Log("" + keypoints.size());
+		fail("Not yet implemented");
+	}
+    
+	public void testDetectMatMatListOfKeyPointListOfFloat() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMatMatListOfKeyPointListOfFloatBoolean() {
+		fail("Not yet implemented");
+	}
 
 	public void testSURF() {
 		surf = new SURF();

modules/java/android_test/src/org/opencv/test/highgui/VideoCaptureTest.java

@@ -57,7 +57,7 @@ public class VideoCaptureTest extends OpenCVTestCase {
 		assertTrue(isOpened);
 	}
 
-	public void testOpenInt() {
+	public void testOpen() {
 		capture = new VideoCapture();
 		capture.open(Highgui.CV_CAP_ANDROID);
 		isOpened = capture.isOpened();
@@ -65,10 +65,6 @@ public class VideoCaptureTest extends OpenCVTestCase {
 		assertTrue(isOpened);
 	}
 
-	public void testOpenString() {
-		fail("Not yet implemented");
-	}
-
 	public void testRead() {
 		capture = new VideoCapture(Highgui.CV_CAP_ANDROID);
 		isSucceed = capture.read(dst);

modules/java/android_test/src/org/opencv/test/imgproc/MomentsTest.java

+package org.opencv.test.imgproc;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class MomentsTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testGet_m00() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_m01() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_m02() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_m03() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_m10() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_m11() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_m12() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_m20() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_m21() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_m30() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_mu02() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_mu03() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_mu11() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_mu12() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_mu20() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_mu21() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_mu30() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_nu02() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_nu03() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_nu11() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_nu12() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_nu20() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_nu21() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_nu30() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_m00() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_m01() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_m02() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_m03() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_m10() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_m11() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_m12() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_m20() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_m21() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_m30() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_mu02() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_mu03() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_mu11() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_mu12() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_mu20() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_mu21() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_mu30() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_nu02() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_nu03() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_nu11() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_nu12() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_nu20() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_nu21() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_nu30() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvANN_MLPTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvANN_MLPTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testClear() {
+		fail("Not yet implemented");
+	}
+
+	public void testCreateMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCreateMatInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testCreateMatIntDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testCreateMatIntDoubleDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvANN_MLP() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvANN_MLPMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvANN_MLPMatInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvANN_MLPMatIntDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvANN_MLPMatIntDoubleDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredict() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMatMatMatCvANN_MLP_TrainParams() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMatMatMatCvANN_MLP_TrainParamsInt() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvANN_MLP_TrainParamsTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvANN_MLP_TrainParamsTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testGet_bp_dw_scale() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_bp_moment_scale() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_rp_dw_max() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_rp_dw_min() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_rp_dw_minus() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_rp_dw_plus() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_rp_dw0() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_train_method() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_bp_dw_scale() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_bp_moment_scale() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_rp_dw_max() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_rp_dw_min() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_rp_dw_minus() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_rp_dw_plus() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_rp_dw0() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_train_method() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvBoostParamsTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvBoostParamsTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testGet_boost_type() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_split_criteria() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_weak_count() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_weight_trim_rate() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_boost_type() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_split_criteria() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_weak_count() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_weight_trim_rate() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvBoostTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvBoostTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testClear() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvBoost() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvBoostMatIntMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvBoostMatIntMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvBoostMatIntMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvBoostMatIntMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvBoostMatIntMatMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvBoostMatIntMatMatMatMatMatCvBoostParams() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMatMatRange() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMatMatRangeBoolean() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMatMatRangeBooleanBoolean() {
+		fail("Not yet implemented");
+	}
+
+	public void testPrune() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMatMatCvBoostParams() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMatMatCvBoostParamsBoolean() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvDTreeParamsTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvDTreeParamsTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testGet_cv_folds() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_max_categories() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_max_depth() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_min_sample_count() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_regression_accuracy() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_truncate_pruned_tree() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_use_1se_rule() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_use_surrogates() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_cv_folds() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_max_categories() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_max_depth() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_min_sample_count() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_regression_accuracy() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_truncate_pruned_tree() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_use_1se_rule() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_use_surrogates() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvDTreeTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvDTreeTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testClear() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvDTree() {
+		fail("Not yet implemented");
+	}
+
+	public void testGetVarImportance() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMatMatCvDTreeParams() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvEMParamsTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvEMParamsTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testGet_cov_mat_type() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_nclusters() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_start_step() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_cov_mat_type() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_nclusters() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_start_step() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvEMTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvEMTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testCalcLikelihood() {
+		fail("Not yet implemented");
+	}
+
+	public void testClear() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvEM() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvEMMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvEMMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvEMMatMatCvEMParams() {
+		fail("Not yet implemented");
+	}
+
+	public void testGetCovs() {
+		fail("Not yet implemented");
+	}
+
+	public void testGetLikelihood() {
+		fail("Not yet implemented");
+	}
+
+	public void testGetLikelihoodDelta() {
+		fail("Not yet implemented");
+	}
+
+	public void testGetMeans() {
+		fail("Not yet implemented");
+	}
+
+	public void testGetNClusters() {
+		fail("Not yet implemented");
+	}
+
+	public void testGetProbs() {
+		fail("Not yet implemented");
+	}
+
+	public void testGetWeights() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMatCvEMParams() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMatCvEMParamsMat() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvERTreesTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvERTreesTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testCvERTrees() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMatMatCvRTParams() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvGBTreesParamsTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvGBTreesParamsTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testGet_loss_function_type() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_shrinkage() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_subsample_portion() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_weak_count() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_loss_function_type() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_shrinkage() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_subsample_portion() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_weak_count() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvGBTreesTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvGBTreesTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testClear() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvGBTrees() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvGBTreesMatIntMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvGBTreesMatIntMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvGBTreesMatIntMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvGBTreesMatIntMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvGBTreesMatIntMatMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvGBTreesMatIntMatMatMatMatMatCvGBTreesParams() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMatMatRange() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMatMatRangeInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMatMatCvGBTreesParams() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMatMatCvGBTreesParamsBoolean() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvKNearestTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvKNearestTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testCvKNearest() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvKNearestMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvKNearestMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvKNearestMatMatMatBoolean() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvKNearestMatMatMatBooleanInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testFind_nearest() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMatMatBoolean() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMatMatBooleanInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMatMatBooleanIntBoolean() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvNormalBayesClassifierTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvNormalBayesClassifierTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testClear() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvNormalBayesClassifier() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvNormalBayesClassifierMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvNormalBayesClassifierMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvNormalBayesClassifierMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMatMatMatBoolean() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvParamGridTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvParamGridTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testGet_max_val() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_min_val() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_step() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_max_val() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_min_val() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_step() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvRTParamsTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvRTParamsTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testGet_calc_var_importance() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_nactive_vars() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_calc_var_importance() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_nactive_vars() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvRTreesTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvRTreesTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testClear() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvRTrees() {
+		fail("Not yet implemented");
+	}
+
+	public void testGetVarImportance() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredict_probMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredict_probMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatIntMatMatMatMatMatCvRTParams() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvSVMParamsTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvSVMParamsTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testGet_C() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_coef0() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_degree() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_gamma() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_kernel_type() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_nu() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_p() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_svm_type() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_C() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_coef0() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_degree() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_gamma() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_kernel_type() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_nu() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_p() {
+		fail("Not yet implemented");
+	}
+
+	public void testSet_svm_type() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvSVMTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvSVMTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testClear() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvSVM() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvSVMMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvSVMMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvSVMMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testCvSVMMatMatMatMatCvSVMParams() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_support_vector_count() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_var_count() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMatBoolean() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrain_autoMatMatMatMatCvSVMParams() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrain_autoMatMatMatMatCvSVMParamsInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrain_autoMatMatMatMatCvSVMParamsIntCvParamGrid() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrain_autoMatMatMatMatCvSVMParamsIntCvParamGridCvParamGrid() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrain_autoMatMatMatMatCvSVMParamsIntCvParamGridCvParamGridCvParamGrid() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrain_autoMatMatMatMatCvSVMParamsIntCvParamGridCvParamGridCvParamGridCvParamGrid() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrain_autoMatMatMatMatCvSVMParamsIntCvParamGridCvParamGridCvParamGridCvParamGridCvParamGrid() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrain_autoMatMatMatMatCvSVMParamsIntCvParamGridCvParamGridCvParamGridCvParamGridCvParamGridCvParamGrid() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrain_autoMatMatMatMatCvSVMParamsIntCvParamGridCvParamGridCvParamGridCvParamGridCvParamGridCvParamGridBoolean() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testTrainMatMatMatMatCvSVMParams() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/ml/CvStatModelTest.java

+package org.opencv.test.ml;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class CvStatModelTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testLoadString() {
+		fail("Not yet implemented");
+	}
+
+	public void testLoadStringString() {
+		fail("Not yet implemented");
+	}
+
+	public void testSaveString() {
+		fail("Not yet implemented");
+	}
+
+	public void testSaveStringString() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/objdetect/HOGDescriptorTest.java

+package org.opencv.test.objdetect;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class HOGDescriptorTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testCheckDetectorSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testComputeGradientMatMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testComputeGradientMatMatMatSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testComputeGradientMatMatMatSizeSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testComputeMatListOfFloat() {
+		fail("Not yet implemented");
+	}
+
+	public void testComputeMatListOfFloatSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testComputeMatListOfFloatSizeSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testComputeMatListOfFloatSizeSizeListOfPoint() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMatListOfPoint() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMatListOfPointDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMatListOfPointDoubleSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMatListOfPointDoubleSizeSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMatListOfPointDoubleSizeSizeListOfPoint() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMatListOfPointListOfDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMatListOfPointListOfDoubleDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMatListOfPointListOfDoubleDoubleSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMatListOfPointListOfDoubleDoubleSizeSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMatListOfPointListOfDoubleDoubleSizeSizeListOfPoint() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMultiScaleMatListOfRect() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMultiScaleMatListOfRectDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMultiScaleMatListOfRectDoubleSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMultiScaleMatListOfRectDoubleSizeSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMultiScaleMatListOfRectDoubleSizeSizeDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMultiScaleMatListOfRectDoubleSizeSizeDoubleDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMultiScaleMatListOfRectDoubleSizeSizeDoubleDoubleBoolean() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMultiScaleMatListOfRectListOfDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMultiScaleMatListOfRectListOfDoubleDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMultiScaleMatListOfRectListOfDoubleDoubleSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMultiScaleMatListOfRectListOfDoubleDoubleSizeSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMultiScaleMatListOfRectListOfDoubleDoubleSizeSizeDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMultiScaleMatListOfRectListOfDoubleDoubleSizeSizeDoubleDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testDetectMultiScaleMatListOfRectListOfDoubleDoubleSizeSizeDoubleDoubleBoolean() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_blockSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_blockStride() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_cellSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_derivAperture() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_gammaCorrection() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_histogramNormType() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_L2HysThreshold() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_nbins() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_nlevels() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_winSigma() {
+		fail("Not yet implemented");
+	}
+
+	public void testGet_winSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testGetDescriptorSize() {
+		fail("Not yet implemented");
+	}
+
+	public void testGetWinSigma() {
+		fail("Not yet implemented");
+	}
+
+	public void testHOGDescriptor() {
+		fail("Not yet implemented");
+	}
+
+	public void testHOGDescriptorSizeSizeSizeSizeInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testHOGDescriptorSizeSizeSizeSizeIntInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testHOGDescriptorSizeSizeSizeSizeIntIntDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testHOGDescriptorSizeSizeSizeSizeIntIntDoubleInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testHOGDescriptorSizeSizeSizeSizeIntIntDoubleIntDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testHOGDescriptorSizeSizeSizeSizeIntIntDoubleIntDoubleBoolean() {
+		fail("Not yet implemented");
+	}
+
+	public void testHOGDescriptorSizeSizeSizeSizeIntIntDoubleIntDoubleBooleanInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testHOGDescriptorString() {
+		fail("Not yet implemented");
+	}
+
+	public void testLoadString() {
+		fail("Not yet implemented");
+	}
+
+	public void testLoadStringString() {
+		fail("Not yet implemented");
+	}
+
+	public void testSaveString() {
+		fail("Not yet implemented");
+	}
+
+	public void testSaveStringString() {
+		fail("Not yet implemented");
+	}
+
+	public void testSetSVMDetector() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/video/BackgroundSubtractorMOGTest.java

+package org.opencv.test.video;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class BackgroundSubtractorMOGTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testBackgroundSubtractorMOG() {
+		fail("Not yet implemented");
+	}
+
+	public void testBackgroundSubtractorMOGIntIntDouble() {
+		fail("Not yet implemented");
+	}
+
+	public void testBackgroundSubtractorMOGIntIntDoubleDouble() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/video/BackgroundSubtractorTest.java

+package org.opencv.test.video;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class BackgroundSubtractorTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testApplyMatMat() {
+		fail("Not yet implemented");
+	}
+
+	public void testApplyMatMatDouble() {
+		fail("Not yet implemented");
+	}
+
+}

modules/java/android_test/src/org/opencv/test/video/KalmanFilterTest.java

+package org.opencv.test.video;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class KalmanFilterTest extends OpenCVTestCase {
+
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	public void testCorrect() {
+		fail("Not yet implemented");
+	}
+
+	public void testKalmanFilter() {
+		fail("Not yet implemented");
+	}
+
+	public void testKalmanFilterIntInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testKalmanFilterIntIntInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testKalmanFilterIntIntIntInt() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredict() {
+		fail("Not yet implemented");
+	}
+
+	public void testPredictMat() {
+		fail("Not yet implemented");
+	}
+
+}