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 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

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:
        unittest.main()
    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_garbage_information()

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
    
    def assertFloatEqual(self, test, value):
        """Assert equality of test and value with some tolerance.

        Assert that the absolute difference between test and value is
        less than self.fp_epsilon.
        """
        self.assert_(self.fp_epsilon > abs(test - value),
                     "abs(%g - %g) >= %g" % (test, value, self.fp_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.
        """
        if epsilon is None:
            epsilon = self.fp_epsilon
        for i in range(len(test)):
            self.assert_(epsilon > abs(test[i] - value[i]),
                         "abs(%g - %g) >= %g" % (test[i], value[i], epsilon))


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)

class FloatTestCase(unittest.TestCase):
    """TestCase with methods for testing floating point values"""
                                                                                                                                                        
    fp_epsilon = 1e-6
    fp_inf = float('1e1000')   # FIXME: hack for infinite
                                                                                                                                                        
    def assertFloatEqual(self, first, second, msg=None):
        """Fail if one float is greater than the other + fp_epsilon"""
        if abs(first) == self.fp_inf:
            self.assertEqual(first, second, msg)
        else:
            self.assert_(self.fp_epsilon > abs(first - second), msg)

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
25			def add_thuban_dir_to_path():
26			"""Insert the Thuban directory at the beginning of the python path.
27
28			If it's already part of the path, remove later occurrences.
29			"""
30			dir = thuban_dir()
31			while 1:
32			try:
33			sys.path.remove(dir)
34			except ValueError:
35			break
36			sys.path.insert(0, dir)
37
38
39			_initthuban_done = 0
40			def initthuban():
41			"""Initialize the interpreter for using Thuban modules
42			"""
43			global _initthuban_done
44			if not _initthuban_done:
45			add_thuban_dir_to_path()
46			import thubaninit
47			_initthuban_done = 1
48
49	bh	596	def run_tests():
50			"""Frontend for unittest.main that prints some additional debug information
51	bh	292
52	bh	596	After calling unittest.main, run the garbage collector and print
53			uncollected objects. Also print any un-unsubscribed messages.
54			"""
55			try:
56			unittest.main()
57			finally:
58			# This has to be in a finally clause because unittest.main()
59			# ends with a sys.exit to make sure that the process exits with
60			# an appropriate exit code
61			print_garbage_information()
62	bh	292
63	bh	596	def print_garbage_information():
64			"""Print information about things that haven't been cleaned up.
65
66			Run the garbage collector and print uncollected objects. Also print
67			any un-unsubscribed messages.
68			"""
69			import gc, Thuban.Lib.connector
70			gc.collect()
71			if gc.garbage:
72			print
73			print "There are %d uncollected objects:" % len(gc.garbage)
74			print gc.garbage
75			Thuban.Lib.connector._the_connector.print_connections()
76
77
78	bh	292	def create_temp_dir():
79			"""Create a temporary directory and return its name.
80
81			The temporary directory is always called temp and is created in the
82			directory where support module is located.
83
84			If the temp directory already exists, just return the name.
85			"""
86			name = os.path.abspath(os.path.join(os.path.dirname(__file__), "temp"))
87
88			# if the directory already exists, we're done
89			if os.path.isdir(name):
90			return name
91
92			# create the directory
93			os.mkdir(name)
94			return name
95
96
97			class FileTestMixin:
98
99			"""Mixin class for tests that use files in the temporary directory
100			"""
101
102			def temp_file_name(self, basename):
103			"""Return the full name of the file named basename in the temp. dir"""
104			return os.path.join(create_temp_dir(), basename)
105
106			def temp_dir(self):
107			"""Return the name of the directory for the temporary files"""
108			return create_temp_dir()
109	bh	324
110
111	bh	956
112			class FileLoadTestCase(unittest.TestCase, FileTestMixin):
113
114			"""Base class for test case that test loading files.
115
116			This base class provides some common infrastructure for testing the
117			reading of files.
118
119			Each test case should be its own class derived from this one. There
120			is one file associated with each class. The contents are defined by
121			the file_contents class attribute and its name by the filename
122			method.
123
124			Derived classes usually only have to provide appropriate values for
125			the file_contents and file_extension class attributes.
126			"""
127
128			file_contents = None
129			file_extension = ""
130
131			def filename(self):
132			"""Return the name of the test file to use.
133
134			The default implementation simply calls self.volatile_file_name
135			with a basename derived from the class name by stripping off a
136			leading 'test_' and appending self.file_extension.
137			"""
138			name = self.__class__.__name__
139			if name.startswith("test_"):
140			name = name[5:]
141			return self.temp_file_name(name + self.file_extension)
142
143			def setUp(self):
144			"""Create the volatile file for the test.
145
146			Write self.contents (which should be a string) to the file named
147			by self.filename().
148			"""
149			filename = self.filename()
150			file = open(filename, "w")
151			file.write(self.file_contents)
152			file.close()
153
154
155	bh	324	class FloatComparisonMixin:
156
157			"""
158			Mixin class for tests comparing floating point numbers.
159
160			This class provides a few methods for testing floating point
161			operations.
162			"""
163
164			fp_epsilon = 1e-6
165
166			def assertFloatEqual(self, test, value):
167			"""Assert equality of test and value with some tolerance.
168
169			Assert that the absolute difference between test and value is
170			less than self.fp_epsilon.
171			"""
172	bh	342	self.assert_(self.fp_epsilon > abs(test - value),
173			"abs(%g - %g) >= %g" % (test, value, self.fp_epsilon))
174	bh	324
175			def assertFloatSeqEqual(self, test, value, epsilon = None):
176			"""Assert equality of the sequences test and value with some tolerance.
177
178			Assert that the absolute difference between each corresponding
179			value in test and value is less than the optional parameter
180			epsilon. If epsilon is not given use self.fp_epsilon.
181			"""
182			if epsilon is None:
183			epsilon = self.fp_epsilon
184			for i in range(len(test)):
185	bh	342	self.assert_(epsilon > abs(test[i] - value[i]),
186			"abs(%g - %g) >= %g" % (test[i], value[i], epsilon))
187	bh	324
188
189			class SubscriberMixin:
190
191			"""Mixin class for tests for messages sent through the Connector
192
193			The SubscriberMixin has some methods that can be used as subscribers
194			of events that when called append information about the message into
195			a list of messages received.
196
197			A derived class should call the clear_messages() method in both its
198			setUp and tearDown methods to clear the list of messages received.
199			"""
200
201			def clear_messages(self):
202			"""Clear the list of received messages.
203
204			Call this at least in the tests setUp and tearDown methods. It's
205			important to do it in tearDown too because otherwise there may
206			be cyclic references.
207			"""
208			self.received_messages = []
209
210			def subscribe_no_params(self):
211			"""Method for subscriptions without parameters.
212
213			Add an empty tuple to the list of received messages.
214			"""
215			self.received_messages.append(())
216
217			def subscribe_with_params(self, *args):
218			"""Method for subscriptions with parameters.
219
220			Append the tuple will all arguments to this function (except for
221			the self argument) to the list of received messages.
222			"""
223			self.received_messages.append(args)
224
225			def check_messages(self, messages):
226			"""Check whether the messages received match the list messages"""
227			self.assertEquals(messages, self.received_messages)
228	jonathan	904
229			class FloatTestCase(unittest.TestCase):
230			"""TestCase with methods for testing floating point values"""
231
232			fp_epsilon = 1e-6
233			fp_inf = float('1e1000') # FIXME: hack for infinite
234
235			def assertFloatEqual(self, first, second, msg=None):
236			"""Fail if one float is greater than the other + fp_epsilon"""
237			if abs(first) == self.fp_inf:
238			self.assertEqual(first, second, msg)
239			else:
240			self.assert_(self.fp_epsilon > abs(first - second), msg)
241
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision