RubyGems - rubyfox-server - Versions diffs - 2.3.0.pre2 - Mend

rubyfox-server 2.3.0.pre2

Files changed (993) hide show

data/lib/rubyfox/server/data/lib/Lib/test/test_htmlparser.py ADDED Viewed

@@ -0,0 +1,294 @@
+"""Tests for HTMLParser.py."""
+import HTMLParser
+import pprint
+import sys
+import test_support
+import unittest
+class EventCollector(HTMLParser.HTMLParser):
+    def __init__(self):
+        self.events = []
+        self.append = self.events.append
+        HTMLParser.HTMLParser.__init__(self)
+    def get_events(self):
+        # Normalize the list of events so that buffer artefacts don't
+        # separate runs of contiguous characters.
+        L = []
+        prevtype = None
+        for event in self.events:
+            type = event[0]
+            if type == prevtype == "data":
+                L[-1] = ("data", L[-1][1] + event[1])
+            else:
+                L.append(event)
+            prevtype = type
+        self.events = L
+        return L
+    # structure markup
+    def handle_starttag(self, tag, attrs):
+        self.append(("starttag", tag, attrs))
+    def handle_startendtag(self, tag, attrs):
+        self.append(("startendtag", tag, attrs))
+    def handle_endtag(self, tag):
+        self.append(("endtag", tag))
+    # all other markup
+    def handle_comment(self, data):
+        self.append(("comment", data))
+    def handle_charref(self, data):
+        self.append(("charref", data))
+    def handle_data(self, data):
+        self.append(("data", data))
+    def handle_decl(self, data):
+        self.append(("decl", data))
+    def handle_entityref(self, data):
+        self.append(("entityref", data))
+    def handle_pi(self, data):
+        self.append(("pi", data))
+    def unknown_decl(self, decl):
+        self.append(("unknown decl", decl))
+class EventCollectorExtra(EventCollector):
+    def handle_starttag(self, tag, attrs):
+        EventCollector.handle_starttag(self, tag, attrs)
+        self.append(("starttag_text", self.get_starttag_text()))
+class TestCaseBase(unittest.TestCase):
+    def _run_check(self, source, expected_events, collector=EventCollector):
+        parser = collector()
+        for s in source:
+            parser.feed(s)
+        parser.close()
+        events = parser.get_events()
+        if events != expected_events:
+            self.fail("received events did not match expected events\n"
+                      "Expected:\n" + pprint.pformat(expected_events) +
+                      "\nReceived:\n" + pprint.pformat(events))
+    def _run_check_extra(self, source, events):
+        self._run_check(source, events, EventCollectorExtra)
+    def _parse_error(self, source):
+        def parse(source=source):
+            parser = HTMLParser.HTMLParser()
+            parser.feed(source)
+            parser.close()
+        self.assertRaises(HTMLParser.HTMLParseError, parse)
+class HTMLParserTestCase(TestCaseBase):
+    def test_processing_instruction_only(self):
+        self._run_check("<?processing instruction>", [
+            ("pi", "processing instruction"),
+            ])
+    def test_simple_html(self):
+        self._run_check("""
+<!DOCTYPE html PUBLIC 'foo'>
+<HTML>&entity;&#32;
+<!--comment1a
+-></foo><bar>&lt;<?pi?></foo<bar
+comment1b-->
+<Img sRc='Bar' isMAP>sample
+text
+&#x201C;
+<!--comment2a-- --comment2b-->
+</Html>
+""", [
+    ("data", "\n"),
+    ("decl", "DOCTYPE html PUBLIC 'foo'"),
+    ("data", "\n"),
+    ("starttag", "html", []),
+    ("entityref", "entity"),
+    ("charref", "32"),
+    ("data", "\n"),
+    ("comment", "comment1a\n-></foo><bar>&lt;<?pi?></foo<bar\ncomment1b"),
+    ("data", "\n"),
+    ("starttag", "img", [("src", "Bar"), ("ismap", None)]),
+    ("data", "sample\ntext\n"),
+    ("charref", "x201C"),
+    ("data", "\n"),
+    ("comment", "comment2a-- --comment2b"),
+    ("data", "\n"),
+    ("endtag", "html"),
+    ("data", "\n"),
+    ])
+    def test_unclosed_entityref(self):
+        self._run_check("&entityref foo", [
+            ("entityref", "entityref"),
+            ("data", " foo"),
+            ])
+    def test_doctype_decl(self):
+        inside = """\
+DOCTYPE html [
+  <!ELEMENT html - O EMPTY>
+  <!ATTLIST html
+      version CDATA #IMPLIED
+      profile CDATA 'DublinCore'>
+  <!NOTATION datatype SYSTEM 'http://xml.python.org/notations/python-module'>
+  <!ENTITY myEntity 'internal parsed entity'>
+  <!ENTITY anEntity SYSTEM 'http://xml.python.org/entities/something.xml'>
+  <!ENTITY % paramEntity 'name|name|name'>
+  %paramEntity;
+  <!-- comment -->
+]"""
+        self._run_check("<!%s>" % inside, [
+            ("decl", inside),
+            ])
+    def test_bad_nesting(self):
+        # Strangely, this *is* supposed to test that overlapping
+        # elements are allowed.  HTMLParser is more geared toward
+        # lexing the input that parsing the structure.
+        self._run_check("<a><b></a></b>", [
+            ("starttag", "a", []),
+            ("starttag", "b", []),
+            ("endtag", "a"),
+            ("endtag", "b"),
+            ])
+    def test_bare_ampersands(self):
+        self._run_check("this text & contains & ampersands &", [
+            ("data", "this text & contains & ampersands &"),
+            ])
+    def test_bare_pointy_brackets(self):
+        self._run_check("this < text > contains < bare>pointy< brackets", [
+            ("data", "this < text > contains < bare>pointy< brackets"),
+            ])
+    def test_attr_syntax(self):
+        output = [
+          ("starttag", "a", [("b", "v"), ("c", "v"), ("d", "v"), ("e", None)])
+          ]
+        self._run_check("""<a b='v' c="v" d=v e>""", output)
+        self._run_check("""<a  b = 'v' c = "v" d = v e>""", output)
+        self._run_check("""<a\nb\n=\n'v'\nc\n=\n"v"\nd\n=\nv\ne>""", output)
+        self._run_check("""<a\tb\t=\t'v'\tc\t=\t"v"\td\t=\tv\te>""", output)
+    def test_attr_values(self):
+        self._run_check("""<a b='xxx\n\txxx' c="yyy\t\nyyy" d='\txyz\n'>""",
+                        [("starttag", "a", [("b", "xxx\n\txxx"),
+                                            ("c", "yyy\t\nyyy"),
+                                            ("d", "\txyz\n")])
+                         ])
+        self._run_check("""<a b='' c="">""", [
+            ("starttag", "a", [("b", ""), ("c", "")]),
+            ])
+    def test_attr_entity_replacement(self):
+        self._run_check("""<a b='&amp;&gt;&lt;&quot;&apos;'>""", [
+            ("starttag", "a", [("b", "&><\"'")]),
+            ])
+    def test_attr_funky_names(self):
+        self._run_check("""<a a.b='v' c:d=v e-f=v>""", [
+            ("starttag", "a", [("a.b", "v"), ("c:d", "v"), ("e-f", "v")]),
+            ])
+    def test_illegal_declarations(self):
+        self._parse_error('<!spacer type="block" height="25">')
+    def test_starttag_end_boundary(self):
+        self._run_check("""<a b='<'>""", [("starttag", "a", [("b", "<")])])
+        self._run_check("""<a b='>'>""", [("starttag", "a", [("b", ">")])])
+    def test_buffer_artefacts(self):
+        output = [("starttag", "a", [("b", "<")])]
+        self._run_check(["<a b='<'>"], output)
+        self._run_check(["<a ", "b='<'>"], output)
+        self._run_check(["<a b", "='<'>"], output)
+        self._run_check(["<a b=", "'<'>"], output)
+        self._run_check(["<a b='<", "'>"], output)
+        self._run_check(["<a b='<'", ">"], output)
+        output = [("starttag", "a", [("b", ">")])]
+        self._run_check(["<a b='>'>"], output)
+        self._run_check(["<a ", "b='>'>"], output)
+        self._run_check(["<a b", "='>'>"], output)
+        self._run_check(["<a b=", "'>'>"], output)
+        self._run_check(["<a b='>", "'>"], output)
+        self._run_check(["<a b='>'", ">"], output)
+    def test_starttag_junk_chars(self):
+        self._parse_error("</>")
+        self._parse_error("</$>")
+        self._parse_error("</")
+        self._parse_error("</a")
+        self._parse_error("<a<a>")
+        self._parse_error("</a<a>")
+        self._parse_error("<!")
+        self._parse_error("<a $>")
+        self._parse_error("<a")
+        self._parse_error("<a foo='bar'")
+        self._parse_error("<a foo='bar")
+        self._parse_error("<a foo='>'")
+        self._parse_error("<a foo='>")
+        self._parse_error("<a foo=>")
+    def test_declaration_junk_chars(self):
+        self._parse_error("<!DOCTYPE foo $ >")
+    def test_startendtag(self):
+        self._run_check("<p/>", [
+            ("startendtag", "p", []),
+            ])
+        self._run_check("<p></p>", [
+            ("starttag", "p", []),
+            ("endtag", "p"),
+            ])
+        self._run_check("<p><img src='foo' /></p>", [
+            ("starttag", "p", []),
+            ("startendtag", "img", [("src", "foo")]),
+            ("endtag", "p"),
+            ])
+    def test_get_starttag_text(self):
+        s = """<foo:bar   \n   one="1"\ttwo=2   >"""
+        self._run_check_extra(s, [
+            ("starttag", "foo:bar", [("one", "1"), ("two", "2")]),
+            ("starttag_text", s)])
+    def test_cdata_content(self):
+        s = """<script> <!-- not a comment --> &not-an-entity-ref; </script>"""
+        self._run_check(s, [
+            ("starttag", "script", []),
+            ("data", " <!-- not a comment --> &not-an-entity-ref; "),
+            ("endtag", "script"),
+            ])
+        s = """<script> <not a='start tag'> </script>"""
+        self._run_check(s, [
+            ("starttag", "script", []),
+            ("data", " <not a='start tag'> "),
+            ("endtag", "script"),
+            ])
+def test_main():
+    test_support.run_unittest(HTMLParserTestCase)
+if __name__ == "__main__":
+    test_main()

