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_cssvalue.py @ 475
History | View | Annotate | Download (32.8 KB)
| 1 |
"""Testcases for cssutils.css.CSSValue and CSSPrimitiveValue."""
|
|---|---|
| 2 |
|
| 3 |
#
|
| 4 |
## from decimal import Decimal # maybe for later tests?
|
| 5 |
#import xml.dom
|
| 6 |
#import basetest
|
| 7 |
#import cssutils
|
| 8 |
#import types
|
| 9 |
#
|
| 10 |
#class CSSValueTestCase(basetest.BaseTestCase):
|
| 11 |
#
|
| 12 |
# def setUp(self):
|
| 13 |
# self.r = cssutils.css.CSSValue() # needed for tests
|
| 14 |
#
|
| 15 |
# def test_init(self):
|
| 16 |
# "CSSValue.__init__()"
|
| 17 |
# v = cssutils.css.CSSValue()
|
| 18 |
# self.assertTrue(u'' == v.cssText)
|
| 19 |
# self.assertTrue(None is v.cssValueType)
|
| 20 |
# self.assertTrue(None == v.cssValueTypeString)
|
| 21 |
#
|
| 22 |
# def test_escapes(self):
|
| 23 |
# "CSSValue Escapes"
|
| 24 |
# v = cssutils.css.CSSValue()
|
| 25 |
# v.cssText = u'1px'
|
| 26 |
# self.assertTrue(v.CSS_PRIMITIVE_VALUE == v.cssValueType)
|
| 27 |
# self.assertTrue(v.CSS_PX == v.primitiveType)
|
| 28 |
# self.assertTrue(u'1px' == v.cssText)
|
| 29 |
#
|
| 30 |
# v.cssText = u'1PX'
|
| 31 |
# self.assertTrue(v.CSS_PRIMITIVE_VALUE == v.cssValueType)
|
| 32 |
# self.assertTrue(v.CSS_PX == v.primitiveType)
|
| 33 |
# self.assertTrue(u'1px' == v.cssText)
|
| 34 |
#
|
| 35 |
# v.cssText = u'1p\\x'
|
| 36 |
# self.assertTrue(v.CSS_PRIMITIVE_VALUE == v.cssValueType)
|
| 37 |
# self.assertTrue(v.CSS_PX == v.primitiveType)
|
| 38 |
# self.assertTrue(u'1px' == v.cssText)
|
| 39 |
#
|
| 40 |
# def test_cssText(self):
|
| 41 |
# "CSSValue.cssText"
|
| 42 |
# v = cssutils.css.CSSValue()
|
| 43 |
# v.cssText = u'1px'
|
| 44 |
# self.assertTrue(v.CSS_PRIMITIVE_VALUE == v.cssValueType)
|
| 45 |
# self.assertTrue(v.CSS_PX == v.primitiveType)
|
| 46 |
# self.assertTrue(u'1px' == v.cssText)
|
| 47 |
#
|
| 48 |
# v = cssutils.css.CSSValue()
|
| 49 |
# v.cssText = u'1px'
|
| 50 |
# self.assertTrue(v.CSS_PRIMITIVE_VALUE == v.cssValueType)
|
| 51 |
# self.assertTrue(v.CSS_PX == v.primitiveType)
|
| 52 |
# self.assertTrue(u'1px' == v.cssText)
|
| 53 |
#
|
| 54 |
# v = cssutils.css.CSSValue()
|
| 55 |
# v.cssText = u'a ,b, c ,"d or d", "e, " '
|
| 56 |
# self.assertEqual(v.CSS_PRIMITIVE_VALUE, v.cssValueType)
|
| 57 |
# self.assertEqual(v.CSS_STRING, v.primitiveType)
|
| 58 |
# self.assertEqual(u'a, b, c, "d or d", "e, "', v.cssText)
|
| 59 |
#
|
| 60 |
# v.cssText = u' 1 px '
|
| 61 |
# self.assertTrue(v.CSS_VALUE_LIST == v.cssValueType)
|
| 62 |
# self.assertTrue('1 px' == v.cssText)
|
| 63 |
#
|
| 64 |
# v.cssText = u' normal 1px a, b, "c" end '
|
| 65 |
# self.assertTrue(v.CSS_VALUE_LIST == v.cssValueType)
|
| 66 |
# self.assertEqual('normal 1px a, b, "c" end', v.cssText)
|
| 67 |
#
|
| 68 |
# for i, x in enumerate(v):
|
| 69 |
# self.assertEqual(x.CSS_PRIMITIVE_VALUE, x.cssValueType)
|
| 70 |
# if x == 0:
|
| 71 |
# self.assertEqual(x.CSS_IDENT, x.primitiveType)
|
| 72 |
# self.assertEqual(u'normal', x.cssText)
|
| 73 |
# elif x == 1:
|
| 74 |
# self.assertEqual(x.CSS_PX, x.primitiveType)
|
| 75 |
# self.assertEqual(u'1px', x.cssText)
|
| 76 |
# if x == 2:
|
| 77 |
# self.assertEqual(x.CSS_STRING, x.primitiveType)
|
| 78 |
# self.assertEqual(u'a, b, "c"', x.cssText)
|
| 79 |
# if x == 3:
|
| 80 |
# self.assertEqual(x.CSS_IDENT, x.primitiveType)
|
| 81 |
# self.assertEqual(u'end', x.cssText)
|
| 82 |
#
|
| 83 |
#
|
| 84 |
# v = cssutils.css.CSSValue()
|
| 85 |
# v.cssText = u' 1 px '
|
| 86 |
# self.assertTrue(v.CSS_VALUE_LIST == v.cssValueType)
|
| 87 |
# self.assertTrue(u'1 px' == v.cssText)
|
| 88 |
#
|
| 89 |
# v.cssText = u'expression(document.body.clientWidth > 972 ? "1014px": "100%" )'
|
| 90 |
# self.assertTrue(v.CSS_PRIMITIVE_VALUE == v.cssValueType)
|
| 91 |
# self.assertTrue(v.CSS_UNKNOWN == v.primitiveType)
|
| 92 |
# self.assertEqual(u'expression(document.body.clientWidth > 972?"1014px": "100%")',
|
| 93 |
# v.cssText)
|
| 94 |
#
|
| 95 |
# def test_cssText2(self):
|
| 96 |
# "CSSValue.cssText 2"
|
| 97 |
# tests = {
|
| 98 |
# # mix
|
| 99 |
# u'a()1,-1,+1,1%,-1%,1px,-1px,"a",a,url(a),#aabb44':
|
| 100 |
# u'a() 1, -1, 1, 1%, -1%, 1px, -1px, "a", a, url(a), #ab4',
|
| 101 |
#
|
| 102 |
# # S or COMMENT
|
| 103 |
# u'red': u'red',
|
| 104 |
# u'red ': u'red',
|
| 105 |
# u' red ': u'red',
|
| 106 |
# u'/**/red': u'/**/ red',
|
| 107 |
# u'red/**/': u'red /**/',
|
| 108 |
# u'/**/red/**/': u'/**/ red /**/',
|
| 109 |
# u'/**/ red': u'/**/ red',
|
| 110 |
# u'red /**/': u'red /**/',
|
| 111 |
# u'/**/ red /**/': u'/**/ red /**/',
|
| 112 |
# u'red-': u'red-',
|
| 113 |
#
|
| 114 |
# # num / dimension
|
| 115 |
# u'.0': u'0',
|
| 116 |
# u'0': u'0',
|
| 117 |
# u'0.0': u'0',
|
| 118 |
# u'00': u'0',
|
| 119 |
# u'0%': u'0%',
|
| 120 |
# u'0px': u'0',
|
| 121 |
# u'-.0': u'0',
|
| 122 |
# u'-0': u'0',
|
| 123 |
# u'-0.0': u'0',
|
| 124 |
# u'-00': u'0',
|
| 125 |
# u'-0%': u'0%',
|
| 126 |
# u'-0px': u'0',
|
| 127 |
# u'+.0': u'0',
|
| 128 |
# u'+0': u'0',
|
| 129 |
# u'+0.0': u'0',
|
| 130 |
# u'+00': u'0',
|
| 131 |
# u'+0%': u'0%',
|
| 132 |
# u'+0px': u'0',
|
| 133 |
# u'1': u'1',
|
| 134 |
# u'1.0': u'1',
|
| 135 |
# u'1px': u'1px',
|
| 136 |
# u'1%': u'1%',
|
| 137 |
# u'1px1': u'1px1',
|
| 138 |
# u'+1': u'1',
|
| 139 |
# u'-1': u'-1',
|
| 140 |
# u'+1.0': u'1',
|
| 141 |
# u'-1.0': u'-1',
|
| 142 |
#
|
| 143 |
# # string, escaped nl is removed during tokenizing
|
| 144 |
# u'"x"': u'"x"',
|
| 145 |
# u"'x'": u'"x"',
|
| 146 |
# #ur''' "1\'2" ''': u'''"1'2"''', #???
|
| 147 |
# #ur"'x\"'": ur'"x\""', #???
|
| 148 |
# ur'''"x\
|
| 149 |
#y"''': u'''"xy"''',
|
| 150 |
#
|
| 151 |
# # hash and rgb/a
|
| 152 |
# u'#112234': u'#112234',
|
| 153 |
# u'#112233': u'#123',
|
| 154 |
# u'rgb(1,2,3)': u'rgb(1, 2, 3)',
|
| 155 |
# u'rgb( 1 , 2 , 3 )': u'rgb(1, 2, 3)',
|
| 156 |
# u'rgb(-1,+2,0)': u'rgb(-1, 2, 0)',
|
| 157 |
# u'rgba(1,2,3,4)': u'rgba(1, 2, 3, 4)',
|
| 158 |
# u'rgba( 1 , 2 , 3 , 4 )': u'rgba(1, 2, 3, 4)',
|
| 159 |
# u'rgba(-1,+2,0, 0)': u'rgba(-1, 2, 0, 0)',
|
| 160 |
#
|
| 161 |
# # FUNCTION
|
| 162 |
# u'f(1,2)': u'f(1, 2)',
|
| 163 |
# u'f( 1 , 2 )': u'f(1, 2)',
|
| 164 |
# u'f(-1,+2)': u'f(-1, 2)',
|
| 165 |
# u'f( -1 , +2 )': u'f(-1, 2)',
|
| 166 |
# u'fun( -1 , +2 )': u'fun(-1, 2)',
|
| 167 |
# u'local( x )': u'local(x)',
|
| 168 |
# u'test(1px, #111, y, 1, 1%, "1", y(), var(x))':
|
| 169 |
# u'test(1px, #111, y, 1, 1%, "1", y(), var(x))',
|
| 170 |
# u'test(-1px, #111, y, -1, -1%, "1", -y())':
|
| 171 |
# u'test(-1px, #111, y, -1, -1%, "1", -y())',
|
| 172 |
# u'url(y) format( "x" , "y" )': u'url(y) format("x", "y")',
|
| 173 |
# u'f(1 2,3 4)': u'f(1 2, 3 4)',
|
| 174 |
#
|
| 175 |
# # IE expression
|
| 176 |
# ur'Expression()': u'Expression()',
|
| 177 |
# ur'expression(-1 < +2)': u'expression(-1< + 2)',
|
| 178 |
# ur'expression(document.width == "1")': u'expression(document.width=="1")',
|
| 179 |
# u'alpha(opacity=80)': u'alpha(opacity=80)',
|
| 180 |
# u'alpha( opacity = 80 , x=2 )': u'alpha(opacity=80, x=2)',
|
| 181 |
#
|
| 182 |
# # unicode-range
|
| 183 |
# 'u+f': 'u+f',
|
| 184 |
# 'U+ABCdef': 'u+abcdef',
|
| 185 |
#
|
| 186 |
# # url
|
| 187 |
# 'url(a)': 'url(a)',
|
| 188 |
# 'uRl(a)': 'url(a)',
|
| 189 |
# 'u\\rl(a)': 'url(a)',
|
| 190 |
# 'url("a")': 'url(a)',
|
| 191 |
# 'url( "a" )': 'url(a)',
|
| 192 |
# 'url(a)': 'url(a)',
|
| 193 |
# 'url(";")': 'url(";")',
|
| 194 |
# 'url(",")': 'url(",")',
|
| 195 |
# 'url(")")': 'url(")")',
|
| 196 |
# '''url("'")''': '''url("'")''',
|
| 197 |
# '''url('"')''': '''url("\\"")''',
|
| 198 |
# '''url("'")''': '''url("'")''',
|
| 199 |
#
|
| 200 |
# # operator
|
| 201 |
# '1': '1',
|
| 202 |
# '1 2': '1 2',
|
| 203 |
# '1 2': '1 2',
|
| 204 |
# '1,2': '1, 2',
|
| 205 |
# '1, 2': '1, 2',
|
| 206 |
# '1 ,2': '1, 2',
|
| 207 |
# '1 , 2': '1, 2',
|
| 208 |
# '1/2': '1/2',
|
| 209 |
# '1/ 2': '1/2',
|
| 210 |
# '1 /2': '1/2',
|
| 211 |
# '1 / 2': '1/2',
|
| 212 |
# # comment
|
| 213 |
# '1/**/2': '1 /**/ 2',
|
| 214 |
# '1 /**/2': '1 /**/ 2',
|
| 215 |
# '1/**/ 2': '1 /**/ 2',
|
| 216 |
# '1 /**/ 2': '1 /**/ 2',
|
| 217 |
# '1 /*a*/ /*b*/ 2': '1 /*a*/ /*b*/ 2',
|
| 218 |
# # , before
|
| 219 |
# '1,/**/2': '1, /**/ 2',
|
| 220 |
# '1 ,/**/2': '1, /**/ 2',
|
| 221 |
# '1, /**/2': '1, /**/ 2',
|
| 222 |
# '1 , /**/2': '1, /**/ 2',
|
| 223 |
# # , after
|
| 224 |
# '1/**/,2': '1 /**/, 2',
|
| 225 |
# '1/**/ ,2': '1 /**/, 2',
|
| 226 |
# '1/**/, 2': '1 /**/, 2',
|
| 227 |
# '1/**/ , 2': '1 /**/, 2',
|
| 228 |
# # all
|
| 229 |
# '1/*a*/ ,/*b*/ 2': '1 /*a*/, /*b*/ 2',
|
| 230 |
# '1 /*a*/, /*b*/2': '1 /*a*/, /*b*/ 2',
|
| 231 |
# '1 /*a*/ , /*b*/ 2': '1 /*a*/, /*b*/ 2',
|
| 232 |
#
|
| 233 |
# # list
|
| 234 |
# 'a b1,b2 b2,b3,b4': 'a b1, b2 b2, b3, b4',
|
| 235 |
# 'a b1 , b2 b2 , b3 , b4': 'a b1, b2 b2, b3, b4',
|
| 236 |
# 'u+1 , u+2-5': 'u+1, u+2-5',
|
| 237 |
# u'local( x ), url(y) format( "x" , "y" )':
|
| 238 |
# u'local(x), url(y) format("x", "y")',
|
| 239 |
# # FUNCTION
|
| 240 |
# u'attr( href )': u'attr(href)',
|
| 241 |
# # PrinceXML extende FUNC syntax with nested FUNC
|
| 242 |
# u'target-counter(attr(href),page)': u'target-counter(attr(href), page)'
|
| 243 |
# }
|
| 244 |
#
|
| 245 |
# self.do_equal_r(tests)
|
| 246 |
#
|
| 247 |
# tests = {
|
| 248 |
# u'a+': xml.dom.SyntaxErr,
|
| 249 |
# u'-': xml.dom.SyntaxErr,
|
| 250 |
# u'+': xml.dom.SyntaxErr,
|
| 251 |
# u'-%': xml.dom.SyntaxErr,
|
| 252 |
# u'+a': xml.dom.SyntaxErr,
|
| 253 |
# u'--1px': xml.dom.SyntaxErr,
|
| 254 |
# u'++1px': xml.dom.SyntaxErr,
|
| 255 |
# u'#': xml.dom.SyntaxErr,
|
| 256 |
# u'#00': xml.dom.SyntaxErr,
|
| 257 |
# u'#0000': xml.dom.SyntaxErr,
|
| 258 |
# u'#00000': xml.dom.SyntaxErr,
|
| 259 |
# u'#0000000': xml.dom.SyntaxErr,
|
| 260 |
# u'-#0': xml.dom.SyntaxErr,
|
| 261 |
# # operator
|
| 262 |
# u',': xml.dom.SyntaxErr,
|
| 263 |
# u'1,,2': xml.dom.SyntaxErr,
|
| 264 |
# u'1,/**/,2': xml.dom.SyntaxErr,
|
| 265 |
# u'1 , /**/ , 2': xml.dom.SyntaxErr,
|
| 266 |
# u'1,': xml.dom.SyntaxErr,
|
| 267 |
# u'1, ': xml.dom.SyntaxErr,
|
| 268 |
# u'1 ,': xml.dom.SyntaxErr,
|
| 269 |
# u'1 , ': xml.dom.SyntaxErr,
|
| 270 |
# u'1 , ': xml.dom.SyntaxErr,
|
| 271 |
# u'1//2': xml.dom.SyntaxErr,
|
| 272 |
# # URL
|
| 273 |
# u'url(x))': xml.dom.SyntaxErr,
|
| 274 |
# # string
|
| 275 |
# u'"': xml.dom.SyntaxErr,
|
| 276 |
# u"'": xml.dom.SyntaxErr,
|
| 277 |
# # function
|
| 278 |
# u'f(-)': xml.dom.SyntaxErr,
|
| 279 |
# u'f(x))': xml.dom.SyntaxErr
|
| 280 |
# }
|
| 281 |
# self.do_raise_r(tests)
|
| 282 |
#
|
| 283 |
# def test_incomplete(self):
|
| 284 |
# "CSSValue (incomplete)"
|
| 285 |
# tests = {
|
| 286 |
# u'url("a': u'url(a)',
|
| 287 |
# u'url(a': u'url(a)'
|
| 288 |
# }
|
| 289 |
# for v, exp in tests.items():
|
| 290 |
# s = cssutils.parseString('a { background: %s' % v)
|
| 291 |
# v = s.cssRules[0].style.background
|
| 292 |
# self.assertEqual(v, exp)
|
| 293 |
#
|
| 294 |
# def test_cssValueType(self):
|
| 295 |
# "CSSValue.cssValueType .cssValueTypeString"
|
| 296 |
# tests = [
|
| 297 |
# ([u'inherit', u'INhe\\rit'], 'CSS_INHERIT', cssutils.css.CSSValue),
|
| 298 |
# (['1', '1%', '1em', '1ex', '1px', '1cm', '1mm', '1in', '1pt', '1pc',
|
| 299 |
# '1deg', '1rad', '1grad', '1ms', '1s', '1hz', '1khz', '1other',
|
| 300 |
# '"string"', "'string'", 'url(x)', 'red',
|
| 301 |
# 'attr(a)', 'counter(x)', 'rect(1px, 2px, 3px, 4px)',
|
| 302 |
# 'rgb(0, 0, 0)', '#000', '#123456', 'rgba(0, 0, 0, 0)',
|
| 303 |
# 'hsl(0, 0, 0)', 'hsla(0, 0, 0, 0)',
|
| 304 |
# ],
|
| 305 |
# 'CSS_PRIMITIVE_VALUE', cssutils.css.CSSPrimitiveValue),
|
| 306 |
# ([u'1px 1px', 'red blue green x'], 'CSS_VALUE_LIST', cssutils.css.CSSValueList),
|
| 307 |
# # what is a custom value?
|
| 308 |
# #([], 'CSS_CUSTOM', cssutils.css.CSSValue)
|
| 309 |
# ]
|
| 310 |
# for values, name, cls in tests:
|
| 311 |
# for value in values:
|
| 312 |
# v = cssutils.css.CSSValue(cssText=value)
|
| 313 |
# if value == "'string'":
|
| 314 |
# # will be changed to " always
|
| 315 |
# value = '"string"'
|
| 316 |
# self.assertEqual(value, v.cssText)
|
| 317 |
# self.assertEqual(name, v.cssValueTypeString)
|
| 318 |
# self.assertEqual(getattr(v, name), v.cssValueType)
|
| 319 |
# self.assertEqual(cls, type(v))
|
| 320 |
#
|
| 321 |
# def test_readonly(self):
|
| 322 |
# "(CSSValue._readonly)"
|
| 323 |
# v = cssutils.css.CSSValue(cssText='inherit')
|
| 324 |
# self.assertTrue(False is v._readonly)
|
| 325 |
#
|
| 326 |
# v = cssutils.css.CSSValue(cssText='inherit', readonly=True)
|
| 327 |
# self.assertTrue(True is v._readonly)
|
| 328 |
# self.assertTrue(u'inherit', v.cssText)
|
| 329 |
# self.assertRaises(xml.dom.NoModificationAllowedErr, v._setCssText, u'x')
|
| 330 |
# self.assertTrue(u'inherit', v.cssText)
|
| 331 |
#
|
| 332 |
# def test_reprANDstr(self):
|
| 333 |
# "CSSValue.__repr__(), .__str__()"
|
| 334 |
# cssText='inherit'
|
| 335 |
#
|
| 336 |
# s = cssutils.css.CSSValue(cssText=cssText)
|
| 337 |
#
|
| 338 |
# self.assertTrue(cssText in str(s))
|
| 339 |
#
|
| 340 |
# s2 = eval(repr(s))
|
| 341 |
# self.assertTrue(isinstance(s2, s.__class__))
|
| 342 |
# self.assertTrue(cssText == s2.cssText)
|
| 343 |
#
|
| 344 |
#
|
| 345 |
#class CSSPrimitiveValueTestCase(basetest.BaseTestCase):
|
| 346 |
#
|
| 347 |
# def test_init(self):
|
| 348 |
# "CSSPrimitiveValue.__init__()"
|
| 349 |
# v = cssutils.css.CSSPrimitiveValue(u'1')
|
| 350 |
# self.assertTrue(u'1' == v.cssText)
|
| 351 |
#
|
| 352 |
# self.assertTrue(v.CSS_PRIMITIVE_VALUE == v.cssValueType)
|
| 353 |
# self.assertTrue("CSS_PRIMITIVE_VALUE" == v.cssValueTypeString)
|
| 354 |
#
|
| 355 |
# self.assertTrue(v.CSS_NUMBER == v.primitiveType)
|
| 356 |
# self.assertTrue("CSS_NUMBER" == v.primitiveTypeString)
|
| 357 |
#
|
| 358 |
# # DUMMY to be able to test empty constructor call
|
| 359 |
# #self.assertRaises(xml.dom.SyntaxErr, v.__init__, None)
|
| 360 |
#
|
| 361 |
# self.assertRaises(xml.dom.InvalidAccessErr, v.getCounterValue)
|
| 362 |
# self.assertRaises(xml.dom.InvalidAccessErr, v.getRGBColorValue)
|
| 363 |
# self.assertRaises(xml.dom.InvalidAccessErr, v.getRectValue)
|
| 364 |
# self.assertRaises(xml.dom.InvalidAccessErr, v.getStringValue)
|
| 365 |
#
|
| 366 |
# def test_CSS_UNKNOWN(self):
|
| 367 |
# "CSSPrimitiveValue.CSS_UNKNOWN"
|
| 368 |
# v = cssutils.css.CSSPrimitiveValue(u'expression(false)')
|
| 369 |
# self.assertTrue(v.CSS_UNKNOWN == v.primitiveType)
|
| 370 |
# self.assertTrue('CSS_UNKNOWN' == v.primitiveTypeString)
|
| 371 |
#
|
| 372 |
# def test_CSS_NUMBER_AND_OTHER_DIMENSIONS(self):
|
| 373 |
# "CSSPrimitiveValue.CSS_NUMBER .. CSS_DIMENSION"
|
| 374 |
# defs = [
|
| 375 |
# ('', 'CSS_NUMBER'),
|
| 376 |
# ('%', 'CSS_PERCENTAGE'),
|
| 377 |
# ('em', 'CSS_EMS'),
|
| 378 |
# ('ex', 'CSS_EXS'),
|
| 379 |
# ('px', 'CSS_PX'),
|
| 380 |
# ('cm', 'CSS_CM'),
|
| 381 |
# ('mm', 'CSS_MM'),
|
| 382 |
# ('in', 'CSS_IN'),
|
| 383 |
# ('pt', 'CSS_PT'),
|
| 384 |
# ('pc', 'CSS_PC'),
|
| 385 |
# ('deg', 'CSS_DEG'),
|
| 386 |
# ('rad', 'CSS_RAD'),
|
| 387 |
# ('grad', 'CSS_GRAD'),
|
| 388 |
# ('ms', 'CSS_MS'),
|
| 389 |
# ('s', 'CSS_S'),
|
| 390 |
# ('hz', 'CSS_HZ'),
|
| 391 |
# ('khz', 'CSS_KHZ'),
|
| 392 |
# ('other_dimension', 'CSS_DIMENSION')
|
| 393 |
# ]
|
| 394 |
# for dim, name in defs:
|
| 395 |
# for n in (0, 1, 1.1, -1, -1.1, -0):
|
| 396 |
# v = cssutils.css.CSSPrimitiveValue('%i%s' % (n, dim))
|
| 397 |
# self.assertEqual(name, v.primitiveTypeString)
|
| 398 |
# self.assertEqual(getattr(v, name), v.primitiveType)
|
| 399 |
#
|
| 400 |
# def test_CSS_STRING_AND_OTHER(self):
|
| 401 |
# "CSSPrimitiveValue.CSS_STRING .. CSS_RGBCOLOR"
|
| 402 |
# defs = [
|
| 403 |
# (('""', "''", '"some thing"', "' A\\ND '",
|
| 404 |
# # comma separated lists are STRINGS FOR NOW!
|
| 405 |
# 'a, b',
|
| 406 |
# '"a", "b"',
|
| 407 |
# ), 'CSS_STRING'),
|
| 408 |
# (('url(a)', 'url("a b")', "url(' ')"), 'CSS_URI'),
|
| 409 |
# (('some', 'or_anth-er'), 'CSS_IDENT'),
|
| 410 |
# (('attr(a)', 'attr(b)'), 'CSS_ATTR'),
|
| 411 |
# (('counter(1)', 'counter(2)'), 'CSS_COUNTER'),
|
| 412 |
# (('rect(1,2,3,4)',), 'CSS_RECT'),
|
| 413 |
# (('rgb(1,2,3)', 'rgb(10%, 20%, 30%)', '#123', '#123456'),
|
| 414 |
# 'CSS_RGBCOLOR'),
|
| 415 |
# (('rgba(1,2,3,4)','rgba(10%, 20%, 30%, 40%)', ),
|
| 416 |
# 'CSS_RGBACOLOR'),
|
| 417 |
# (('U+0', 'u+ffffff', 'u+000000-f',
|
| 418 |
# 'u+0-f, U+ee-ff'), 'CSS_UNICODE_RANGE')
|
| 419 |
# ]
|
| 420 |
#
|
| 421 |
# for examples, name in defs:
|
| 422 |
# for x in examples:
|
| 423 |
# v = cssutils.css.CSSPrimitiveValue(x)
|
| 424 |
# self.assertEqual(getattr(v, name), v.primitiveType)
|
| 425 |
# self.assertEqual(name, v.primitiveTypeString)
|
| 426 |
#
|
| 427 |
# def test_getFloat(self):
|
| 428 |
# "CSSPrimitiveValue.getFloatValue()"
|
| 429 |
# # NOT TESTED are float values as it seems difficult to
|
| 430 |
# # compare these. Maybe use decimal.Decimal?
|
| 431 |
#
|
| 432 |
# v = cssutils.css.CSSPrimitiveValue(u'1px')
|
| 433 |
# tests = {
|
| 434 |
# '0': (v.CSS_NUMBER, 0),
|
| 435 |
# '-1.1': (v.CSS_NUMBER, -1.1),
|
| 436 |
# '1%': (v.CSS_PERCENTAGE, 1),
|
| 437 |
# '-1%': (v.CSS_PERCENTAGE, -1),
|
| 438 |
# '1em': (v.CSS_EMS, 1),
|
| 439 |
# '-1.1em': (v.CSS_EMS, -1.1),
|
| 440 |
# '1ex': (v.CSS_EXS, 1),
|
| 441 |
# '1px': (v.CSS_PX, 1),
|
| 442 |
#
|
| 443 |
# '1cm': (v.CSS_CM, 1),
|
| 444 |
# '1cm': (v.CSS_MM, 10),
|
| 445 |
# '254cm': (v.CSS_IN, 100),
|
| 446 |
# '1mm': (v.CSS_MM, 1),
|
| 447 |
# '10mm': (v.CSS_CM, 1),
|
| 448 |
# '254mm': (v.CSS_IN, 10),
|
| 449 |
# '1in': (v.CSS_IN, 1),
|
| 450 |
# '100in': (v.CSS_CM, 254), # ROUNDED!!!
|
| 451 |
# '10in': (v.CSS_MM, 254), # ROUNDED!!!
|
| 452 |
#
|
| 453 |
# '1pt': (v.CSS_PT, 1),
|
| 454 |
# '1pc': (v.CSS_PC, 1),
|
| 455 |
#
|
| 456 |
# '1deg': (v.CSS_DEG, 1),
|
| 457 |
# '1rad': (v.CSS_RAD, 1),
|
| 458 |
# '1grad': (v.CSS_GRAD, 1),
|
| 459 |
#
|
| 460 |
# '1ms': (v.CSS_MS, 1),
|
| 461 |
# '1000ms': (v.CSS_S, 1),
|
| 462 |
# '1s': (v.CSS_S, 1),
|
| 463 |
# '1s': (v.CSS_MS, 1000),
|
| 464 |
#
|
| 465 |
# '1hz': (v.CSS_HZ, 1),
|
| 466 |
# '1000hz': (v.CSS_KHZ, 1),
|
| 467 |
# '1khz': (v.CSS_KHZ, 1),
|
| 468 |
# '1khz': (v.CSS_HZ, 1000),
|
| 469 |
#
|
| 470 |
# '1DIMENSION': (v.CSS_DIMENSION, 1),
|
| 471 |
# }
|
| 472 |
# for cssText in tests:
|
| 473 |
# v.cssText = cssText
|
| 474 |
# unitType, exp = tests[cssText]
|
| 475 |
# val = v.getFloatValue(unitType)
|
| 476 |
# if unitType in (v.CSS_IN, v.CSS_CM):
|
| 477 |
# val = round(val)
|
| 478 |
# self.assertEqual(val , exp)
|
| 479 |
#
|
| 480 |
# def test_setFloat(self):
|
| 481 |
# "CSSPrimitiveValue.setFloatValue()"
|
| 482 |
# V = cssutils.css.CSSPrimitiveValue
|
| 483 |
#
|
| 484 |
# tests = {
|
| 485 |
# # unitType, value
|
| 486 |
# (V.CSS_NUMBER, 1): [
|
| 487 |
# # unitType, setvalue,
|
| 488 |
# # getvalue or expected exception, msg or cssText
|
| 489 |
# (V.CSS_NUMBER, 0, 0, '0'),
|
| 490 |
# (V.CSS_NUMBER, 0.1, 0.1, '0.1'),
|
| 491 |
# (V.CSS_NUMBER, -0, 0, '0'),
|
| 492 |
# (V.CSS_NUMBER, 2, 2, '2'),
|
| 493 |
# (V.CSS_NUMBER, 2.0, 2, '2'),
|
| 494 |
# (V.CSS_NUMBER, 2.1, 2.1, '2.1'),
|
| 495 |
# (V.CSS_NUMBER, -2.1, -2.1, '-2.1'),
|
| 496 |
# # setting with string does work
|
| 497 |
# (V.CSS_NUMBER, '1', 1, '1'),
|
| 498 |
# (V.CSS_NUMBER, '1.1', 1.1, '1.1'),
|
| 499 |
# (V.CSS_PX, 1, xml.dom.InvalidAccessErr, None),
|
| 500 |
# (V.CSS_DEG, 1, xml.dom.InvalidAccessErr, None),
|
| 501 |
# (V.CSS_RAD, 1, xml.dom.InvalidAccessErr, None),
|
| 502 |
# (V.CSS_GRAD, 1, xml.dom.InvalidAccessErr, None),
|
| 503 |
# (V.CSS_S, 1, xml.dom.InvalidAccessErr, None),
|
| 504 |
# (V.CSS_MS, 1, xml.dom.InvalidAccessErr, None),
|
| 505 |
# (V.CSS_KHZ, 1, xml.dom.InvalidAccessErr, None),
|
| 506 |
# (V.CSS_HZ, 1, xml.dom.InvalidAccessErr, None),
|
| 507 |
# (V.CSS_DIMENSION, 1, xml.dom.InvalidAccessErr, None),
|
| 508 |
# (V.CSS_MM, 2, xml.dom.InvalidAccessErr, None),
|
| 509 |
#
|
| 510 |
# (V.CSS_NUMBER, 'x', xml.dom.InvalidAccessErr,
|
| 511 |
# "CSSPrimitiveValue: floatValue 'x' is not a float"),
|
| 512 |
# (V.CSS_NUMBER, '1x', xml.dom.InvalidAccessErr,
|
| 513 |
# "CSSPrimitiveValue: floatValue '1x' is not a float"),
|
| 514 |
#
|
| 515 |
# (V.CSS_STRING, 'x', xml.dom.InvalidAccessErr,
|
| 516 |
# "CSSPrimitiveValue: unitType 'CSS_STRING' is not a float type"),
|
| 517 |
# (V.CSS_URI, 'x', xml.dom.InvalidAccessErr,
|
| 518 |
# "CSSPrimitiveValue: unitType 'CSS_URI' is not a float type"),
|
| 519 |
# (V.CSS_ATTR, 'x', xml.dom.InvalidAccessErr,
|
| 520 |
# "CSSPrimitiveValue: unitType 'CSS_ATTR' is not a float type"),
|
| 521 |
# (V.CSS_IDENT, 'x', xml.dom.InvalidAccessErr,
|
| 522 |
# "CSSPrimitiveValue: unitType 'CSS_IDENT' is not a float type"),
|
| 523 |
# (V.CSS_RGBCOLOR, 'x', xml.dom.InvalidAccessErr,
|
| 524 |
# "CSSPrimitiveValue: unitType 'CSS_RGBCOLOR' is not a float type"),
|
| 525 |
# (V.CSS_RGBACOLOR, 'x', xml.dom.InvalidAccessErr,
|
| 526 |
# "CSSPrimitiveValue: unitType 'CSS_RGBACOLOR' is not a float type"),
|
| 527 |
# (V.CSS_RECT, 'x', xml.dom.InvalidAccessErr,
|
| 528 |
# "CSSPrimitiveValue: unitType 'CSS_RECT' is not a float type"),
|
| 529 |
# (V.CSS_COUNTER, 'x', xml.dom.InvalidAccessErr,
|
| 530 |
# "CSSPrimitiveValue: unitType 'CSS_COUNTER' is not a float type"),
|
| 531 |
# (V.CSS_EMS, 1, xml.dom.InvalidAccessErr,
|
| 532 |
# "CSSPrimitiveValue: Cannot coerce primitiveType 'CSS_NUMBER' to 'CSS_EMS'"),
|
| 533 |
# (V.CSS_EXS, 1, xml.dom.InvalidAccessErr,
|
| 534 |
# "CSSPrimitiveValue: Cannot coerce primitiveType 'CSS_NUMBER' to 'CSS_EXS'")
|
| 535 |
# ],
|
| 536 |
# (V.CSS_MM, '1mm'): [
|
| 537 |
# (V.CSS_MM, 2, 2, '2mm'),
|
| 538 |
# (V.CSS_MM, 0, 0, '0mm'),
|
| 539 |
# (V.CSS_MM, 0.1, 0.1, '0.1mm'),
|
| 540 |
# (V.CSS_MM, -0, -0, '0mm'),
|
| 541 |
# (V.CSS_MM, 3.0, 3, '3mm'),
|
| 542 |
# (V.CSS_MM, 3.1, 3.1, '3.1mm'),
|
| 543 |
# (V.CSS_MM, -3.1, -3.1, '-3.1mm'),
|
| 544 |
# (V.CSS_CM, 1, 10, '10mm'),
|
| 545 |
# (V.CSS_IN, 10, 254, '254mm'),
|
| 546 |
# (V.CSS_PT, 1, 1828.8, '1828.8mm'),
|
| 547 |
# (V.CSS_PX, 1, xml.dom.InvalidAccessErr, None),
|
| 548 |
# (V.CSS_NUMBER, 2, xml.dom.InvalidAccessErr, None)
|
| 549 |
# ],
|
| 550 |
# (V.CSS_PT, '1pt'): [
|
| 551 |
# (V.CSS_PT, 2, 2, '2pt'),
|
| 552 |
# (V.CSS_PC, 12, 1, '1pt'),
|
| 553 |
# (V.CSS_NUMBER, 1, xml.dom.InvalidAccessErr, None),
|
| 554 |
# (V.CSS_DEG, 1, xml.dom.InvalidAccessErr, None),
|
| 555 |
# (V.CSS_PX, 1, xml.dom.InvalidAccessErr, None)
|
| 556 |
# ],
|
| 557 |
# (V.CSS_KHZ, '1khz'): [
|
| 558 |
# (V.CSS_HZ, 2000, 2, '2khz'),
|
| 559 |
# (V.CSS_NUMBER, 1, xml.dom.InvalidAccessErr, None),
|
| 560 |
# (V.CSS_DEG, 1, xml.dom.InvalidAccessErr, None),
|
| 561 |
# (V.CSS_PX, 1, xml.dom.InvalidAccessErr, None)
|
| 562 |
# ]
|
| 563 |
# }
|
| 564 |
# for test in tests:
|
| 565 |
# initialType, initialValue = test
|
| 566 |
# pv = cssutils.css.CSSPrimitiveValue(initialValue)
|
| 567 |
# for setType, setValue, exp, cssText in tests[test]:
|
| 568 |
# if type(exp) == types.TypeType or\
|
| 569 |
# type(exp) == types.ClassType: # 2.4 compatibility
|
| 570 |
# if cssText:
|
| 571 |
# self.assertRaisesMsg(
|
| 572 |
# exp, cssText, pv.setFloatValue, setType, setValue)
|
| 573 |
# else:
|
| 574 |
# self.assertRaises(
|
| 575 |
# exp, pv.setFloatValue, setType, setValue)
|
| 576 |
# else:
|
| 577 |
# pv.setFloatValue(setType, setValue)
|
| 578 |
# self.assertEqual(pv._value[0], cssText)
|
| 579 |
# if cssText == '0mm':
|
| 580 |
# cssText = '0'
|
| 581 |
# self.assertEqual(pv.cssText, cssText)
|
| 582 |
# self.assertEqual(pv.getFloatValue(initialType), exp)
|
| 583 |
#
|
| 584 |
# def test_getString(self):
|
| 585 |
# "CSSPrimitiveValue.getStringValue()"
|
| 586 |
# v = cssutils.css.CSSPrimitiveValue(u'1px')
|
| 587 |
# self.assertTrue(v.primitiveType == v.CSS_PX)
|
| 588 |
# self.assertRaises(xml.dom.InvalidAccessErr,
|
| 589 |
# v.getStringValue)
|
| 590 |
#
|
| 591 |
# pv = cssutils.css.CSSPrimitiveValue
|
| 592 |
# tests = {
|
| 593 |
# pv.CSS_STRING: ("'red'", 'red'),
|
| 594 |
# pv.CSS_STRING: ('"red"', 'red'),
|
| 595 |
# pv.CSS_URI: ('url(http://example.com)', None),
|
| 596 |
# pv.CSS_URI: ("url('http://example.com')",
|
| 597 |
# u"http://example.com"),
|
| 598 |
# pv.CSS_URI: ('url("http://example.com")',
|
| 599 |
# u'http://example.com'),
|
| 600 |
# pv.CSS_URI: ('url("http://example.com?)")',
|
| 601 |
# u'http://example.com?)'),
|
| 602 |
# pv.CSS_IDENT: ('red', None),
|
| 603 |
# pv.CSS_ATTR: ('attr(att-name)',
|
| 604 |
# u'att-name'), # the name of the attrr
|
| 605 |
# }
|
| 606 |
# for t in tests:
|
| 607 |
# val, exp = tests[t]
|
| 608 |
# if not exp:
|
| 609 |
# exp = val
|
| 610 |
#
|
| 611 |
# v = cssutils.css.CSSPrimitiveValue(val)
|
| 612 |
# self.assertEqual(v.primitiveType, t)
|
| 613 |
# self.assertEqual(v.getStringValue(), exp)
|
| 614 |
#
|
| 615 |
# def test_setString(self):
|
| 616 |
# "CSSPrimitiveValue.setStringValue()"
|
| 617 |
# # CSS_STRING
|
| 618 |
# v = cssutils.css.CSSPrimitiveValue(u'"a"')
|
| 619 |
# self.assertTrue(v.CSS_STRING == v.primitiveType)
|
| 620 |
# v.setStringValue(v.CSS_STRING, 'b')
|
| 621 |
# self.assertTrue(('b', 'STRING') == v._value)
|
| 622 |
# self.assertEqual('b', v.getStringValue())
|
| 623 |
# self.assertRaisesMsg(xml.dom.InvalidAccessErr,
|
| 624 |
# u"CSSPrimitiveValue: Cannot coerce primitiveType 'CSS_STRING' to 'CSS_URI'",
|
| 625 |
# v.setStringValue, *(v.CSS_URI, 'x'))
|
| 626 |
# self.assertRaisesMsg(xml.dom.InvalidAccessErr,
|
| 627 |
# u"CSSPrimitiveValue: Cannot coerce primitiveType 'CSS_STRING' to 'CSS_IDENT'",
|
| 628 |
# v.setStringValue, *(v.CSS_IDENT, 'x'))
|
| 629 |
# self.assertRaisesMsg(xml.dom.InvalidAccessErr,
|
| 630 |
# u"CSSPrimitiveValue: Cannot coerce primitiveType 'CSS_STRING' to 'CSS_ATTR'",
|
| 631 |
# v.setStringValue, *(v.CSS_ATTR, 'x'))
|
| 632 |
#
|
| 633 |
# # CSS_IDENT
|
| 634 |
# v = cssutils.css.CSSPrimitiveValue('new')
|
| 635 |
# v.setStringValue(v.CSS_IDENT, 'ident')
|
| 636 |
# self.assertTrue(v.CSS_IDENT == v.primitiveType)
|
| 637 |
# self.assertTrue(('ident', 'IDENT') == v._value)
|
| 638 |
# self.assertTrue('ident' == v.getStringValue())
|
| 639 |
# self.assertRaisesMsg(xml.dom.InvalidAccessErr,
|
| 640 |
# u"CSSPrimitiveValue: Cannot coerce primitiveType 'CSS_IDENT' to 'CSS_URI'",
|
| 641 |
# v.setStringValue, *(v.CSS_URI, 'x'))
|
| 642 |
# self.assertRaisesMsg(xml.dom.InvalidAccessErr,
|
| 643 |
# u"CSSPrimitiveValue: Cannot coerce primitiveType 'CSS_IDENT' to 'CSS_STRING'",
|
| 644 |
# v.setStringValue, *(v.CSS_STRING, '"x"'))
|
| 645 |
# self.assertRaisesMsg(xml.dom.InvalidAccessErr,
|
| 646 |
# u"CSSPrimitiveValue: Cannot coerce primitiveType 'CSS_IDENT' to 'CSS_ATTR'",
|
| 647 |
# v.setStringValue, *(v.CSS_ATTR, 'x'))
|
| 648 |
#
|
| 649 |
# # CSS_URI
|
| 650 |
# v = cssutils.css.CSSPrimitiveValue('url(old)')
|
| 651 |
# v.setStringValue(v.CSS_URI, '(')
|
| 652 |
# self.assertEqual((u'(', 'URI'), v._value)
|
| 653 |
# self.assertEqual(u'(', v.getStringValue())
|
| 654 |
#
|
| 655 |
# v.setStringValue(v.CSS_URI, ')')
|
| 656 |
# self.assertEqual((u')', 'URI'), v._value)
|
| 657 |
# self.assertEqual(u')', v.getStringValue())
|
| 658 |
#
|
| 659 |
# v.setStringValue(v.CSS_URI, '"')
|
| 660 |
# self.assertEqual(ur'"', v.getStringValue())
|
| 661 |
# self.assertEqual((ur'"', 'URI'), v._value)
|
| 662 |
#
|
| 663 |
# v.setStringValue(v.CSS_URI, "''")
|
| 664 |
# self.assertEqual(ur"''", v.getStringValue())
|
| 665 |
# self.assertEqual((ur"''", 'URI'), v._value)
|
| 666 |
#
|
| 667 |
# v.setStringValue(v.CSS_URI, ',')
|
| 668 |
# self.assertEqual(ur',', v.getStringValue())
|
| 669 |
# self.assertEqual((ur',', 'URI'), v._value)
|
| 670 |
#
|
| 671 |
# v.setStringValue(v.CSS_URI, ' ')
|
| 672 |
# self.assertEqual((u' ', 'URI'), v._value)
|
| 673 |
# self.assertEqual(u' ', v.getStringValue())
|
| 674 |
#
|
| 675 |
# v.setStringValue(v.CSS_URI, 'a)')
|
| 676 |
# self.assertEqual((u'a)', 'URI'), v._value)
|
| 677 |
# self.assertEqual(u'a)', v.getStringValue())
|
| 678 |
#
|
| 679 |
# v.setStringValue(v.CSS_URI, 'a')
|
| 680 |
# self.assertTrue(v.CSS_URI == v.primitiveType)
|
| 681 |
# self.assertEqual((u'a', 'URI'), v._value)
|
| 682 |
# self.assertEqual(u'a', v.getStringValue())
|
| 683 |
#
|
| 684 |
# self.assertRaisesMsg(xml.dom.InvalidAccessErr,
|
| 685 |
# u"CSSPrimitiveValue: Cannot coerce primitiveType 'CSS_URI' to 'CSS_IDENT'",
|
| 686 |
# v.setStringValue, *(v.CSS_IDENT, 'x'))
|
| 687 |
# self.assertRaisesMsg(xml.dom.InvalidAccessErr,
|
| 688 |
# u"CSSPrimitiveValue: Cannot coerce primitiveType 'CSS_URI' to 'CSS_STRING'",
|
| 689 |
# v.setStringValue, *(v.CSS_STRING, '"x"'))
|
| 690 |
# self.assertRaisesMsg(xml.dom.InvalidAccessErr,
|
| 691 |
# u"CSSPrimitiveValue: Cannot coerce primitiveType 'CSS_URI' to 'CSS_ATTR'",
|
| 692 |
# v.setStringValue, *(v.CSS_ATTR, 'x'))
|
| 693 |
#
|
| 694 |
# # CSS_ATTR
|
| 695 |
# v = cssutils.css.CSSPrimitiveValue('attr(old)')
|
| 696 |
# v.setStringValue(v.CSS_ATTR, 'a')
|
| 697 |
# self.assertTrue(v.CSS_ATTR == v.primitiveType)
|
| 698 |
# self.assertTrue('a' == v.getStringValue())
|
| 699 |
# self.assertRaisesMsg(xml.dom.InvalidAccessErr,
|
| 700 |
# u"CSSPrimitiveValue: Cannot coerce primitiveType 'CSS_ATTR' to 'CSS_IDENT'",
|
| 701 |
# v.setStringValue, *(v.CSS_IDENT, 'x'))
|
| 702 |
# self.assertRaisesMsg(xml.dom.InvalidAccessErr,
|
| 703 |
# u"CSSPrimitiveValue: Cannot coerce primitiveType 'CSS_ATTR' to 'CSS_STRING'",
|
| 704 |
# v.setStringValue, *(v.CSS_STRING, '"x"'))
|
| 705 |
# self.assertRaisesMsg(xml.dom.InvalidAccessErr,
|
| 706 |
# u"CSSPrimitiveValue: Cannot coerce primitiveType 'CSS_ATTR' to 'CSS_URI'",
|
| 707 |
# v.setStringValue, *(v.CSS_URI, 'x'))
|
| 708 |
#
|
| 709 |
# # TypeError as 'x' is no valid type
|
| 710 |
# self.assertRaisesMsg(xml.dom.InvalidAccessErr,
|
| 711 |
# u"CSSPrimitiveValue: stringType 'x' (UNKNOWN TYPE) is not a string type",
|
| 712 |
# v.setStringValue, *('x', 'brown'))
|
| 713 |
# # IndexError as 111 is no valid type
|
| 714 |
# self.assertRaisesMsg(xml.dom.InvalidAccessErr,
|
| 715 |
# u"CSSPrimitiveValue: stringType 111 (UNKNOWN TYPE) is not a string type",
|
| 716 |
# v.setStringValue, *(111, 'brown'))
|
| 717 |
# # CSS_PX is no string type
|
| 718 |
# self.assertRaisesMsg(xml.dom.InvalidAccessErr,
|
| 719 |
# u"CSSPrimitiveValue: stringType CSS_PX is not a string type",
|
| 720 |
# v.setStringValue, *(v.CSS_PX, 'brown'))
|
| 721 |
#
|
| 722 |
# def test_typeRGBColor(self):
|
| 723 |
# "RGBColor"
|
| 724 |
# v = cssutils.css.CSSPrimitiveValue('RGB(1, 5, 10)')
|
| 725 |
# self.assertEqual(v.CSS_RGBCOLOR, v.primitiveType)
|
| 726 |
# self.assertEqual(u'rgb(1, 5, 10)', v.cssText)
|
| 727 |
#
|
| 728 |
# v = cssutils.css.CSSPrimitiveValue('rgb(1, 5, 10)')
|
| 729 |
# self.assertEqual(v.CSS_RGBCOLOR, v.primitiveType)
|
| 730 |
# self.assertEqual(u'rgb(1, 5, 10)', v.cssText)
|
| 731 |
#
|
| 732 |
# v = cssutils.css.CSSPrimitiveValue('rgb(1%, 5%, 10%)')
|
| 733 |
# self.assertEqual(v.CSS_RGBCOLOR, v.primitiveType)
|
| 734 |
# self.assertEqual(u'rgb(1%, 5%, 10%)', v.cssText)
|
| 735 |
#
|
| 736 |
# v = cssutils.css.CSSPrimitiveValue(' rgb( 1 ,5, 10 )')
|
| 737 |
# self.assertEqual(v.CSS_RGBCOLOR, v.primitiveType)
|
| 738 |
# v = cssutils.css.CSSPrimitiveValue('rgb(1,5,10)')
|
| 739 |
# self.assertEqual(v.CSS_RGBCOLOR, v.primitiveType)
|
| 740 |
# v = cssutils.css.CSSPrimitiveValue('rgb(1%, .5%, 10.1%)')
|
| 741 |
# self.assertEqual(v.CSS_RGBCOLOR, v.primitiveType)
|
| 742 |
#
|
| 743 |
# def test_reprANDstr(self):
|
| 744 |
# "CSSPrimitiveValue.__repr__(), .__str__()"
|
| 745 |
# v='111'
|
| 746 |
#
|
| 747 |
# s = cssutils.css.CSSPrimitiveValue(v)
|
| 748 |
#
|
| 749 |
# self.assertTrue(v in str(s))
|
| 750 |
# self.assertTrue('CSS_NUMBER' in str(s))
|
| 751 |
#
|
| 752 |
# s2 = eval(repr(s))
|
| 753 |
# self.assertTrue(isinstance(s2, s.__class__))
|
| 754 |
# self.assertTrue(v == s2.cssText)
|
| 755 |
#
|
| 756 |
#
|
| 757 |
#class CSSValueListTestCase(basetest.BaseTestCase):
|
| 758 |
#
|
| 759 |
# def test_init(self):
|
| 760 |
# "CSSValueList.__init__()"
|
| 761 |
# v = cssutils.css.CSSValue(cssText=u'red blue')
|
| 762 |
# self.assertTrue(v.CSS_VALUE_LIST == v.cssValueType)
|
| 763 |
# self.assertEqual('red blue', v.cssText)
|
| 764 |
#
|
| 765 |
# self.assertTrue(2 == v.length)
|
| 766 |
#
|
| 767 |
# item = v.item(0)
|
| 768 |
# item.setStringValue(item.CSS_IDENT, 'green')
|
| 769 |
# self.assertEqual('green blue', v.cssText)
|
| 770 |
#
|
| 771 |
# def test_numbers(self):
|
| 772 |
# "CSSValueList.cssText"
|
| 773 |
# tests = {
|
| 774 |
# u'0 0px -0px +0px': (u'0 0 0 0', 4),
|
| 775 |
# u'1 2 3 4': (None, 4),
|
| 776 |
# u'-1 -2 -3 -4': (None, 4),
|
| 777 |
# u'-1 2': (None, 2),
|
| 778 |
# u'-1px red "x"': (None, 3),
|
| 779 |
# u'a, b c': (None, 2),
|
| 780 |
# u'1px1 2% 3': (u'1px1 2% 3', 3),
|
| 781 |
# u'f(+1pX, -2, 5%) 1': (u'f(1px, -2, 5%) 1', 2),
|
| 782 |
# u'0 f()0': (u'0 f() 0', 3),
|
| 783 |
# u'f()0': (u'f() 0', 2),
|
| 784 |
# u'f()1%': (u'f() 1%', 2),
|
| 785 |
# u'f()1px': (u'f() 1px', 2),
|
| 786 |
# u'f()"str"': (u'f() "str"', 2),
|
| 787 |
# u'f()ident': (u'f() ident', 2),
|
| 788 |
# u'f()#123': (u'f() #123', 2),
|
| 789 |
# u'f()url()': (u'f() url()', 2),
|
| 790 |
# u'f()f()': (u'f() f()', 2),
|
| 791 |
# u'url(x.gif)0 0': (u'url(x.gif) 0 0', 3),
|
| 792 |
# u'url(x.gif)no-repeat': (u'url(x.gif) no-repeat', 2)
|
| 793 |
# }
|
| 794 |
# for test in tests:
|
| 795 |
# exp, num = tests[test]
|
| 796 |
# if not exp:
|
| 797 |
# exp = test
|
| 798 |
# v = cssutils.css.CSSValue(cssText=test)
|
| 799 |
# self.assertTrue(v.CSS_VALUE_LIST == v.cssValueType)
|
| 800 |
# self.assertEqual(num, v.length)
|
| 801 |
# self.assertEqual(exp, v.cssText)
|
| 802 |
#
|
| 803 |
# def test_reprANDstr(self):
|
| 804 |
# "CSSValueList.__repr__(), .__str__()"
|
| 805 |
# v='1px 2px'
|
| 806 |
#
|
| 807 |
# s = cssutils.css.CSSValue(v)
|
| 808 |
# self.assertTrue(isinstance(s, cssutils.css.CSSValueList))
|
| 809 |
#
|
| 810 |
# self.assertTrue('length=2' in str(s))
|
| 811 |
# self.assertTrue(v in str(s))
|
| 812 |
#
|
| 813 |
# # not "eval()"able!
|
| 814 |
# #s2 = eval(repr(s))
|
| 815 |
#
|
| 816 |
#
|
| 817 |
#if __name__ == '__main__':
|
| 818 |
# import unittest
|
| 819 |
# unittest.main()
|