rubyfox-server 2.3.0.pre2

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

@@ -0,0 +1,170 @@
+"""Test program for MimeWriter module.
+
+The test program was too big to comfortably fit in the MimeWriter
+class, so it's here in its own file.
+
+This should generate Barry's example, modulo some quotes and newlines.
+
+"""
+
+
+from MimeWriter import MimeWriter
+
+SELLER = '''\
+INTERFACE Seller-1;
+
+TYPE Seller = OBJECT
+    DOCUMENTATION "A simple Seller interface to test ILU"
+    METHODS
+            price():INTEGER,
+    END;
+'''
+
+BUYER = '''\
+class Buyer:
+    def __setup__(self, maxprice):
+        self._maxprice = maxprice
+
+    def __main__(self, kos):
+        """Entry point upon arrival at a new KOS."""
+        broker = kos.broker()
+        # B4 == Barry's Big Bass Business :-)
+        seller = broker.lookup('Seller_1.Seller', 'B4')
+        if seller:
+            price = seller.price()
+            print 'Seller wants $', price, '... '
+            if price > self._maxprice:
+                print 'too much!'
+            else:
+                print "I'll take it!"
+        else:
+            print 'no seller found here'
+'''                                     # Don't ask why this comment is here
+
+STATE = '''\
+# instantiate a buyer instance and put it in a magic place for the KOS
+# to find.
+__kp__ = Buyer()
+__kp__.__setup__(500)
+'''
+
+SIMPLE_METADATA = [
+        ("Interpreter", "python"),
+        ("Interpreter-Version", "1.3"),
+        ("Owner-Name", "Barry Warsaw"),
+        ("Owner-Rendezvous", "bwarsaw@cnri.reston.va.us"),
+        ("Home-KSS", "kss.cnri.reston.va.us"),
+        ("Identifier", "hdl://cnri.kss/my_first_knowbot"),
+        ("Launch-Date", "Mon Feb 12 16:39:03 EST 1996"),
+        ]
+
+COMPLEX_METADATA = [
+        ("Metadata-Type", "complex"),
+        ("Metadata-Key", "connection"),
+        ("Access", "read-only"),
+        ("Connection-Description", "Barry's Big Bass Business"),
+        ("Connection-Id", "B4"),
+        ("Connection-Direction", "client"),
+        ]
+
+EXTERNAL_METADATA = [
+        ("Metadata-Type", "complex"),
+        ("Metadata-Key", "generic-interface"),
+        ("Access", "read-only"),
+        ("Connection-Description", "Generic Interface for All Knowbots"),
+        ("Connection-Id", "generic-kp"),
+        ("Connection-Direction", "client"),
+        ]
+
+
+def main():
+    import sys
+
+    # Toplevel headers
+
+    toplevel = MimeWriter(sys.stdout)
+    toplevel.addheader("From", "bwarsaw@cnri.reston.va.us")
+    toplevel.addheader("Date", "Mon Feb 12 17:21:48 EST 1996")
+    toplevel.addheader("To", "kss-submit@cnri.reston.va.us")
+    toplevel.addheader("MIME-Version", "1.0")
+
+    # Toplevel body parts
+
+    f = toplevel.startmultipartbody("knowbot", "801spam999",
+                                    [("version", "0.1")], prefix=0)
+    f.write("This is a multi-part message in MIME format.\n")
+
+    # First toplevel body part: metadata
+
+    md = toplevel.nextpart()
+    md.startmultipartbody("knowbot-metadata", "802spam999")
+
+    # Metadata part 1
+
+    md1 = md.nextpart()
+    md1.addheader("KP-Metadata-Type", "simple")
+    md1.addheader("KP-Access", "read-only")
+    m = MimeWriter(md1.startbody("message/rfc822"))
+    for key, value in SIMPLE_METADATA:
+        m.addheader("KPMD-" + key, value)
+    m.flushheaders()
+    del md1
+
+    # Metadata part 2
+
+    md2 = md.nextpart()
+    for key, value in COMPLEX_METADATA:
+        md2.addheader("KP-" + key, value)
+    f = md2.startbody("text/isl")
+    f.write(SELLER)
+    del md2
+
+    # Metadata part 3
+
+    md3 = md.nextpart()
+    f = md3.startbody("message/external-body",
+                      [("access-type", "URL"),
+                       ("URL", "hdl://cnri.kss/generic-knowbot")])
+    m = MimeWriter(f)
+    for key, value in EXTERNAL_METADATA:
+        md3.addheader("KP-" + key, value)
+    md3.startbody("text/isl")
+    # Phantom body doesn't need to be written
+
+    md.lastpart()
+
+    # Second toplevel body part: code
+
+    code = toplevel.nextpart()
+    code.startmultipartbody("knowbot-code", "803spam999")
+
+    # Code: buyer program source
+
+    buyer = code.nextpart()
+    buyer.addheader("KP-Module-Name", "BuyerKP")
+    f = buyer.startbody("text/plain")
+    f.write(BUYER)
+
+    code.lastpart()
+
+    # Third toplevel body part: state
+
+    state = toplevel.nextpart()
+    state.addheader("KP-Main-Module", "main")
+    state.startmultipartbody("knowbot-state", "804spam999")
+
+    # State: a bunch of assignments
+
+    st = state.nextpart()
+    st.addheader("KP-Module-Name", "main")
+    f = st.startbody("text/plain")
+    f.write(STATE)
+
+    state.lastpart()
+
+    # End toplevel body parts
+
+    toplevel.lastpart()
+
+
+main()

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

