gvsig-scripting / org.gvsig.scripting / trunk / org.gvsig.scripting / org.gvsig.scripting.app / org.gvsig.scripting.app.mainplugin / src / main / resources-plugin / scripting / lib / cssutils / tests / test_csspagerule.py @ 475
History | View | Annotate | Download (14.3 KB)
1 |
"""Testcases for cssutils.css.CSSPageRule"""
|
---|---|
2 |
|
3 |
import xml.dom |
4 |
import test_cssrule |
5 |
import cssutils |
6 |
|
7 |
class CSSPageRuleTestCase(test_cssrule.CSSRuleTestCase): |
8 |
|
9 |
def setUp(self): |
10 |
super(CSSPageRuleTestCase, self).setUp() |
11 |
|
12 |
cssutils.ser.prefs.useDefaults() |
13 |
self.r = cssutils.css.CSSPageRule()
|
14 |
self.rRO = cssutils.css.CSSPageRule(readonly=True) |
15 |
self.r_type = cssutils.css.CSSPageRule.PAGE_RULE# |
16 |
self.r_typeString = 'PAGE_RULE' |
17 |
|
18 |
def tearDown(self): |
19 |
cssutils.ser.prefs.useDefaults() |
20 |
|
21 |
def test_init(self): |
22 |
"CSSPageRule.__init__()"
|
23 |
super(CSSPageRuleTestCase, self).test_init() |
24 |
|
25 |
r = cssutils.css.CSSPageRule() |
26 |
self.assertEqual(u'', r.selectorText) |
27 |
self.assertEqual(cssutils.css.CSSStyleDeclaration, type(r.style)) |
28 |
self.assertEqual(r, r.style.parentRule)
|
29 |
|
30 |
# until any properties
|
31 |
self.assertEqual(u'', r.cssText) |
32 |
|
33 |
# only possible to set @... similar name
|
34 |
self.assertRaises(xml.dom.InvalidModificationErr, self.r._setAtkeyword, 'x') |
35 |
|
36 |
def checkrefs(ff): |
37 |
self.assertEqual(ff, ff.style.parentRule)
|
38 |
for p in ff.style: |
39 |
self.assertEqual(ff.style, p.parent)
|
40 |
|
41 |
checkrefs(cssutils.css.CSSPageRule( |
42 |
style=cssutils.css.CSSStyleDeclaration('font-family: x')))
|
43 |
|
44 |
r = cssutils.css.CSSPageRule() |
45 |
r.cssText = '@page { font-family: x }'
|
46 |
checkrefs(r) |
47 |
|
48 |
r = cssutils.css.CSSPageRule() |
49 |
r.style.setProperty('font-family', 'y') |
50 |
checkrefs(r) |
51 |
|
52 |
r = cssutils.css.CSSPageRule() |
53 |
r.style['font-family'] = 'z' |
54 |
checkrefs(r) |
55 |
|
56 |
r = cssutils.css.CSSPageRule() |
57 |
r.style.fontFamily = 'a'
|
58 |
checkrefs(r) |
59 |
|
60 |
def test_InvalidModificationErr(self): |
61 |
"CSSPageRule.cssText InvalidModificationErr"
|
62 |
self._test_InvalidModificationErr(u'@page') |
63 |
tests = { |
64 |
u'@pag {}': xml.dom.InvalidModificationErr,
|
65 |
} |
66 |
self.do_raise_r(tests)
|
67 |
|
68 |
def test_incomplete(self): |
69 |
"CSSPageRule (incomplete)"
|
70 |
tests = { |
71 |
u'@page :left { ':
|
72 |
u'', # no } and no content |
73 |
u'@page :left { color: red':
|
74 |
u'@page :left {\n color: red\n }', # no } |
75 |
} |
76 |
self.do_equal_p(tests) # parse |
77 |
|
78 |
def test_cssText(self): |
79 |
"CSSPageRule.cssText"
|
80 |
EXP = u'@page %s {\n margin: 0\n }'
|
81 |
tests = { |
82 |
u'@page {}': u'', |
83 |
u'@page:left{}': u'', |
84 |
u'@page :right {}': u'', |
85 |
u'@page {margin:0;}': u'@page {\n margin: 0\n }', |
86 |
|
87 |
u'@page name { margin: 0 }': EXP % u'name', |
88 |
u'@page name:left { margin: 0 }': EXP % u'name:left', |
89 |
u'@page name:right { margin: 0 }': EXP % u'name:right', |
90 |
u'@page name:first { margin: 0 }': EXP % u'name:first', |
91 |
u'@page :left { margin: 0 }': EXP % u':left', |
92 |
u'@page:left { margin: 0 }': EXP % u':left', |
93 |
u'@page :right { margin: 0 }': EXP % u':right', |
94 |
u'@page :first { margin: 0 }': EXP % u':first', |
95 |
u'@page :UNKNOWNIDENT { margin: 0 }': EXP % u':UNKNOWNIDENT', |
96 |
|
97 |
u'@PAGE:left{margin:0;}': u'@page :left {\n margin: 0\n }', |
98 |
u'@\\page:left{margin:0;}': u'@page :left {\n margin: 0\n }', |
99 |
|
100 |
# comments
|
101 |
u'@page/*1*//*2*/:left/*3*//*4*/{margin:0;}':
|
102 |
u'@page /*1*/ /*2*/ :left /*3*/ /*4*/ {\n margin: 0\n }',
|
103 |
# WS
|
104 |
u'@page:left{margin:0;}':
|
105 |
u'@page :left {\n margin: 0\n }',
|
106 |
u'@page\n\r\f\t :left\n\r\f\t {margin:0;}':
|
107 |
u'@page :left {\n margin: 0\n }',
|
108 |
|
109 |
# MarginRule
|
110 |
u'@page { @top-right { content: "2" } }':
|
111 |
u'@page {\n @top-right {\n content: "2"\n }\n }',
|
112 |
u'@page {padding: 1cm; margin: 1cm; @top-left {content: "1"}@top-right {content: "2";left: 1}}':
|
113 |
u'@page {\n padding: 1cm;\n margin: 1cm;\n @top-left {\n content: "1"\n }\n @top-right {\n content: "2";\n left: 1\n }\n }',
|
114 |
u'@page {@top-right { content: "1a"; content: "1b"; x: 1 }@top-right { content: "2"; y: 2 }}':
|
115 |
u'''@page {\n @top-right {
|
116 |
content: "1a";
|
117 |
content: "1b";
|
118 |
x: 1;
|
119 |
content: "2";
|
120 |
y: 2
|
121 |
}\n }''',
|
122 |
|
123 |
} |
124 |
self.do_equal_r(tests)
|
125 |
self.do_equal_p(tests)
|
126 |
|
127 |
tests = { |
128 |
# auto is not allowed
|
129 |
u'@page AUto {}': xml.dom.SyntaxErr,
|
130 |
u'@page AUto:left {}': xml.dom.SyntaxErr,
|
131 |
|
132 |
u'@page : {}': xml.dom.SyntaxErr,
|
133 |
u'@page :/*1*/left {}': xml.dom.SyntaxErr,
|
134 |
u'@page : left {}': xml.dom.SyntaxErr,
|
135 |
u'@page :left :right {}': xml.dom.SyntaxErr,
|
136 |
u'@page :left a {}': xml.dom.SyntaxErr,
|
137 |
# no S between IDENT and PSEUDO
|
138 |
u'@page a :left {}': xml.dom.SyntaxErr,
|
139 |
|
140 |
u'@page :left;': xml.dom.SyntaxErr,
|
141 |
u'@page :left }': xml.dom.SyntaxErr,
|
142 |
} |
143 |
self.do_raise_p(tests) # parse |
144 |
tests.update({ |
145 |
# false selector
|
146 |
u'@page :right :left {}': xml.dom.SyntaxErr, # no } |
147 |
u'@page :right X {}': xml.dom.SyntaxErr, # no } |
148 |
u'@page X Y {}': xml.dom.SyntaxErr, # no } |
149 |
|
150 |
u'@page :left {': xml.dom.SyntaxErr, # no } |
151 |
# trailing
|
152 |
u'@page :left {}1': xml.dom.SyntaxErr, # no } |
153 |
u'@page :left {}/**/': xml.dom.SyntaxErr, # no } |
154 |
u'@page :left {} ': xml.dom.SyntaxErr, # no } |
155 |
}) |
156 |
self.do_raise_r(tests) # set cssText |
157 |
|
158 |
def test_cssText2(self): |
159 |
"CSSPageRule.cssText 2"
|
160 |
r = cssutils.css.CSSPageRule() |
161 |
s = u'a:left'
|
162 |
r.selectorText = s |
163 |
self.assertEqual(r.selectorText, s)
|
164 |
|
165 |
st = 'size: a4'
|
166 |
r.style = st |
167 |
self.assertEqual(r.style.cssText, st)
|
168 |
|
169 |
# invalid selector
|
170 |
self.assertRaises(xml.dom.SyntaxErr, r._setStyle, '$') |
171 |
self.assertEqual(r.selectorText, s)
|
172 |
self.assertEqual(r.style.cssText, st)
|
173 |
|
174 |
self.assertRaises(xml.dom.SyntaxErr, r._setCssText, '@page $ { color: red }') |
175 |
self.assertEqual(r.selectorText, s)
|
176 |
self.assertEqual(r.style.cssText, st)
|
177 |
|
178 |
|
179 |
# invalid style
|
180 |
self.assertRaises(xml.dom.SyntaxErr, r._setSelectorText, '$') |
181 |
self.assertEqual(r.selectorText, s)
|
182 |
self.assertEqual(r.style.cssText, st)
|
183 |
|
184 |
self.assertRaises(xml.dom.SyntaxErr, r._setCssText, '@page b:right { x }') |
185 |
self.assertEqual(r.selectorText, s)
|
186 |
self.assertEqual(r.style.cssText, st)
|
187 |
|
188 |
def test_selectorText(self): |
189 |
"CSSPageRule.selectorText"
|
190 |
r = cssutils.css.CSSPageRule() |
191 |
r.selectorText = u'a:left'
|
192 |
self.assertEqual(r.selectorText, u'a:left') |
193 |
|
194 |
tests = { |
195 |
u'': u'', |
196 |
u'name': None, |
197 |
u':left': None, |
198 |
u':right': None, |
199 |
u':first': None, |
200 |
u':UNKNOWNIDENT': None, |
201 |
u'name:left': None, |
202 |
u' :left': u':left', |
203 |
u':left': u':left', |
204 |
u'/*1*/:left/*a*/': u'/*1*/ :left /*a*/', |
205 |
u'/*1*/ :left /*a*/ /*b*/': None, |
206 |
u':left/*a*/': u':left /*a*/', |
207 |
u'/*1*/:left': u'/*1*/ :left', |
208 |
} |
209 |
self.do_equal_r(tests, att='selectorText') |
210 |
|
211 |
tests = { |
212 |
u':': xml.dom.SyntaxErr,
|
213 |
u':/*1*/left': xml.dom.SyntaxErr,
|
214 |
u': left': xml.dom.SyntaxErr,
|
215 |
u':left :right': xml.dom.SyntaxErr,
|
216 |
u':left a': xml.dom.SyntaxErr,
|
217 |
u'name :left': xml.dom.SyntaxErr,
|
218 |
} |
219 |
self.do_raise_r(tests, att='_setSelectorText') |
220 |
|
221 |
def test_specificity(self): |
222 |
"CSSPageRule.specificity"
|
223 |
r = cssutils.css.CSSPageRule() |
224 |
tests = { |
225 |
u'': (0, 0, 0), |
226 |
u'name': (1, 0, 0), |
227 |
u':first': (0, 1, 0), |
228 |
u':left': (0, 0, 1), |
229 |
u':right': (0, 0, 1), |
230 |
u':UNKNOWNIDENT': (0, 0, 1), |
231 |
u'name:first': (1, 1, 0), |
232 |
u'name:left': (1, 0, 1), |
233 |
u'name:right': (1, 0, 1), |
234 |
u'name:X': (1, 0, 1) |
235 |
} |
236 |
for sel, exp in tests.items(): |
237 |
r.selectorText = sel |
238 |
self.assertEqual(r.specificity, exp)
|
239 |
|
240 |
r = cssutils.css.CSSPageRule() |
241 |
r.cssText = u'@page %s {}' % sel
|
242 |
self.assertEqual(r.specificity, exp)
|
243 |
|
244 |
def test_cssRules(self): |
245 |
"CSSPageRule.cssRules"
|
246 |
s = cssutils.parseString(u'@page {}')
|
247 |
p = s.cssRules[0]
|
248 |
|
249 |
self.assertEqual(len(p.cssRules), 0) |
250 |
|
251 |
# add and insert
|
252 |
m1 = cssutils.css.MarginRule(u'@top-left', u'color: red') |
253 |
i = p.add(m1) |
254 |
self.assertEqual(i, 0) |
255 |
self.assertEqual(len(p.cssRules), 1) |
256 |
|
257 |
m3 = cssutils.css.MarginRule() |
258 |
m3.cssText = u'@top-right { color: blue }'
|
259 |
i = p.insertRule(m3) |
260 |
self.assertEqual(i, 1) |
261 |
self.assertEqual(len(p.cssRules), 2) |
262 |
|
263 |
m2 = cssutils.css.MarginRule() |
264 |
m2.margin = u'@top-center'
|
265 |
m2.style = u'color: green'
|
266 |
i = p.insertRule(m2, 1)
|
267 |
self.assertEqual(i, 1) |
268 |
self.assertEqual(len(p.cssRules), 3) |
269 |
|
270 |
self.assertEqual(p.cssText, u'''@page { |
271 |
@top-left {
|
272 |
color: red
|
273 |
}
|
274 |
@top-center {
|
275 |
color: green
|
276 |
}
|
277 |
@top-right {
|
278 |
color: blue
|
279 |
}
|
280 |
}''')
|
281 |
|
282 |
# keys and dict index
|
283 |
self.assertEqual(u'@top-left' in p, True) |
284 |
self.assertEqual(u'@bottom-left' in p, False) |
285 |
|
286 |
self.assertEqual(p.keys(), [u'@top-left', |
287 |
u'@top-center',
|
288 |
u'@top-right'])
|
289 |
|
290 |
self.assertEqual(p[u'@bottom-left'], None) |
291 |
self.assertEqual(p[u'@top-left'].cssText, u'color: red') |
292 |
p[u'@top-left'] = u'color: #f00' |
293 |
self.assertEqual(p[u'@top-left'].cssText, u'color: #f00') |
294 |
|
295 |
# delete
|
296 |
p.deleteRule(m2) |
297 |
self.assertEqual(len(p.cssRules), 2) |
298 |
self.assertEqual(p.cssText, u'''@page { |
299 |
@top-left {
|
300 |
color: #f00
|
301 |
}
|
302 |
@top-right {
|
303 |
color: blue
|
304 |
}
|
305 |
}''')
|
306 |
|
307 |
p.deleteRule(0)
|
308 |
self.assertEqual(len(p.cssRules), 1) |
309 |
self.assertEqual(m3, p.cssRules[0]) |
310 |
self.assertEqual(p.cssText, u'''@page { |
311 |
@top-right {
|
312 |
color: blue
|
313 |
}
|
314 |
}''')
|
315 |
|
316 |
del p['@top-right'] |
317 |
self.assertEqual(len(p.cssRules), 0) |
318 |
|
319 |
|
320 |
def test_style(self): |
321 |
"CSSPageRule.style (and references)"
|
322 |
r = cssutils.css.CSSPageRule() |
323 |
s1 = r.style |
324 |
self.assertEqual(r, s1.parentRule)
|
325 |
self.assertEqual(u'', s1.cssText) |
326 |
|
327 |
# set rule.cssText
|
328 |
r.cssText = '@page { font-family: x1 }'
|
329 |
self.assertNotEqual(r.style, s1)
|
330 |
self.assertEqual(r, r.style.parentRule)
|
331 |
self.assertEqual(r.cssText, u'@page {\n font-family: x1\n }') |
332 |
self.assertEqual(r.style.cssText, u'font-family: x1') |
333 |
self.assertEqual(s1.cssText, u'') |
334 |
s2 = r.style |
335 |
|
336 |
# set invalid rule.cssText
|
337 |
try:
|
338 |
r.cssText = '@page { $ }'
|
339 |
except xml.dom.SyntaxErr, e:
|
340 |
pass
|
341 |
self.assertEqual(r.style, s2)
|
342 |
self.assertEqual(r, r.style.parentRule)
|
343 |
self.assertEqual(r.cssText, u'@page {\n font-family: x1\n }') |
344 |
self.assertEqual(r.style.cssText, u'font-family: x1') |
345 |
self.assertEqual(s2.cssText, u'font-family: x1') |
346 |
s3 = r.style |
347 |
|
348 |
# set rule.style.cssText
|
349 |
r.style.cssText = 'font-family: x2'
|
350 |
self.assertEqual(r.style, s3)
|
351 |
self.assertEqual(r, r.style.parentRule)
|
352 |
self.assertEqual(r.cssText, u'@page {\n font-family: x2\n }') |
353 |
self.assertEqual(r.style.cssText, u'font-family: x2') |
354 |
|
355 |
# set new style object s2
|
356 |
s2 = cssutils.css.CSSStyleDeclaration('font-family: y1')
|
357 |
r.style = s2 |
358 |
self.assertEqual(r.style, s2)
|
359 |
self.assertEqual(r, s2.parentRule)
|
360 |
self.assertEqual(r.cssText, u'@page {\n font-family: y1\n }') |
361 |
self.assertEqual(s2.cssText, u'font-family: y1') |
362 |
self.assertEqual(r.style.cssText, u'font-family: y1') |
363 |
self.assertEqual(s3.cssText, u'font-family: x2') # old |
364 |
|
365 |
# set s2.cssText
|
366 |
s2.cssText = 'font-family: y2'
|
367 |
self.assertEqual(r.style, s2)
|
368 |
self.assertEqual(r.cssText, u'@page {\n font-family: y2\n }') |
369 |
self.assertEqual(r.style.cssText, u'font-family: y2') |
370 |
self.assertEqual(s3.cssText, u'font-family: x2') # old |
371 |
# set invalid s2.cssText
|
372 |
try:
|
373 |
s2.cssText = '$'
|
374 |
except xml.dom.SyntaxErr, e:
|
375 |
pass
|
376 |
self.assertEqual(r.style, s2)
|
377 |
self.assertEqual(r.cssText, u'@page {\n font-family: y2\n }') |
378 |
self.assertEqual(r.style.cssText, u'font-family: y2') |
379 |
self.assertEqual(s3.cssText, u'font-family: x2') # old |
380 |
|
381 |
# set r.style with text
|
382 |
r.style = 'font-family: z'
|
383 |
self.assertNotEqual(r.style, s2)
|
384 |
self.assertEqual(r.cssText, u'@page {\n font-family: z\n }') |
385 |
self.assertEqual(r.style.cssText, u'font-family: z') |
386 |
|
387 |
def test_properties(self): |
388 |
"CSSPageRule.style properties"
|
389 |
r = cssutils.css.CSSPageRule() |
390 |
r.style.cssText = '''
|
391 |
margin-top: 0;
|
392 |
margin-right: 0;
|
393 |
margin-bottom: 0;
|
394 |
margin-left: 0;
|
395 |
margin: 0;
|
396 |
|
397 |
page-break-before: auto;
|
398 |
page-break-after: auto;
|
399 |
page-break-inside: auto;
|
400 |
|
401 |
orphans: 3;
|
402 |
widows: 3;
|
403 |
'''
|
404 |
exp = u'''@page {
|
405 |
margin-top: 0;
|
406 |
margin-right: 0;
|
407 |
margin-bottom: 0;
|
408 |
margin-left: 0;
|
409 |
margin: 0;
|
410 |
page-break-before: auto;
|
411 |
page-break-after: auto;
|
412 |
page-break-inside: auto;
|
413 |
orphans: 3;
|
414 |
widows: 3
|
415 |
}'''
|
416 |
self.assertEqual(exp, r.cssText)
|
417 |
|
418 |
def test_reprANDstr(self): |
419 |
"CSSPageRule.__repr__(), .__str__()"
|
420 |
sel=u':left'
|
421 |
|
422 |
s = cssutils.css.CSSPageRule(selectorText=sel) |
423 |
|
424 |
self.assertTrue(sel in str(s)) |
425 |
|
426 |
s2 = eval(repr(s)) |
427 |
self.assertTrue(isinstance(s2, s.__class__)) |
428 |
self.assertTrue(sel == s2.selectorText)
|
429 |
|
430 |
|
431 |
if __name__ == '__main__': |
432 |
import unittest |
433 |
unittest.main() |