separated opencv 1.x and opencv 2.x wrappers. moved tests/python/* to modules/python/test

modules/python/CMakeLists.txt

@@ -5,7 +5,8 @@ project(opencv_python)
 
 include_directories(${PYTHON_INCLUDE_PATH})
 include_directories(
-    "${CMAKE_CURRENT_SOURCE_DIR}/src"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src1"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src2"
     "${CMAKE_SOURCE_DIR}/modules/core/include"
     "${CMAKE_SOURCE_DIR}/modules/imgproc/include"
     "${CMAKE_SOURCE_DIR}/modules/video/include"
@@ -30,64 +31,75 @@ set(opencv_hdrs "${CMAKE_SOURCE_DIR}/modules/core/include/opencv2/core/core.hpp"
     "${CMAKE_SOURCE_DIR}/modules/features2d/include/opencv2/features2d/features2d.hpp"
     "${CMAKE_SOURCE_DIR}/modules/calib3d/include/opencv2/calib3d/calib3d.hpp"
     "${CMAKE_SOURCE_DIR}/modules/objdetect/include/opencv2/objdetect/objdetect.hpp"
-    "${CMAKE_SOURCE_DIR}/modules/python/src/opencv_extra_api.hpp")
-
-set(generated_hdrs
-        "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_funcs.h"
-        "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_func_tab.h"
-        "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_types.h"
-        "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_type_reg.h"
-        "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_const_reg.h")
+    "${CMAKE_SOURCE_DIR}/modules/python/src2/opencv_extra_api.hpp")
 
 if(MSVC)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3")
 endif()
 
-file(GLOB lib_srcs "src/*.cpp")
-file(GLOB lib_hdrs "src/*.h")
-
 add_custom_command(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/generated0.i
-   COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/src/gen.py" "${CMAKE_CURRENT_SOURCE_DIR}/src"
-   DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src/api
-   DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src/defs
-   DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src/gen.py
+   COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/src1/gen.py" "${CMAKE_CURRENT_SOURCE_DIR}/src1"
+   DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src1/api
+   DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src1/defs
+   DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src1/gen.py
    )
 
-add_custom_command(
-  OUTPUT ${generated_hdrs}
-  COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/src/gen2.py" ${CMAKE_CURRENT_BINARY_DIR} ${opencv_hdrs}
-  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src/gen2.py
-  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src/hdr_parser.py
-  DEPENDS ${opencv_hdrs}
-  )
-
-set(the_target "opencv_python")
-add_library(${the_target} ${lib_srcs} ${lib_hdrs} ${lib_int_hdrs} ${CMAKE_CURRENT_BINARY_DIR}/generated0.i src/opencv2x.h src/opencv_extra_api.hpp ${generated_hdrs})
-target_link_libraries(${the_target} ${PYTHON_LIBRARIES} opencv_core opencv_imgproc opencv_video opencv_ml opencv_features2d opencv_highgui opencv_calib3d opencv_objdetect opencv_legacy opencv_contrib)
+
+set(cv_target "opencv_python")
+add_library(${cv_target} src1/cv.cpp ${CMAKE_CURRENT_BINARY_DIR}/generated0.i)
+target_link_libraries(${cv_target} ${PYTHON_LIBRARIES} opencv_core opencv_imgproc opencv_video opencv_ml opencv_features2d opencv_highgui opencv_calib3d opencv_objdetect opencv_legacy opencv_contrib)
     
-set_target_properties(${the_target} PROPERTIES PREFIX "")
-set_target_properties(${the_target} PROPERTIES OUTPUT_NAME "cv")
+set_target_properties(${cv_target} PROPERTIES PREFIX "")
+set_target_properties(${cv_target} PROPERTIES OUTPUT_NAME "cv")
 
 execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import distutils.sysconfig; print distutils.sysconfig.get_config_var('SO')"
                 RESULT_VARIABLE PYTHON_CVPY_PROCESS
                 OUTPUT_VARIABLE CVPY_SUFFIX
                 OUTPUT_STRIP_TRAILING_WHITESPACE)
 
-set_target_properties(${the_target} PROPERTIES SUFFIX ${CVPY_SUFFIX})
+set_target_properties(${cv_target} PROPERTIES SUFFIX ${CVPY_SUFFIX})
+
+set(cvpymodules ${cv_target})
+
+if(PYTHON_USE_NUMPY)
+
+set(cv2_generated_hdrs
+    "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_funcs.h"
+    "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_func_tab.h"
+    "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_types.h"
+    "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_type_reg.h"
+    "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_const_reg.h")
 
-set(cvpy_files cv${CVPY_SUFFIX})
+add_custom_command(
+      OUTPUT ${cv2_generated_hdrs}
+      COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/src2/gen2.py" ${CMAKE_CURRENT_BINARY_DIR} ${opencv_hdrs}
+      DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src2/gen2.py
+      DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src2/hdr_parser.py
+      DEPENDS ${opencv_hdrs})
+
+set(cv2_target "opencv2_python")
+add_library(${cv2_target} src2/cv2.cpp src2/opencv_extra_api.hpp ${cv2_generated_headers})
+target_link_libraries(${cv2_target} ${PYTHON_LIBRARIES} opencv_core opencv_imgproc opencv_video opencv_ml opencv_features2d opencv_highgui opencv_calib3d opencv_objdetect opencv_legacy opencv_contrib)
+
+set_target_properties(${cv2_target} PROPERTIES PREFIX "")
+set_target_properties(${cv2_target} PROPERTIES OUTPUT_NAME "cv2")
+set_target_properties(${cv2_target} PROPERTIES SUFFIX ${CVPY_SUFFIX})
+
+set(cvpymodules ${cvpymodules} ${cv2_target})
+
+endif()
 
 if(WIN32)
-    install(TARGETS ${the_target}
-            RUNTIME DESTINATION "Python${PYTHON_VERSION_MAJOR_MINOR}/Lib/site-packages" COMPONENT main
-            LIBRARY DESTINATION "Python${PYTHON_VERSION_MAJOR_MINOR}/Lib/site-packages" COMPONENT main
-            ARCHIVE DESTINATION "Python${PYTHON_VERSION_MAJOR_MINOR}/Lib/site-packages" COMPONENT main
-            )
+  install(TARGETS ${cvpymodules}
+          RUNTIME DESTINATION "Python${PYTHON_VERSION_MAJOR_MINOR}/Lib/site-packages" COMPONENT main
+          LIBRARY DESTINATION "Python${PYTHON_VERSION_MAJOR_MINOR}/Lib/site-packages" COMPONENT main
+          ARCHIVE DESTINATION "Python${PYTHON_VERSION_MAJOR_MINOR}/Lib/site-packages" COMPONENT main
+          )
 else()
-    #install(FILES ${LIBRARY_OUTPUT_PATH}/cv${CVPY_SUFFIX} DESTINATION ${PYTHON_PACKAGES_PATH})
-    install(TARGETS ${the_target} 
-            RUNTIME DESTINATION ${PYTHON_PACKAGES_PATH} COMPONENT main
-            LIBRARY DESTINATION ${PYTHON_PACKAGES_PATH} COMPONENT main
-            ARCHIVE DESTINATION ${PYTHON_PACKAGES_PATH} COMPONENT main)
+  #install(FILES ${LIBRARY_OUTPUT_PATH}/cv${CVPY_SUFFIX} DESTINATION ${PYTHON_PACKAGES_PATH})
+  install(TARGETS ${cvpymodules} 
+          RUNTIME DESTINATION ${PYTHON_PACKAGES_PATH} COMPONENT main
+          LIBRARY DESTINATION ${PYTHON_PACKAGES_PATH} COMPONENT main
+          ARCHIVE DESTINATION ${PYTHON_PACKAGES_PATH} COMPONENT main)
 endif()

modules/python/src/opencv2x.h → modules/python/src2/cv2.cpp

-#ifndef OPENCV2X_PYTHON_WRAPPERS
-#define OPENCV2X_PYTHON_WRAPPERS
+#include <Python.h>
+
+#if !PYTHON_USE_NUMPY
+#error "The module can only be built if NumPy is available"
+#endif
+
+#define MODULESTR "cv2"
+
+#include "numpy/ndarrayobject.h"
 
 #include "opencv2/core/core.hpp"
 #include "opencv2/imgproc/imgproc.hpp"
@@ -12,6 +19,21 @@
 #include "opencv2/highgui/highgui.hpp"
 #include "opencv_extra_api.hpp"
 
+static PyObject* opencv_error = 0;
+
+static int failmsg(const char *fmt, ...)
+{
+    char str[1000];
+    
+    va_list ap;
+    va_start(ap, fmt);
+    vsnprintf(str, sizeof(str), fmt, ap);
+    va_end(ap);
+    
+    PyErr_SetString(PyExc_TypeError, str);
+    return 0;
+}
+
 #define ERRWRAP2(expr) \
 try \
 { \
@@ -693,4 +715,131 @@ static inline PyObject* pyopencv_from(const CvDTreeNode* node)
     return value == ivalue ? PyInt_FromLong(ivalue) : PyFloat_FromDouble(value);
 }
 
+#define MKTYPE2(NAME) pyopencv_##NAME##_specials(); if (!to_ok(&pyopencv_##NAME##_Type)) return
+
+#include "pyopencv_generated_types.h"
+#include "pyopencv_generated_funcs.h"
+
+static PyMethodDef methods[] = {
+
+#include "pyopencv_generated_func_tab.h"
+
+  {NULL, NULL},
+};
+
+/************************************************************************/
+/* Module init */
+
+static int to_ok(PyTypeObject *to)
+{
+  to->tp_alloc = PyType_GenericAlloc;
+  to->tp_new = PyType_GenericNew;
+  to->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;
+  return (PyType_Ready(to) == 0);
+}
+
+extern "C"
+#if defined WIN32 || defined _WIN32
+__declspec(dllexport)
+#endif
+
+void initcv2()
+{
+#if PYTHON_USE_NUMPY
+    import_array();
+#endif
+    
+#if PYTHON_USE_NUMPY
+#include "pyopencv_generated_type_reg.h"
 #endif
+
+  PyObject* m = Py_InitModule(MODULESTR"", methods);
+  PyObject* d = PyModule_GetDict(m);
+
+  PyDict_SetItemString(d, "__version__", PyString_FromString("$Rev: 4557 $"));
+
+  opencv_error = PyErr_NewException((char*)MODULESTR".error", NULL, NULL);
+  PyDict_SetItemString(d, "error", opencv_error);
+
+  // AFAIK the only floating-point constant
+  PyDict_SetItemString(d, "CV_PI", PyFloat_FromDouble(CV_PI));
+
+#define PUBLISH(I) PyDict_SetItemString(d, #I, PyInt_FromLong(I))
+#define PUBLISHU(I) PyDict_SetItemString(d, #I, PyLong_FromUnsignedLong(I))
+#define PUBLISH2(I, value) PyDict_SetItemString(d, #I, PyLong_FromLong(value))
+
+  PUBLISHU(IPL_DEPTH_8U);
+  PUBLISHU(IPL_DEPTH_8S);
+  PUBLISHU(IPL_DEPTH_16U);
+  PUBLISHU(IPL_DEPTH_16S);
+  PUBLISHU(IPL_DEPTH_32S);
+  PUBLISHU(IPL_DEPTH_32F);
+  PUBLISHU(IPL_DEPTH_64F);
+
+  PUBLISH(CV_LOAD_IMAGE_COLOR);
+  PUBLISH(CV_LOAD_IMAGE_GRAYSCALE);
+  PUBLISH(CV_LOAD_IMAGE_UNCHANGED);
+  PUBLISH(CV_HIST_ARRAY);
+  PUBLISH(CV_HIST_SPARSE);
+  PUBLISH(CV_8U);
+  PUBLISH(CV_8UC1);
+  PUBLISH(CV_8UC2);
+  PUBLISH(CV_8UC3);
+  PUBLISH(CV_8UC4);
+  PUBLISH(CV_8S);
+  PUBLISH(CV_8SC1);
+  PUBLISH(CV_8SC2);
+  PUBLISH(CV_8SC3);
+  PUBLISH(CV_8SC4);
+  PUBLISH(CV_16U);
+  PUBLISH(CV_16UC1);
+  PUBLISH(CV_16UC2);
+  PUBLISH(CV_16UC3);
+  PUBLISH(CV_16UC4);
+  PUBLISH(CV_16S);
+  PUBLISH(CV_16SC1);
+  PUBLISH(CV_16SC2);
+  PUBLISH(CV_16SC3);
+  PUBLISH(CV_16SC4);
+  PUBLISH(CV_32S);
+  PUBLISH(CV_32SC1);
+  PUBLISH(CV_32SC2);
+  PUBLISH(CV_32SC3);
+  PUBLISH(CV_32SC4);
+  PUBLISH(CV_32F);
+  PUBLISH(CV_32FC1);
+  PUBLISH(CV_32FC2);
+  PUBLISH(CV_32FC3);
+  PUBLISH(CV_32FC4);
+  PUBLISH(CV_64F);
+  PUBLISH(CV_64FC1);
+  PUBLISH(CV_64FC2);
+  PUBLISH(CV_64FC3);
+  PUBLISH(CV_64FC4);
+  PUBLISH(CV_NEXT_AROUND_ORG);
+  PUBLISH(CV_NEXT_AROUND_DST);
+  PUBLISH(CV_PREV_AROUND_ORG);
+  PUBLISH(CV_PREV_AROUND_DST);
+  PUBLISH(CV_NEXT_AROUND_LEFT);
+  PUBLISH(CV_NEXT_AROUND_RIGHT);
+  PUBLISH(CV_PREV_AROUND_LEFT);
+  PUBLISH(CV_PREV_AROUND_RIGHT);
+
+  PUBLISH(CV_WINDOW_AUTOSIZE);
+
+  PUBLISH(CV_PTLOC_INSIDE);
+  PUBLISH(CV_PTLOC_ON_EDGE);
+  PUBLISH(CV_PTLOC_VERTEX);
+  PUBLISH(CV_PTLOC_OUTSIDE_RECT);
+
+  PUBLISH(GC_BGD);
+  PUBLISH(GC_FGD);
+  PUBLISH(GC_PR_BGD);
+  PUBLISH(GC_PR_FGD);
+  PUBLISH(GC_INIT_WITH_RECT);
+  PUBLISH(GC_INIT_WITH_MASK);
+  PUBLISH(GC_EVAL);
+
+#include "pyopencv_generated_const_reg.h"
+}
+

