rubyfox-server 2.3.0.pre2

data/lib/rubyfox/server/data/lib/Lib/test/test_b2.py

@@ -0,0 +1,365 @@
+# Python test set -- part 4b, built-in functions n-z
+
+from test_support import *
+
+print 'oct'
+if oct(100) != '0144': raise TestFailed, 'oct(100)'
+if oct(100L) != '0144L': raise TestFailed, 'oct(100L)'
+if oct(-100) not in ('037777777634', '01777777777777777777634'):
+    raise TestFailed, 'oct(-100)'
+if oct(-100L) != '-0144L': raise TestFailed, 'oct(-100L)'
+
+print 'open'
+# NB the first 4 lines are also used to test input and raw_input, below
+fp = open(TESTFN, 'w')
+try:
+    fp.write('1+1\n')
+    fp.write('1+1\n')
+    fp.write('The quick brown fox jumps over the lazy dog')
+    fp.write('.\n')
+    fp.write('Dear John\n')
+    fp.write('XXX'*100)
+    fp.write('YYY'*100)
+finally:
+    fp.close()
+#
+fp = open(TESTFN, 'r')
+try:
+    if fp.readline(4) != '1+1\n': raise TestFailed, 'readline(4) # exact'
+    if fp.readline(4) != '1+1\n': raise TestFailed, 'readline(4) # exact'
+    if fp.readline() != 'The quick brown fox jumps over the lazy dog.\n':
+        raise TestFailed, 'readline() # default'
+    if fp.readline(4) != 'Dear': raise TestFailed, 'readline(4) # short'
+    if fp.readline(100) != ' John\n': raise TestFailed, 'readline(100)'
+    if fp.read(300) != 'XXX'*100: raise TestFailed, 'read(300)'
+    if fp.read(1000) != 'YYY'*100: raise TestFailed, 'read(1000) # truncate'
+finally:
+    fp.close()
+
+print 'ord'
+if ord(' ') != 32: raise TestFailed, 'ord(\' \')'
+if ord('A') != 65: raise TestFailed, 'ord(\'A\')'
+if ord('a') != 97: raise TestFailed, 'ord(\'a\')'
+
+print 'pow'
+if pow(0,0) != 1: raise TestFailed, 'pow(0,0)'
+if pow(0,1) != 0: raise TestFailed, 'pow(0,1)'
+if pow(1,0) != 1: raise TestFailed, 'pow(1,0)'
+if pow(1,1) != 1: raise TestFailed, 'pow(1,1)'
+#
+if pow(2,0) != 1: raise TestFailed, 'pow(2,0)'
+if pow(2,10) != 1024: raise TestFailed, 'pow(2,10)'
+if pow(2,20) != 1024*1024: raise TestFailed, 'pow(2,20)'
+if pow(2,30) != 1024*1024*1024: raise TestFailed, 'pow(2,30)'
+#
+if pow(-2,0) != 1: raise TestFailed, 'pow(-2,0)'
+if pow(-2,1) != -2: raise TestFailed, 'pow(-2,1)'
+if pow(-2,2) != 4: raise TestFailed, 'pow(-2,2)'
+if pow(-2,3) != -8: raise TestFailed, 'pow(-2,3)'
+#
+if pow(0L,0) != 1: raise TestFailed, 'pow(0L,0)'
+if pow(0L,1) != 0: raise TestFailed, 'pow(0L,1)'
+if pow(1L,0) != 1: raise TestFailed, 'pow(1L,0)'
+if pow(1L,1) != 1: raise TestFailed, 'pow(1L,1)'
+#
+if pow(2L,0) != 1: raise TestFailed, 'pow(2L,0)'
+if pow(2L,10) != 1024: raise TestFailed, 'pow(2L,10)'
+if pow(2L,20) != 1024*1024: raise TestFailed, 'pow(2L,20)'
+if pow(2L,30) != 1024*1024*1024: raise TestFailed, 'pow(2L,30)'
+#
+if pow(-2L,0) != 1: raise TestFailed, 'pow(-2L,0)'
+if pow(-2L,1) != -2: raise TestFailed, 'pow(-2L,1)'
+if pow(-2L,2) != 4: raise TestFailed, 'pow(-2L,2)'
+if pow(-2L,3) != -8: raise TestFailed, 'pow(-2L,3)'
+#
+if fcmp(pow(0.,0), 1.): raise TestFailed, 'pow(0.,0)'
+if fcmp(pow(0.,1), 0.): raise TestFailed, 'pow(0.,1)'
+if fcmp(pow(1.,0), 1.): raise TestFailed, 'pow(1.,0)'
+if fcmp(pow(1.,1), 1.): raise TestFailed, 'pow(1.,1)'
+#
+if fcmp(pow(2.,0), 1.): raise TestFailed, 'pow(2.,0)'
+if fcmp(pow(2.,10), 1024.): raise TestFailed, 'pow(2.,10)'
+if fcmp(pow(2.,20), 1024.*1024.): raise TestFailed, 'pow(2.,20)'
+if fcmp(pow(2.,30), 1024.*1024.*1024.): raise TestFailed, 'pow(2.,30)'
+#
+if fcmp(pow(-2.,0), 1.): raise TestFailed, 'pow(-2.,0)'
+if fcmp(pow(-2.,1), -2.): raise TestFailed, 'pow(-2.,1)'
+if fcmp(pow(-2.,2), 4.): raise TestFailed, 'pow(-2.,2)'
+if fcmp(pow(-2.,3), -8.): raise TestFailed, 'pow(-2.,3)'
+
+from types import FloatType
+for x in 2, 2L, 2.0:
+    for y in 10, 10L, 10.0:
+        for z in 1000, 1000L, 1000.0:
+            if isinstance(x, FloatType) or \
+               isinstance(y, FloatType) or \
+               isinstance(z, FloatType):
+                try:
+                    pow(x, y, z)
+                except TypeError:
+                    pass
+                else:
+                    raise TestFailed("3-arg float pow(%s, %s, %s) should "
+                                     "have raised TypeError" % (x, y, z))
+            else:
+                if fcmp(pow(x, y, z), 24.0):
+                    raise TestFailed, 'pow(%s, %s, %s)' % (x, y, z)
+
+print 'range'
+if range(3) != [0, 1, 2]: raise TestFailed, 'range(3)'
+if range(1, 5) != [1, 2, 3, 4]: raise TestFailed, 'range(1, 5)'
+if range(0) != []: raise TestFailed, 'range(0)'
+if range(-3) != []: raise TestFailed, 'range(-3)'
+if range(1, 10, 3) != [1, 4, 7]: raise TestFailed, 'range(1, 10, 3)'
+if range(5, -5, -3) != [5, 2, -1, -4]: raise TestFailed, 'range(5, -5, -3)'
+
+print 'input and raw_input'
+import sys
+fp = open(TESTFN, 'r')
+savestdin = sys.stdin
+try:
+    sys.stdin = fp
+    if input() != 2: raise TestFailed, 'input()'
+    if input('testing\n') != 2: raise TestFailed, 'input()'
+    if raw_input() != 'The quick brown fox jumps over the lazy dog.':
+        raise TestFailed, 'raw_input()'
+    if raw_input('testing\n') != 'Dear John':
+        raise TestFailed, 'raw_input(\'testing\\n\')'
+finally:
+    sys.stdin = savestdin
+    fp.close()
+
+print 'reduce'
+if reduce(lambda x, y: x+y, ['a', 'b', 'c'], '') != 'abc':
+    raise TestFailed, 'reduce(): implode a string'
+if reduce(lambda x, y: x+y,
+          [['a', 'c'], [], ['d', 'w']], []) != ['a','c','d','w']:
+    raise TestFailed, 'reduce(): append'
+if reduce(lambda x, y: x*y, range(2,8), 1) != 5040:
+    raise TestFailed, 'reduce(): compute 7!'
+if reduce(lambda x, y: x*y, range(2,21), 1L) != 2432902008176640000L:
+    raise TestFailed, 'reduce(): compute 20!, use long'
+class Squares:
+    def __init__(self, max):
+        self.max = max
+        self.sofar = []
+    def __len__(self): return len(self.sofar)
+    def __getitem__(self, i):
+        if not 0 <= i < self.max: raise IndexError
+        n = len(self.sofar)
+        while n <= i:
+            self.sofar.append(n*n)
+            n = n+1
+        return self.sofar[i]
+if reduce(lambda x, y: x+y, Squares(10)) != 285:
+    raise TestFailed, 'reduce(<+>, Squares(10))'
+if reduce(lambda x, y: x+y, Squares(10), 0) != 285:
+    raise TestFailed, 'reduce(<+>, Squares(10), 0)'
+if reduce(lambda x, y: x+y, Squares(0), 0) != 0:
+    raise TestFailed, 'reduce(<+>, Squares(0), 0)'
+
+
+print 'reload'
+import marshal
+reload(marshal)
+import string
+reload(string)
+## import sys
+## try: reload(sys)
+## except ImportError: pass
+## else: raise TestFailed, 'reload(sys) should fail'
+
+print 'repr'
+if repr('') != '\'\'': raise TestFailed, 'repr(\'\')'
+if repr(0) != '0': raise TestFailed, 'repr(0)'
+if repr(0L) != '0L': raise TestFailed, 'repr(0L)'
+if repr(()) != '()': raise TestFailed, 'repr(())'
+if repr([]) != '[]': raise TestFailed, 'repr([])'
+if repr({}) != '{}': raise TestFailed, 'repr({})'
+
+print 'round'
+if round(0.0) != 0.0: raise TestFailed, 'round(0.0)'
+if round(1.0) != 1.0: raise TestFailed, 'round(1.0)'
+if round(10.0) != 10.0: raise TestFailed, 'round(10.0)'
+if round(1000000000.0) != 1000000000.0:
+    raise TestFailed, 'round(1000000000.0)'
+if round(1e20) != 1e20: raise TestFailed, 'round(1e20)'
+
+if round(-1.0) != -1.0: raise TestFailed, 'round(-1.0)'
+if round(-10.0) != -10.0: raise TestFailed, 'round(-10.0)'
+if round(-1000000000.0) != -1000000000.0:
+    raise TestFailed, 'round(-1000000000.0)'
+if round(-1e20) != -1e20: raise TestFailed, 'round(-1e20)'
+
+if round(0.1) != 0.0: raise TestFailed, 'round(0.0)'
+if round(1.1) != 1.0: raise TestFailed, 'round(1.0)'
+if round(10.1) != 10.0: raise TestFailed, 'round(10.0)'
+if round(1000000000.1) != 1000000000.0:
+    raise TestFailed, 'round(1000000000.0)'
+
+if round(-1.1) != -1.0: raise TestFailed, 'round(-1.0)'
+if round(-10.1) != -10.0: raise TestFailed, 'round(-10.0)'
+if round(-1000000000.1) != -1000000000.0:
+    raise TestFailed, 'round(-1000000000.0)'
+
+if round(0.9) != 1.0: raise TestFailed, 'round(0.9)'
+if round(9.9) != 10.0: raise TestFailed, 'round(9.9)'
+if round(999999999.9) != 1000000000.0:
+    raise TestFailed, 'round(999999999.9)'
+
+if round(-0.9) != -1.0: raise TestFailed, 'round(-0.9)'
+if round(-9.9) != -10.0: raise TestFailed, 'round(-9.9)'
+if round(-999999999.9) != -1000000000.0:
+    raise TestFailed, 'round(-999999999.9)'
+
+print 'setattr'
+import sys
+setattr(sys, 'spam', 1)
+if sys.spam != 1: raise TestFailed, 'setattr(sys, \'spam\', 1)'
+try:
+    setattr(sys, 1, 'spam')
+except TypeError:
+    pass
+else:
+    raise TestFailed, "setattr(sys, 1, 'spam') should raise exception"
+
+print 'str'
+if str('') != '': raise TestFailed, 'str(\'\')'
+if str(0) != '0': raise TestFailed, 'str(0)'
+if str(0L) != '0': raise TestFailed, 'str(0L)'
+if str(()) != '()': raise TestFailed, 'str(())'
+if str([]) != '[]': raise TestFailed, 'str([])'
+if str({}) != '{}': raise TestFailed, 'str({})'
+
+print 'tuple'
+if tuple(()) != (): raise TestFailed, 'tuple(())'
+t0_3 = (0, 1, 2, 3)
+t0_3_bis = tuple(t0_3)
+if t0_3 is not t0_3_bis: raise TestFailed, 'tuple((0, 1, 2, 3))'
+if tuple([]) != (): raise TestFailed, 'tuple([])'
+if tuple([0, 1, 2, 3]) != (0, 1, 2, 3): raise TestFailed, 'tuple([0, 1, 2, 3])'
+if tuple('') != (): raise TestFailed, 'tuple('')'
+if tuple('spam') != ('s', 'p', 'a', 'm'): raise TestFailed, "tuple('spam')"
+
+print 'type'
+if type('') != type('123') or type('') == type(()):
+    raise TestFailed, 'type()'
+
+print 'vars'
+a = b = None
+a = vars().keys()
+b = dir()
+a.sort()
+b.sort()
+if a != b: raise TestFailed, 'vars()'
+import sys
+a = vars(sys).keys()
+b = dir(sys)
+a.sort()
+b.sort()
+if a != b: raise TestFailed, 'vars(sys)'
+def f0():
+    if vars() != {}: raise TestFailed, 'vars() in f0()'
+f0()
+def f2():
+    f0()
+    a = 1
+    b = 2
+    if vars() != {'a': a, 'b': b}: raise TestFailed, 'vars() in f2()'
+f2()
+
+print 'xrange'
+import warnings
+warnings.filterwarnings('ignore', r".*xrange", DeprecationWarning)
+if tuple(xrange(10)) != tuple(range(10)): raise TestFailed, 'xrange(10)'
+if tuple(xrange(5,10)) != tuple(range(5,10)): raise TestFailed, 'xrange(5,10)'
+if tuple(xrange(0,10,2)) != tuple(range(0,10,2)):
+    raise TestFailed, 'xrange(0,10,2)'
+r = xrange(10)
+if r.tolist() != range(10): raise TestFailed, 'xrange(10).tolist()'
+if r.start != 0: raise TestFailed, 'xrange(10).start'
+if r.stop != 10: raise TestFailed, 'xrange(10).stop'
+if r.step != 1: raise TestFailed, 'xrange(10).step'
+r = xrange(3, 10)
+if r.tolist() != range(3, 10): raise TestFailed, 'xrange(3, 10).tolist()'
+if r.start != 3: raise TestFailed, 'xrange(3, 10).start'
+if r.stop != 10: raise TestFailed, 'xrange(3, 10).stop'
+if r.step != 1: raise TestFailed, 'xrange(3, 10).step'
+r = xrange(3, 10, 2)
+if r.tolist() != range(3, 10, 2): raise TestFailed, 'xrange(3, 10, 2).tolist()'
+if r.start != 3: raise TestFailed, 'xrange(3, 10, 2).start'
+if r.stop != 11: raise TestFailed, 'xrange(3, 10, 2).stop'
+if r.step != 2: raise TestFailed, 'xrange(3, 10, 2).step'
+r = xrange(10, 3, -1)
+if r.tolist() != range(10, 3, -1):
+    raise TestFailed, 'xrange(10, 3, -1).tolist()'
+if r.start != 10: raise TestFailed, 'xrange(10, 3, -1).start'
+if r.stop != 3: raise TestFailed, 'xrange(10, 3, -1).stop'
+if r.step != -1: raise TestFailed, 'xrange(10, 3, -1).step'
+# regression tests for SourceForge bug #221965
+def _range_test(r):
+    verify(r.start != r.stop, 'Test not valid for passed-in xrange object.')
+    if r.stop in r:
+        raise TestFailed, 'r.stop in ' + `r`
+    if r.stop-r.step not in r:
+        raise TestFailed, 'r.stop-r.step not in ' + `r`
+    if r.start not in r:
+        raise TestFailed, 'r.start not in ' + `r`
+    if r.stop+r.step in r:
+        raise TestFailed, 'r.stop+r.step in ' + `r`
+_range_test(xrange(10))
+_range_test(xrange(9, -1, -1))
+_range_test(xrange(0, 10, 2))
+
+print 'zip'
+a = (1, 2, 3)
+b = (4, 5, 6)
+t = [(1, 4), (2, 5), (3, 6)]
+if zip(a, b) != t: raise TestFailed, 'zip(a, b) - same size, both tuples'
+b = [4, 5, 6]
+if zip(a, b) != t: raise TestFailed, 'zip(a, b) - same size, tuple/list'
+b = (4, 5, 6, 7)
+if zip(a, b) != t: raise TestFailed, 'zip(a, b) - b is longer'
+class I:
+    def __getitem__(self, i):
+        if i < 0 or i > 2: raise IndexError
+        return i + 4
+if zip(a, I()) != t: raise TestFailed, 'zip(a, b) - b is instance'
+exc = 0
+try:
+    zip()
+except TypeError:
+    exc = 1
+except:
+    e = sys.exc_info()[0]
+    raise TestFailed, 'zip() - no args, expected TypeError, got %s' % e
+if not exc:
+    raise TestFailed, 'zip() - no args, missing expected TypeError'
+
+exc = 0
+try:
+    zip(None)
+except TypeError:
+    exc = 1
+except:
+    e = sys.exc_info()[0]
+    raise TestFailed, 'zip(None) - expected TypeError, got %s' % e
+if not exc:
+    raise TestFailed, 'zip(None) - missing expected TypeError'
+class G:
+    pass
+exc = 0
+try:
+    zip(a, G())
+except TypeError:
+    exc = 1
+except:
+    e = sys.exc_info()[0]
+    raise TestFailed, 'zip(a, b) - b instance w/o __getitem__'
+if not exc:
+    raise TestFailed, 'zip(a, b) - missing expected TypeError'
+
+
+# Epilogue -- unlink the temp file
+
+unlink(TESTFN)