@@ -0,0 +1,88 @@
+#
+# Matt Shelton <matt@mattshelton.com>
+#
+
+from SimpleXMLRPCServer import SimpleXMLRPCServer
+import threading, xmlrpclib, unittest
+
+HOST = "127.0.0.1"
+PORT = 7218
+
+def multiply(x, y):
+    return x * y
+
+class MyService:
+    """This test class is going to be used to test an entire class being
+    exposed via XML-RPC."""
+    
+    def _dispatch(self, method, params):
+        """This method is called whenever a call is made to the 
+        service."""
+        func = getattr(self, 'expose_' + method)
+        return func(*params)
+
+    def expose_squared(self, x):
+        """Square"""
+        return x * x
+
+class ServerThread(threading.Thread):
+    """A test harness for launching a SimpleXMLRPCServer instance in the
+       background."""
+    def __init__(self, server):
+        threading.Thread.__init__(self)
+        self.server = server
+
+    def run(self):
+        self.server.socket.settimeout(5)
+        self.server.allow_reuse_address = 1
+        self.server.handle_request()
+        self.server.server_close()
+    
+class SimpleXMLRPCServerTestCase(unittest.TestCase):
+    """Test case for the Python SimpleXMLRPCServer module."""
+    def test_exposeLambda(self):
+        """Expose a lambda function via XML-RPC."""
+        # Create a server instance.
+        server = SimpleXMLRPCServer((HOST, PORT))
+        server.register_function(lambda x,y: x+y, 'add')
+        ServerThread(server).start()
+
+        # Access the exposed service.
+        client = xmlrpclib.ServerProxy("http://%s:%d" % (HOST, PORT))
+        self.assertEqual(client.add(10, 20), 30)
+
+    def test_exposeFunction1(self):
+        """Expose a function via XML-RPC."""
+        server = SimpleXMLRPCServer((HOST, PORT + 1))
+        server.register_function(multiply)
+        ServerThread(server).start()
+
+        # Access the exposed service.
+        client = xmlrpclib.ServerProxy("http://%s:%d" % (HOST, PORT + 1))
+        self.assertEqual(client.multiply(5, 10), 50)
+
+    def test_exposeFunction2(self):
+        """Expose a function using a different name via XML-RPC."""
+        server = SimpleXMLRPCServer((HOST, PORT + 2))
+        server.register_function(multiply, "mult")
+        ServerThread(server).start()
+
+        # Access the exposed service.
+        client = xmlrpclib.ServerProxy("http://%s:%d" % (HOST, PORT + 2))
+        self.assertEqual(client.mult(7, 11), 77)
+
+    def test_exposeClass(self):
+        """Expose an entire class and test the _dispatch method."""
+        server = SimpleXMLRPCServer((HOST, PORT + 3))
+        server.register_instance(MyService())
+        ServerThread(server).start()
+
+        # Access the exposed service.
+        client = xmlrpclib.ServerProxy("http://%s:%d" % (HOST, PORT + 3))
+        self.assertEqual(client.squared(10), 100)
+
+
+if __name__ == "__main__":
+    unittest.main()
+
+# vim:et:ts=4:sw=4:

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

@@ -0,0 +1,113 @@
+# Tests StringIO and cStringIO
+
+import unittest
+import StringIO
+import cStringIO
+import types
+import test_support
+
+
+class TestGenericStringIO(unittest.TestCase):
+    # use a class variable MODULE to define which module is being tested
+
+    # Line of data to test as string
+    _line = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!'
+
+    # Constructor to use for the test data (._line is passed to this
+    # constructor)
+    constructor = str
+
+    def setUp(self):
+        self._line = self.constructor(self._line)
+        self._lines = self.constructor((self._line + '\n') * 5)
+        self._fp = self.MODULE.StringIO(self._lines)
+
+    def test_reads(self):
+        eq = self.assertEqual
+        eq(self._fp.read(10), self._line[:10])
+        eq(self._fp.readline(), self._line[10:] + '\n')
+        eq(len(self._fp.readlines(60)), 2)
+
+    def test_writes(self):
+        f = self.MODULE.StringIO()
+        f.write(self._line[:6])
+        f.seek(3)
+        f.write(self._line[20:26])
+        f.write(self._line[52])
+        self.assertEqual(f.getvalue(), 'abcuvwxyz!')
+
+    def test_writelines(self):
+        f = self.MODULE.StringIO()
+        f.writelines([self._line[0], self._line[1], self._line[2]])
+        f.seek(0)
+        self.assertEqual(f.getvalue(), 'abc')
+
+    def test_truncate(self):
+        eq = self.assertEqual
+        f = self.MODULE.StringIO()
+        f.write(self._lines)
+        f.seek(10)
+        f.truncate()
+        eq(f.getvalue(), 'abcdefghij')
+        f.seek(0)
+        f.truncate(5)
+        eq(f.getvalue(), 'abcde')
+        f.close()
+        self.assertRaises(ValueError, f.write, 'frobnitz')
+
+    def test_iterator(self):
+        eq = self.assertEqual
+        unless = self.failUnless
+        it = iter(self._fp)
+        # Does this object support the iteration protocol?
+        unless(hasattr(it, '__iter__'))
+        unless(hasattr(it, 'next'))
+        i = 0
+        for line in self._fp:
+            eq(line, self._line + '\n')
+            i += 1
+        eq(i, 5)
+
+class TestStringIO(TestGenericStringIO):
+    MODULE = StringIO
+
+    if test_support.have_unicode:
+        def test_unicode(self):
+
+            # The StringIO module also supports concatenating Unicode
+            # snippets to larger Unicode strings. This is tested by this
+            # method. Note that cStringIO does not support this extension.
+
+            f = self.MODULE.StringIO()
+            f.write(self._line[:6])
+            f.seek(3)
+            f.write(unicode(self._line[20:26]))
+            f.write(unicode(self._line[52]))
+            s = f.getvalue()
+            self.assertEqual(s, unicode('abcuvwxyz!'))
+            self.assertEqual(type(s), types.UnicodeType)
+
+class TestcStringIO(TestGenericStringIO):
+    MODULE = cStringIO
+
+import sys
+if sys.platform.startswith('java'):
+    # Jython doesn't have a buffer object, so we just do a useless
+    # fake of the buffer tests.
+    buffer = str
+
+class TestBufferStringIO(TestStringIO):
+    constructor = buffer
+
+class TestBuffercStringIO(TestcStringIO):
+    constructor = buffer
+
+
+def test_main():
+    test_support.run_unittest(TestStringIO)
+    test_support.run_unittest(TestcStringIO)
+    test_support.run_unittest(TestBufferStringIO)
+    test_support.run_unittest(TestBuffercStringIO)
+
+if __name__ == '__main__':
+    test_main()

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

@@ -0,0 +1,158 @@
+from test_support import verify, verbose
+import sys
+
+def check_all(modname):
+    names = {}
+    try:
+        exec "import %s" % modname in names
+    except ImportError:
+        # Silent fail here seems the best route since some modules
+        # may not be available in all environments.
+        # Since an ImportError may leave a partial module object in
+        # sys.modules, get rid of that first.  Here's what happens if
+        # you don't:  importing pty fails on Windows because pty tries to
+        # import FCNTL, which doesn't exist.  That raises an ImportError,
+        # caught here.  It also leaves a partial pty module in sys.modules.
+        # So when test_pty is called later, the import of pty succeeds,
+        # but shouldn't.  As a result, test_pty crashes with an
+        # AttributeError instead of an ImportError, and regrtest interprets
+        # the latter as a test failure (ImportError is treated as "test
+        # skipped" -- which is what test_pty should say on Windows).
+        try:
+            del sys.modules[modname]
+        except KeyError:
+            pass
+        return
+    verify(hasattr(sys.modules[modname], "__all__"),
+           "%s has no __all__ attribute" % modname)
+    names = {}
+    exec "from %s import *" % modname in names
+    if names.has_key("__builtins__"):
+        del names["__builtins__"]
+    keys = names.keys()
+    keys.sort()
+    all = list(sys.modules[modname].__all__) # in case it's a tuple
+    all.sort()
+    verify(keys==all, "%s != %s" % (keys, all))
+
+if not sys.platform.startswith('java'):
+    # In case _socket fails to build, make this test fail more gracefully
+    # than an AttributeError somewhere deep in CGIHTTPServer.
+    import _socket
+
+check_all("BaseHTTPServer")
+check_all("CGIHTTPServer")
+check_all("ConfigParser")
+check_all("Cookie")
+check_all("MimeWriter")
+check_all("SimpleHTTPServer")
+check_all("SocketServer")
+check_all("StringIO")
+check_all("UserString")
+check_all("aifc")
+check_all("atexit")
+check_all("audiodev")
+check_all("base64")
+check_all("bdb")
+check_all("binhex")
+check_all("calendar")
+check_all("cgi")
+check_all("cmd")
+check_all("code")
+check_all("codecs")
+check_all("codeop")
+check_all("colorsys")
+check_all("commands")
+check_all("compileall")
+check_all("copy")
+check_all("copy_reg")
+check_all("dbhash")
+check_all("dircache")
+check_all("dis")
+check_all("doctest")
+check_all("dospath")
+check_all("filecmp")
+check_all("fileinput")
+check_all("fnmatch")
+check_all("fpformat")
+check_all("ftplib")
+check_all("getopt")
+check_all("getpass")
+check_all("gettext")
+check_all("glob")
+check_all("gopherlib")
+check_all("gzip")
+check_all("htmllib")
+check_all("httplib")
+check_all("ihooks")
+check_all("imaplib")
+check_all("imghdr")
+check_all("imputil")
+check_all("keyword")
+check_all("linecache")
+check_all("locale")
+check_all("macpath")
+check_all("macurl2path")
+check_all("mailbox")
+check_all("mhlib")
+check_all("mimetools")
+check_all("mimetypes")
+check_all("mimify")
+check_all("multifile")
+check_all("netrc")
+check_all("nntplib")
+check_all("ntpath")
+check_all("os")
+check_all("pdb")
+check_all("pickle")
+check_all("pipes")
+check_all("popen2")
+check_all("poplib")
+check_all("posixpath")
+check_all("pprint")
+check_all("pre")
+check_all("profile")
+check_all("pstats")
+check_all("pty")
+check_all("py_compile")
+check_all("pyclbr")
+check_all("quopri")
+check_all("random")
+check_all("re")
+check_all("reconvert")
+import warnings
+warnings.filterwarnings("ignore", ".* regsub .*", DeprecationWarning, "regsub",
+                        append=1)
+check_all("regsub")
+check_all("repr")
+check_all("rexec")
+check_all("rfc822")
+check_all("rlcompleter")
+check_all("robotparser")
+check_all("sched")
+check_all("sgmllib")
+check_all("shelve")
+check_all("shlex")
+check_all("shutil")
+check_all("smtpd")
+check_all("smtplib")
+check_all("sndhdr")
+check_all("socket")
+check_all("sre")
+check_all("stat_cache")
+check_all("tabnanny")
+check_all("telnetlib")
+check_all("tempfile")
+check_all("toaiff")
+check_all("tokenize")
+check_all("traceback")
+check_all("tty")
+check_all("urllib")
+check_all("urlparse")
+check_all("uu")
+check_all("warnings")
+check_all("wave")
+check_all("weakref")
+check_all("webbrowser")
+check_all("xdrlib")
+check_all("zipfile")

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

@@ -0,0 +1,59 @@
+#! /usr/bin/env python
+from test_support import verbose, verify
+from types import TupleType, StringType, IntType
+import __future__
+
+GOOD_SERIALS = ("alpha", "beta", "candidate", "final")
+
+features = __future__.all_feature_names
+
+# Verify that all_feature_names appears correct.
+given_feature_names = features[:]
+for name in dir(__future__):
+    obj = getattr(__future__, name, None)
+    if obj is not None and isinstance(obj, __future__._Feature):
+        verify(name in given_feature_names,
+               "%r should have been in all_feature_names" % name)
+        given_feature_names.remove(name)
+verify(len(given_feature_names) == 0,
+       "all_feature_names has too much: %r" % given_feature_names)
+del given_feature_names
+
+for feature in features:
+    value = getattr(__future__, feature)
+    if verbose:
+        print "Checking __future__ ", feature, "value", value
+
+    optional = value.getOptionalRelease()
+    mandatory = value.getMandatoryRelease()
+
+    verify(type(optional) is TupleType, "optional isn't tuple")
+    verify(len(optional) == 5, "optional isn't 5-tuple")
+    major, minor, micro, level, serial = optional
+    verify(type(major) is IntType, "optional major isn't int")
+    verify(type(minor) is IntType, "optional minor isn't int")
+    verify(type(micro) is IntType, "optional micro isn't int")
+    verify(type(level) is StringType, "optional level isn't string")
+    verify(level in GOOD_SERIALS,
+           "optional level string has unknown value")
+    verify(type(serial) is IntType, "optional serial isn't int")
+
+    verify(type(mandatory) is TupleType or
+           mandatory is None, "mandatory isn't tuple or None")
+    if mandatory is not None:
+        verify(len(mandatory) == 5, "mandatory isn't 5-tuple")
+        major, minor, micro, level, serial = mandatory
+        verify(type(major) is IntType, "mandatory major isn't int")
+        verify(type(minor) is IntType, "mandatory minor isn't int")
+        verify(type(micro) is IntType, "mandatory micro isn't int")
+        verify(type(level) is StringType, "mandatory level isn't string")
+        verify(level in GOOD_SERIALS,
+               "mandatory serial string has unknown value")
+        verify(type(serial) is IntType, "mandatory serial isn't int")
+        verify(optional < mandatory,
+               "optional not less than mandatory, and mandatory not None")
+
+    verify(hasattr(value, "compiler_flag"),
+           "feature is missing a .compiler_flag attr")
+    verify(type(getattr(value, "compiler_flag")) is IntType,
+           ".compiler_flag isn't int")

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

@@ -0,0 +1,23 @@
+#! /usr/bin/env python
+"""Whimpy test script for the al module
+   Roger E. Masse
+"""
+import al
+from test_support import verbose
+
+alattrs = ['__doc__', '__name__', 'getdefault', 'getminmax', 'getname', 'getparams',
+           'newconfig', 'openport', 'queryparams', 'setparams']
+
+# This is a very unobtrusive test for the existence of the al module and all it's
+# attributes.  More comprehensive examples can be found in Demo/al
+
+def main():
+    # touch all the attributes of al without doing anything
+    if verbose:
+        print 'Touching al module attributes...'
+    for attr in alattrs:
+        if verbose:
+            print 'touching: ', attr
+        getattr(al, attr)
+
+main()