removed the obsolete tests from the trunk as well.

tests/CMakeLists.txt

-#ENABLE_TESTING()
-
-#add_subdirectory(cv)
-#add_subdirectory(cxcore)
-#add_subdirectory(ml)
-#add_subdirectory(cxts)
-
-#add_subdirectory(gpu)
-

tests/python/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()

tests/python/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)

tests/python/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..."

tests/python/leak3.py

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

tests/python/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)

tests/python/test_functions.py

-import sys
-import cv
-
-def hs_histogram(src):
-    # Convert to HSV
-    hsv = cv.CreateImage(cv.GetSize(src), 8, 3)
-    cv.CvtColor(src, hsv, cv.CV_BGR2HSV)
-
-    # Extract the H and S planes
-    h_plane = cv.CreateMat(src.rows, src.cols, cv.CV_8UC1)
-    s_plane = cv.CreateMat(src.rows, src.cols, cv.CV_8UC1)
-    cv.Split(hsv, h_plane, s_plane, None, None)
-    planes = [h_plane, s_plane]
-
-    h_bins = 30
-    s_bins = 32
-    hist_size = [h_bins, s_bins]
-    # hue varies from 0 (~0 deg red) to 180 (~360 deg red again */
-    h_ranges = [0, 180]
-    # saturation varies from 0 (black-gray-white) to
-    # 255 (pure spectrum color)
-    s_ranges = [0, 255]
-    ranges = [h_ranges, s_ranges]
-    scale = 10
-    hist = cv.CreateHist([h_bins, s_bins], cv.CV_HIST_ARRAY, ranges, 1)
-    cv.CalcHist([cv.GetImage(i) for i in planes], hist)
-    (_, max_value, _, _) = cv.GetMinMaxHistValue(hist)
-
-    hist_img = cv.CreateImage((h_bins*scale, s_bins*scale), 8, 3)
-
-    for h in range(h_bins):
-        for s in range(s_bins):
-            bin_val = cv.QueryHistValue_2D(hist, h, s)
-            intensity = cv.Round(bin_val * 255 / max_value)
-            cv.Rectangle(hist_img,
-                         (h*scale, s*scale),
-                         ((h+1)*scale - 1, (s+1)*scale - 1),
-                         cv.RGB(intensity, intensity, intensity), 
-                         cv.CV_FILLED)
-    return hist_img
-    
-def precornerdetect(image):
-    # assume that the image is floating-point 
-    corners = cv.CloneMat(image)
-    cv.PreCornerDetect(image, corners, 3)
-    dilated_corners = cv.CloneMat(image)
-    cv.Dilate(corners, dilated_corners, None, 1)
-    corner_mask = cv.CreateMat(image.rows, image.cols, cv.CV_8UC1)
-    cv.Sub(corners, dilated_corners, corners)
-    cv.CmpS(corners, 0, corner_mask, cv.CV_CMP_GE)
-    return (corners, corner_mask)
-
-def findstereocorrespondence(image_left, image_right):
-    # image_left and image_right are the input 8-bit single-channel images
-    # from the left and the right cameras, respectively
-    (r, c) = (image_left.rows, image_left.cols)
-    disparity_left = cv.CreateMat(r, c, cv.CV_16S)
-    disparity_right = cv.CreateMat(r, c, cv.CV_16S)
-    state = cv.CreateStereoGCState(16, 2)
-    cv.FindStereoCorrespondenceGC(image_left, image_right, disparity_left, disparity_right, state, 0)
-    return (disparity_left, disparity_right)

tests/python/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()

tests/python/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)

tests/swig_python/cmp_tests.py