modules/python/test/goodfeatures.py

+import cv
+import unittest
+
+class TestGoodFeaturesToTrack(unittest.TestCase):
+    def test(self):
+        arr = cv.LoadImage("../samples/c/lena.jpg", 0)
+        original = cv.CloneImage(arr)
+        size = cv.GetSize(arr)
+        eig_image = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
+        temp_image = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
+        threshes = [ x / 100. for x in range(1,10) ]
+
+        results = dict([(t, cv.GoodFeaturesToTrack(arr, eig_image, temp_image, 20000, t, 2, use_harris = 1)) for t in threshes])
+
+        # Check that GoodFeaturesToTrack has not modified input image
+        self.assert_(arr.tostring() == original.tostring())
+
+        # Check for repeatability
+        for i in range(10):
+            results2 = dict([(t, cv.GoodFeaturesToTrack(arr, eig_image, temp_image, 20000, t, 2, use_harris = 1)) for t in threshes])
+            self.assert_(results == results2)
+
+        for t0,t1 in zip(threshes, threshes[1:]):
+             r0 = results[t0]
+             r1 = results[t1]
+
+             # Increasing thresh should make result list shorter
+             self.assert_(len(r0) > len(r1))
+
+             # Increasing thresh should monly truncate result list
+             self.assert_(r0[:len(r1)] == r1)
+
+if __name__ == '__main__':
+    unittest.main()