data/lib/rubyfox/server/data/lib/Lib/test/test_httplib.py ADDED Viewed

@@ -0,0 +1,58 @@
+from test_support import verify,verbose
+import httplib
+import StringIO
+class FakeSocket:
+    def __init__(self, text):
+        self.text = text
+    def makefile(self, mode, bufsize=None):
+        if mode != 'r' and mode != 'rb':
+            raise httplib.UnimplementedFileMode()
+        return StringIO.StringIO(self.text)
+# Test HTTP status lines
+body = "HTTP/1.1 200 Ok\n\nText"
+sock = FakeSocket(body)
+resp = httplib.HTTPResponse(sock, 1)
+resp.begin()
+print resp.read()
+resp.close()
+body = "HTTP/1.1 400.100 Not Ok\n\nText"
+sock = FakeSocket(body)
+resp = httplib.HTTPResponse(sock, 1)
+try:
+    resp.begin()
+except httplib.BadStatusLine:
+    print "BadStatusLine raised as expected"
+else:
+    print "Expect BadStatusLine"
+# Check invalid host_port
+for hp in ("www.python.org:abc", "www.python.org:"):
+    try:
+        h = httplib.HTTP(hp)
+    except httplib.InvalidURL:
+        print "InvalidURL raised as expected"
+    else:
+        print "Expect InvalidURL"
+# test response with multiple message headers with the same field name.
+text = ('HTTP/1.1 200 OK\n'
+        'Set-Cookie: Customer="WILE_E_COYOTE"; Version="1"; Path="/acme"\n'
+        'Set-Cookie: Part_Number="Rocket_Launcher_0001"; Version="1";'
+        ' Path="/acme"\n'
+        '\n'
+        'No body\n')
+hdr = ('Customer="WILE_E_COYOTE"; Version="1"; Path="/acme"'
+       ', '
+       'Part_Number="Rocket_Launcher_0001"; Version="1"; Path="/acme"')
+s = FakeSocket(text)
+r = httplib.HTTPResponse(s, 1)
+r.begin()
+cookies = r.getheader("Set-Cookie")
+if cookies != hdr:
+    raise AssertionError, "multiple headers not combined properly"