data/lib/rubyfox/server/data/lib/Lib/test/test_base64.py

@@ -0,0 +1,53 @@
+import unittest
+import test_support
+import base64
+from binascii import Error as binascii_error
+
+class Base64TestCase(unittest.TestCase):
+    def test_encode_string(self):
+        """Testing encode string"""
+        test_support.verify(base64.encodestring("www.python.org") ==
+            "d3d3LnB5dGhvbi5vcmc=\n",
+            reason="www.python.org encodestring failed")
+        test_support.verify(base64.encodestring("a") ==
+            "YQ==\n",
+            reason="a encodestring failed")
+        test_support.verify(base64.encodestring("ab") ==
+            "YWI=\n",
+            reason="ab encodestring failed")
+        test_support.verify(base64.encodestring("abc") ==
+            "YWJj\n",
+            reason="abc encodestring failed")
+        test_support.verify(base64.encodestring("") ==
+            "",
+            reason="null encodestring failed")
+        test_support.verify(base64.encodestring(
+            "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#0^&*();:<>,. []{}") ==
+            "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0\nNTY3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==\n",
+            reason = "long encodestring failed")
+
+    def test_decode_string(self):
+        """Testing decode string"""
+        test_support.verify(base64.decodestring("d3d3LnB5dGhvbi5vcmc=\n") ==
+            "www.python.org",
+            reason="www.python.org decodestring failed")
+        test_support.verify(base64.decodestring("YQ==\n") ==
+            "a",
+            reason="a decodestring failed")
+        test_support.verify(base64.decodestring("YWI=\n") ==
+            "ab",
+            reason="ab decodestring failed")
+        test_support.verify(base64.decodestring("YWJj\n") ==
+            "abc",
+            reason="abc decodestring failed")
+        test_support.verify(base64.decodestring(
+            "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0\nNTY3ODkhQCMwXiYqKCk7Ojw+LC4gW117fQ==\n") ==
+            "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#0^&*();:<>,. []{}",
+            reason = "long decodestring failed")
+        test_support.verify(base64.decodestring('') == '')
+
+def test_main():
+    test_support.run_unittest(Base64TestCase)
+
+if __name__ == "__main__":
+    test_main()

data/lib/rubyfox/server/data/lib/Lib/test/test_bastion.py

@@ -0,0 +1,3 @@
+##import Bastion
+##
+##Bastion._test()

data/lib/rubyfox/server/data/lib/Lib/test/test_binascii.py

@@ -0,0 +1,119 @@
+"""Test the binascii C module."""
+
+from test_support import verify, verbose
+import binascii
+
+# Show module doc string
+print binascii.__doc__
+
+# Show module exceptions
+print binascii.Error
+print binascii.Incomplete
+
+# Check presence and display doc strings of all functions
+funcs = []
+for suffix in "base64", "hqx", "uu":
+    prefixes = ["a2b_", "b2a_"]
+    if suffix == "hqx":
+        prefixes.extend(["crc_", "rlecode_", "rledecode_"])
+    for prefix in prefixes:
+        name = prefix + suffix
+        funcs.append(getattr(binascii, name))
+for func in funcs:
+    print "%-15s: %s" % (func.__name__, func.__doc__)
+
+# Create binary test data
+testdata = "The quick brown fox jumps over the lazy dog.\r\n"
+for i in range(256):
+    # Be slow so we don't depend on other modules
+    testdata = testdata + chr(i)
+testdata = testdata + "\r\nHello world.\n"
+
+# Test base64 with valid data
+print "base64 test"
+MAX_BASE64 = 57
+lines = []
+for i in range(0, len(testdata), MAX_BASE64):
+    b = testdata[i:i+MAX_BASE64]
+    a = binascii.b2a_base64(b)
+    lines.append(a)
+    print a,
+res = ""
+for line in lines:
+    b = binascii.a2b_base64(line)
+    res = res + b
+verify(res == testdata)
+
+# Test base64 with random invalid characters sprinkled throughout
+# (This requires a new version of binascii.)
+fillers = ""
+valid = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/"
+for i in range(256):
+    c = chr(i)
+    if c not in valid:
+        fillers = fillers + c
+def addnoise(line):
+    noise = fillers
+    ratio = len(line) // len(noise)
+    res = ""
+    while line and noise:
+        if len(line) // len(noise) > ratio:
+            c, line = line[0], line[1:]
+        else:
+            c, noise = noise[0], noise[1:]
+        res = res + c
+    return res + noise + line
+res = ""
+for line in map(addnoise, lines):
+    b = binascii.a2b_base64(line)
+    res = res + b
+verify(res == testdata)
+
+# Test base64 with just invalid characters, which should return
+# empty strings.
+verify(binascii.a2b_base64(fillers) == '')
+
+# Test uu
+print "uu test"
+MAX_UU = 45
+lines = []
+for i in range(0, len(testdata), MAX_UU):
+    b = testdata[i:i+MAX_UU]
+    a = binascii.b2a_uu(b)
+    lines.append(a)
+    print a,
+res = ""
+for line in lines:
+    b = binascii.a2b_uu(line)
+    res = res + b
+verify(res == testdata)
+
+# Test crc32()
+crc = binascii.crc32("Test the CRC-32 of")
+crc = binascii.crc32(" this string.", crc)
+if crc != 1571220330:
+    print "binascii.crc32() failed."
+
+# The hqx test is in test_binhex.py
+
+# test hexlification
+s = '{s\005\000\000\000worldi\002\000\000\000s\005\000\000\000helloi\001\000\000\0000'
+t = binascii.b2a_hex(s)
+u = binascii.a2b_hex(t)
+if s != u:
+    print 'binascii hexlification failed'
+try:
+    binascii.a2b_hex(t[:-1])
+except TypeError:
+    pass
+else:
+    print 'expected TypeError not raised'
+try:
+    binascii.a2b_hex(t[:-1] + 'q')
+except TypeError:
+    pass
+else:
+    print 'expected TypeError not raised'
+
+# Verify the treatment of Unicode strings
+verify(binascii.hexlify(u'a') == '61', "hexlify failed for Unicode")

data/lib/rubyfox/server/data/lib/Lib/test/test_binhex.py

@@ -0,0 +1,50 @@
+#! /usr/bin/env python
+"""Test script for the binhex C module
+
+   Uses the mechanism of the python binhex module
+   Based on an original test by Roger E. Masse.
+"""
+import binhex
+import os
+import tempfile
+import test_support
+import unittest
+
+
+class BinHexTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self.fname1 = tempfile.mktemp()
+        self.fname2 = tempfile.mktemp()
+
+    def tearDown(self):
+        try: os.unlink(self.fname1)
+        except OSError: pass
+
+        try: os.unlink(self.fname2)
+        except OSError: pass
+
+    DATA = 'Jack is my hero'
+
+    def test_binhex(self):
+        f = open(self.fname1, 'w')
+        f.write(self.DATA)
+        f.close()
+
+        binhex.binhex(self.fname1, self.fname2)
+
+        binhex.hexbin(self.fname2, self.fname1)
+
+        f = open(self.fname1, 'r')
+        finish = f.readline()
+        f.close()
+
+        self.assertEqual(self.DATA, finish)
+
+
+def test_main():
+    test_support.run_unittest(BinHexTestCase)
+
+
+if __name__ == "__main__":
+    test_main()