modules/python/test/leak1.py

+import cv
+import numpy as np
+cv.NamedWindow('Leak')
+while 1:
+    leak = np.random.random((480, 640)) * 255
+    cv.ShowImage('Leak', leak.astype(np.uint8))
+    cv.WaitKey(10)

modules/python/test/leak2.py

+import cv
+import numpy as np
+import time
+
+while True:
+    for i in range(4000):
+        a = cv.CreateImage((1024,1024), cv.IPL_DEPTH_8U, 1)
+        b = cv.CreateMat(1024, 1024, cv.CV_8UC1)
+        c = cv.CreateMatND([1024,1024], cv.CV_8UC1)
+    print "pause..."

modules/python/test/leak3.py

+import cv
+import math
+import time
+
+while True:
+    h = cv.CreateHist([40], cv.CV_HIST_ARRAY, [[0,255]], 1)

modules/python/test/leak4.py

+import cv
+import math
+import time
+
+N=50000
+print "leak4"
+while True:
+    seq=list((i*1., i*1.) for i in range(N))
+    cv.Moments(seq)

modules/python/test/ticket_6.py

+import urllib
+import cv
+import Image
+import unittest
+
+class TestLoadImage(unittest.TestCase):
+    def setUp(self):
+        open("large.jpg", "w").write(urllib.urlopen("http://www.cs.ubc.ca/labs/lci/curious_george/img/ROS_bug_imgs/IMG_3560.jpg").read())
+
+    def test_load(self):
+        pilim = Image.open("large.jpg")
+        cvim = cv.LoadImage("large.jpg")
+        self.assert_(len(pilim.tostring()) == len(cvim.tostring()))
+
+if __name__ == '__main__':
+    unittest.main()

modules/python/test/tickets.py

+import unittest
+import random
+import time
+import math
+import sys
+import array
+import os
+
+import cv
+
+def find_sample(s):
+    for d in ["../samples/c/", "../doc/pics/"]:
+        path = os.path.join(d, s)
+        if os.access(path, os.R_OK):
+            return path
+    return s
+
+class TestTickets(unittest.TestCase):
+
+    def test_2542670(self):
+        xys = [(94, 121), (94, 122), (93, 123), (92, 123), (91, 124), (91, 125), (91, 126), (92, 127), (92, 128), (92, 129), (92, 130), (92, 131), (91, 132), (90, 131), (90, 130), (90, 131), (91, 132), (92, 133), (92, 134), (93, 135), (94, 136), (94, 137), (94, 138), (95, 139), (96, 140), (96, 141), (96, 142), (96, 143), (97, 144), (97, 145), (98, 146), (99, 146), (100, 146), (101, 146), (102, 146), (103, 146), (104, 146), (105, 146), (106, 146), (107, 146), (108, 146), (109, 146), (110, 146), (111, 146), (112, 146), (113, 146), (114, 146), (115, 146), (116, 146), (117, 146), (118, 146), (119, 146), (120, 146), (121, 146), (122, 146), (123, 146), (124, 146), (125, 146), (126, 146), (126, 145), (126, 144), (126, 143), (126, 142), (126, 141), (126, 140), (127, 139), (127, 138), (127, 137), (127, 136), (127, 135), (127, 134), (127, 133), (128, 132), (129, 132), (130, 131), (131, 130), (131, 129), (131, 128), (132, 127), (133, 126), (134, 125), (134, 124), (135, 123), (136, 122), (136, 121), (135, 121), (134, 121), (133, 121), (132, 121), (131, 121), (130, 121), (129, 121), (128, 121), (127, 121), (126, 121), (125, 121), (124, 121), (123, 121), (122, 121), (121, 121), (120, 121), (119, 121), (118, 121), (117, 121), (116, 121), (115, 121), (114, 121), (113, 121), (112, 121), (111, 121), (110, 121), (109, 121), (108, 121), (107, 121), (106, 121), (105, 121), (104, 121), (103, 121), (102, 121), (101, 121), (100, 121), (99, 121), (98, 121), (97, 121), (96, 121), (95, 121)]
+
+        #xys = xys[:12] + xys[16:]
+        pts = cv.CreateMat(len(xys), 1, cv.CV_32SC2)
+        for i,(x,y) in enumerate(xys):
+            pts[i,0] = (x, y)
+        storage = cv.CreateMemStorage()
+        hull = cv.ConvexHull2(pts, storage)
+        hullp = cv.ConvexHull2(pts, storage, return_points = 1)
+        defects = cv.ConvexityDefects(pts, hull, storage)
+
+        vis = cv.CreateImage((1000,1000), 8, 3)
+        x0 = min([x for (x,y) in xys]) - 10
+        x1 = max([x for (x,y) in xys]) + 10
+        y0 = min([y for (y,y) in xys]) - 10
+        y1 = max([y for (y,y) in xys]) + 10
+        def xform(pt):
+            x,y = pt
+            return (1000 * (x - x0) / (x1 - x0),
+                    1000 * (y - y0) / (y1 - y0))
+
+        for d in defects[:2]:
+            cv.Zero(vis)
+
+            # First draw the defect as a red triangle
+            cv.FillConvexPoly(vis, [xform(p) for p in d[:3]], cv.RGB(255,0,0))
+
+            # Draw the convex hull as a thick green line
+            for a,b in zip(hullp, hullp[1:]):
+                cv.Line(vis, xform(a), xform(b), cv.RGB(0,128,0), 3)
+
+            # Draw the original contour as a white line
+            for a,b in zip(xys, xys[1:]):
+                cv.Line(vis, xform(a), xform(b), (255,255,255))
+
+            self.snap(vis)
+
+    def test_2686307(self):
+        lena = cv.LoadImage(find_sample("lena.jpg"), 1)
+        dst = cv.CreateImage((512,512), 8, 3)
+        cv.Set(dst, (128,192,255))
+        mask = cv.CreateImage((512,512), 8, 1)
+        cv.Zero(mask)
+        cv.Rectangle(mask, (10,10), (300,100), 255, -1)
+        cv.Copy(lena, dst, mask)
+        self.snapL([lena, dst, mask])
+        m = cv.CreateMat(480, 640, cv.CV_8UC1)
+        print "ji", m
+        print m.rows, m.cols, m.type, m.step
+
+    def snap(self, img):
+        self.snapL([img])
+
+    def snapL(self, L):
+        for i,img in enumerate(L):
+            cv.NamedWindow("snap-%d" % i, 1)
+            cv.ShowImage("snap-%d" % i, img)
+        cv.WaitKey()
+        cv.DestroyAllWindows()
+
+if __name__ == '__main__':
+    random.seed(0)
+    if len(sys.argv) == 1:
+        suite = unittest.TestLoader().loadTestsFromTestCase(TestTickets)
+        unittest.TextTestRunner(verbosity=2).run(suite)
+    else:
+        suite = unittest.TestSuite()
+        suite.addTest(TestTickets(sys.argv[1]))
+        unittest.TextTestRunner(verbosity=2).run(suite)