-#!/usr/bin/env python
-import unittest
-import cvtestutils
-from cv import *
-
-class cmp_test(unittest.TestCase):
-    def setUp(self):
-        self.w=17
-        self.h=17
-        self.x0 = cvCreateMat(self.w,self.h,CV_32F)
-        self.x1 = cvCreateMat(self.w,self.h,CV_32F)
-        cvSet(self.x0, cvScalarAll(0.0))
-        cvSet(self.x1, cvScalarAll(1.0))
-    def check_format(self, y):
-        assert( y.rows == self.h )
-        assert( y.cols == self.w )
-        assert( CV_MAT_DEPTH(y.type)==CV_8U )
-    def check_allzero(self, y):
-        assert( cvCountNonZero(y)==0 )
-    def check_all255(self, y):
-        nonzero=cvCountNonZero(y)
-        assert( nonzero==self.w*self.h )
-        sum = cvSum(y)[0]
-        assert( sum == self.w*self.h*255 )
-
-    def test_CvMat_gt(self):
-        y=self.x1>0
-        self.check_format( y )
-        self.check_all255( y )
-        y=self.x0>0
-        self.check_format( y )
-        self.check_allzero( y )
-
-    def test_CvMat_gte(self):
-        y=self.x1>=0
-        self.check_format( y )
-        self.check_all255( y )
-        y=self.x0>=0
-        self.check_format( y )
-        self.check_all255( y )
-
-    def test_CvMat_lt(self):
-        y=self.x1<1
-        self.check_format( y )
-        self.check_allzero( y )
-        y=self.x0<1
-        self.check_format( y )
-        self.check_all255( y )
-
-    def test_CvMat_lte(self):
-        y=self.x1<=1
-        self.check_format( y )
-        self.check_all255( y )
-        y=self.x0<=1
-        self.check_format( y )
-
-def suite():
-    return unittest.TestLoader().loadTestsFromTestCase(cmp_test)
-
-if __name__ == '__main__':
-    unittest.TextTestRunner(verbosity=2).run(suite())

tests/swig_python/cvtestutils.py

-# cvtestutils.py
-#
-# This module is meant to aid writing and running Python-based tests 
-# within the OpenCV tree.  
-#
-# 2009-01-23, Roman Stanchak <rstanchak@gmail.com>
-#
-#
-# Upon importing, this module adds the following python module 
-# directories from the dev tree to sys.path (i.e. PYTHON_PATH):
-#    opencv/interfaces/swig/python and opencv/lib
-#
-# Using it in a test case is simple, just be sure to import 
-# cvtestutils before cv, highgui, etc
-#
-# Usage:
-# import cvtestutils
-# import cv
-
-import os
-import imp
-import sys
-
-def top_srcdir():
-    """
-    Return a string containing the top-level source directory in the OpenCV tree
-    """
-    dir = os.path.dirname(os.path.realpath(__file__))
-
-    # top level dir should be two levels up from this file
-    return os.path.realpath( os.path.join( dir, '..', '..' ) )
-
-def top_builddir():
-    """
-    Return a string containing the top-level build directory in the OpenCV tree.
-    Either returns realpath(argv[1]) or top_srcdir();
-    """
-    if len(sys.argv)>1: return os.path.realpath( sys.argv[1] );
-    else: return top_srcdir();
-
-def initpath():
-    """
-    Prepend the python module directories from the dev tree to sys.path 
-    (i.e. PYTHON_PATH)
-    """
-
-    # add path for OpenCV source directory (for adapters.py)
-    moduledir = os.path.join(top_srcdir(), 'interfaces','swig','python')
-    moduledir = os.path.realpath(moduledir)
-    sys.path.insert(0, moduledir) 
-
-    # add path for OpenCV build directory
-    moduledir = os.path.join(top_builddir(), 'interfaces','swig','python')
-    moduledir = os.path.realpath(moduledir)
-    sys.path.insert(0, moduledir) 
-
-    libdir = os.path.join(top_builddir(), 'lib' )
-    libdir = os.path.realpath(libdir)
-    sys.path.insert(0, libdir)
-
-def which():
-    """
-    Print the directory containing cv.py
-    """
-    import cv 
-    print "Using OpenCV Python in: " + os.path.dirname(cv.__file__)
-
-def datadir():
-    """
-    Return a string containing the full path to the python testdata directory
-    """
-    return os.path.sep.join([top_srcdir(), '..', 'opencv_extra', 'testdata', 'python'])
-
-### Module Initialization
-try:
-    if MODULE_LOADED:
-        pass
-except NameError:
-    initpath()
-    which()
-    MODULE_LOADED=1

tests/swig_python/feature_tree_tests.py

-#!/usr/bin/env python
-
-# 2009-01-16, Xavier Delacour <xavier.delacour@gmail.com>
-
-import unittest
-from numpy import *;
-from numpy.linalg import *;
-import sys;
-import cvtestutils
-from cv import *;
-from adaptors import *;
-
-def planted_neighbors(query_points, R = .4):
-    n,d = query_points.shape
-    data = zeros(query_points.shape)
-    for i in range(0,n):
-        a = random.rand(d)
-        a = random.rand()*R*a/sqrt(sum(a**2))
-        data[i] = query_points[i] + a
-    return data
-
-class feature_tree_test(unittest.TestCase):
-
-    def test_kdtree_basic(self):
-        n = 1000;
-        d = 64;
-        query_points = random.rand(n,d)*2-1;
-        data = planted_neighbors(query_points)
-
-        tr = cvCreateKDTree(data);
-        indices,dist = cvFindFeatures(tr, query_points, 1, 100);
-
-        correct = sum([i == j for j,i in enumerate(indices)])
-        assert(correct >= n * .75);
-
-    def test_spilltree_basic(self):
-        n = 1000;
-        d = 64;
-        query_points = random.rand(n,d)*2-1;
-        data = planted_neighbors(query_points)
-
-        tr = cvCreateSpillTree(data);
-        indices,dist = cvFindFeatures(tr, query_points, 1, 100);
-
-        correct = sum([i == j for j,i in enumerate(indices)])
-        assert(correct >= n * .75);
-
-def suite():
-    return unittest.TestLoader().loadTestsFromTestCase(feature_tree_test)
-
-if __name__ == '__main__':
-    suite = suite()
-    unittest.TextTestRunner(verbosity=2).run(suite)
-

tests/swig_python/highgui/cvCreateFileCapture.py

-"""
-This script will test highgui's video reading functionality
-for a given parameter RAW formats.
-"""
-
-# needed for sys.exit(int) and .works file handling
-import os
-import sys
-import works
-from works import *
-
-# import the necessary things for OpenCV
-from highgui import *
-from cv import *
-
-
-# some defines
-TESTNAME = "cvCreateFileCapture"
-REQUIRED = []
-PREFIX   = os.path.join(os.environ["srcdir"],"../../opencv_extra/testdata/python/videos/qcif_")
-EXTENSION= ".avi"
-
-
-# this functions tries to open a videofile
-# using the filename PREFIX+FORMAT+.EXTENSION  and returns True/False 
-# on success/fail.
-
-def video_ok( FORMAT ):
-	
-	# check requirements and delete old .works file
-	if not works.check_files( REQUIRED, TESTNAME+FORMAT ):
-		return false
-
-	filename = PREFIX+FORMAT+EXTENSION
-	video = cvCreateFileCapture(PREFIX+FORMAT+EXTENSION)
-	if video is None:
-		sys.exit(1)
-	works.set_file( TESTNAME+FORMAT )
-	return True

tests/swig_python/highgui/cvCreateFileCaptureRGB.py

-#! /usr/bin/env python
-"""
-This script will test highgui's video reading functionality
-for RAW RGB .avi files
-"""
-
-# pixel format to check
-FORMAT   = "RGB"
-
-# import check routine
-import cvCreateFileCapture
-
-# check video file of format FORMAT,
-# the function also exits and returns
-# 0,1 or 77 accordingly.
-
-cvCreateFileCapture.video_ok(FORMAT)
-

tests/swig_python/highgui/cvCreateFileCaptureRGBA.py

-#! /usr/bin/env python
-"""
-This script will test highgui's video reading functionality
-for RAW RGBA (dummy alpha channel) .avi files
-"""
-
-# pixel format to check
-FORMAT   = "RGBA"
-
-# import check routine
-import cvCreateFileCapture
-
-# check video file of format FORMAT,
-# the function also exits and returns
-# 0,1 or 77 accordingly.
-
-cvCreateFileCapture.video_ok(FORMAT)

tests/swig_python/highgui/cvCreateFileCaptureUYVY.py

-#! /usr/bin/env python
-"""
-This script will test highgui's video reading functionality
-for RAW UYVY .avi files
-"""
-
-# pixel format to check
-FORMAT   = "UYVY"
-
-# import check routine
-import cvCreateFileCapture
-
-# check video file of format FORMAT,
-# the function also exits and returns
-# 0,1 or 77 accordingly.
-
-cvCreateFileCapture.video_ok(FORMAT)

tests/swig_python/highgui/cvCreateFileCaptureY8.py

-#! /usr/bin/env python
-"""
-This script will test highgui's video reading functionality
-for RAW Y8 (luminance only) .avi files
-"""
-
-# pixel format to check
-FORMAT   = "Y8"
-
-# import check routine
-import cvCreateFileCapture
-
-# check video file of format FORMAT,
-# the function also exits and returns
-# 0,1 or 77 accordingly.
-
-cvCreateFileCapture.video_ok(FORMAT)

tests/swig_python/highgui/cvCreateFileCaptureYUY2.py

-#! /usr/bin/env python
-"""
-This script will test highgui's video reading functionality
-for RAW YUY2 .avi files
-"""
-
-# pixel format to check
-FORMAT   = "YUY2"
-
-# import check routine
-import cvCreateFileCapture
-
-# check video file of format FORMAT,
-# the function also exits and returns
-# 0,1 or 77 accordingly.
-
-cvCreateFileCapture.video_ok(FORMAT)

tests/swig_python/highgui/cvCreateFileCaptureYV12.py

-#! /usr/bin/env python
-"""
-This script will test highgui's video reading functionality
-for RAW YV12 .avi files
-"""
-
-# pixel format to check
-FORMAT   = "YV12"
-
-# import check routine
-import cvCreateFileCapture
-
-# check video file of format FORMAT,
-# the function also exits and returns
-# 0,1 or 77 accordingly.
-
-cvCreateFileCapture.video_ok(FORMAT)

tests/swig_python/highgui/cvCreateFileCaptureYV16.py

-#! /usr/bin/env python
-"""
-This script will test highgui's video reading functionality
-for RAW YV16 .avi files
-"""
-
-# pixel format to check
-FORMAT   = "YV16"
-
-# import check routine
-import cvCreateFileCapture
-
-# check video file of format FORMAT,
-# the function also exits and returns
-# 0,1 or 77 accordingly.
-
-cvCreateFileCapture.video_ok(FORMAT)

tests/swig_python/highgui/cvCreateFileCaptureYVU9.py

-#! /usr/bin/env python
-"""
-This script will test highgui's video reading functionality
-for RAW YVU9 .avi files
-"""
-
-# pixel format to check
-FORMAT   = "YVU9"
-
-# import check routine
-import cvCreateFileCapture
-
-# check video file of format FORMAT,
-# the function also exits and returns
-# 0,1 or 77 accordingly.
-
-cvCreateFileCapture.video_ok(FORMAT)

tests/swig_python/highgui/cvCreateTrackbar.py

