root/livinglogic.python.xist/test/test_xist.py @ 2559:8d4552168c39

Revision 2559:8d4552168c39, 22.5 KB (checked in by Walter Doerwald <walter@…>, 13 years ago)

Add setuptools to the list of requirements.

Update NEWS items.

parsed() can now return a different node (This is used by specials.url)

The PI specials.url has been added that does the same URL handling as
xsc.URLAttr.

Unused stuff (encode, Queue, Esc*Text) has been removed from presenters.
NormalPresenter? has been dropped.

Fixed a small bug in CodePresenter?.presentProcInst().

Exceptions and warning no longer have to output the node location
themselves as it is included in the normal repr() output.

Fixed a few str() methods for warnings that still used astyle.color().

The Node methods repr() and asrepr() have been removed.

Renamed venom to detox.

Line 
1#! /usr/bin/env/python
2# -*- coding: iso-8859-1 -*-
3
4## Copyright 1999-2005 by LivingLogic AG, Bayreuth/Germany.
5## Copyright 1999-2005 by Walter Dörwald
6##
7## All Rights Reserved
8##
9## See xist/__init__.py for the license
10
11import sys, unittest, cStringIO, warnings
12
13from xml.sax import saxlib
14from xml.parsers import expat
15
16import py.test
17
18from ll import url
19from ll.xist import xsc, parsers, cssparsers, presenters, converters, helpers, options, sims, xnd, xfind
20from ll.xist.ns import wml, ihtml, html, chars, abbr, specials, htmlspecials, meta, form, php, xml, tld, docbook
21
22import common
23
24
25# set to something ASCII, so presenters work, even if the system default encoding is ascii
26options.reprtab = "  "
27
28
29def check_lenunicode(node, _len, content):
30    assert len(node) == _len
31    assert unicode(node) == content
32
33
34def test_fraglen():
35    check_lenunicode(xsc.Frag(), 0, u"")
36    check_lenunicode(xsc.Frag(1), 1, u"1")
37    check_lenunicode(xsc.Frag(1, 2, 3), 3, u"123")
38    check_lenunicode(xsc.Frag(None), 0, u"")
39    check_lenunicode(xsc.Frag(None, None, None), 0, u"")
40    check_lenunicode(xsc.Frag(1, None, 2, None, 3, None, 4), 4, u"1234")
41    check_lenunicode(xsc.Frag(1, (2, 3)), 3, u"123")
42    check_lenunicode(xsc.Frag(1, (None, None)), 1, u"1")
43
44
45def test_append():
46    for cls in (xsc.Frag, html.div):
47        node = cls()
48        node.append(1)
49        check_lenunicode(node, 1, u"1")
50        node.append(2)
51        check_lenunicode(node, 2, u"12")
52        node.append()
53        check_lenunicode(node, 2, u"12")
54        node.append(3, 4)
55        check_lenunicode(node, 4, u"1234")
56        node.append(None)
57        check_lenunicode(node, 4, u"1234")
58        node.append((5, 6))
59        check_lenunicode(node, 6, u"123456")
60
61
62def test_extend():
63    for cls in (xsc.Frag, html.div):
64        node = cls()
65        node.extend([1])
66        check_lenunicode(node, 1, u"1")
67        node.extend([2])
68        check_lenunicode(node, 2, u"12")
69        node.extend([])
70        check_lenunicode(node, 2, u"12")
71        node.extend([None])
72        check_lenunicode(node, 2, u"12")
73        node.extend([3, 4])
74        check_lenunicode(node, 4, u"1234")
75        node.extend([[], [[], [5], []]])
76        check_lenunicode(node, 5, u"12345")
77
78
79def test_insert():
80    for cls in (xsc.Frag, html.div):
81        node = cls()
82        node.insert(0, 1)
83        check_lenunicode(node, 1, u"1")
84        node.insert(0, 2)
85        check_lenunicode(node, 2, u"21")
86        node.insert(0, 3, 4)
87        check_lenunicode(node, 4, u"3421")
88        node.insert(0, None)
89        check_lenunicode(node, 4, u"3421")
90        node.insert(0, (5, 6))
91        check_lenunicode(node, 6, u"563421")
92
93
94def test_iadd():
95    for cls in (xsc.Frag, html.div):
96        node = cls()
97        node += [1]
98        check_lenunicode(node, 1, u"1")
99        node += [2]
100        check_lenunicode(node, 2, u"12")
101        node += []
102        check_lenunicode(node, 2, u"12")
103        node += [None]
104        check_lenunicode(node, 2, u"12")
105        node += [3, 4]
106        check_lenunicode(node, 4, u"1234")
107        node += [[], [[], [5], []]]
108        check_lenunicode(node, 5, u"12345")
109
110
111def test_len():
112    for cls in (xsc.Frag, html.div):
113        check_lenunicode(cls(), 0, u"")
114        check_lenunicode(cls(1), 1, u"1")
115        check_lenunicode(cls(1, 2, 3), 3, u"123")
116        check_lenunicode(cls(None), 0, u"")
117        check_lenunicode(cls(None, None, None), 0, u"")
118        check_lenunicode(cls(1, None, 2, None, 3, None, 4), 4, u"1234")
119        check_lenunicode(cls(1, (2, 3)), 3, u"123")
120        check_lenunicode(cls(1, (None, None)), 1, u"1")
121
122
123def test_standardmethods():
124    for node in common.allnodes():
125        node.compact()
126        node.normalized()
127        list(node.walk((True, xsc.enterattrs, xsc.entercontent)))
128        list(node.walknode((True, xsc.enterattrs, xsc.entercontent)))
129        list(node.walkindex((True, xsc.enterattrs, xsc.entercontent)))
130        list(node.walkpath((True, xsc.enterattrs, xsc.entercontent)))
131        node.pretty()
132        node.clone()
133        node.conv()
134        node.normalized().compact().pretty()
135
136
137def test_standardmethods2():
138    for node in (common.createelement(), common.createfrag()):
139        node.sorted()
140        node.shuffled()
141        node.reversed()
142
143
144def test_stringify():
145    for node in common.allnodes():
146        unicode(node)
147        str(node)
148        node.asString()
149        node.asBytes()
150
151
152def test_asText():
153    for node in common.allnodes():
154        node.asText()
155        node.asText(monochrome=True)
156        node.asText(squeezeBlankLines=True)
157        node.asText(lineNumbers=True)
158        node.asText(width=120)
159
160
161def test_number():
162    node = html.div(class_=1234)
163    assert int(node["class_"]) == 1234
164    assert long(node["class_"]) == 1234L
165    assert abs(float(node["class_"]) - 1234.) < 1e-2
166    node = html.div(class_="1+1j")
167    compl = complex(node["class_"])
168    assert abs(compl.real - 1.) < 1e-2
169    assert abs(compl.imag - 1.) < 1e-2
170
171
172def test_prefix():
173    node = html.div()
174    assert node.xmlprefix() == "html"
175
176
177def test_write():
178    node = html.div()
179    io = cStringIO.StringIO()
180    node.write(io, xhtml=2)
181    assert io.getvalue() == "<div/>"
182
183
184def test_mul():
185    node = xsc.Frag("a")
186    assert 3*node == xsc.Frag(list("aaa"))
187    assert node*3 == xsc.Frag(list("aaa"))
188
189    node = html.div()
190    assert 3*node == xsc.Frag(html.div(), html.div(), html.div())
191    assert node*3 == xsc.Frag(html.div(), html.div(), html.div())
192
193
194def test_text():
195    s = "test"
196    node = xsc.Text(s)
197    hash(node)
198    assert len(node), 4
199    assert node[1] == xsc.Text("e")
200    assert 3*node == xsc.Text(3*s)
201    assert node*3 == xsc.Text(s*3)
202    assert node[1:3] == xsc.Text("es")
203    assert node.capitalize() == xsc.Text("Test")
204    assert node.center(8) == xsc.Text("  test  ")
205    assert node.count("t") == 2
206    assert node.endswith("st") is True
207    assert node.index("s") == 2
208    assert node.isalpha() is True
209    assert node.isalnum() is True
210    assert node.isdecimal() is False
211    assert node.isdigit() is False
212    assert node.islower() is True
213    assert node.isnumeric() is False
214    assert node.isspace() is False
215    assert node.istitle() is False
216    assert node.isupper() is False
217    assert node.join(xsc.Frag(list("abc"))) == xsc.Frag("a", "test", "b", "test", "c")
218    assert node.ljust(6) == xsc.Text("test  ")
219    assert node.ljust(6, ".") == xsc.Text("test..")
220    assert node.lower() == xsc.Text("test")
221    assert xsc.Text("  test").lstrip() == xsc.Text("test")
222    assert node.replace("s", "x") == xsc.Text("text")
223    assert node.rjust(6) == xsc.Text("  test")
224    assert node.rjust(6, ".") == xsc.Text("..test")
225    assert xsc.Text("test  ").rstrip() == xsc.Text("test")
226    assert node.rfind("s") == 2
227    assert node.rindex("s") == 2
228    assert node.split("e") == xsc.Frag("t", "st")
229    assert xsc.Text("a\nb\n").splitlines() == xsc.Frag("a", "b")
230    assert node.startswith("te") is True
231    assert xsc.Text("  test  ").strip() == xsc.Text("test")
232    assert node.swapcase() == xsc.Text("TEST")
233    assert node.title() == xsc.Text("Test")
234    assert node.upper() == xsc.Text("TEST")
235
236
237def test_charref():
238    node = chars.ouml()
239    hash(node)
240    assert len(node) == 1
241    assert node[0] == xsc.Text(u"ö")
242    assert 3*node == xsc.Text(u"ööö")
243    assert node*3 == xsc.Text(u"ööö")
244    assert node[1:-2] == xsc.Text()
245    assert node.capitalize() == xsc.Text(u"Ö")
246    assert node.center(5) == xsc.Text(u"  ö  ")
247    assert node.count(u"t") == 0
248    assert node.endswith(u"ö") is True
249    assert node.index(u"ö") == 0
250    assert node.isalpha() is True
251    assert node.isalnum() is True
252    assert node.isdecimal() is False
253    assert node.isdigit() is False
254    assert node.islower() is True
255    assert node.isnumeric() is False
256    assert node.isspace() is False
257    assert node.istitle() is False
258    assert node.isupper() is False
259    assert node.ljust(3) == xsc.Text(u"ö  ")
260    assert node.ljust(3, ".") == xsc.Text(u"ö..")
261    assert node.lower() == xsc.Text(u"ö")
262    assert node.replace(u"ö", "x") == xsc.Text("x")
263    assert node.rjust(3) == xsc.Text(u"  ö")
264    assert node.rjust(3, ".") == xsc.Text(u"..ö")
265    assert node.rfind(u"ö") == 0
266    assert node.rindex(u"ö") == 0
267    assert node.startswith(u"ö") is True
268    assert node.swapcase() == xsc.Text(u"Ö")
269    assert node.title() == xsc.Text(u"Ö")
270    assert node.upper() == xsc.Text(u"Ö")
271
272
273def test_getsetitem():
274    for cls in (xsc.Frag, html.div):
275        for attr in ("class_", (xml, "lang")):
276            node = cls(html.div("foo", html.div({attr: "gurk"}), "bar"))
277            assert node[[]] is node
278            assert str(node[[0, 1, attr]]) == "gurk"
279            node[[0, 1, attr]] = "hurz"
280            assert str(node[[0, 1, attr]]) == "hurz"
281            i = node[0][xsc.Text]
282            assert str(i.next()) == "foo"
283            assert str(i.next()) == "bar"
284            py.test.raises(StopIteration, i.next)
285            py.test.raises(ValueError, node.__setitem__, [], None)
286            py.test.raises(ValueError, node.__delitem__, [])
287
288
289def test_conv():
290    def mappedmapper(node, converter):
291        if isinstance(node, xsc.Text):
292            node = node.replace("gurk", "hurz")
293        return node
294
295    node = common.createfrag()
296    node.conv()
297    node.conv(converters.Converter())
298    node.mapped(mappedmapper, converters.Converter())
299
300
301def test_repr():
302    tests = common.allnodes()
303    allpresenters = [c for c in presenters.__dict__.itervalues() if isinstance(c, type) and c is not presenters.Presenter and issubclass(c, presenters.Presenter)]
304    for node in tests:
305        repr(node)
306        for class_ in allpresenters:
307            presenter = class_(node)
308            # do it multiple time, to make sure the presenter gets properly reset
309            for i in xrange(3):
310                list(presenter)
311                str(presenter)
312
313
314def test_attrsclone():
315    class newa(html.a):
316        def convert(self, converter):
317            attrs = self.attrs.clone()
318            attrs["href"].insert(0, "foo")
319            e = html.a(self.content, attrs)
320            return e.convert(converter)
321    e = newa("gurk", href="hurz")
322    e = e.conv().conv()
323    assert unicode(e["href"]) == "foohurz"
324    assert str(e["href"]) == "foohurz"
325
326
327def test_attributes():
328    node = html.h1("gurk", {(xml, "lang"): "de"}, lang="de")
329    assert node.attrs.has("lang")
330    assert node.attrs.has((xml, "lang"))
331    assert "lang" in node.attrs
332    assert (xml, "lang") in node.attrs
333
334
335def test_attributekeysvaluesitems():
336    def check(node, xml, attrname, attrvalue):
337        assert node.attrs.allowedkeys(xml=xml) == [attrname]
338        iter = node.attrs.iterallowedkeys(xml=xml)
339        assert iter.next() == attrname
340        py.test.raises(StopIteration, iter.next)
341
342        assert node.attrs.allowedvalues() == [node.Attrs.attr_]
343        iter = node.attrs.iterallowedvalues()
344        assert iter.next() == node.Attrs.attr_
345        py.test.raises(StopIteration, iter.next)
346
347        assert node.attrs.alloweditems(xml=xml) == [(attrname, node.Attrs.attr_)]
348        iter = node.attrs.iteralloweditems(xml=xml)
349        assert iter.next() == (attrname, node.Attrs.attr_)
350        py.test.raises(StopIteration, iter.next)
351
352        if attrvalue:
353            assert node.attrs.keys(xml=xml) == [attrname]
354            iter = node.attrs.iterkeys(xml=xml)
355            assert iter.next() == attrname
356            py.test.raises(StopIteration, iter.next)
357        else:
358            assert node.attrs.keys(xml=xml) == []
359            iter = node.attrs.iterkeys(xml=xml)
360            py.test.raises(StopIteration, iter.next)
361
362        if attrvalue:
363            res = node.attrs.values()
364            assert len(res) == 1
365            assert res[0].__class__ is node.Attrs.attr_
366            assert unicode(res[0]) == attrvalue
367            iter = node.attrs.itervalues()
368            res = iter.next()
369            assert res.__class__ is node.Attrs.attr_
370            assert unicode(res) == attrvalue
371            py.test.raises(StopIteration, iter.next)
372        else:
373            res = node.attrs.values()
374            assert len(res) == 0
375            iter = node.attrs.itervalues()
376            py.test.raises(StopIteration, iter.next)
377
378        if attrvalue:
379            res = node.attrs.items(xml=xml)
380            assert len(res) == 1
381            assert res[0][0] == attrname
382            assert res[0][1].__class__ is node.Attrs.attr_
383            assert unicode(res[0][1]) == attrvalue
384            iter = node.attrs.iteritems(xml=xml)
385            res = iter.next()
386            assert res[0] == attrname
387            assert res[1].__class__ is node.Attrs.attr_
388            assert unicode(res[1]) == attrvalue
389            py.test.raises(StopIteration, iter.next)
390        else:
391            res = node.attrs.items(xml=xml)
392            assert len(res) == 0
393            iter = node.attrs.iteritems(xml=xml)
394            py.test.raises(StopIteration, iter.next)
395
396    class Test1(xsc.Element):
397        class Attrs(xsc.Element.Attrs):
398            class attr_(xsc.TextAttr):
399                xmlname = "attr"
400                default = 42
401    class Test2(xsc.Element):
402        class Attrs(xsc.Element.Attrs):
403            class attr_(xsc.TextAttr):
404                xmlname = "attr"
405
406    for (xml, attrname) in ((False, u"attr_"), (True, u"attr")):
407        check(Test1(), xml, attrname, u"42")
408        check(Test1(attr_=17), xml, attrname, u"17")
409        check(Test1(attr_=None), xml, attrname, None)
410
411        check(Test2(), xml, attrname, None)
412        check(Test2(attr_=17), xml, attrname, u"17")
413        check(Test2(attr_=None), xml, attrname, None)
414
415
416def test_attributeswithout():
417    # Use a sub namespace of xml to test the issubclass checks
418    class xml2(xml):
419        class Attrs(xml.Attrs):
420            class lang(xml.Attrs.lang):
421                default = 42
422
423    node = html.h1("gurk",
424        {(xml2, "space"): 1, (xml2, "lang"): "de", (xml2, "base"): "http://www.livinglogic.de/"},
425        lang="de",
426        style="color: #fff",
427        align="right",
428        title="gurk",
429        class_="important",
430        id=42,
431        dir="ltr"
432    )
433    keys = node.attrs.keys()
434    keys.sort()
435    keys.remove("class_")
436
437    keys1 = node.attrs.without(["class_"]).keys()
438    keys1.sort()
439    assert keys == keys1
440
441    keys.remove((xml2, "space"))
442    keys2 = node.attrs.without(["class_", (xml, "space")]).keys()
443    keys2.sort()
444    assert keys == keys2
445
446    keys.remove((xml2, "lang"))
447    keys.remove((xml2, "base"))
448    keys3 = node.attrs.without(["class_"], [xml]).keys()
449    keys3.sort()
450    assert keys == keys3
451
452    # Check that non existing attrs are handled correctly
453    keys4 = node.attrs.without(["class_", "src"], keepglobals=False).keys()
454    keys4.sort()
455    assert keys == keys4
456
457
458def test_attributeswith():
459    # Use a sub namespace of xml to test the issubclass checks
460    class xml2(xml):
461        class Attrs(xml.Attrs):
462            class lang(xml.Attrs.lang):
463                default = 42
464
465    node = html.h1("gurk",
466        {(xml2, "space"): 1, (xml2, "lang"): "de"},
467        lang="de",
468        align="right"
469    )
470    keys = node.attrs.keys()
471    keys.sort()
472    keys.remove("lang")
473
474    assert node.attrs.with(["lang"]).keys() == ["lang"]
475
476    keys1 = node.attrs.with(["lang", "align"]).keys()
477    keys1.sort()
478    assert keys1 == ["align", "lang"]
479
480    keys = ["lang", (xml2, "lang")]
481    keys.sort()
482    keys2 = node.attrs.with(keys).keys()
483    keys2.sort()
484    assert keys2 == keys
485
486    keys = ["lang", (xml2, "lang"), (xml2, "space")]
487    keys.sort()
488    keys3 = node.attrs.with(["lang"], [xml]).keys()
489    keys3.sort()
490    assert keys3 == keys
491
492
493def test_defaultattributes():
494    class Test(xsc.Element):
495        class Attrs(xsc.Element.Attrs):
496            class withdef(xsc.TextAttr):
497                default = 42
498            class withoutdef(xsc.TextAttr):
499                pass
500    node = Test()
501    assert "withdef" in node.attrs
502    assert "withoutdef" not in node.attrs
503    py.test.raises(xsc.IllegalAttrError, node.attrs.__contains__, "illegal")
504    node = Test(withdef=None)
505    assert "withdef" not in node.attrs
506
507
508def test_attributedictmethods():
509    def check(listexp, *lists):
510        for l in lists:
511            count = 0
512            for item in l:
513                assert item in listexp
514                count += 1
515            assert count == len(listexp)
516
517    class Test(xsc.Element):
518        class Attrs(xsc.Element.Attrs):
519            class withdef(xsc.TextAttr):
520                default = 42
521            class withoutdef(xsc.TextAttr):
522                pass
523            class another(xsc.URLAttr):
524                pass
525
526    node = Test(withoutdef=42)
527
528    check(
529        [ "withdef", "withoutdef" ],
530        node.attrs.keys(),
531        node.attrs.iterkeys()
532    )
533    check(
534        [ Test.Attrs.withdef(42), Test.Attrs.withoutdef(42)],
535        node.attrs.values(),
536        node.attrs.itervalues()
537    )
538    check(
539        [ ("withdef", Test.Attrs.withdef(42)), ("withoutdef", Test.Attrs.withoutdef(42)) ],
540        node.attrs.items(),
541        node.attrs.iteritems()
542    )
543
544    check(
545        [ "another", "withdef", "withoutdef" ],
546        node.attrs.allowedkeys(),
547        node.attrs.iterallowedkeys()
548    )
549    check(
550        [ Test.Attrs.another, Test.Attrs.withdef, Test.Attrs.withoutdef ],
551        node.attrs.allowedvalues(),
552        node.attrs.iterallowedvalues()
553    )
554    check(
555        [ ("another", Test.Attrs.another), ("withdef", Test.Attrs.withdef), ("withoutdef", Test.Attrs.withoutdef) ],
556        node.attrs.alloweditems(),
557        node.attrs.iteralloweditems()
558    )
559
560
561def test_fragattrdefault():
562    class testelem(xsc.Element):
563        class Attrs(xsc.Element.Attrs):
564            class testattr(xsc.TextAttr):
565                default = 42
566
567    node = testelem()
568    assert unicode(node["testattr"]) == "42"
569    assert unicode(node.conv()["testattr"]) == "42"
570
571    node["testattr"].clear()
572    assert "testattr" not in node.attrs
573    assert "testattr" not in node.conv().attrs
574
575    node = testelem(testattr=23)
576    assert unicode(node["testattr"]) == "23"
577    assert unicode(node.conv()["testattr"]) == "23"
578
579    del node["testattr"]
580    assert unicode(node["testattr"]) == ""
581    assert unicode(node.conv()["testattr"]) == ""
582
583    node["testattr"] = 23
584    node["testattr"] = None
585    assert "testattr" not in node.attrs
586    assert "testattr" not in node.conv().attrs
587
588    node = testelem(testattr=None)
589    assert "testattr" not in node.attrs
590    assert "testattr" not in node.conv().attrs
591
592
593def test_checkisallowed():
594    class testelem(xsc.Element):
595        class Attrs(xsc.Element.Attrs):
596            class testattr(xsc.TextAttr):
597                pass
598
599    class testelem2(testelem):
600        pass
601
602    class testelem3(testelem2):
603        class Attrs(testelem2.Attrs):
604            class testattr3(xsc.TextAttr):
605                pass
606
607    class testelem4(testelem3):
608        class Attrs(testelem3.Attrs):
609            testattr = None
610
611    node = testelem()
612    assert node.attrs.isallowed("testattr") is True
613    assert node.attrs.isallowed("notestattr") is False
614
615    node = testelem2()
616    assert node.attrs.isallowed("testattr") is True
617    assert node.attrs.isallowed("notestattr") is False
618
619    node = testelem3()
620    assert node.attrs.isallowed("testattr") is True
621    assert node.attrs.isallowed("testattr3") is True
622
623    node = testelem4()
624    assert node.attrs.isallowed("testattr") is False
625    assert node.attrs.isallowed("testattr3") is True
626
627
628def test_withsep():
629    for class_ in (xsc.Frag, html.div):
630        node = class_(1,2,3)
631        assert unicode(node.withsep(",")) == u"1,2,3"
632        node = class_(1)
633        assert unicode(node.withsep(",")) == u"1"
634        node = class_()
635        assert unicode(node.withsep(",")) == u""
636
637
638def test_allowedattr():
639    assert html.a.Attrs.allowedattr("href") is html.a.Attrs.href
640    py.test.raises(xsc.IllegalAttrError, html.a.Attrs.allowedattr, "gurk")
641    assert html.a.Attrs.allowedattr((xml, "lang")) is xml.Attrs.lang
642
643
644def test_plaintableattrs():
645    e = htmlspecials.plaintable(border=3)
646    assert isinstance(e["border"], html.table.Attrs.border)
647    assert isinstance(e["cellpadding"], html.table.Attrs.cellpadding)
648    e = e.conv()
649    assert isinstance(e["border"], html.table.Attrs.border)
650    assert isinstance(e["cellpadding"], html.table.Attrs.cellpadding)
651
652
653def test_attrupdate():
654    node = html.a(href="gurk", class_="hurz")
655    node.attrs.update(xml.Attrs(lang="de"), {"href": "gurk2", "id": 42})
656    assert unicode(node["href"]) == u"gurk2"
657    assert unicode(node["id"]) == u"42"
658    assert unicode(node[(xml, "lang")]) == u"de"
659
660    node = html.a(href="gurk", class_="hurz")
661    node.attrs.updatenew(xml.Attrs(lang="de"), {"href": "gurk2", "id": 42})
662    assert unicode(node["href"]) == u"gurk"
663    assert unicode(node["id"]) == u"42"
664    assert unicode(node[(xml, "lang")]) == u"de"
665
666    node = html.a(href="gurk", class_="hurz")
667    node.attrs.updateexisting({"href": "gurk2", "id": 42})
668    assert unicode(node["href"]) == u"gurk2"
669    assert "id" not in node.attrs
670    assert (xml, "lang") not in node.attrs
671
672    node = html.a({(xml, "lang"): "de"}, href="gurk", class_="hurz")
673    assert unicode(node[(xml, "lang")]) == u"de"
674
675    node = html.a(xml.Attrs(lang="de"), href="gurk", class_="hurz")
676    assert unicode(node[(xml, "lang")]) == u"de"
677
678    class Gurk(xsc.Element):
679        model = False
680        class Attrs(xsc.Element.Attrs):
681            class gurk(xsc.TextAttr): pass
682            class hurz(xsc.TextAttr): default = "hinz+kunz"
683
684    node1 = Gurk()
685    node2 = Gurk(hurz=None)
686    node1.attrs.update(node2.attrs)
687    assert "hurz" not in node1.attrs
688
689    node1 = Gurk(hurz=None)
690    node2 = Gurk()
691    node1.attrs.update(node2.attrs)
692    assert "hurz" in node1.attrs
693
694    node = Gurk(Gurk(hurz=None).attrs)
695    assert "hurz" not in node.attrs
696
697    attrs = Gurk.Attrs(Gurk.Attrs(hurz=None))
698    assert "hurz" not in attrs
699
700    # No global attributes inside global attributes
701    py.test.raises(xsc.IllegalAttrError, xml.Attrs, xml.Attrs(lang="de"))
702
703
704def test_classrepr():
705    repr(xsc.Base)
706    repr(xsc.Node)
707    repr(xsc.Null.__class__)
708    repr(xsc.Element)
709    repr(xsc.ProcInst)
710    repr(xsc.Entity)
711    repr(xsc.CharRef)
712    repr(xsc.Element.Attrs)
713    repr(xml.Attrs)
714    repr(xml.Attrs.lang)
715
716
717def test_itemslice():
718    for cls in (xsc.Frag, html.div):
719        # __get(item|slice)__
720        e = cls(range(6))
721        assert e[2] == xsc.Text(2)
722        assert e[-1] == xsc.Text(5)
723        assert e[:] == e
724        assert e[:2] == cls(0, 1)
725        assert e[-2:] == cls(4, 5)
726        assert e[::2] == cls(0, 2, 4)
727        assert e[1::2] == cls(1, 3, 5)
728        assert e[::-1] == cls(range(5, -1, -1))
729        e[1] = 10
730        assert e == cls(0, 10, 2, 3, 4, 5)
731        e[1] = None
732        assert e == cls(0, 2, 3, 4, 5)
733        e[1] = ()
734        assert e == cls(0, 3, 4, 5)
735
736        # __set(item|slice)__
737        e = cls(range(6))
738        e[-1] = None
739        assert e == cls(0, 1, 2, 3, 4)
740
741        e = cls(range(6))
742        e[1:5] = (100, 200)
743        assert e == cls(0, 100, 200, 5)
744
745        e = cls(range(6))
746        e[:] = (100, 200)
747        assert e == cls(100, 200)
748
749        e = cls(range(6))
750        e[::2] = (100, 120, 140)
751        assert e == cls(100, 1, 120, 3, 140, 5)
752
753        e = cls(range(6))
754        e[1::2] = (110, 130, 150)
755        assert e == cls(0, 110, 2, 130, 4, 150)
756
757        e = cls(range(6))
758        e[::-1] = range(6)
759        assert e == cls(range(5, -1, -1))
760
761        # __del(item|slice)__
762        e = cls(range(6))
763        del e[0]
764        assert e == cls(1, 2, 3, 4, 5)
765        del e[-1]
766        assert e == cls(1, 2, 3, 4)
767
768        e = cls(range(6))
769        del e[1:5]
770        assert e == cls(0, 5)
771
772        e = cls(range(6))
773        del e[2:]
774        assert e == cls(0, 1)
775
776        e = cls(range(6))
777        del e[-2:]
778        assert e == cls(0, 1, 2, 3)
779
780        e = cls(range(6))
781        del e[:2]
782        assert e == cls(2, 3, 4, 5)
783
784        e = cls(range(6))
785        del e[:-2]
786        assert e == cls(4, 5)
787
788        e = cls(range(6))
789        del e[:]
790        assert e == cls()
791
792        e = cls(range(6))
793        del e[::2]
794        assert e == cls(1, 3, 5)
795
796        e = cls(range(6))
797        del e[1::2]
798        assert e == cls(0, 2, 4)
799
800    e = html.div(range(6), id=42)
801    assert e[2] == xsc.Text(2)
802    assert e[-1] == xsc.Text(5)
803    assert e[:] == e
804    assert e[:2] == cls(0, 1, id=42)
805    assert e[-2:] == cls(4, 5, id=42)
806    assert e[::2] == cls(0, 2, 4, id=42)
807    assert e[1::2] == cls(1, 3, 5, id=42)
808    assert e[::-1] == cls(range(5, -1, -1), id=42)
809
810
811def test_clone():
812    for cls in (xsc.Frag, html.div):
813        e = html.div(1)
814
815        src = cls(1, e, e)
816
817        dst = src.clone()
818        assert src is not dst
819        assert src[0] is dst[0]
820        assert src[1] is not dst[1]
821        assert dst[1] is not dst[2]
822
823        e.append(e) # create a cycle
824
825        dst = src.copy()
826        assert src is not dst
827        assert src[0] is dst[0]
828        assert src[1] is dst[1]
829        assert dst[1] is dst[2]
830
831        dst = src.deepcopy()
832        assert src is not dst
833        assert src[0] is dst[0]
834        assert src[1] is not dst[1]
835        assert dst[1] is dst[2]
836
837    e = html.div(id=(17, html.div(23), 42))
838    for src in (e, e.attrs):
839        dst = src.clone()
840        assert src["id"] is not dst["id"]
841        assert src["id"][0] is dst["id"][0]
842        assert src["id"][1] is not dst["id"][1]
843
844    e["id"][1] = e # create a cycle
845    e["id"][2] = e # create a cycle
846    for src in (e, e.attrs):
847        dst = src.copy()
848        assert src["id"] is dst["id"]
849        assert src["id"][0] is dst["id"][0]
850        assert src["id"][1] is dst["id"][1]
851        assert dst["id"][1] is dst["id"][2]
852        dst = src.deepcopy()
853        assert src["id"] is not dst["id"]
854        assert src["id"][0] is dst["id"][0]
855        assert src["id"][1] is not dst["id"][1]
856        assert dst["id"][1] is dst["id"][2]
857
858
859def test_sortedreversed():
860    for class_ in (xsc.Frag, html.div):
861        node = class_(3, 2, 1)
862        node2 = node.sorted(key=str)
863        assert node == class_(3, 2, 1)
864        assert node2 == class_(1, 2, 3)
865
866    for class_ in (xsc.Frag, html.div):
867        node = class_(3, 2, 1)
868        node2 = node.reversed()
869        assert node == class_(3, 2, 1)
870        assert node2 == class_(1, 2, 3)
Note: See TracBrowser for help on using the browser.