data/lib/rubyfox/server/data/lib/Lib/test/test_imageop.py ADDED Viewed

@@ -0,0 +1,171 @@
+#! /usr/bin/env python
+"""Test script for the imageop module.  This has the side
+   effect of partially testing the imgfile module as well.
+   Roger E. Masse
+"""
+from test_support import verbose, unlink
+import imageop, uu, os
+def main(use_rgbimg=1):
+    # Create binary test files
+    uu.decode(get_qualified_path('testrgb'+os.extsep+'uue'), 'test'+os.extsep+'rgb')
+    if use_rgbimg:
+        image, width, height = getrgbimage('test'+os.extsep+'rgb')
+    else:
+        image, width, height = getimage('test'+os.extsep+'rgb')
+    # Return the selected part of image, which should by width by height
+    # in size and consist of pixels of psize bytes.
+    if verbose:
+        print 'crop'
+    newimage = imageop.crop (image, 4, width, height, 0, 0, 1, 1)
+    # Return image scaled to size newwidth by newheight. No interpolation
+    # is done, scaling is done by simple-minded pixel duplication or removal.
+    # Therefore, computer-generated images or dithered images will
+    # not look nice after scaling.
+    if verbose:
+        print 'scale'
+    scaleimage = imageop.scale(image, 4, width, height, 1, 1)
+    # Run a vertical low-pass filter over an image. It does so by computing
+    # each destination pixel as the average of two vertically-aligned source
+    # pixels. The main use of this routine is to forestall excessive flicker
+    # if the image two vertically-aligned source pixels,  hence the name.
+    if verbose:
+        print 'tovideo'
+    videoimage = imageop.tovideo (image, 4, width, height)
+    # Convert an rgb image to an 8 bit rgb
+    if verbose:
+        print 'rgb2rgb8'
+    greyimage = imageop.rgb2rgb8(image, width, height)
+    # Convert an 8 bit rgb image to a 24 bit rgb image
+    if verbose:
+        print 'rgb82rgb'
+    image = imageop.rgb82rgb(greyimage, width, height)
+    # Convert an rgb image to an 8 bit greyscale image
+    if verbose:
+        print 'rgb2grey'
+    greyimage = imageop.rgb2grey(image, width, height)
+    # Convert an 8 bit greyscale image to a 24 bit rgb image
+    if verbose:
+        print 'grey2rgb'
+    image = imageop.grey2rgb(greyimage, width, height)
+    # Convert a 8-bit deep greyscale image to a 1-bit deep image by
+    # thresholding all the pixels. The resulting image is tightly packed
+    # and is probably only useful as an argument to mono2grey.
+    if verbose:
+        print 'grey2mono'
+    monoimage = imageop.grey2mono (greyimage, width, height, 0)
+    # monoimage, width, height = getimage('monotest.rgb')
+    # Convert a 1-bit monochrome image to an 8 bit greyscale or color image.
+    # All pixels that are zero-valued on input get value p0 on output and
+    # all one-value input pixels get value p1 on output. To convert a
+    # monochrome  black-and-white image to greyscale pass the values 0 and
+    # 255 respectively.
+    if verbose:
+        print 'mono2grey'
+    greyimage = imageop.mono2grey (monoimage, width, height, 0, 255)
+    # Convert an 8-bit greyscale image to a 1-bit monochrome image using a
+    # (simple-minded) dithering algorithm.
+    if verbose:
+        print 'dither2mono'
+    monoimage = imageop.dither2mono (greyimage, width, height)
+    # Convert an 8-bit greyscale image to a 4-bit greyscale image without
+    # dithering.
+    if verbose:
+        print 'grey2grey4'
+    grey4image = imageop.grey2grey4 (greyimage, width, height)
+    # Convert an 8-bit greyscale image to a 2-bit greyscale image without
+    # dithering.
+    if verbose:
+        print 'grey2grey2'
+    grey2image = imageop.grey2grey2 (greyimage, width, height)
+    # Convert an 8-bit greyscale image to a 2-bit greyscale image with
+    # dithering. As for dither2mono, the dithering algorithm is currently
+    # very simple.
+    if verbose:
+        print 'dither2grey2'
+    grey2image = imageop.dither2grey2 (greyimage, width, height)
+    # Convert a 4-bit greyscale image to an 8-bit greyscale image.
+    if verbose:
+        print 'grey42grey'
+    greyimage = imageop.grey42grey (grey4image, width, height)
+    # Convert a 2-bit greyscale image to an 8-bit greyscale image.
+    if verbose:
+        print 'grey22grey'
+    image = imageop.grey22grey (grey2image, width, height)
+    # Cleanup
+    unlink('test'+os.extsep+'rgb')
+def getrgbimage(name):
+    """return a tuple consisting of image (in 'imgfile' format but
+    using rgbimg instead) width and height"""
+    import rgbimg
+    try:
+        sizes = rgbimg.sizeofimage(name)
+    except rgbimg.error:
+        name = get_qualified_path(name)
+        sizes = rgbimg.sizeofimage(name)
+    if verbose:
+        print 'rgbimg opening test image: %s, sizes: %s' % (name, str(sizes))
+    image = rgbimg.longimagedata(name)
+    return (image, sizes[0], sizes[1])
+def getimage(name):
+    """return a tuple consisting of
+       image (in 'imgfile' format) width and height
+    """
+    import imgfile
+    try:
+        sizes = imgfile.getsizes(name)
+    except imgfile.error:
+        name = get_qualified_path(name)
+        sizes = imgfile.getsizes(name)
+    if verbose:
+        print 'imgfile opening test image: %s, sizes: %s' % (name, str(sizes))
+    image = imgfile.read(name)
+    return (image, sizes[0], sizes[1])
+def get_qualified_path(name):
+    """ return a more qualified path to name"""
+    import sys
+    import os
+    path = sys.path
+    try:
+        path = [os.path.dirname(__file__)] + path
+    except NameError:
+        pass
+    for dir in path:
+        fullname = os.path.join(dir, name)
+        if os.path.exists(fullname):
+            return fullname
+    return name
+# rgbimg (unlike imgfile) is portable to platforms other than SGI.
+# So we prefer to use it.
+main(use_rgbimg=1)

