Changeset 2642:a490963718de in livinglogic.python.xist

Show
Ignore:
Timestamp:
01/31/07 17:44:58 (13 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Remove namespace subclassing test.

Move some of the namespace tests (with test pool functionality) to test_pool.py

Location:
test
Files:
2 modified

Legend:

Unmodified
Added
Removed
  • test/test_namespaces.py

    r2641 r2642  
    1616from ll.xist import xsc 
    1717from ll.xist.ns import html, xml, chars, abbr, ihtml, wml, specials, htmlspecials, form, meta, svg, fo, docbook, jsp, struts_html, struts_config, tld 
    18  
    19  
    20 def test_mixedattrnames(): 
    21     with xsc.Pool() as r: 
    22         xmlns = "test" 
    23  
    24         class Attrs(xsc.Attrs): 
    25             class a(xsc.TextAttr): 
    26                 xmlns = "test" 
    27                 xmlname = "A" 
    28             class A(xsc.TextAttr): 
    29                 xmlns = "test" 
    30                 xmlname = "a" 
    31      
    32         class Test(xsc.Element): 
    33             xmlns = "test" 
    34             class Attrs(xsc.Element.Attrs): 
    35                 class a(xsc.TextAttr): 
    36                     xmlname = "A" 
    37                 class A(xsc.TextAttr): 
    38                     xmlname = "a" 
    39  
    40     node = Test( 
    41         { 
    42             ("a", xmlns): "a2", 
    43             ("A", xmlns): "A2", 
    44         }, 
    45         a="a", 
    46         A="A" 
    47     ) 
    48  
    49     def check(name, value): 
    50         assert unicode(node[name]) == value 
    51         assert unicode(node.attrs[name]) == value 
    52         if not isinstance(name, tuple): 
    53             assert unicode(getattr(node.attrs, name)) == value 
    54         assert unicode(node.attrs.get(name)) == value 
    55         if isinstance(name, tuple): 
    56             name = (name[0], name[1].swapcase()) 
    57         else: 
    58             name = name.swapcase() 
    59         assert unicode(node.attrs.get_xml(name)) == value 
    60  
    61     tests = [ 
    62         ("a", "a"), 
    63         ("A", "A"), 
    64         (("a", xmlns), "a2"), 
    65         (("A", xmlns), "A2") 
    66     ] 
    67     for (name, value) in tests: 
    68         yield check, name, value 
    6918 
    7019 
     
    12271    assert xml.Attrs.lang.xmlname == u"lang" 
    12372    assert xml.Attrs.lang.xmlns == xml.xmlns 
    124  
    125  
    126 def test_subclassing(): 
    127     class NS1(xsc.Namespace): 
    128         xmlname = "test" 
    129  
    130         class foo(xsc.Element): 
    131             model = False 
    132             def convert(self, converter): 
    133                 e = self.xmlns().bar() 
    134                 return e.convert(converter) 
    135  
    136         class bar(xsc.Entity): 
    137             def convert(self, converter): 
    138                 return xsc.Text(17) 
    139  
    140     class NS2(NS1): 
    141         xmlname = "test" 
    142  
    143         class bar(xsc.Entity): 
    144             def convert(self, converter): 
    145                 return xsc.Text(23) 
    146  
    147     assert unicode(NS1.foo().conv()) == u"17" 
    148     assert unicode(NS2.foo().conv()) == u"23" 
    149  
    150  
    151 def test_poolkeysvaluesitems(): 
    152     with xsc.Pool() as r: 
    153         class el_(xsc.Element): 
    154             xmlname = "el" 
    155         class en_(xsc.Entity): 
    156             xmlname = "en" 
    157         class pi_(xsc.ProcInst): 
    158             xmlname = "pi" 
    159         class cr_(xsc.CharRef): 
    160             xmlname = "cr" 
    161             codepoint = 0x4242 
    162  
    163     # Test elements 
    164     assert list(r.elementkeys()) == [("el_", None)] 
    165     assert list(r.elementkeys_xml()) == [("el", None)] 
    166     assert list(r.elementvalues()) == [el_] 
    167     assert list(r.elementitems()) == [(("el_", None), el_)] 
    168     assert list(r.elementitems_xml()) == [(("el", None), el_)] 
    169      
    170     # Test entities 
    171     keys = list(r.entitykeys()) 
    172     assert len(keys) == 2 
    173     assert "en_" in keys 
    174     assert "cr_" in keys 
    175     keys = list(r.entitykeys_xml()) 
    176     assert len(keys) == 2 
    177     assert "en" in keys 
    178     assert "cr" in keys 
    179     values = list(r.entityvalues()) 
    180     assert len(values) == 2 
    181     assert en_ in values 
    182     assert cr_ in values 
    183     items = list(r.entityitems()) 
    184     assert len(items) == 2 
    185     assert ("en_", en_) in items 
    186     assert ("cr_", cr_) in items 
    187     items = list(r.entityitems_xml()) 
    188     assert len(items) == 2 
    189     assert ("en", en_) in items 
    190     assert ("cr", cr_) in items 
    191  
    192     # Test procinsts 
    193     assert list(r.procinstkeys()) == ["pi_"] 
    194     assert list(r.procinstkeys_xml()) == ["pi"] 
    195     assert list(r.procinstvalues()) == [pi_] 
    196     assert list(r.procinstitems()) == [("pi_", pi_)] 
    197     assert list(r.procinstitems_xml()) == [("pi", pi_)] 
    198  
    199     # Test charrefs 
    200     assert list(r.charrefkeys()) == ["cr_"] 
    201     assert list(r.charrefkeys_xml()) == ["cr"] 
    202     assert list(r.charrefvalues()) == [cr_] 
    203     assert list(r.charrefitems()) == [("cr_", cr_)] 
    204     assert list(r.charrefitems_xml()) == [("cr", cr_)] 
  • test/test_pool.py

    r2641 r2642  
    168168 
    169169 
     170def test_names2(): 
     171    with xsc.Pool() as r: 
     172        class el_(xsc.Element): 
     173            xmlname = "el" 
     174        class en_(xsc.Entity): 
     175            xmlname = "en" 
     176        class pi_(xsc.ProcInst): 
     177            xmlname = "pi" 
     178        class cr_(xsc.CharRef): 
     179            xmlname = "cr" 
     180            codepoint = 0x4242 
     181 
     182    # Test elements 
     183    assert list(r.elementkeys()) == [("el_", None)] 
     184    assert list(r.elementkeys_xml()) == [("el", None)] 
     185    assert list(r.elementvalues()) == [el_] 
     186    assert list(r.elementitems()) == [(("el_", None), el_)] 
     187    assert list(r.elementitems_xml()) == [(("el", None), el_)] 
     188     
     189    # Test entities 
     190    keys = list(r.entitykeys()) 
     191    assert len(keys) == 2 
     192    assert "en_" in keys 
     193    assert "cr_" in keys 
     194    keys = list(r.entitykeys_xml()) 
     195    assert len(keys) == 2 
     196    assert "en" in keys 
     197    assert "cr" in keys 
     198    values = list(r.entityvalues()) 
     199    assert len(values) == 2 
     200    assert en_ in values 
     201    assert cr_ in values 
     202    items = list(r.entityitems()) 
     203    assert len(items) == 2 
     204    assert ("en_", en_) in items 
     205    assert ("cr_", cr_) in items 
     206    items = list(r.entityitems_xml()) 
     207    assert len(items) == 2 
     208    assert ("en", en_) in items 
     209    assert ("cr", cr_) in items 
     210 
     211    # Test procinsts 
     212    assert list(r.procinstkeys()) == ["pi_"] 
     213    assert list(r.procinstkeys_xml()) == ["pi"] 
     214    assert list(r.procinstvalues()) == [pi_] 
     215    assert list(r.procinstitems()) == [("pi_", pi_)] 
     216    assert list(r.procinstitems_xml()) == [("pi", pi_)] 
     217 
     218    # Test charrefs 
     219    assert list(r.charrefkeys()) == ["cr_"] 
     220    assert list(r.charrefkeys_xml()) == ["cr"] 
     221    assert list(r.charrefvalues()) == [cr_] 
     222    assert list(r.charrefitems()) == [("cr_", cr_)] 
     223    assert list(r.charrefitems_xml()) == [("cr", cr_)] 
     224 
     225 
    170226def test_stack(): 
    171227    with xsc.Pool() as r1: 
     
    220276    assert r2.elementclass_xml("foo", "nix") is foo 
    221277    assert r2.elementclass_xml("bar", "nix") is bar 
     278 
     279 
     280def test_mixedattrnames(): 
     281    with xsc.Pool() as r: 
     282        xmlns = "test" 
     283 
     284        class Attrs(xsc.Attrs): 
     285            class a(xsc.TextAttr): 
     286                xmlns = "test" 
     287                xmlname = "A" 
     288            class A(xsc.TextAttr): 
     289                xmlns = "test" 
     290                xmlname = "a" 
     291     
     292        class Test(xsc.Element): 
     293            xmlns = "test" 
     294            class Attrs(xsc.Element.Attrs): 
     295                class a(xsc.TextAttr): 
     296                    xmlname = "A" 
     297                class A(xsc.TextAttr): 
     298                    xmlname = "a" 
     299 
     300    node = Test( 
     301        { 
     302            ("a", xmlns): "a2", 
     303            ("A", xmlns): "A2", 
     304        }, 
     305        a="a", 
     306        A="A" 
     307    ) 
     308 
     309    def check(name, value): 
     310        assert unicode(node[name]) == value 
     311        assert unicode(node.attrs[name]) == value 
     312        if not isinstance(name, tuple): 
     313            assert unicode(getattr(node.attrs, name)) == value 
     314        assert unicode(node.attrs.get(name)) == value 
     315        if isinstance(name, tuple): 
     316            name = (name[0], name[1].swapcase()) 
     317        else: 
     318            name = name.swapcase() 
     319        assert unicode(node.attrs.get_xml(name)) == value 
     320 
     321    tests = [ 
     322        ("a", "a"), 
     323        ("A", "A"), 
     324        (("a", xmlns), "a2"), 
     325        (("A", xmlns), "A2") 
     326    ] 
     327    for (name, value) in tests: 
     328        yield check, name, value