Initial import to Tizen
[profile/ivi/python-pyOpenSSL.git] / OpenSSL / test / util.py
1 # Copyright (C) Jean-Paul Calderone
2 # Copyright (C) Twisted Matrix Laboratories.
3 # See LICENSE for details.
4
5 """
6 Helpers for the OpenSSL test suite, largely copied from
7 U{Twisted<http://twistedmatrix.com/>}.
8 """
9
10 import shutil
11 import os, os.path
12 from tempfile import mktemp
13 from unittest import TestCase
14 import sys
15
16 from OpenSSL.crypto import Error, _exception_from_error_queue
17
18 if sys.version_info < (3, 0):
19     def b(s):
20         return s
21     bytes = str
22 else:
23     def b(s):
24         return s.encode("charmap")
25     bytes = bytes
26
27
28 class TestCase(TestCase):
29     """
30     L{TestCase} adds useful testing functionality beyond what is available
31     from the standard library L{unittest.TestCase}.
32     """
33     def tearDown(self):
34         """
35         Clean up any files or directories created using L{TestCase.mktemp}.
36         Subclasses must invoke this method if they override it or the
37         cleanup will not occur.
38         """
39         if False and self._temporaryFiles is not None:
40             for temp in self._temporaryFiles:
41                 if os.path.isdir(temp):
42                     shutil.rmtree(temp)
43                 elif os.path.exists(temp):
44                     os.unlink(temp)
45         try:
46             _exception_from_error_queue()
47         except Error:
48             e = sys.exc_info()[1]
49             if e.args != ([],):
50                 self.fail("Left over errors in OpenSSL error queue: " + repr(e))
51
52
53     def failUnlessIdentical(self, first, second, msg=None):
54         """
55         Fail the test if C{first} is not C{second}.  This is an
56         obect-identity-equality test, not an object equality
57         (i.e. C{__eq__}) test.
58
59         @param msg: if msg is None, then the failure message will be
60         '%r is not %r' % (first, second)
61         """
62         if first is not second:
63             raise self.failureException(msg or '%r is not %r' % (first, second))
64         return first
65     assertIdentical = failUnlessIdentical
66
67
68     def failIfIdentical(self, first, second, msg=None):
69         """
70         Fail the test if C{first} is C{second}.  This is an
71         obect-identity-equality test, not an object equality
72         (i.e. C{__eq__}) test.
73
74         @param msg: if msg is None, then the failure message will be
75         '%r is %r' % (first, second)
76         """
77         if first is second:
78             raise self.failureException(msg or '%r is %r' % (first, second))
79         return first
80     assertNotIdentical = failIfIdentical
81
82
83     def failUnlessRaises(self, exception, f, *args, **kwargs):
84         """
85         Fail the test unless calling the function C{f} with the given
86         C{args} and C{kwargs} raises C{exception}. The failure will report
87         the traceback and call stack of the unexpected exception.
88
89         @param exception: exception type that is to be expected
90         @param f: the function to call
91
92         @return: The raised exception instance, if it is of the given type.
93         @raise self.failureException: Raised if the function call does
94             not raise an exception or if it raises an exception of a
95             different type.
96         """
97         try:
98             result = f(*args, **kwargs)
99         except exception:
100             inst = sys.exc_info()[1]
101             return inst
102         except:
103             raise self.failureException('%s raised instead of %s'
104                                         % (sys.exc_info()[0],
105                                            exception.__name__,
106                                           ))
107         else:
108             raise self.failureException('%s not raised (%r returned)'
109                                         % (exception.__name__, result))
110     assertRaises = failUnlessRaises
111
112
113     _temporaryFiles = None
114     def mktemp(self):
115         """
116         Pathetic substitute for twisted.trial.unittest.TestCase.mktemp.
117         """
118         if self._temporaryFiles is None:
119             self._temporaryFiles = []
120         temp = mktemp(dir=".")
121         self._temporaryFiles.append(temp)
122         return temp
123
124
125     # Python 2.3 compatibility.
126     def assertTrue(self, *a, **kw):
127         return self.failUnless(*a, **kw)
128
129
130     def assertFalse(self, *a, **kw):
131         return self.failIf(*a, **kw)
132
133
134     # Other stuff
135     def assertConsistentType(self, theType, name, *constructionArgs):
136         """
137         Perform various assertions about C{theType} to ensure that it is a
138         well-defined type.  This is useful for extension types, where it's
139         pretty easy to do something wacky.  If something about the type is
140         unusual, an exception will be raised.
141
142         @param theType: The type object about which to make assertions.
143         @param name: A string giving the name of the type.
144         @param constructionArgs: Positional arguments to use with C{theType} to
145             create an instance of it.
146         """
147         self.assertEqual(theType.__name__, name)
148         self.assertTrue(isinstance(theType, type))
149         instance = theType(*constructionArgs)
150         self.assertIdentical(type(instance), theType)