-#! /usr/bin/env python
-"""
-This script will test highgui's trackbar functionality
-"""
-
-# name if this test and it's requirements
-TESTNAME = "cvCreateTrackbar"
-REQUIRED = ["cvShowImage"]
-
-# needed for sys.exit(int) and .works file handling
-import os
-import sys
-import works
-
-# check requirements and delete old flag file, if it exists
-if not works.check_files(REQUIRED,TESTNAME):
-	sys.exit(77)
-
-# import the necessary things for OpenCV
-from highgui import *
-from cv import *
-
-# some definitions
-win_name = "testing..."
-bar_name = "brightness"
-bar_count= 100
-
-
-# position of imagefiles we need
-PREFIX=os.path.join(os.environ["srcdir"],"../../opencv_extra/testdata/python/images/")
-
-# 'moved' indicates if trackbar has been moved
-moved = False
-
-# 'range' indicates if trackbar was outside range [0..bar_count]
-range = False
-
-
-# function to call on a trackbar event
-def trackcall( p ):
-	# Trackbar position must be in [0..bar_count]
-	if (p > bar_count or p < 0):
-		globals()["range"] = True
-
-	cvConvertScale( image, image2,float(p)/float(bar_count) )
-	cvShowImage( win_name, image2 );
-	globals()["moved"] = True
-
-
-# create output window
-cvNamedWindow(win_name,CV_WINDOW_AUTOSIZE)
-image  = cvLoadImage(PREFIX+"cvCreateTrackbar.jpg")
-image2 = cvLoadImage(PREFIX+"cvCreateTrackbar.jpg")
-cvShowImage(win_name,image)
-
-# create the trackbar and save return value
-res = cvCreateTrackbar( bar_name, win_name, 0, bar_count, trackcall )
-
-# check return value
-if res == 0:
-	# something went wrong, so return an error code
-	print "(ERROR) Couldn't create trackbar."
-	sys.exit(1)
-	
-# init. window with image
-trackcall(bar_count/2)
-# reset 'moved' indicator
-moved = False
-
-# now give the user 20 seconds to do some input
-print "(INFO) Please move trackbar within the next 20 SECONDS to 'PASS' this test."
-print "(HINT) You can complete this test prematurely by pressing any key."
-print "(INFO) In the case of no user input, the test will be remarked as 'FAIL'."
-
-key = cvWaitKey(20000)
-
-if range:
-	# trackbar position value was outside allowed range [0..bar_count]
-	print "(ERROR) Trackbar position was outside range."
-	sys.exit(1)
-
-if not moved and (key==-1):
-	# trackbar has not been moved
-	print "(ERROR) No user input detected."
-	sys.exit(1)
-elif not moved and (key>0):
-	# 20sec. passed, trackbar has been moved
-	print "(INFO) No trackbar movement detected (but key pressed)."
-	sys.exit(77)
-
-# create flag file for following tests
-works.set_file(TESTNAME)
-
-# return 0 ('PASS')
-sys.exit(0)

tests/swig_python/highgui/cvGetWindowHandleName.py

-#! /usr/bin/env python
-"""
-This script will test highgui's window handle/name functionality
-"""
-
-# name of this test and it's requirements
-TESTNAME = "cvGetWindowHandleName"
-REQUIRED = ["cvNamedWindow"]
-
- 
-# needed for sys.exit(int) and .works file handling
-import sys
-import works
-
-# check requirements and delete old flag file, if it exists
-if not works.check_files(REQUIRED,TESTNAME):
-	sys.exit(77)
-
-# import the necessary things for OpenCV
-from highgui import *
-from cv import *
-
-
-# some definitions
-win_name = "testing..."
-
-# create a window ( 'cvNamedWindow.works' says: "Ok, go for it!" )
-cvNamedWindow(win_name,CV_WINDOW_AUTOSIZE)
-
-# check if the window handle and the according name are correct
-win_name_2 = cvGetWindowName( cvGetWindowHandle(win_name) )
-if win_name_2!=win_name:
-#	print "(ERROR) Incorrect window handle/name."
-	sys.exit(1)
-
-# destroy the window
-cvDestroyWindow( win_name )
-
-# create flag file for following tests
-works.set_file(TESTNAME)
-
-# return 0 ('PASS')
-sys.exit(0)

tests/swig_python/highgui/frames.py

-QCIF=["QCIF_00.bmp","QCIF_01.bmp","QCIF_02.bmp","QCIF_03.bmp","QCIF_04.bmp","QCIF_05.bmp",
-      "QCIF_06.bmp","QCIF_07.bmp","QCIF_08.bmp","QCIF_09.bmp","QCIF_10.bmp","QCIF_11.bmp",
-      "QCIF_12.bmp","QCIF_13.bmp","QCIF_14.bmp","QCIF_15.bmp","QCIF_16.bmp","QCIF_17.bmp",
-      "QCIF_18.bmp","QCIF_19.bmp","QCIF_20.bmp","QCIF_21.bmp","QCIF_22.bmp","QCIF_23.bmp",
-      "QCIF_24.bmp","QCIF_25.bmp","QCIF_26.bmp","QCIF_27.bmp","QCIF_28.bmp","QCIF_29.bmp"]