root/livinglogic.python.xist/test/test_xist.py @ 2711:113988ef6cf0

Revision 2711:113988ef6cf0, 22.5 KB (checked in by Walter Doerwald <walter@…>, 13 years ago)

Raise error in tonode() instead of issueing a warning.

Remove second implementation for Attrs.iter() (which was wrong).

Raise an error for Attrs passed to tonode().

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