data/lib/rubyfox/server/data/lib/Lib/test/test_imgfile.py ADDED Viewed

@@ -0,0 +1,116 @@
+#! /usr/bin/env python
+"""Simple test script for imgfile.c
+   Roger E. Masse
+"""
+from test_support import verbose, unlink, findfile
+import imgfile, uu, os
+def main():
+    uu.decode(findfile('testrgb.uue'), 'test.rgb')
+    uu.decode(findfile('greyrgb.uue'), 'greytest.rgb')
+    # Test a 3 byte color image
+    testimage('test.rgb')
+    # Test a 1 byte greyscale image
+    testimage('greytest.rgb')
+    unlink('test.rgb')
+    unlink('greytest.rgb')
+def testimage(name):
+    """Run through the imgfile's battery of possible methods
+       on the image passed in name.
+    """
+    import sys
+    import os
+    outputfile = '/tmp/deleteme'
+    # try opening the name directly
+    try:
+        # This function returns a tuple (x, y, z) where x and y are the size
+        # of the image in pixels and z is the number of bytes per pixel. Only
+        # 3 byte RGB pixels and 1 byte greyscale pixels are supported.
+        sizes = imgfile.getsizes(name)
+    except imgfile.error:
+        # get a more qualified path component of the script...
+        if __name__ == '__main__':
+            ourname = sys.argv[0]
+        else: # ...or the full path of the module
+            ourname = sys.modules[__name__].__file__
+        parts = ourname.split(os.sep)
+        parts[-1] = name
+        name = os.sep.join(parts)
+        sizes = imgfile.getsizes(name)
+    if verbose:
+        print 'Opening test image: %s, sizes: %s' % (name, str(sizes))
+    # This function reads and decodes the image on the specified file,
+    # and returns it as a python string. The string has either 1 byte
+    # greyscale pixels or 4 byte RGBA pixels. The bottom left pixel
+    # is the first in the string. This format is suitable to pass
+    # to gl.lrectwrite, for instance.
+    image = imgfile.read(name)
+    # This function writes the RGB or greyscale data in data to
+    # image file file. x and y give the size of the image, z is
+    # 1 for 1 byte greyscale images or 3 for RGB images (which
+    # are stored as 4 byte values of which only the lower three
+    # bytes are used). These are the formats returned by gl.lrectread.
+    if verbose:
+        print 'Writing output file'
+    imgfile.write (outputfile, image, sizes[0], sizes[1], sizes[2])
+    if verbose:
+        print 'Opening scaled test image: %s, sizes: %s' % (name, str(sizes))
+    # This function is identical to read but it returns an image that
+    # is scaled to the given x and y sizes. If the filter and blur
+    # parameters are omitted scaling is done by simply dropping
+    # or duplicating pixels, so the result will be less than perfect,
+    # especially for computer-generated images.  Alternatively,
+    # you can specify a filter to use to smoothen the image after
+    # scaling. The filter forms supported are 'impulse', 'box',
+    # 'triangle', 'quadratic' and 'gaussian'. If a filter is
+    # specified blur is an optional parameter specifying the
+    # blurriness of the filter. It defaults to 1.0.  readscaled
+    # makes no attempt to keep the aspect ratio correct, so that
+    # is the users' responsibility.
+    if verbose:
+        print 'Filtering with "impulse"'
+    simage = imgfile.readscaled (name, sizes[0]/2, sizes[1]/2, 'impulse', 2.0)
+    # This function sets a global flag which defines whether the
+    # scan lines of the image are read or written from bottom to
+    # top (flag is zero, compatible with SGI GL) or from top to
+    # bottom(flag is one, compatible with X). The default is zero.
+    if verbose:
+        print 'Switching to X compatibility'
+    imgfile.ttob (1)
+    if verbose:
+        print 'Filtering with "triangle"'
+    simage = imgfile.readscaled (name, sizes[0]/2, sizes[1]/2, 'triangle', 3.0)
+    if verbose:
+        print 'Switching back to SGI compatibility'
+    imgfile.ttob (0)
+    if verbose: print 'Filtering with "quadratic"'
+    simage = imgfile.readscaled (name, sizes[0]/2, sizes[1]/2, 'quadratic')
+    if verbose: print 'Filtering with "gaussian"'
+    simage = imgfile.readscaled (name, sizes[0]/2, sizes[1]/2, 'gaussian', 1.0)
+    if verbose:
+        print 'Writing output file'
+    imgfile.write (outputfile, simage, sizes[0]/2, sizes[1]/2, sizes[2])
+    os.unlink(outputfile)
+main()