WIP-pyshapelib-bramz/test/support.py

# Copyright (c) 2002, 2003 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""
Support classes and function for the test suite
"""

__version__ = "$Revision$"
# $Source$
# $Id$

import os, sys
import unittest

def thuban_dir():
    """Return the directory containing the Thuban package"""
    thisdir = os.path.dirname(__file__)
    return os.path.join(thisdir, os.pardir)

def resource_dir():
    return os.path.join(thuban_dir(), "Resources")

def add_thuban_dir_to_path():
    """Insert the Thuban directory at the beginning of the python path.

    If it's already part of the path, remove later occurrences.
    """
    dir = thuban_dir()
    while 1:
        try:
            sys.path.remove(dir)
        except ValueError:
            break
    sys.path.insert(0, dir)


_initthuban_done = 0
def initthuban():
    """Initialize the interpreter for using Thuban modules
    """
    global _initthuban_done
    if not _initthuban_done:
        add_thuban_dir_to_path()
        import thubaninit
        _initthuban_done = 1


#
# Special test runner and result that support skipping tests
#

class SkipTest(Exception):
    """Exception to raise in tests that are skipped for some reason

    For instance, since gdal support is optional, test cases that
    require gdal raise this exception to indicate that they are skipped.
    Skipped is different from failure or error in that it is expected
    under certain circumstances.
    """

class ThubanTestResult(unittest._TextTestResult):

    def __init__(self, stream, descriptions, verbosity):
        unittest._TextTestResult.__init__(self, stream, descriptions,
                                          verbosity)
        self.skipped_tests = {}

    def add_skipped_test(self, test, exc):
        reason = str(exc)
        self.skipped_tests.setdefault(reason, []).append(test)

    def count_skipped(self):
        sum = 0
        for tests in self.skipped_tests.values():
            sum += len(tests)
        return sum

    def addError(self, test, err):
        """Extend inherited method to handle SkipTest exceptions specially
        """
        #print "addError", test, err
        if isinstance(err[1], SkipTest):
            self.add_skipped_test(test, err[1])
            if self.showAll:
                self.stream.writeln("skipped")
            elif self.dots:
                self.stream.write('S')
        else:
            unittest._TextTestResult.addError(self, test, err)

    def printErrors(self):
        if self.skipped_tests:
            if self.dots or self.showAll:
                self.stream.writeln()
            self.stream.writeln("Skipped tests:")
            for reason, tests in self.skipped_tests.items():
                self.stream.writeln("%s:" % reason)
                for test in tests:
                    self.stream.writeln("    " + test.id())
        unittest._TextTestResult.printErrors(self)


class ThubanTestRunner(unittest.TextTestRunner):

    def _makeResult(self):
        return ThubanTestResult(self.stream, self.descriptions, self.verbosity)

    def run(self, test):
        result = unittest.TextTestRunner.run(self, test)
        self.stream.writeln("skipped = %d" % result.count_skipped())
        return result


class ThubanTestProgram(unittest.TestProgram):

    def runTests(self):
        """Extend inherited method so that we use a ThubanTestRunner"""
        print "ThubanTestProgram.runTests"
        self.testRunner = ThubanTestRunner(verbosity = self.verbosity)
        unittest.TestProgram.runTests(self)


def run_tests():
    """Frontend for unittest.main that prints some additional debug information

    After calling unittest.main, run the garbage collector and print
    uncollected objects. Also print any un-unsubscribed messages.
    """
    try:
        ThubanTestProgram()
    finally:
        # This has to be in a finally clause because unittest.main()
        # ends with a sys.exit to make sure that the process exits with
        # an appropriate exit code
        print_additional_summary()

def print_additional_summary():
    """Print some additional summary information after tests have been run"""
    print_garbage_information()
    import xmlsupport
    xmlsupport.print_summary_message()

def print_garbage_information():
    """Print information about things that haven't been cleaned up.

    Run the garbage collector and print uncollected objects. Also print
    any un-unsubscribed messages.
    """
    import gc, Thuban.Lib.connector
    gc.collect()
    if gc.garbage:
        print
        print "There are %d uncollected objects:" % len(gc.garbage)
        print gc.garbage
    Thuban.Lib.connector._the_connector.print_connections()

#

def create_temp_dir():
    """Create a temporary directory and return its name.

    The temporary directory is always called temp and is created in the
    directory where support module is located.

    If the temp directory already exists, just return the name.
    """
    name = os.path.abspath(os.path.join(os.path.dirname(__file__), "temp"))

    # if the directory already exists, we're done
    if os.path.isdir(name):
        return name

    # create the directory
    os.mkdir(name)
    return name


class FileTestMixin:

    """Mixin class for tests that use files in the temporary directory
    """

    def temp_file_name(self, basename):
        """Return the full name of the file named basename in the temp. dir"""
        return os.path.join(create_temp_dir(), basename)

    def temp_dir(self):
        """Return the name of the directory for the temporary files"""
        return create_temp_dir()


class FileLoadTestCase(unittest.TestCase, FileTestMixin):

    """Base class for test case that test loading files.

    This base class provides some common infrastructure for testing the
    reading of files.

    Each test case should be its own class derived from this one. There
    is one file associated with each class. The contents are defined by
    the file_contents class attribute and its name by the filename
    method.

    Derived classes usually only have to provide appropriate values for
    the file_contents and file_extension class attributes.
    """

    file_contents = None
    file_extension = ""

    def filename(self):
        """Return the name of the test file to use.

        The default implementation simply calls self.volatile_file_name
        with a basename derived from the class name by stripping off a
        leading 'test_' and appending self.file_extension.
        """
        name = self.__class__.__name__
        if name.startswith("test_"):
            name = name[5:]
        return self.temp_file_name(name + self.file_extension)

    def setUp(self):
        """Create the volatile file for the test.

        Write self.contents (which should be a string) to the file named
        by self.filename().
        """
        filename = self.filename()
        file = open(filename, "w")
        file.write(self.file_contents)
        file.close()


class FloatComparisonMixin:

    """
    Mixin class for tests comparing floating point numbers.

    This class provides a few methods for testing floating point
    operations.
    """

    fp_epsilon = 1e-6
    fp_inf = float('1e1000')   # FIXME: hack for infinite

    def assertFloatEqual(self, test, value, epsilon = None):
        """Assert equality of test and value with some tolerance.

        Assert that the absolute difference between test and value is
        less than self.fp_epsilon.
        """
        if epsilon is None:
            epsilon = self.fp_epsilon
        if abs(test) == self.fp_inf:
            self.assertEqual(test, value)
        else:
            self.assert_(epsilon > abs(test - value),
                     "abs(%g - %g) >= %g" % (test, value, epsilon))

    def assertFloatSeqEqual(self, test, value, epsilon = None):
        """Assert equality of the sequences test and value with some tolerance.

        Assert that the absolute difference between each corresponding
        value in test and value is less than the optional parameter
        epsilon. If epsilon is not given use self.fp_epsilon.
        """
        for i in range(len(test)):
            self.assertFloatEqual(test[i], value[i], epsilon)

    def assertPointListEquals(self, test, value):
        """Assert equality of two lists of lists of tuples of float

        This assertion is usually used to compare the geometry of shapes
        as returned by a Shape object's Points() method, hence the name.
        """
        for i in range(len(test)):
            self.assertEquals(len(test[i]), len(value[i]))
            for j in range(len(test[i])):
                self.assertFloatSeqEqual(test[i][j], value[i][j])


class SubscriberMixin:

    """Mixin class for tests for messages sent through the Connector

    The SubscriberMixin has some methods that can be used as subscribers
    of events that when called append information about the message into
    a list of messages received.

    A derived class should call the clear_messages() method in both its
    setUp and tearDown methods to clear the list of messages received.
    """

    def clear_messages(self):
        """Clear the list of received messages.

        Call this at least in the tests setUp and tearDown methods. It's
        important to do it in tearDown too because otherwise there may
        be cyclic references.
        """
        self.received_messages = []

    def subscribe_no_params(self):
        """Method for subscriptions without parameters.

        Add an empty tuple to the list of received messages.
        """
        self.received_messages.append(())

    def subscribe_with_params(self, *args):
        """Method for subscriptions with parameters.

        Append the tuple will all arguments to this function (except for
        the self argument) to the list of received messages.
        """
        self.received_messages.append(args)

    def check_messages(self, messages):
        """Check whether the messages received match the list messages"""
        self.assertEquals(messages, self.received_messages)

1	bh	596	# Copyright (c) 2002, 2003 by Intevation GmbH
2	bh	292	# Authors:
3			# Bernhard Herzog <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with Thuban for details.
7
8			"""
9			Support classes and function for the test suite
10			"""
11
12			__version__ = "$Revision$"
13			# $Source$
14			# $Id$
15
16			import os, sys
17			import unittest
18
19			def thuban_dir():
20			"""Return the directory containing the Thuban package"""
21			thisdir = os.path.dirname(__file__)
22			return os.path.join(thisdir, os.pardir)
23
24	bh	1245	def resource_dir():
25			return os.path.join(thuban_dir(), "Resources")
26	bh	292
27			def add_thuban_dir_to_path():
28			"""Insert the Thuban directory at the beginning of the python path.
29
30			If it's already part of the path, remove later occurrences.
31			"""
32			dir = thuban_dir()
33			while 1:
34			try:
35			sys.path.remove(dir)
36			except ValueError:
37			break
38			sys.path.insert(0, dir)
39
40
41			_initthuban_done = 0
42			def initthuban():
43			"""Initialize the interpreter for using Thuban modules
44			"""
45			global _initthuban_done
46			if not _initthuban_done:
47			add_thuban_dir_to_path()
48			import thubaninit
49			_initthuban_done = 1
50
51	bh	1555
52			#
53			# Special test runner and result that support skipping tests
54			#
55
56			class SkipTest(Exception):
57			"""Exception to raise in tests that are skipped for some reason
58
59			For instance, since gdal support is optional, test cases that
60			require gdal raise this exception to indicate that they are skipped.
61			Skipped is different from failure or error in that it is expected
62			under certain circumstances.
63			"""
64
65			class ThubanTestResult(unittest._TextTestResult):
66
67			def __init__(self, stream, descriptions, verbosity):
68			unittest._TextTestResult.__init__(self, stream, descriptions,
69			verbosity)
70			self.skipped_tests = {}
71
72			def add_skipped_test(self, test, exc):
73			reason = str(exc)
74			self.skipped_tests.setdefault(reason, []).append(test)
75
76			def count_skipped(self):
77			sum = 0
78			for tests in self.skipped_tests.values():
79			sum += len(tests)
80			return sum
81
82			def addError(self, test, err):
83			"""Extend inherited method to handle SkipTest exceptions specially
84			"""
85			#print "addError", test, err
86			if isinstance(err[1], SkipTest):
87			self.add_skipped_test(test, err[1])
88			if self.showAll:
89			self.stream.writeln("skipped")
90			elif self.dots:
91			self.stream.write('S')
92			else:
93			unittest._TextTestResult.addError(self, test, err)
94
95			def printErrors(self):
96			if self.skipped_tests:
97			if self.dots or self.showAll:
98			self.stream.writeln()
99			self.stream.writeln("Skipped tests:")
100			for reason, tests in self.skipped_tests.items():
101			self.stream.writeln("%s:" % reason)
102			for test in tests:
103			self.stream.writeln(" " + test.id())
104			unittest._TextTestResult.printErrors(self)
105
106
107			class ThubanTestRunner(unittest.TextTestRunner):
108
109			def _makeResult(self):
110			return ThubanTestResult(self.stream, self.descriptions, self.verbosity)
111
112			def run(self, test):
113			result = unittest.TextTestRunner.run(self, test)
114			self.stream.writeln("skipped = %d" % result.count_skipped())
115			return result
116
117
118			class ThubanTestProgram(unittest.TestProgram):
119
120			def runTests(self):
121			"""Extend inherited method so that we use a ThubanTestRunner"""
122			print "ThubanTestProgram.runTests"
123			self.testRunner = ThubanTestRunner(verbosity = self.verbosity)
124			unittest.TestProgram.runTests(self)
125
126
127	bh	596	def run_tests():
128			"""Frontend for unittest.main that prints some additional debug information
129	bh	292
130	bh	596	After calling unittest.main, run the garbage collector and print
131			uncollected objects. Also print any un-unsubscribed messages.
132			"""
133			try:
134	bh	1555	ThubanTestProgram()
135	bh	596	finally:
136			# This has to be in a finally clause because unittest.main()
137			# ends with a sys.exit to make sure that the process exits with
138			# an appropriate exit code
139	bh	1245	print_additional_summary()
140	bh	292
141	bh	1245	def print_additional_summary():
142			"""Print some additional summary information after tests have been run"""
143			print_garbage_information()
144			import xmlsupport
145			xmlsupport.print_summary_message()
146
147	bh	596	def print_garbage_information():
148			"""Print information about things that haven't been cleaned up.
149
150			Run the garbage collector and print uncollected objects. Also print
151			any un-unsubscribed messages.
152			"""
153			import gc, Thuban.Lib.connector
154			gc.collect()
155			if gc.garbage:
156			print
157			print "There are %d uncollected objects:" % len(gc.garbage)
158			print gc.garbage
159			Thuban.Lib.connector._the_connector.print_connections()
160
161	bh	1555	#
162	bh	596
163	bh	292	def create_temp_dir():
164			"""Create a temporary directory and return its name.
165
166			The temporary directory is always called temp and is created in the
167			directory where support module is located.
168
169			If the temp directory already exists, just return the name.
170			"""
171			name = os.path.abspath(os.path.join(os.path.dirname(__file__), "temp"))
172
173			# if the directory already exists, we're done
174			if os.path.isdir(name):
175			return name
176
177			# create the directory
178			os.mkdir(name)
179			return name
180
181
182			class FileTestMixin:
183
184			"""Mixin class for tests that use files in the temporary directory
185			"""
186
187			def temp_file_name(self, basename):
188			"""Return the full name of the file named basename in the temp. dir"""
189			return os.path.join(create_temp_dir(), basename)
190
191			def temp_dir(self):
192			"""Return the name of the directory for the temporary files"""
193			return create_temp_dir()
194	bh	324
195
196	bh	956
197			class FileLoadTestCase(unittest.TestCase, FileTestMixin):
198
199			"""Base class for test case that test loading files.
200
201			This base class provides some common infrastructure for testing the
202			reading of files.
203
204			Each test case should be its own class derived from this one. There
205			is one file associated with each class. The contents are defined by
206			the file_contents class attribute and its name by the filename
207			method.
208
209			Derived classes usually only have to provide appropriate values for
210			the file_contents and file_extension class attributes.
211			"""
212
213			file_contents = None
214			file_extension = ""
215
216			def filename(self):
217			"""Return the name of the test file to use.
218
219			The default implementation simply calls self.volatile_file_name
220			with a basename derived from the class name by stripping off a
221			leading 'test_' and appending self.file_extension.
222			"""
223			name = self.__class__.__name__
224			if name.startswith("test_"):
225			name = name[5:]
226			return self.temp_file_name(name + self.file_extension)
227
228			def setUp(self):
229			"""Create the volatile file for the test.
230
231			Write self.contents (which should be a string) to the file named
232			by self.filename().
233			"""
234			filename = self.filename()
235			file = open(filename, "w")
236			file.write(self.file_contents)
237			file.close()
238
239
240	bh	1421	class FloatComparisonMixin:
241	bh	324
242			"""
243			Mixin class for tests comparing floating point numbers.
244
245			This class provides a few methods for testing floating point
246			operations.
247			"""
248
249			fp_epsilon = 1e-6
250	jonathan	1263	fp_inf = float('1e1000') # FIXME: hack for infinite
251	bh	1574
252	jonathan	1397	def assertFloatEqual(self, test, value, epsilon = None):
253	bh	324	"""Assert equality of test and value with some tolerance.
254
255			Assert that the absolute difference between test and value is
256			less than self.fp_epsilon.
257			"""
258	jonathan	1397	if epsilon is None:
259			epsilon = self.fp_epsilon
260	jonathan	1263	if abs(test) == self.fp_inf:
261			self.assertEqual(test, value)
262			else:
263	jonathan	1397	self.assert_(epsilon > abs(test - value),
264			"abs(%g - %g) >= %g" % (test, value, epsilon))
265	bh	324
266			def assertFloatSeqEqual(self, test, value, epsilon = None):
267			"""Assert equality of the sequences test and value with some tolerance.
268
269			Assert that the absolute difference between each corresponding
270			value in test and value is less than the optional parameter
271			epsilon. If epsilon is not given use self.fp_epsilon.
272			"""
273			for i in range(len(test)):
274	jonathan	1397	self.assertFloatEqual(test[i], value[i], epsilon)
275	bh	324
276	bh	1574	def assertPointListEquals(self, test, value):
277			"""Assert equality of two lists of lists of tuples of float
278
279			This assertion is usually used to compare the geometry of shapes
280			as returned by a Shape object's Points() method, hence the name.
281			"""
282			for i in range(len(test)):
283			self.assertEquals(len(test[i]), len(value[i]))
284			for j in range(len(test[i])):
285			self.assertFloatSeqEqual(test[i][j], value[i][j])
286
287
288	bh	324	class SubscriberMixin:
289
290			"""Mixin class for tests for messages sent through the Connector
291
292			The SubscriberMixin has some methods that can be used as subscribers
293			of events that when called append information about the message into
294			a list of messages received.
295
296			A derived class should call the clear_messages() method in both its
297			setUp and tearDown methods to clear the list of messages received.
298			"""
299
300			def clear_messages(self):
301			"""Clear the list of received messages.
302
303			Call this at least in the tests setUp and tearDown methods. It's
304			important to do it in tearDown too because otherwise there may
305			be cyclic references.
306			"""
307			self.received_messages = []
308
309			def subscribe_no_params(self):
310			"""Method for subscriptions without parameters.
311
312			Add an empty tuple to the list of received messages.
313			"""
314			self.received_messages.append(())
315
316			def subscribe_with_params(self, *args):
317			"""Method for subscriptions with parameters.
318
319			Append the tuple will all arguments to this function (except for
320			the self argument) to the list of received messages.
321			"""
322			self.received_messages.append(args)
323
324			def check_messages(self, messages):
325			"""Check whether the messages received match the list messages"""
326			self.assertEquals(messages, self.received_messages)
327	jonathan	904
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision