From b1136b5c52b4ad548bdd338654ee6ae1370e1f0d Mon Sep 17 00:00:00 2001
From: Hugo van Kemenade <hugovk@users.noreply.github.com>
Date: Fri, 31 Dec 2021 00:41:28 +0200
Subject: [PATCH 1/2] Replace removed assertEquals with assertEqual

---
 css_parser_tests/basetest.py  |  2 +-
 css_parser_tests/test_util.py | 32 ++++++++++++++++----------------
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/css_parser_tests/basetest.py b/css_parser_tests/basetest.py
index 115053f..f45a620 100644
--- a/css_parser_tests/basetest.py
+++ b/css_parser_tests/basetest.py
@@ -261,7 +261,7 @@ class GenerateTests(type):
     Example::
 
         def gen_test_length(self, string, expected):
-            self.assertEquals(len(string), expected)
+            self.assertEqual(len(string), expected)
         gen_test_length.cases = [
             ("a", 1),
             ("aa", 2),
diff --git a/css_parser_tests/test_util.py b/css_parser_tests/test_util.py
index 9ccd151..7ab1388 100644
--- a/css_parser_tests/test_util.py
+++ b/css_parser_tests/test_util.py
@@ -442,12 +442,12 @@ def test_ensure(self):
     def test_calling(self):
         self.assertIsNone(self.lazyre('bar'))
         match = self.lazyre('foobar')
-        self.assertEquals(match.group(), 'foo')
+        self.assertEqual(match.group(), 'foo')
 
     def test_matching(self):
         self.assertIsNone(self.lazyre.match('bar'))
         match = self.lazyre.match('foobar')
-        self.assertEquals(match.group(), 'foo')
+        self.assertEqual(match.group(), 'foo')
 
     def test_matching_with_position_parameters(self):
         self.assertIsNone(self.lazyre.match('foo', 1))
@@ -456,56 +456,56 @@ def test_matching_with_position_parameters(self):
     def test_searching(self):
         self.assertIsNone(self.lazyre.search('rafuubar'))
         match = self.lazyre.search('rafoobar')
-        self.assertEquals(match.group(), 'foo')
+        self.assertEqual(match.group(), 'foo')
 
     def test_searching_with_position_parameters(self):
         self.assertIsNone(self.lazyre.search('rafoobar', 3))
         self.assertIsNone(self.lazyre.search('rafoobar', 0, 4))
         match = self.lazyre.search('rafoofuobar', 4)
-        self.assertEquals(match.group(), 'fuo')
+        self.assertEqual(match.group(), 'fuo')
 
     def test_split(self):
-        self.assertEquals(self.lazyre.split('rafoobarfoobaz'),
+        self.assertEqual(self.lazyre.split('rafoobarfoobaz'),
                           ['ra', 'bar', 'baz'])
-        self.assertEquals(self.lazyre.split('rafoobarfoobaz', 1),
+        self.assertEqual(self.lazyre.split('rafoobarfoobaz', 1),
                           ['ra', 'barfoobaz'])
 
     def test_findall(self):
-        self.assertEquals(self.lazyre.findall('rafoobarfuobaz'),
+        self.assertEqual(self.lazyre.findall('rafoobarfuobaz'),
                           ['foo', 'fuo'])
 
     def test_finditer(self):
         result = self.lazyre.finditer('rafoobarfuobaz')
-        self.assertEquals([m.group() for m in result], ['foo', 'fuo'])
+        self.assertEqual([m.group() for m in result], ['foo', 'fuo'])
 
     def test_sub(self):
-        self.assertEquals(self.lazyre.sub('bar', 'foofoo'), 'barbar')
-        self.assertEquals(self.lazyre.sub(lambda x: 'baz', 'foofoo'), 'bazbaz')
+        self.assertEqual(self.lazyre.sub('bar', 'foofoo'), 'barbar')
+        self.assertEqual(self.lazyre.sub(lambda x: 'baz', 'foofoo'), 'bazbaz')
 
     def test_subn(self):
         subbed = self.lazyre.subn('bar', 'foofoo')
-        self.assertEquals(subbed, ('barbar', 2))
+        self.assertEqual(subbed, ('barbar', 2))
         subbed = self.lazyre.subn(lambda x: 'baz', 'foofoo')
-        self.assertEquals(subbed, ('bazbaz', 2))
+        self.assertEqual(subbed, ('bazbaz', 2))
 
     def test_groups(self):
         lazyre = LazyRegex('(.)(.)')
         self.assertIsNone(lazyre.groups)
         lazyre.ensure()
-        self.assertEquals(lazyre.groups, 2)
+        self.assertEqual(lazyre.groups, 2)
 
     def test_groupindex(self):
         lazyre = LazyRegex('(?P<foo>.)')
         self.assertIsNone(lazyre.groupindex)
         lazyre.ensure()
-        self.assertEquals(lazyre.groupindex, {'foo': 1})
+        self.assertEqual(lazyre.groupindex, {'foo': 1})
 
     def test_flags(self):
         self.lazyre.ensure()
-        self.assertEquals(self.lazyre.flags, re.compile('.').flags)
+        self.assertEqual(self.lazyre.flags, re.compile('.').flags)
 
     def test_pattern(self):
-        self.assertEquals(self.lazyre.pattern, 'f.o')
+        self.assertEqual(self.lazyre.pattern, 'f.o')
 
 
 if __name__ == '__main__':

From 9857454707a3687ff6617f4f7afdaf30f75b53ea Mon Sep 17 00:00:00 2001
From: Hugo van Kemenade <hugovk@users.noreply.github.com>
Date: Fri, 31 Dec 2021 00:42:50 +0200
Subject: [PATCH 2/2] Upgrade other unittest asserts for clearer error messages

---
 css_parser_tests/basetest.py                  |   9 +-
 css_parser_tests/test_codec.py                |   4 +-
 css_parser_tests/test_csscharsetrule.py       |   8 +-
 css_parser_tests/test_csscomment.py           |   4 +-
 css_parser_tests/test_cssfontfacerule.py      | 484 ++++++------
 css_parser_tests/test_cssimportrule.py        |  10 +-
 css_parser_tests/test_cssmediarule.py         |   6 +-
 css_parser_tests/test_cssnamespacerule.py     |  10 +-
 css_parser_tests/test_csspagerule.py          |   6 +-
 css_parser_tests/test_cssstyledeclaration.py  |  14 +-
 css_parser_tests/test_cssstylerule.py         |   6 +-
 css_parser_tests/test_cssstylesheet.py        |  18 +-
 css_parser_tests/test_cssunknownrule.py       |   2 +-
 css_parser_tests/test_cssutils.py             |  14 +-
 .../test_cssvariablesdeclaration.py           | 700 +++++++++---------
 css_parser_tests/test_cssvariablesrule.py     | 310 ++++----
 css_parser_tests/test_domimplementation.py    |  90 +--
 css_parser_tests/test_marginrule.py           |   6 +-
 css_parser_tests/test_medialist.py            |   6 +-
 css_parser_tests/test_mediaquery.py           | 216 +++---
 css_parser_tests/test_property.py             |  14 +-
 css_parser_tests/test_selector.py             |   6 +-
 css_parser_tests/test_selectorlist.py         |   4 +-
 css_parser_tests/test_value.py                |  48 +-
 24 files changed, 998 insertions(+), 997 deletions(-)

diff --git a/css_parser_tests/basetest.py b/css_parser_tests/basetest.py
index f45a620..ecb79a3 100644
--- a/css_parser_tests/basetest.py
+++ b/css_parser_tests/basetest.py
@@ -131,10 +131,11 @@ def assertRaisesEx(self, exception, callable, *args, **kwargs):
             callable(*args, **kwargs)
         except exception as exc:
             if exc_args is not None:
-                self.failIf(exc.args != exc_args,
-                            "%s raised %s with unexpected args: "
-                            "expected=%r, actual=%r"
-                            % (callsig, exc.__class__, exc_args, exc.args))
+                self.assertEqual(
+                    exc.args,
+                    exc_args,
+                    '%s raised %s with unexpected args: expected=%r, actual=%r' % (callsig, exc.__class__, exc_args, exc.args)
+                )
             if exc_pattern is not None:
                 self.assertTrue(exc_pattern.search(str(exc)),
                                 "%s raised %s, but the exception "
diff --git a/css_parser_tests/test_codec.py b/css_parser_tests/test_codec.py
index 1771162..d72499c 100644
--- a/css_parser_tests/test_codec.py
+++ b/css_parser_tests/test_codec.py
@@ -117,10 +117,10 @@ def test_detectencoding_unicode(self):
     def test_fixencoding(self):
         "codec._fixencoding()"
         s = '@charset "'
-        self.assertTrue(codec._fixencoding(s, "utf-8") is None)
+        self.assertIsNone(codec._fixencoding(s, 'utf-8'))
 
         s = '@charset "x'
-        self.assertTrue(codec._fixencoding(s, "utf-8") is None)
+        self.assertIsNone(codec._fixencoding(s, 'utf-8'))
 
         s = '@charset "x'
         self.assertEqual(codec._fixencoding(s, "utf-8", True), s)
diff --git a/css_parser_tests/test_csscharsetrule.py b/css_parser_tests/test_csscharsetrule.py
index 5a8a29e..cc5f347 100644
--- a/css_parser_tests/test_csscharsetrule.py
+++ b/css_parser_tests/test_csscharsetrule.py
@@ -107,7 +107,7 @@ def test_cssText(self):
     def test_repr(self):
         "CSSCharsetRule.__repr__()"
         self.r.encoding = 'utf-8'
-        self.assertTrue('utf-8' in repr(self.r))
+        self.assertIn('utf-8', repr(self.r))
 
     def test_reprANDstr(self):
         "CSSCharsetRule.__repr__(), .__str__()"
@@ -115,11 +115,11 @@ def test_reprANDstr(self):
 
         s = css_parser.css.CSSCharsetRule(encoding=encoding)
 
-        self.assertTrue(encoding in str(s))
+        self.assertIn(encoding, str(s))
 
         s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
-        self.assertTrue(encoding == s2.encoding)
+        self.assertIsInstance(s2, s.__class__)
+        self.assertEqual(encoding, s2.encoding)
 
 
 if __name__ == '__main__':
diff --git a/css_parser_tests/test_csscomment.py b/css_parser_tests/test_csscomment.py
index 25bd920..864257d 100644
--- a/css_parser_tests/test_csscomment.py
+++ b/css_parser_tests/test_csscomment.py
@@ -66,8 +66,8 @@ def test_reprANDstr(self):
         s = css_parser.css.CSSComment(cssText=text)
 
         s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
-        self.assertTrue(text == s2.cssText)
+        self.assertIsInstance(s2, s.__class__)
+        self.assertEqual(text, s2.cssText)
 
 
 if __name__ == '__main__':
diff --git a/css_parser_tests/test_cssfontfacerule.py b/css_parser_tests/test_cssfontfacerule.py
index e5112c7..244e27f 100644
--- a/css_parser_tests/test_cssfontfacerule.py
+++ b/css_parser_tests/test_cssfontfacerule.py
@@ -1,244 +1,244 @@
-"""Testcases for css_parser.css.CSSFontFaceRule"""
-
+"""Testcases for css_parser.css.CSSFontFaceRule"""
+
 from __future__ import absolute_import
 from __future__ import unicode_literals
-import xml.dom
-from . import test_cssrule
-import css_parser
-
-
-class CSSFontFaceRuleTestCase(test_cssrule.CSSRuleTestCase):
-
-    def setUp(self):
-        super(CSSFontFaceRuleTestCase, self).setUp()
-        self.r = css_parser.css.CSSFontFaceRule()
-        self.rRO = css_parser.css.CSSFontFaceRule(readonly=True)
-        self.r_type = css_parser.css.CSSFontFaceRule.FONT_FACE_RULE
-        self.r_typeString = 'FONT_FACE_RULE'
-
-    def test_init(self):
-        "CSSFontFaceRule.__init__()"
-        super(CSSFontFaceRuleTestCase, self).test_init()
-
-        r = css_parser.css.CSSFontFaceRule()
-        self.assertTrue(isinstance(r.style, css_parser.css.CSSStyleDeclaration))
-        self.assertEqual(r, r.style.parentRule)
-
-        # until any properties
-        self.assertEqual('', r.cssText)
-
-        # only possible to set @... similar name
-        self.assertRaises(xml.dom.InvalidModificationErr, self.r._setAtkeyword, 'x')
-
-        def checkrefs(ff):
-            self.assertEqual(ff, ff.style.parentRule)
-            for p in ff.style:
-                self.assertEqual(ff.style, p.parent)
-
-        checkrefs(css_parser.css.CSSFontFaceRule(
-            style=css_parser.css.CSSStyleDeclaration('font-family: x')))
-
-        r = css_parser.css.CSSFontFaceRule()
-        r.cssText = '@font-face { font-family: x }'
-        checkrefs(r)
-
-        r = css_parser.css.CSSFontFaceRule()
-        r.style.setProperty('font-family', 'y')
-        checkrefs(r)
-
-        r = css_parser.css.CSSFontFaceRule()
-        r.style['font-family'] = 'z'
-        checkrefs(r)
-
-        r = css_parser.css.CSSFontFaceRule()
-        r.style.fontFamily = 'a'
-        checkrefs(r)
-
-    def test_cssText(self):
-        "CSSFontFaceRule.cssText"
-        tests = {
-            '''@font-face {
-    font-family: x;
-    src: url(../fonts/LateefRegAAT.ttf) format("truetype-aat"), url(../fonts/LateefRegOT.ttf) format("opentype");
-    font-style: italic;
-    font-weight: 500;
-    font-stretch: condensed;
-    unicode-range: u+1-ff, u+111
-    }''': None,
-            '@font-face{font-family: x;}': '@font-face {\n    font-family: x\n    }',
-            '@font-face  {  font-family: x;  }': '@font-face {\n    font-family: x\n    }',
-            '@f\\ont\\-face{font-family : x;}': '@font-face {\n    font-family: x\n    }',
-            # comments
-            '@font-face/*1*//*2*/{font-family: x;}':
-                '@font-face /*1*/ /*2*/ {\n    font-family: x\n    }',
-            # WS
-            '@font-face\n\t\f {\n\t\f font-family:x;\n\t\f }':
-                '@font-face {\n    font-family: x\n    }',
-        }
-        self.do_equal_r(tests)
-        self.do_equal_p(tests)
-
-        tests = {
-            '@font-face;': xml.dom.SyntaxErr,
-            '@font-face }': xml.dom.SyntaxErr,
-        }
-        self.do_raise_p(tests)  # parse
-        tests.update({
-            '@font-face {': xml.dom.SyntaxErr,  # no }
-            # trailing
-            '@font-face {}1': xml.dom.SyntaxErr,
-            '@font-face {}/**/': xml.dom.SyntaxErr,
-            '@font-face {} ': xml.dom.SyntaxErr,
-        })
-        self.do_raise_r(tests)  # set cssText
-
-    def test_style(self):
-        "CSSFontFaceRule.style (and references)"
-        r = css_parser.css.CSSFontFaceRule()
-        s1 = r.style
-        self.assertEqual(r, s1.parentRule)
-        self.assertEqual('', s1.cssText)
-
-        # set rule.cssText
-        r.cssText = '@font-face { font-family: x1 }'
-        self.assertNotEqual(r.style, s1)
-        self.assertEqual(r, r.style.parentRule)
-        self.assertEqual(r.cssText, '@font-face {\n    font-family: x1\n    }')
-        self.assertEqual(r.style.cssText, 'font-family: x1')
-        self.assertEqual(s1.cssText, '')
-        s2 = r.style
-
-        # set invalid rule.cssText
-        try:
-            r.cssText = '@font-face { $ }'
-        except xml.dom.SyntaxErr as e:
-            pass
-        self.assertEqual(r.style, s2)
-        self.assertEqual(r, s2.parentRule)
-        self.assertEqual(r.cssText, '@font-face {\n    font-family: x1\n    }')
-        self.assertEqual(s2.cssText, 'font-family: x1')
-        self.assertEqual(r.style.cssText, 'font-family: x1')
-
-        # set rule.style.cssText
-        r.style.cssText = 'font-family: x2'
-        self.assertEqual(r.style, s2)
-        self.assertEqual(r, s2.parentRule)
-        self.assertEqual(r.cssText, '@font-face {\n    font-family: x2\n    }')
-        self.assertEqual(s2.cssText, 'font-family: x2')
-        self.assertEqual(r.style.cssText, 'font-family: x2')
-
-        # set new style object s2
-        sn = css_parser.css.CSSStyleDeclaration('font-family: y1')
-        r.style = sn
-        self.assertEqual(r.style, sn)
-        self.assertEqual(r, sn.parentRule)
-        self.assertEqual(r.cssText, '@font-face {\n    font-family: y1\n    }')
-        self.assertEqual(sn.cssText, 'font-family: y1')
-        self.assertEqual(r.style.cssText, 'font-family: y1')
-        self.assertEqual(s2.cssText, 'font-family: x2')  # old
-
-        # set s2.cssText
-        sn.cssText = 'font-family: y2'
-        self.assertEqual(r.style, sn)
-        self.assertEqual(r.cssText, '@font-face {\n    font-family: y2\n    }')
-        self.assertEqual(r.style.cssText, 'font-family: y2')
-        self.assertEqual(s2.cssText, 'font-family: x2')  # old
-
-        # set invalid s2.cssText
-        try:
-            sn.cssText = '$'
-        except xml.dom.SyntaxErr as e:
-            pass
-        self.assertEqual(r.style, sn)
-        self.assertEqual(r.style.cssText, 'font-family: y2')
-        self.assertEqual(r.cssText, '@font-face {\n    font-family: y2\n    }')
-
-        # set r.style with text
-        r.style = 'font-family: z'
-        self.assertNotEqual(r.style, sn)
-        self.assertEqual(r.cssText, '@font-face {\n    font-family: z\n    }')
-        self.assertEqual(r.style.cssText, 'font-family: z')
-        self.assertEqual(sn.cssText, 'font-family: y2')
-
-    def test_properties(self):
-        "CSSFontFaceRule.style properties"
-        r = css_parser.css.CSSFontFaceRule()
-        r.style.cssText = '''
-        src: url(x)
-        '''
-        exp = '''@font-face {
-    src: url(x)
-    }'''
-        self.assertEqual(exp, r.cssText)
-
-        tests = {
-            'font-family': [  # ('serif', True),
-                #                            ('x', True),
-                #                            ('"x"', True),
-                ('x, y', False),
-                ('"x", y', False),
-                ('x, "y"', False),
-                #                            ('"x", "y"', False)
-            ]
-        }
-        for n, t in tests.items():
-            for (v, valid) in t:
-                r = css_parser.css.CSSFontFaceRule()
-                r.style[n] = v
-                self.assertEqual(r.style.getProperty(n).parent, r.style)
-                self.assertEqual(r.style.getProperty(n).valid, valid)
-
-    def test_incomplete(self):
-        "CSSFontFaceRule (incomplete)"
-        tests = {
-            '@font-face{':
-                '',  # no } and no content
-            '@font-face { ':
-                '',  # no } and no content
-            '@font-face { font-family: x':
-                '@font-face {\n    font-family: x\n    }',  # no }
-        }
-        self.do_equal_p(tests)  # parse
-
-    def test_InvalidModificationErr(self):
-        "CSSFontFaceRule.cssText InvalidModificationErr"
-        self._test_InvalidModificationErr('@font-face')
-        tests = {
-            '@font-fac {}': xml.dom.InvalidModificationErr,
-        }
-        self.do_raise_r(tests)
-
-    def test_valid(self):
-        "CSSFontFaceRule.valid"
-        r = css_parser.css.CSSFontFaceRule()
-        self.assertEqual(False, r.valid)
-        N = 'font-family: x; src: local(x);'
-        tests = {
-            True: (N,
-                   N + 'font-style: italic; font-weight: bold',
-                   ),
-            False: ('',
-                    'font-family: x, y; src: local(x);',
-                    N + 'font-style: inherit',
-                    N + 'invalid: 1')
-        }
-        for valid, testlist in tests.items():
-            for test in testlist:
-                r.style.cssText = test
-                self.assertEqual(valid, r.valid)
-
-    def test_reprANDstr(self):
-        "CSSFontFaceRule.__repr__(), .__str__()"
-        style = 'src: url(x)'
-        s = css_parser.css.CSSFontFaceRule(style=style)
-
-        self.assertTrue(style in str(s))
-
-        s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
-        self.assertTrue(style == s2.style.cssText)
-
-
-if __name__ == '__main__':
-    import unittest
-    unittest.main()
+import xml.dom
+from . import test_cssrule
+import css_parser
+
+
+class CSSFontFaceRuleTestCase(test_cssrule.CSSRuleTestCase):
+
+    def setUp(self):
+        super(CSSFontFaceRuleTestCase, self).setUp()
+        self.r = css_parser.css.CSSFontFaceRule()
+        self.rRO = css_parser.css.CSSFontFaceRule(readonly=True)
+        self.r_type = css_parser.css.CSSFontFaceRule.FONT_FACE_RULE
+        self.r_typeString = 'FONT_FACE_RULE'
+
+    def test_init(self):
+        "CSSFontFaceRule.__init__()"
+        super(CSSFontFaceRuleTestCase, self).test_init()
+
+        r = css_parser.css.CSSFontFaceRule()
+        self.assertIsInstance(r.style, css_parser.css.CSSStyleDeclaration)
+        self.assertEqual(r, r.style.parentRule)
+
+        # until any properties
+        self.assertEqual('', r.cssText)
+
+        # only possible to set @... similar name
+        self.assertRaises(xml.dom.InvalidModificationErr, self.r._setAtkeyword, 'x')
+
+        def checkrefs(ff):
+            self.assertEqual(ff, ff.style.parentRule)
+            for p in ff.style:
+                self.assertEqual(ff.style, p.parent)
+
+        checkrefs(css_parser.css.CSSFontFaceRule(
+            style=css_parser.css.CSSStyleDeclaration('font-family: x')))
+
+        r = css_parser.css.CSSFontFaceRule()
+        r.cssText = '@font-face { font-family: x }'
+        checkrefs(r)
+
+        r = css_parser.css.CSSFontFaceRule()
+        r.style.setProperty('font-family', 'y')
+        checkrefs(r)
+
+        r = css_parser.css.CSSFontFaceRule()
+        r.style['font-family'] = 'z'
+        checkrefs(r)
+
+        r = css_parser.css.CSSFontFaceRule()
+        r.style.fontFamily = 'a'
+        checkrefs(r)
+
+    def test_cssText(self):
+        "CSSFontFaceRule.cssText"
+        tests = {
+            '''@font-face {
+    font-family: x;
+    src: url(../fonts/LateefRegAAT.ttf) format("truetype-aat"), url(../fonts/LateefRegOT.ttf) format("opentype");
+    font-style: italic;
+    font-weight: 500;
+    font-stretch: condensed;
+    unicode-range: u+1-ff, u+111
+    }''': None,
+            '@font-face{font-family: x;}': '@font-face {\n    font-family: x\n    }',
+            '@font-face  {  font-family: x;  }': '@font-face {\n    font-family: x\n    }',
+            '@f\\ont\\-face{font-family : x;}': '@font-face {\n    font-family: x\n    }',
+            # comments
+            '@font-face/*1*//*2*/{font-family: x;}':
+                '@font-face /*1*/ /*2*/ {\n    font-family: x\n    }',
+            # WS
+            '@font-face\n\t\f {\n\t\f font-family:x;\n\t\f }':
+                '@font-face {\n    font-family: x\n    }',
+        }
+        self.do_equal_r(tests)
+        self.do_equal_p(tests)
+
+        tests = {
+            '@font-face;': xml.dom.SyntaxErr,
+            '@font-face }': xml.dom.SyntaxErr,
+        }
+        self.do_raise_p(tests)  # parse
+        tests.update({
+            '@font-face {': xml.dom.SyntaxErr,  # no }
+            # trailing
+            '@font-face {}1': xml.dom.SyntaxErr,
+            '@font-face {}/**/': xml.dom.SyntaxErr,
+            '@font-face {} ': xml.dom.SyntaxErr,
+        })
+        self.do_raise_r(tests)  # set cssText
+
+    def test_style(self):
+        "CSSFontFaceRule.style (and references)"
+        r = css_parser.css.CSSFontFaceRule()
+        s1 = r.style
+        self.assertEqual(r, s1.parentRule)
+        self.assertEqual('', s1.cssText)
+
+        # set rule.cssText
+        r.cssText = '@font-face { font-family: x1 }'
+        self.assertNotEqual(r.style, s1)
+        self.assertEqual(r, r.style.parentRule)
+        self.assertEqual(r.cssText, '@font-face {\n    font-family: x1\n    }')
+        self.assertEqual(r.style.cssText, 'font-family: x1')
+        self.assertEqual(s1.cssText, '')
+        s2 = r.style
+
+        # set invalid rule.cssText
+        try:
+            r.cssText = '@font-face { $ }'
+        except xml.dom.SyntaxErr as e:
+            pass
+        self.assertEqual(r.style, s2)
+        self.assertEqual(r, s2.parentRule)
+        self.assertEqual(r.cssText, '@font-face {\n    font-family: x1\n    }')
+        self.assertEqual(s2.cssText, 'font-family: x1')
+        self.assertEqual(r.style.cssText, 'font-family: x1')
+
+        # set rule.style.cssText
+        r.style.cssText = 'font-family: x2'
+        self.assertEqual(r.style, s2)
+        self.assertEqual(r, s2.parentRule)
+        self.assertEqual(r.cssText, '@font-face {\n    font-family: x2\n    }')
+        self.assertEqual(s2.cssText, 'font-family: x2')
+        self.assertEqual(r.style.cssText, 'font-family: x2')
+
+        # set new style object s2
+        sn = css_parser.css.CSSStyleDeclaration('font-family: y1')
+        r.style = sn
+        self.assertEqual(r.style, sn)
+        self.assertEqual(r, sn.parentRule)
+        self.assertEqual(r.cssText, '@font-face {\n    font-family: y1\n    }')
+        self.assertEqual(sn.cssText, 'font-family: y1')
+        self.assertEqual(r.style.cssText, 'font-family: y1')
+        self.assertEqual(s2.cssText, 'font-family: x2')  # old
+
+        # set s2.cssText
+        sn.cssText = 'font-family: y2'
+        self.assertEqual(r.style, sn)
+        self.assertEqual(r.cssText, '@font-face {\n    font-family: y2\n    }')
+        self.assertEqual(r.style.cssText, 'font-family: y2')
+        self.assertEqual(s2.cssText, 'font-family: x2')  # old
+
+        # set invalid s2.cssText
+        try:
+            sn.cssText = '$'
+        except xml.dom.SyntaxErr as e:
+            pass
+        self.assertEqual(r.style, sn)
+        self.assertEqual(r.style.cssText, 'font-family: y2')
+        self.assertEqual(r.cssText, '@font-face {\n    font-family: y2\n    }')
+
+        # set r.style with text
+        r.style = 'font-family: z'
+        self.assertNotEqual(r.style, sn)
+        self.assertEqual(r.cssText, '@font-face {\n    font-family: z\n    }')
+        self.assertEqual(r.style.cssText, 'font-family: z')
+        self.assertEqual(sn.cssText, 'font-family: y2')
+
+    def test_properties(self):
+        "CSSFontFaceRule.style properties"
+        r = css_parser.css.CSSFontFaceRule()
+        r.style.cssText = '''
+        src: url(x)
+        '''
+        exp = '''@font-face {
+    src: url(x)
+    }'''
+        self.assertEqual(exp, r.cssText)
+
+        tests = {
+            'font-family': [  # ('serif', True),
+                #                            ('x', True),
+                #                            ('"x"', True),
+                ('x, y', False),
+                ('"x", y', False),
+                ('x, "y"', False),
+                #                            ('"x", "y"', False)
+            ]
+        }
+        for n, t in tests.items():
+            for (v, valid) in t:
+                r = css_parser.css.CSSFontFaceRule()
+                r.style[n] = v
+                self.assertEqual(r.style.getProperty(n).parent, r.style)
+                self.assertEqual(r.style.getProperty(n).valid, valid)
+
+    def test_incomplete(self):
+        "CSSFontFaceRule (incomplete)"
+        tests = {
+            '@font-face{':
+                '',  # no } and no content
+            '@font-face { ':
+                '',  # no } and no content
+            '@font-face { font-family: x':
+                '@font-face {\n    font-family: x\n    }',  # no }
+        }
+        self.do_equal_p(tests)  # parse
+
+    def test_InvalidModificationErr(self):
+        "CSSFontFaceRule.cssText InvalidModificationErr"
+        self._test_InvalidModificationErr('@font-face')
+        tests = {
+            '@font-fac {}': xml.dom.InvalidModificationErr,
+        }
+        self.do_raise_r(tests)
+
+    def test_valid(self):
+        "CSSFontFaceRule.valid"
+        r = css_parser.css.CSSFontFaceRule()
+        self.assertEqual(False, r.valid)
+        N = 'font-family: x; src: local(x);'
+        tests = {
+            True: (N,
+                   N + 'font-style: italic; font-weight: bold',
+                   ),
+            False: ('',
+                    'font-family: x, y; src: local(x);',
+                    N + 'font-style: inherit',
+                    N + 'invalid: 1')
+        }
+        for valid, testlist in tests.items():
+            for test in testlist:
+                r.style.cssText = test
+                self.assertEqual(valid, r.valid)
+
+    def test_reprANDstr(self):
+        "CSSFontFaceRule.__repr__(), .__str__()"
+        style = 'src: url(x)'
+        s = css_parser.css.CSSFontFaceRule(style=style)
+
+        self.assertIn(style, str(s))
+
+        s2 = eval(repr(s))
+        self.assertIsInstance(s2, s.__class__)
+        self.assertEqual(style, s2.style.cssText)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()
diff --git a/css_parser_tests/test_cssimportrule.py b/css_parser_tests/test_cssimportrule.py
index c475617..ba426f4 100644
--- a/css_parser_tests/test_cssimportrule.py
+++ b/css_parser_tests/test_cssimportrule.py
@@ -428,14 +428,14 @@ def test_reprANDstr(self):
         s = css_parser.css.CSSImportRule(href=href, mediaText=mediaText, name=name)
 
         # str(): mediaText nor name are present here
-        self.assertTrue(href in str(s))
+        self.assertIn(href, str(s))
 
         # repr()
         s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
-        self.assertTrue(href == s2.href)
-        self.assertTrue(mediaText == s2.media.mediaText)
-        self.assertTrue(name == s2.name)
+        self.assertIsInstance(s2, s.__class__)
+        self.assertEqual(href, s2.href)
+        self.assertEqual(mediaText, s2.media.mediaText)
+        self.assertEqual(name, s2.name)
 
 
 if __name__ == '__main__':
diff --git a/css_parser_tests/test_cssmediarule.py b/css_parser_tests/test_cssmediarule.py
index 028d880..fd3a007 100644
--- a/css_parser_tests/test_cssmediarule.py
+++ b/css_parser_tests/test_cssmediarule.py
@@ -439,11 +439,11 @@ def test_reprANDstr(self):
 
         s = css_parser.css.CSSMediaRule(mediaText=mediaText)
 
-        self.assertTrue(mediaText in str(s))
+        self.assertIn(mediaText, str(s))
 
         s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
-        self.assertTrue(mediaText == s2.media.mediaText)
+        self.assertIsInstance(s2, s.__class__)
+        self.assertEqual(mediaText, s2.media.mediaText)
 
 
 if __name__ == '__main__':
diff --git a/css_parser_tests/test_cssnamespacerule.py b/css_parser_tests/test_cssnamespacerule.py
index 6058134..0a5d20b 100644
--- a/css_parser_tests/test_cssnamespacerule.py
+++ b/css_parser_tests/test_cssnamespacerule.py
@@ -222,13 +222,13 @@ def test_reprANDstr(self):
 
         s = css_parser.css.CSSNamespaceRule(namespaceURI=namespaceURI, prefix=prefix)
 
-        self.assertTrue(namespaceURI in str(s))
-        self.assertTrue(prefix in str(s))
+        self.assertIn(namespaceURI, str(s))
+        self.assertIn(prefix, str(s))
 
         s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
-        self.assertTrue(namespaceURI == s2.namespaceURI)
-        self.assertTrue(prefix == s2.prefix)
+        self.assertIsInstance(s2, s.__class__)
+        self.assertEqual(namespaceURI, s2.namespaceURI)
+        self.assertEqual(prefix, s2.prefix)
 
 
 if __name__ == '__main__':
diff --git a/css_parser_tests/test_csspagerule.py b/css_parser_tests/test_csspagerule.py
index 226cfe5..9a9a98d 100644
--- a/css_parser_tests/test_csspagerule.py
+++ b/css_parser_tests/test_csspagerule.py
@@ -422,11 +422,11 @@ def test_reprANDstr(self):
 
         s = css_parser.css.CSSPageRule(selectorText=sel)
 
-        self.assertTrue(sel in str(s))
+        self.assertIn(sel, str(s))
 
         s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
-        self.assertTrue(sel == s2.selectorText)
+        self.assertIsInstance(s2, s.__class__)
+        self.assertEqual(sel, s2.selectorText)
 
 
 if __name__ == '__main__':
diff --git a/css_parser_tests/test_cssstyledeclaration.py b/css_parser_tests/test_cssstyledeclaration.py
index 0f16b11..a37f4c1 100644
--- a/css_parser_tests/test_cssstyledeclaration.py
+++ b/css_parser_tests/test_cssstyledeclaration.py
@@ -64,11 +64,11 @@ def test__contains__(self):
         "CSSStyleDeclaration.__contains__(nameOrProperty)"
         s = css_parser.css.CSSStyleDeclaration(cssText=r'x: 1;\y: 2')
         for test in ('x', r'x', 'y', r'y'):
-            self.assertTrue(test in s)
-            self.assertTrue(test.upper() in s)
-            self.assertTrue(css_parser.css.Property(test, '1') in s)
-        self.assertTrue('z' not in s)
-        self.assertTrue(css_parser.css.Property('z', '1') not in s)
+            self.assertIn(test, s)
+            self.assertIn(test.upper(), s)
+            self.assertIn(css_parser.css.Property(test, '1'), s)
+        self.assertNotIn('z', s)
+        self.assertNotIn(css_parser.css.Property('z', '1'), s)
 
     def test__iter__item(self):
         "CSSStyleDeclaration.__iter__ and .item"
@@ -584,10 +584,10 @@ def test_reprANDstr(self):
         "CSSStyleDeclaration.__repr__(), .__str__()"
         s = css_parser.css.CSSStyleDeclaration(cssText='a:1;b:2')
 
-        self.assertTrue("2" in str(s))  # length
+        self.assertIn('2', str(s)) # length
 
         s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
+        self.assertIsInstance(s2, s.__class__)
 
     def test_valid(self):
         "CSSStyleDeclaration.valid"
diff --git a/css_parser_tests/test_cssstylerule.py b/css_parser_tests/test_cssstylerule.py
index db74668..0d00df9 100644
--- a/css_parser_tests/test_cssstylerule.py
+++ b/css_parser_tests/test_cssstylerule.py
@@ -241,11 +241,11 @@ def test_reprANDstr(self):
 
         s = css_parser.css.CSSStyleRule(selectorText=sel)
 
-        self.assertTrue(sel in str(s))
+        self.assertIn(sel, str(s))
 
         s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
-        self.assertTrue(sel == s2.selectorText)
+        self.assertIsInstance(s2, s.__class__)
+        self.assertEqual(sel, s2.selectorText)
 
     def test_valid(self):
         "CSSStyleRule.valid"
diff --git a/css_parser_tests/test_cssstylesheet.py b/css_parser_tests/test_cssstylesheet.py
index fe50ff5..008447e 100644
--- a/css_parser_tests/test_cssstylesheet.py
+++ b/css_parser_tests/test_cssstylesheet.py
@@ -322,9 +322,9 @@ def test_namespaces1(self):
                          {'': 'default', 'ex2': 'example'})
 
         # __contains__
-        self.assertTrue('' in s.namespaces)
-        self.assertTrue('ex2' in s.namespaces)
-        self.assertFalse('NOTSET' in s.namespaces)
+        self.assertIn('', s.namespaces)
+        self.assertIn('ex2', s.namespaces)
+        self.assertNotIn('NOTSET', s.namespaces)
         # __delitem__
         self.assertRaises(xml.dom.NoModificationAllowedErr,
                           s.namespaces.__delitem__, 'ex2')
@@ -450,7 +450,7 @@ def test_namespaces3(self):
         self.assertRaises(xml.dom.NamespaceErr, s.add, css)
 
         s.add('@namespace x "html";')
-        self.assertTrue(s.namespaces['x'] == 'html')
+        self.assertEqual(s.namespaces['x'], 'html')
 
         r = css_parser.css.CSSStyleRule()
         r.cssText = ((css, {'h': 'html'}))
@@ -871,13 +871,13 @@ def test_reprANDstr(self):
 
         s = css_parser.css.CSSStyleSheet(href=href, title=title)
 
-        self.assertTrue(href in str(s))
-        self.assertTrue(title in str(s))
+        self.assertIn(href, str(s))
+        self.assertIn(title, str(s))
 
         s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
-        self.assertTrue(href == s2.href)
-        self.assertTrue(title == s2.title)
+        self.assertIsInstance(s2, s.__class__)
+        self.assertEqual(href, s2.href)
+        self.assertEqual(title, s2.title)
 
     def test_valid(self):
         cases = [
diff --git a/css_parser_tests/test_cssunknownrule.py b/css_parser_tests/test_cssunknownrule.py
index 9d5c398..3c8e4d0 100644
--- a/css_parser_tests/test_cssunknownrule.py
+++ b/css_parser_tests/test_cssunknownrule.py
@@ -146,7 +146,7 @@ def test_reprANDstr(self):
         s = css_parser.css.CSSUnknownRule(cssText='@x;')
 
         s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
+        self.assertIsInstance(s2, s.__class__)
 
 
 if __name__ == '__main__':
diff --git a/css_parser_tests/test_cssutils.py b/css_parser_tests/test_cssutils.py
index cc8e7ff..a60f65c 100644
--- a/css_parser_tests/test_cssutils.py
+++ b/css_parser_tests/test_cssutils.py
@@ -63,7 +63,7 @@ def test_parseString(self):
         "css_parser.parseString()"
         s = css_parser.parseString(
             self.exp, media='handheld, screen', title='from string')
-        self.assertTrue(isinstance(s, css_parser.css.CSSStyleSheet))
+        self.assertIsInstance(s, css_parser.css.CSSStyleSheet)
         self.assertEqual(None, s.href)
         self.assertEqual(self.exp.encode(), s.cssText)
         self.assertEqual('utf-8', s.encoding)
@@ -84,7 +84,7 @@ def test_parseString(self):
         ir = s.cssRules[0]
         self.assertEqual('import/import2.css', ir.href)
         irs = ir.styleSheet
-        self.assertTrue(isinstance(irs, css_parser.css.CSSStyleSheet))
+        self.assertIsInstance(irs, css_parser.css.CSSStyleSheet)
         self.assertEqual(
             irs.cssText,
             '@import "../import3.css";\n@import "import-impossible.css" print;\n.import2 {\n    /* sheets/import2.css */\n    background: url(http://example.com/images/example.gif);\n    background: url(//example.com/images/example.gif);\n    background: url(/images/example.gif);\n    background: url(images2/example.gif);\n    background: url(./images2/example.gif);\n    background: url(../images/example.gif);\n    background: url(./../images/example.gif)\n    }'  # noqa
@@ -103,7 +103,7 @@ def test_parseFile(self):
         href = css_parser.helper.path2url(name)
         s = css_parser.parseFile(
             name, href=href, media='screen', title='from file')
-        self.assertTrue(isinstance(s, css_parser.css.CSSStyleSheet))
+        self.assertIsInstance(s, css_parser.css.CSSStyleSheet)
         if sys.platform.startswith('java'):
             # on Jython only file:
             self.assertTrue(s.href.startswith('file:'))
@@ -119,7 +119,7 @@ def test_parseFile(self):
         ir = s.cssRules[0]
         self.assertEqual('import/import2.css', ir.href)
         irs = ir.styleSheet
-        self.assertTrue(isinstance(irs, css_parser.css.CSSStyleSheet))
+        self.assertIsInstance(irs, css_parser.css.CSSStyleSheet)
         self.assertEqual(
             irs.cssText,
             '@import "../import3.css";\n@import "import-impossible.css" print;\n.import2 {\n    /* sheets/import2.css */\n    background: url(http://example.com/images/example.gif);\n    background: url(//example.com/images/example.gif);\n    background: url(/images/example.gif);\n    background: url(images2/example.gif);\n    background: url(./images2/example.gif);\n    background: url(../images/example.gif);\n    background: url(./../images/example.gif)\n    }'  # noqa
@@ -131,7 +131,7 @@ def test_parseFile(self):
         name = basetest.get_sheet_filename('import.css')
 
         s = css_parser.parseFile(name, media='screen', title='from file')
-        self.assertTrue(isinstance(s, css_parser.css.CSSStyleSheet))
+        self.assertIsInstance(s, css_parser.css.CSSStyleSheet)
         if sys.platform.startswith('java'):
             # on Jython only file:
             self.assertTrue(s.href.startswith('file:'))
@@ -147,7 +147,7 @@ def test_parseFile(self):
         ir = s.cssRules[0]
         self.assertEqual('import/import2.css', ir.href)
         irs = ir.styleSheet
-        self.assertTrue(isinstance(irs, css_parser.css.CSSStyleSheet))
+        self.assertIsInstance(irs, css_parser.css.CSSStyleSheet)
         self.assertEqual(
             irs.cssText,
             '@import "../import3.css";\n@import "import-impossible.css" print;\n.import2 {\n    /* sheets/import2.css */\n    background: url(http://example.com/images/example.gif);\n    background: url(//example.com/images/example.gif);\n    background: url(/images/example.gif);\n    background: url(images2/example.gif);\n    background: url(./images2/example.gif);\n    background: url(../images/example.gif);\n    background: url(./../images/example.gif)\n    }'  # noqa
@@ -201,7 +201,7 @@ def test_parseUrl(self):
         href = css_parser.helper.path2url(href)
         # href = 'http://seewhatever.de/sheets/import.css'
         s = css_parser.parseUrl(href, media='tv, print', title='from url')
-        self.assertTrue(isinstance(s, css_parser.css.CSSStyleSheet))
+        self.assertIsInstance(s, css_parser.css.CSSStyleSheet)
         self.assertEqual(href, s.href)
         self.assertEqual(self.exp.encode(), s.cssText)
         self.assertEqual('utf-8', s.encoding)
diff --git a/css_parser_tests/test_cssvariablesdeclaration.py b/css_parser_tests/test_cssvariablesdeclaration.py
index abe9255..c33f611 100644
--- a/css_parser_tests/test_cssvariablesdeclaration.py
+++ b/css_parser_tests/test_cssvariablesdeclaration.py
@@ -1,350 +1,350 @@
-"""Testcases for css_parser.css.cssvariablesdelaration.CSSVariablesDeclaration."""
-from __future__ import absolute_import
-from __future__ import unicode_literals
-__version__ = '$Id: test_cssstyledeclaration.py 1869 2009-10-17 19:37:40Z cthedot $'
-
-import xml.dom
-from . import basetest
-import css_parser
-
-
-class CSSVariablesDeclarationTestCase(basetest.BaseTestCase):
-
-    def setUp(self):
-        self.r = css_parser.css.CSSVariablesDeclaration()
-        css_parser.ser.prefs.useDefaults()
-
-    def tearDown(self):
-        css_parser.ser.prefs.useDefaults()
-
-    def test_init(self):
-        "CSSVariablesDeclaration.__init__()"
-        v = css_parser.css.CSSVariablesDeclaration()
-        self.assertEqual('', v.cssText)
-        self.assertEqual(0, v.length)
-        self.assertEqual(None, v.parentRule)
-
-        v = css_parser.css.CSSVariablesDeclaration(cssText='x: 0')
-        self.assertEqual('x: 0', v.cssText)
-        self.assertEqual('0', v.getVariableValue('x'))
-
-        rule = css_parser.css.CSSVariablesRule()
-        v = css_parser.css.CSSVariablesDeclaration(cssText='x: 0',
-                                                 parentRule=rule)
-        self.assertEqual(rule, v.parentRule)
-
-    def test__contains__(self):
-        "CSSVariablesDeclaration.__contains__(name)"
-        v = css_parser.css.CSSVariablesDeclaration(cssText='x: 0; y: 2')
-        for test in ('x', 'y'):
-            self.assertTrue(test in v)
-            self.assertTrue(test.upper() in v)
-
-        self.assertTrue('z' not in v)
-
-    def test_items(self):
-        "CSSVariablesDeclaration[variableName]"
-        v = css_parser.css.CSSVariablesDeclaration()
-
-        value = '0'
-        v['X'] = value
-        self.assertEqual(value, v['X'])
-        self.assertEqual(value, v.getVariableValue('X'))
-        self.assertEqual(value, v['x'])
-        self.assertEqual(value, v.getVariableValue('x'))
-
-        self.assertEqual('', v['y'])
-        self.assertEqual('', v.getVariableValue('y'))
-
-        v['z'] = '1'
-        self.assertEqual(2, v.length)
-
-        items = []
-        # unsorted!
-        self.assertEqual(sorted(v), ['x', 'z'])
-
-        del v['z']
-        self.assertEqual(1, v.length)
-        self.assertEqual(1, v.length)
-
-        self.assertEqual('0', v.removeVariable('x'))
-        self.assertEqual('', v.removeVariable('z'))
-        self.assertEqual(0, v.length)
-
-        v.cssText = 'x:0; y:1'
-        keys = []
-        # unsorted!
-        for i in range(0, v.length):
-            keys.append(v.item(i))
-        self.assertEqual(sorted(keys), ['x', 'y'])
-
-    def test_keys(self):
-        "CSSVariablesDeclaration.keys()"
-        v = css_parser.css.CSSVariablesDeclaration(cssText='x: 0; Y: 2')
-        self.assertEqual(['x', 'y'], sorted(v.keys()))
-
-    def test_cssText(self):
-        "CSSVariablesDeclaration.cssText"
-        # empty
-        tests = {
-            '': '',
-            ' ': '',
-            ' \t \n  ': '',
-            'x: 1': None,
-            'x: "a"': None,
-            'x: rgb(1, 2, 3)': None,
-            'x: 1px 2px 3px': None,
-
-            'x:1': 'x: 1',
-            'x:1;': 'x: 1',
-
-            'x  :  1  ': 'x: 1',
-            'x  :  1  ;  ': 'x: 1',
-
-            'x:1;y:2': 'x: 1;\ny: 2',
-            'x:1;y:2;': 'x: 1;\ny: 2',
-            'x  :  1  ;  y  :  2  ': 'x: 1;\ny: 2',
-            'x  :  1  ;  y  :  2  ;  ': 'x: 1;\ny: 2',
-
-            '/*x*/': '/*x*/',
-            'x555: 5': None,
-            'xxx:1;yyy:2': 'xxx: 1;\nyyy: 2',
-            'xxx : 1; yyy : 2': 'xxx: 1;\nyyy: 2',
-            'x:1;x:2;X:2': 'x: 2',
-            'same:1;SAME:2;': 'same: 2',
-            '/**/x/**/:/**/1/**/;/**/y/**/:/**/2/**/':
-                '/**/\n /**/\n /**/\n x: 1 /**/;\n/**/\n /**/\n /**/\n y: 2 /**/'
-        }
-        self.do_equal_r(tests)
-
-    # TODO: Fix?
-#    def test_cssText2(self):
-#        "CSSVariablesDeclaration.cssText"
-#        # exception
-#        tests = {
-#                 u'top': xml.dom.SyntaxErr,
-#                 u'top:': xml.dom.SyntaxErr,
-#                 u'top : ': xml.dom.SyntaxErr,
-#                 u'top:;': xml.dom.SyntaxErr,
-#                 u'top 0': xml.dom.SyntaxErr,
-#                 u'top 0;': xml.dom.SyntaxErr,
-#
-#                 u':': xml.dom.SyntaxErr,
-#                 u':0': xml.dom.SyntaxErr,
-#                 u':0;': xml.dom.SyntaxErr,
-#                 u':;': xml.dom.SyntaxErr,
-#                 u': ;': xml.dom.SyntaxErr,
-#
-#                 u'0': xml.dom.SyntaxErr,
-#                 u'0;': xml.dom.SyntaxErr,
-#
-#                 u';': xml.dom.SyntaxErr,
-#            }
-#        self.do_raise_r(tests)
-
-    def test_xVariable(self):
-        "CSSVariablesDeclaration.xVariable()"
-        v = css_parser.css.CSSVariablesDeclaration()
-        # unset
-        self.assertEqual('', v.getVariableValue('x'))
-        # set
-        v.setVariable('x', '0')
-        self.assertEqual('0', v.getVariableValue('x'))
-        self.assertEqual('0', v.getVariableValue('X'))
-        self.assertEqual('x: 0', v.cssText)
-        v.setVariable('X', '0')
-        self.assertEqual('0', v.getVariableValue('x'))
-        self.assertEqual('0', v.getVariableValue('X'))
-        self.assertEqual('x: 0', v.cssText)
-        # remove
-        self.assertEqual('0', v.removeVariable('x'))
-        self.assertEqual('', v.removeVariable('x'))
-        self.assertEqual('', v.getVariableValue('x'))
-        self.assertEqual('', v.cssText)
-
-    def test_imports(self):
-        "CSSVariables imports"
-        def fetcher(url):
-            url = url.replace('\\', '/')
-            url = url[url.rfind('/')+1:]
-            return (None, {
-                '3.css': '''
-                    @variables {
-                        over3-2-1-0: 3;
-                        over3-2-1: 3;
-                        over3-2: 3;
-                        over3-2-0: 3;
-                        over3-1: 3;
-                        over3-1-0: 3;
-                        over3-0: 3;
-                        local3: 3;
-                    }
-                
-                ''',
-                '2.css': '''
-                    @variables {
-                        over3-2-1-0: 2;
-                        over3-2-1: 2;
-                        over3-2-0: 2;
-                        over3-2: 2;
-                        over2-1: 2;
-                        over2-1-0: 2;
-                        over2-0: 2;
-                        local2: 2;
-                    }
-                
-                ''',
-                '1.css': '''
-                    @import "3.css";
-                    @import "2.css";
-                    @variables {
-                        over3-2-1-0: 1;
-                        over3-2-1: 1;
-                        over3-1: 1;
-                        over3-1-0: 1;
-                        over2-1: 1;
-                        over2-1-0: 1;
-                        over1-0: 1;
-                        local1: 1;
-                    }
-                
-                '''
-            }[url])
-
-        css = '''
-            @import "1.css";
-            @variables {
-                over3-2-1-0: 0;
-                over3-2-0: 0;
-                over3-1-0: 0;
-                over2-1-0: 0;
-                over3-0: 0;
-                over2-0: 0;
-                over1-0: 0;
-                local0: 0;
-            }
-            a {
-                local0: var(local0);
-                local1: var(local1);
-                local2: var(local2);
-                local3: var(local3);
-                over1-0: var(over1-0);
-                over2-0: var(over2-0);
-                over3-0: var(over3-0);
-                over2-1: var(over2-1);
-                over3-1: var(over3-1);
-                over3-2: var(over3-2);
-                over2-1-0: var(over2-1-0);
-                over3-2-0: var(over3-2-0);
-                over3-2-1: var(over3-2-1);
-                over3-2-1-0: var(over3-2-1-0);
-            }
-        '''
-        p = css_parser.CSSParser(fetcher=fetcher)
-        s = p.parseString(css)
-
-        # only these in rule of this sheet
-        self.assertEqual(s.cssRules[1].variables.length, 8)
-        # but all vars in s available!
-        self.assertEqual(s.variables.length, 15)
-        self.assertEqual(['local0', 'local1', 'local2', 'local3',
-                          'over1-0', 'over2-0', 'over2-1', 'over2-1-0',
-                          'over3-0', 'over3-1', 'over3-1-0', 'over3-2',
-                          'over3-2-0', 'over3-2-1', 'over3-2-1-0'],
-                         sorted(s.variables.keys()))
-
-        # test with variables rule
-        css_parser.ser.prefs.resolveVariables = False
-        self.assertEqual(s.cssText, '''@import "1.css";
-@variables {
-    over3-2-1-0: 0;
-    over3-2-0: 0;
-    over3-1-0: 0;
-    over2-1-0: 0;
-    over3-0: 0;
-    over2-0: 0;
-    over1-0: 0;
-    local0: 0
-    }
-a {
-    local0: var(local0);
-    local1: var(local1);
-    local2: var(local2);
-    local3: var(local3);
-    over1-0: var(over1-0);
-    over2-0: var(over2-0);
-    over3-0: var(over3-0);
-    over2-1: var(over2-1);
-    over3-1: var(over3-1);
-    over3-2: var(over3-2);
-    over2-1-0: var(over2-1-0);
-    over3-2-0: var(over3-2-0);
-    over3-2-1: var(over3-2-1);
-    over3-2-1-0: var(over3-2-1-0)
-    }'''.encode())
-
-        # test with resolved vars
-        css_parser.ser.prefs.resolveVariables = True
-        self.assertEqual(s.cssText, '''@import "1.css";
-a {
-    local0: 0;
-    local1: 1;
-    local2: 2;
-    local3: 3;
-    over1-0: 0;
-    over2-0: 0;
-    over3-0: 0;
-    over2-1: 1;
-    over3-1: 1;
-    over3-2: 2;
-    over2-1-0: 0;
-    over3-2-0: 0;
-    over3-2-1: 1;
-    over3-2-1-0: 0
-    }'''.encode())
-
-        s = css_parser.resolveImports(s)
-        self.assertEqual(s.cssText, '''/* START @import "1.css" */
-/* START @import "3.css" */
-/* START @import "2.css" */
-a {
-    local0: 0;
-    local1: 1;
-    local2: 2;
-    local3: 3;
-    over1-0: 0;
-    over2-0: 0;
-    over3-0: 0;
-    over2-1: 1;
-    over3-1: 1;
-    over3-2: 2;
-    over2-1-0: 0;
-    over3-2-0: 0;
-    over3-2-1: 1;
-    over3-2-1-0: 0
-    }'''.encode())
-
-    def test_parentRule(self):
-        "CSSVariablesDeclaration.parentRule"
-        s = css_parser.parseString('@variables { a:1}')
-        r = s.cssRules[0]
-        d = r.variables
-        self.assertEqual(r, d.parentRule)
-
-        d2 = css_parser.css.CSSVariablesDeclaration('b: 2')
-        r.variables = d2
-        self.assertEqual(r, d2.parentRule)
-
-    def test_reprANDstr(self):
-        "CSSVariablesDeclaration.__repr__(), .__str__()"
-        s = css_parser.css.CSSVariablesDeclaration(cssText='a:1;b:2')
-
-        self.assertTrue("2" in str(s))  # length
-
-        s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
-
-
-if __name__ == '__main__':
-    import unittest
-    unittest.main()
+"""Testcases for css_parser.css.cssvariablesdelaration.CSSVariablesDeclaration."""
+from __future__ import absolute_import
+from __future__ import unicode_literals
+__version__ = '$Id: test_cssstyledeclaration.py 1869 2009-10-17 19:37:40Z cthedot $'
+
+import xml.dom
+from . import basetest
+import css_parser
+
+
+class CSSVariablesDeclarationTestCase(basetest.BaseTestCase):
+
+    def setUp(self):
+        self.r = css_parser.css.CSSVariablesDeclaration()
+        css_parser.ser.prefs.useDefaults()
+
+    def tearDown(self):
+        css_parser.ser.prefs.useDefaults()
+
+    def test_init(self):
+        "CSSVariablesDeclaration.__init__()"
+        v = css_parser.css.CSSVariablesDeclaration()
+        self.assertEqual('', v.cssText)
+        self.assertEqual(0, v.length)
+        self.assertEqual(None, v.parentRule)
+
+        v = css_parser.css.CSSVariablesDeclaration(cssText='x: 0')
+        self.assertEqual('x: 0', v.cssText)
+        self.assertEqual('0', v.getVariableValue('x'))
+
+        rule = css_parser.css.CSSVariablesRule()
+        v = css_parser.css.CSSVariablesDeclaration(cssText='x: 0',
+                                                 parentRule=rule)
+        self.assertEqual(rule, v.parentRule)
+
+    def test__contains__(self):
+        "CSSVariablesDeclaration.__contains__(name)"
+        v = css_parser.css.CSSVariablesDeclaration(cssText='x: 0; y: 2')
+        for test in ('x', 'y'):
+            self.assertIn(test, v)
+            self.assertIn(test.upper(), v)
+
+        self.assertNotIn('z', v)
+
+    def test_items(self):
+        "CSSVariablesDeclaration[variableName]"
+        v = css_parser.css.CSSVariablesDeclaration()
+
+        value = '0'
+        v['X'] = value
+        self.assertEqual(value, v['X'])
+        self.assertEqual(value, v.getVariableValue('X'))
+        self.assertEqual(value, v['x'])
+        self.assertEqual(value, v.getVariableValue('x'))
+
+        self.assertEqual('', v['y'])
+        self.assertEqual('', v.getVariableValue('y'))
+
+        v['z'] = '1'
+        self.assertEqual(2, v.length)
+
+        items = []
+        # unsorted!
+        self.assertEqual(sorted(v), ['x', 'z'])
+
+        del v['z']
+        self.assertEqual(1, v.length)
+        self.assertEqual(1, v.length)
+
+        self.assertEqual('0', v.removeVariable('x'))
+        self.assertEqual('', v.removeVariable('z'))
+        self.assertEqual(0, v.length)
+
+        v.cssText = 'x:0; y:1'
+        keys = []
+        # unsorted!
+        for i in range(0, v.length):
+            keys.append(v.item(i))
+        self.assertEqual(sorted(keys), ['x', 'y'])
+
+    def test_keys(self):
+        "CSSVariablesDeclaration.keys()"
+        v = css_parser.css.CSSVariablesDeclaration(cssText='x: 0; Y: 2')
+        self.assertEqual(['x', 'y'], sorted(v.keys()))
+
+    def test_cssText(self):
+        "CSSVariablesDeclaration.cssText"
+        # empty
+        tests = {
+            '': '',
+            ' ': '',
+            ' \t \n  ': '',
+            'x: 1': None,
+            'x: "a"': None,
+            'x: rgb(1, 2, 3)': None,
+            'x: 1px 2px 3px': None,
+
+            'x:1': 'x: 1',
+            'x:1;': 'x: 1',
+
+            'x  :  1  ': 'x: 1',
+            'x  :  1  ;  ': 'x: 1',
+
+            'x:1;y:2': 'x: 1;\ny: 2',
+            'x:1;y:2;': 'x: 1;\ny: 2',
+            'x  :  1  ;  y  :  2  ': 'x: 1;\ny: 2',
+            'x  :  1  ;  y  :  2  ;  ': 'x: 1;\ny: 2',
+
+            '/*x*/': '/*x*/',
+            'x555: 5': None,
+            'xxx:1;yyy:2': 'xxx: 1;\nyyy: 2',
+            'xxx : 1; yyy : 2': 'xxx: 1;\nyyy: 2',
+            'x:1;x:2;X:2': 'x: 2',
+            'same:1;SAME:2;': 'same: 2',
+            '/**/x/**/:/**/1/**/;/**/y/**/:/**/2/**/':
+                '/**/\n /**/\n /**/\n x: 1 /**/;\n/**/\n /**/\n /**/\n y: 2 /**/'
+        }
+        self.do_equal_r(tests)
+
+    # TODO: Fix?
+#    def test_cssText2(self):
+#        "CSSVariablesDeclaration.cssText"
+#        # exception
+#        tests = {
+#                 u'top': xml.dom.SyntaxErr,
+#                 u'top:': xml.dom.SyntaxErr,
+#                 u'top : ': xml.dom.SyntaxErr,
+#                 u'top:;': xml.dom.SyntaxErr,
+#                 u'top 0': xml.dom.SyntaxErr,
+#                 u'top 0;': xml.dom.SyntaxErr,
+#
+#                 u':': xml.dom.SyntaxErr,
+#                 u':0': xml.dom.SyntaxErr,
+#                 u':0;': xml.dom.SyntaxErr,
+#                 u':;': xml.dom.SyntaxErr,
+#                 u': ;': xml.dom.SyntaxErr,
+#
+#                 u'0': xml.dom.SyntaxErr,
+#                 u'0;': xml.dom.SyntaxErr,
+#
+#                 u';': xml.dom.SyntaxErr,
+#            }
+#        self.do_raise_r(tests)
+
+    def test_xVariable(self):
+        "CSSVariablesDeclaration.xVariable()"
+        v = css_parser.css.CSSVariablesDeclaration()
+        # unset
+        self.assertEqual('', v.getVariableValue('x'))
+        # set
+        v.setVariable('x', '0')
+        self.assertEqual('0', v.getVariableValue('x'))
+        self.assertEqual('0', v.getVariableValue('X'))
+        self.assertEqual('x: 0', v.cssText)
+        v.setVariable('X', '0')
+        self.assertEqual('0', v.getVariableValue('x'))
+        self.assertEqual('0', v.getVariableValue('X'))
+        self.assertEqual('x: 0', v.cssText)
+        # remove
+        self.assertEqual('0', v.removeVariable('x'))
+        self.assertEqual('', v.removeVariable('x'))
+        self.assertEqual('', v.getVariableValue('x'))
+        self.assertEqual('', v.cssText)
+
+    def test_imports(self):
+        "CSSVariables imports"
+        def fetcher(url):
+            url = url.replace('\\', '/')
+            url = url[url.rfind('/')+1:]
+            return (None, {
+                '3.css': '''
+                    @variables {
+                        over3-2-1-0: 3;
+                        over3-2-1: 3;
+                        over3-2: 3;
+                        over3-2-0: 3;
+                        over3-1: 3;
+                        over3-1-0: 3;
+                        over3-0: 3;
+                        local3: 3;
+                    }
+                
+                ''',
+                '2.css': '''
+                    @variables {
+                        over3-2-1-0: 2;
+                        over3-2-1: 2;
+                        over3-2-0: 2;
+                        over3-2: 2;
+                        over2-1: 2;
+                        over2-1-0: 2;
+                        over2-0: 2;
+                        local2: 2;
+                    }
+                
+                ''',
+                '1.css': '''
+                    @import "3.css";
+                    @import "2.css";
+                    @variables {
+                        over3-2-1-0: 1;
+                        over3-2-1: 1;
+                        over3-1: 1;
+                        over3-1-0: 1;
+                        over2-1: 1;
+                        over2-1-0: 1;
+                        over1-0: 1;
+                        local1: 1;
+                    }
+                
+                '''
+            }[url])
+
+        css = '''
+            @import "1.css";
+            @variables {
+                over3-2-1-0: 0;
+                over3-2-0: 0;
+                over3-1-0: 0;
+                over2-1-0: 0;
+                over3-0: 0;
+                over2-0: 0;
+                over1-0: 0;
+                local0: 0;
+            }
+            a {
+                local0: var(local0);
+                local1: var(local1);
+                local2: var(local2);
+                local3: var(local3);
+                over1-0: var(over1-0);
+                over2-0: var(over2-0);
+                over3-0: var(over3-0);
+                over2-1: var(over2-1);
+                over3-1: var(over3-1);
+                over3-2: var(over3-2);
+                over2-1-0: var(over2-1-0);
+                over3-2-0: var(over3-2-0);
+                over3-2-1: var(over3-2-1);
+                over3-2-1-0: var(over3-2-1-0);
+            }
+        '''
+        p = css_parser.CSSParser(fetcher=fetcher)
+        s = p.parseString(css)
+
+        # only these in rule of this sheet
+        self.assertEqual(s.cssRules[1].variables.length, 8)
+        # but all vars in s available!
+        self.assertEqual(s.variables.length, 15)
+        self.assertEqual(['local0', 'local1', 'local2', 'local3',
+                          'over1-0', 'over2-0', 'over2-1', 'over2-1-0',
+                          'over3-0', 'over3-1', 'over3-1-0', 'over3-2',
+                          'over3-2-0', 'over3-2-1', 'over3-2-1-0'],
+                         sorted(s.variables.keys()))
+
+        # test with variables rule
+        css_parser.ser.prefs.resolveVariables = False
+        self.assertEqual(s.cssText, '''@import "1.css";
+@variables {
+    over3-2-1-0: 0;
+    over3-2-0: 0;
+    over3-1-0: 0;
+    over2-1-0: 0;
+    over3-0: 0;
+    over2-0: 0;
+    over1-0: 0;
+    local0: 0
+    }
+a {
+    local0: var(local0);
+    local1: var(local1);
+    local2: var(local2);
+    local3: var(local3);
+    over1-0: var(over1-0);
+    over2-0: var(over2-0);
+    over3-0: var(over3-0);
+    over2-1: var(over2-1);
+    over3-1: var(over3-1);
+    over3-2: var(over3-2);
+    over2-1-0: var(over2-1-0);
+    over3-2-0: var(over3-2-0);
+    over3-2-1: var(over3-2-1);
+    over3-2-1-0: var(over3-2-1-0)
+    }'''.encode())
+
+        # test with resolved vars
+        css_parser.ser.prefs.resolveVariables = True
+        self.assertEqual(s.cssText, '''@import "1.css";
+a {
+    local0: 0;
+    local1: 1;
+    local2: 2;
+    local3: 3;
+    over1-0: 0;
+    over2-0: 0;
+    over3-0: 0;
+    over2-1: 1;
+    over3-1: 1;
+    over3-2: 2;
+    over2-1-0: 0;
+    over3-2-0: 0;
+    over3-2-1: 1;
+    over3-2-1-0: 0
+    }'''.encode())
+
+        s = css_parser.resolveImports(s)
+        self.assertEqual(s.cssText, '''/* START @import "1.css" */
+/* START @import "3.css" */
+/* START @import "2.css" */
+a {
+    local0: 0;
+    local1: 1;
+    local2: 2;
+    local3: 3;
+    over1-0: 0;
+    over2-0: 0;
+    over3-0: 0;
+    over2-1: 1;
+    over3-1: 1;
+    over3-2: 2;
+    over2-1-0: 0;
+    over3-2-0: 0;
+    over3-2-1: 1;
+    over3-2-1-0: 0
+    }'''.encode())
+
+    def test_parentRule(self):
+        "CSSVariablesDeclaration.parentRule"
+        s = css_parser.parseString('@variables { a:1}')
+        r = s.cssRules[0]
+        d = r.variables
+        self.assertEqual(r, d.parentRule)
+
+        d2 = css_parser.css.CSSVariablesDeclaration('b: 2')
+        r.variables = d2
+        self.assertEqual(r, d2.parentRule)
+
+    def test_reprANDstr(self):
+        "CSSVariablesDeclaration.__repr__(), .__str__()"
+        s = css_parser.css.CSSVariablesDeclaration(cssText='a:1;b:2')
+
+        self.assertIn('2', str(s)) # length
+
+        s2 = eval(repr(s))
+        self.assertIsInstance(s2, s.__class__)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()
diff --git a/css_parser_tests/test_cssvariablesrule.py b/css_parser_tests/test_cssvariablesrule.py
index 5390cb1..ed50436 100644
--- a/css_parser_tests/test_cssvariablesrule.py
+++ b/css_parser_tests/test_cssvariablesrule.py
@@ -1,157 +1,157 @@
-"""Testcases for css_parser.css.CSSPageRule"""
+"""Testcases for css_parser.css.CSSPageRule"""
 from __future__ import absolute_import
 from __future__ import unicode_literals
-__version__ = '$Id: test_csspagerule.py 1869 2009-10-17 19:37:40Z cthedot $'
-
-import xml.dom
-from . import test_cssrule
-import css_parser
-
-
-class CSSVariablesRuleTestCase(test_cssrule.CSSRuleTestCase):
-
-    def setUp(self):
-        super(CSSVariablesRuleTestCase, self).setUp()
-        self.r = css_parser.css.CSSVariablesRule()
-        self.rRO = css_parser.css.CSSVariablesRule(readonly=True)
-        self.r_type = css_parser.css.CSSPageRule.VARIABLES_RULE
-        self.r_typeString = 'VARIABLES_RULE'
-
-        css_parser.ser.prefs.resolveVariables = False
-
-    def test_init(self):
-        "CSSVariablesRule.__init__()"
-        super(CSSVariablesRuleTestCase, self).test_init()
-
-        r = css_parser.css.CSSVariablesRule()
-        self.assertEqual(css_parser.css.CSSVariablesDeclaration,
-                         type(r.variables))
-        self.assertEqual(r, r.variables.parentRule)
-
-        # until any variables
-        self.assertEqual('', r.cssText)
-
-        # only possible to set @... similar name
-        self.assertRaises(xml.dom.InvalidModificationErr,
-                          self.r._setAtkeyword, 'x')
-
-    def test_InvalidModificationErr(self):
-        "CSSVariablesRule.cssText InvalidModificationErr"
-        self._test_InvalidModificationErr('@variables')
-        tests = {
-            '@var {}': xml.dom.InvalidModificationErr,
-        }
-        self.do_raise_r(tests)
-
-    def test_incomplete(self):
-        "CSSVariablesRule (incomplete)"
-        tests = {
-            '@variables { ':
-                '',  # no } and no content
-            '@variables { x: red':
-                '@variables {\n    x: red\n    }',  # no }
-        }
-        self.do_equal_p(tests)  # parse
-
-    def test_cssText(self):
-        "CSSVariablesRule"
-        EXP = '@variables {\n    margin: 0\n    }'
-        tests = {
-            '@variables {}': '',
-            '@variables     {margin:0;}': EXP,
-            '@variables     {margin:0}': EXP,
-            '@VaRIables {   margin    :   0   ;    }': EXP,
-            '@\\VaRIables {    margin : 0    }': EXP,
-
-            '@variables {a:1;b:2}':
-                '@variables {\n    a: 1;\n    b: 2\n    }',
-
-            # comments
-            '@variables   /*1*/   {margin:0;}':
-                '@variables /*1*/ {\n    margin: 0\n    }',
-            '@variables/*1*/{margin:0;}':
-                '@variables /*1*/ {\n    margin: 0\n    }',
-        }
-        self.do_equal_r(tests)
-        self.do_equal_p(tests)
-
-    def test_media(self):
-        "CSSVariablesRule.media"
-        r = css_parser.css.CSSVariablesRule()
-        self.assertRaises(AttributeError, r.__getattribute__, 'media')
-        self.assertRaises(AttributeError, r.__setattr__, 'media', '?')
-
-    def test_variables(self):
-        "CSSVariablesRule.variables"
-        r = css_parser.css.CSSVariablesRule(
-            variables=css_parser.css.CSSVariablesDeclaration('x: 1'))
-        self.assertEqual(r, r.variables.parentRule)
-
-        # cssText
-        r = css_parser.css.CSSVariablesRule()
-        r.cssText = '@variables { x: 1 }'
-        vars1 = r.variables
-        self.assertEqual(r, r.variables.parentRule)
-        self.assertEqual(vars1, r.variables)
-        self.assertEqual(r.variables.cssText, 'x: 1')
-        self.assertEqual(r.cssText, '@variables {\n    x: 1\n    }')
-
-        r.cssText = '@variables {y:2}'
-        self.assertEqual(r, r.variables.parentRule)
-        self.assertNotEqual(vars1, r.variables)
-        self.assertEqual(r.variables.cssText, 'y: 2')
-        self.assertEqual(r.cssText, '@variables {\n    y: 2\n    }')
-
-        vars2 = r.variables
-
-        # fail
-        try:
-            r.cssText = '@variables {$:1}'
-        except xml.dom.DOMException as e:
-            pass
-
-        self.assertEqual(vars2, r.variables)
-        self.assertEqual(r.variables.cssText, 'y: 2')
-        self.assertEqual(r.cssText, '@variables {\n    y: 2\n    }')
-
-        # var decl
-        vars3 = css_parser.css.CSSVariablesDeclaration('z: 3')
-        r.variables = vars3
-
-        self.assertEqual(r, r.variables.parentRule)
-        self.assertEqual(vars3, r.variables)
-        self.assertEqual(r.variables.cssText, 'z: 3')
-        self.assertEqual(r.cssText, '@variables {\n    z: 3\n    }')
-
-        # string
-        r.variables = 'a: x'
-        self.assertNotEqual(vars3, r.variables)
-        self.assertEqual(r, r.variables.parentRule)
-        self.assertEqual(r.variables.cssText, 'a: x')
-        self.assertEqual(r.cssText, '@variables {\n    a: x\n    }')
-        vars4 = r.variables
-
-        # string fail
-        try:
-            r.variables = '$: x'
-        except xml.dom.DOMException as e:
-            pass
-        self.assertEqual(vars4, r.variables)
-        self.assertEqual(r, r.variables.parentRule)
-        self.assertEqual(r.variables.cssText, 'a: x')
-        self.assertEqual(r.cssText, '@variables {\n    a: x\n    }')
-
-    def test_reprANDstr(self):
-        "CSSVariablesRule.__repr__(), .__str__()"
-        r = css_parser.css.CSSVariablesRule()
-        r.cssText = '@variables { xxx: 1 }'
-        self.assertTrue('xxx' in str(r))
-
-        r2 = eval(repr(r))
-        self.assertTrue(isinstance(r2, r.__class__))
-        self.assertTrue(r.cssText == r2.cssText)
-
-
-if __name__ == '__main__':
-    import unittest
-    unittest.main()
+__version__ = '$Id: test_csspagerule.py 1869 2009-10-17 19:37:40Z cthedot $'
+
+import xml.dom
+from . import test_cssrule
+import css_parser
+
+
+class CSSVariablesRuleTestCase(test_cssrule.CSSRuleTestCase):
+
+    def setUp(self):
+        super(CSSVariablesRuleTestCase, self).setUp()
+        self.r = css_parser.css.CSSVariablesRule()
+        self.rRO = css_parser.css.CSSVariablesRule(readonly=True)
+        self.r_type = css_parser.css.CSSPageRule.VARIABLES_RULE
+        self.r_typeString = 'VARIABLES_RULE'
+
+        css_parser.ser.prefs.resolveVariables = False
+
+    def test_init(self):
+        "CSSVariablesRule.__init__()"
+        super(CSSVariablesRuleTestCase, self).test_init()
+
+        r = css_parser.css.CSSVariablesRule()
+        self.assertEqual(css_parser.css.CSSVariablesDeclaration,
+                         type(r.variables))
+        self.assertEqual(r, r.variables.parentRule)
+
+        # until any variables
+        self.assertEqual('', r.cssText)
+
+        # only possible to set @... similar name
+        self.assertRaises(xml.dom.InvalidModificationErr,
+                          self.r._setAtkeyword, 'x')
+
+    def test_InvalidModificationErr(self):
+        "CSSVariablesRule.cssText InvalidModificationErr"
+        self._test_InvalidModificationErr('@variables')
+        tests = {
+            '@var {}': xml.dom.InvalidModificationErr,
+        }
+        self.do_raise_r(tests)
+
+    def test_incomplete(self):
+        "CSSVariablesRule (incomplete)"
+        tests = {
+            '@variables { ':
+                '',  # no } and no content
+            '@variables { x: red':
+                '@variables {\n    x: red\n    }',  # no }
+        }
+        self.do_equal_p(tests)  # parse
+
+    def test_cssText(self):
+        "CSSVariablesRule"
+        EXP = '@variables {\n    margin: 0\n    }'
+        tests = {
+            '@variables {}': '',
+            '@variables     {margin:0;}': EXP,
+            '@variables     {margin:0}': EXP,
+            '@VaRIables {   margin    :   0   ;    }': EXP,
+            '@\\VaRIables {    margin : 0    }': EXP,
+
+            '@variables {a:1;b:2}':
+                '@variables {\n    a: 1;\n    b: 2\n    }',
+
+            # comments
+            '@variables   /*1*/   {margin:0;}':
+                '@variables /*1*/ {\n    margin: 0\n    }',
+            '@variables/*1*/{margin:0;}':
+                '@variables /*1*/ {\n    margin: 0\n    }',
+        }
+        self.do_equal_r(tests)
+        self.do_equal_p(tests)
+
+    def test_media(self):
+        "CSSVariablesRule.media"
+        r = css_parser.css.CSSVariablesRule()
+        self.assertRaises(AttributeError, r.__getattribute__, 'media')
+        self.assertRaises(AttributeError, r.__setattr__, 'media', '?')
+
+    def test_variables(self):
+        "CSSVariablesRule.variables"
+        r = css_parser.css.CSSVariablesRule(
+            variables=css_parser.css.CSSVariablesDeclaration('x: 1'))
+        self.assertEqual(r, r.variables.parentRule)
+
+        # cssText
+        r = css_parser.css.CSSVariablesRule()
+        r.cssText = '@variables { x: 1 }'
+        vars1 = r.variables
+        self.assertEqual(r, r.variables.parentRule)
+        self.assertEqual(vars1, r.variables)
+        self.assertEqual(r.variables.cssText, 'x: 1')
+        self.assertEqual(r.cssText, '@variables {\n    x: 1\n    }')
+
+        r.cssText = '@variables {y:2}'
+        self.assertEqual(r, r.variables.parentRule)
+        self.assertNotEqual(vars1, r.variables)
+        self.assertEqual(r.variables.cssText, 'y: 2')
+        self.assertEqual(r.cssText, '@variables {\n    y: 2\n    }')
+
+        vars2 = r.variables
+
+        # fail
+        try:
+            r.cssText = '@variables {$:1}'
+        except xml.dom.DOMException as e:
+            pass
+
+        self.assertEqual(vars2, r.variables)
+        self.assertEqual(r.variables.cssText, 'y: 2')
+        self.assertEqual(r.cssText, '@variables {\n    y: 2\n    }')
+
+        # var decl
+        vars3 = css_parser.css.CSSVariablesDeclaration('z: 3')
+        r.variables = vars3
+
+        self.assertEqual(r, r.variables.parentRule)
+        self.assertEqual(vars3, r.variables)
+        self.assertEqual(r.variables.cssText, 'z: 3')
+        self.assertEqual(r.cssText, '@variables {\n    z: 3\n    }')
+
+        # string
+        r.variables = 'a: x'
+        self.assertNotEqual(vars3, r.variables)
+        self.assertEqual(r, r.variables.parentRule)
+        self.assertEqual(r.variables.cssText, 'a: x')
+        self.assertEqual(r.cssText, '@variables {\n    a: x\n    }')
+        vars4 = r.variables
+
+        # string fail
+        try:
+            r.variables = '$: x'
+        except xml.dom.DOMException as e:
+            pass
+        self.assertEqual(vars4, r.variables)
+        self.assertEqual(r, r.variables.parentRule)
+        self.assertEqual(r.variables.cssText, 'a: x')
+        self.assertEqual(r.cssText, '@variables {\n    a: x\n    }')
+
+    def test_reprANDstr(self):
+        "CSSVariablesRule.__repr__(), .__str__()"
+        r = css_parser.css.CSSVariablesRule()
+        r.cssText = '@variables { xxx: 1 }'
+        self.assertIn('xxx', str(r))
+
+        r2 = eval(repr(r))
+        self.assertIsInstance(r2, r.__class__)
+        self.assertEqual(r.cssText, r2.cssText)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()
diff --git a/css_parser_tests/test_domimplementation.py b/css_parser_tests/test_domimplementation.py
index ec248bf..857857e 100644
--- a/css_parser_tests/test_domimplementation.py
+++ b/css_parser_tests/test_domimplementation.py
@@ -1,47 +1,47 @@
-"""Testcases for css_parser.css.DOMImplementation"""
-
+"""Testcases for css_parser.css.DOMImplementation"""
+
 from __future__ import absolute_import
 from __future__ import unicode_literals
-import xml.dom
-import xml.dom.minidom
-import unittest
-import css_parser
-
-
-class DOMImplementationTestCase(unittest.TestCase):
-
-    def setUp(self):
-        self.domimpl = css_parser.DOMImplementationCSS()
-
-    def test_createCSSStyleSheet(self):
-        "DOMImplementationCSS.createCSSStyleSheet()"
-        title, media = 'Test Title', css_parser.stylesheets.MediaList('all')
-        sheet = self.domimpl.createCSSStyleSheet(title, media)
-        self.assertEqual(True, isinstance(sheet, css_parser.css.CSSStyleSheet))
-        self.assertEqual(title, sheet.title)
-        self.assertEqual(media, sheet.media)
-
-    def test_createDocument(self):
-        "DOMImplementationCSS.createDocument()"
-        doc = self.domimpl.createDocument(None, None, None)
-        self.assertTrue(isinstance(doc, xml.dom.minidom.Document))
-
-    def test_createDocumentType(self):
-        "DOMImplementationCSS.createDocumentType()"
-        doctype = self.domimpl.createDocumentType('foo', 'bar', 'raboof')
-        self.assertTrue(isinstance(doctype, xml.dom.minidom.DocumentType))
-
-    def test_hasFeature(self):
-        "DOMImplementationCSS.hasFeature()"
-        tests = [
-            ('css', '1.0'),
-            ('css', '2.0'),
-            ('stylesheets', '1.0'),
-            ('stylesheets', '2.0')
-        ]
-        for name, version in tests:
-            self.assertEqual(True, self.domimpl.hasFeature(name, version))
-
-
-if __name__ == '__main__':
-    unittest.main()
+import xml.dom
+import xml.dom.minidom
+import unittest
+import css_parser
+
+
+class DOMImplementationTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self.domimpl = css_parser.DOMImplementationCSS()
+
+    def test_createCSSStyleSheet(self):
+        "DOMImplementationCSS.createCSSStyleSheet()"
+        title, media = 'Test Title', css_parser.stylesheets.MediaList('all')
+        sheet = self.domimpl.createCSSStyleSheet(title, media)
+        self.assertEqual(True, isinstance(sheet, css_parser.css.CSSStyleSheet))
+        self.assertEqual(title, sheet.title)
+        self.assertEqual(media, sheet.media)
+
+    def test_createDocument(self):
+        "DOMImplementationCSS.createDocument()"
+        doc = self.domimpl.createDocument(None, None, None)
+        self.assertIsInstance(doc, xml.dom.minidom.Document)
+
+    def test_createDocumentType(self):
+        "DOMImplementationCSS.createDocumentType()"
+        doctype = self.domimpl.createDocumentType('foo', 'bar', 'raboof')
+        self.assertIsInstance(doctype, xml.dom.minidom.DocumentType)
+
+    def test_hasFeature(self):
+        "DOMImplementationCSS.hasFeature()"
+        tests = [
+            ('css', '1.0'),
+            ('css', '2.0'),
+            ('stylesheets', '1.0'),
+            ('stylesheets', '2.0')
+        ]
+        for name, version in tests:
+            self.assertEqual(True, self.domimpl.hasFeature(name, version))
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/css_parser_tests/test_marginrule.py b/css_parser_tests/test_marginrule.py
index 1fcda78..03b3c2c 100644
--- a/css_parser_tests/test_marginrule.py
+++ b/css_parser_tests/test_marginrule.py
@@ -88,11 +88,11 @@ def test_reprANDstr(self):
 
         s = css_parser.css.MarginRule(margin=margin, style='left: 0')
 
-        self.assertTrue(margin in str(s))
+        self.assertIn(margin, str(s))
 
         s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
-        self.assertTrue(margin == s2.margin)
+        self.assertIsInstance(s2, s.__class__)
+        self.assertEqual(margin, s2.margin)
 
 
 if __name__ == '__main__':
diff --git a/css_parser_tests/test_medialist.py b/css_parser_tests/test_medialist.py
index e5b24f1..6d99edf 100644
--- a/css_parser_tests/test_medialist.py
+++ b/css_parser_tests/test_medialist.py
@@ -193,11 +193,11 @@ def test_reprANDstr(self):
 
         s = css_parser.stylesheets.MediaList(mediaText=mediaText)
 
-        self.assertTrue(mediaText in str(s))
+        self.assertIn(mediaText, str(s))
 
         s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
-        self.assertTrue(mediaText == s2.mediaText)
+        self.assertIsInstance(s2, s.__class__)
+        self.assertEqual(mediaText, s2.mediaText)
 
 
 if __name__ == '__main__':
diff --git a/css_parser_tests/test_mediaquery.py b/css_parser_tests/test_mediaquery.py
index b8582cc..91742f8 100644
--- a/css_parser_tests/test_mediaquery.py
+++ b/css_parser_tests/test_mediaquery.py
@@ -1,108 +1,108 @@
-# -*- coding: iso-8859-1 -*-
-"""Testcases for css_parser.stylesheets.MediaQuery"""
-
-from __future__ import absolute_import
-from __future__ import unicode_literals
-import xml.dom
-import logging
-from . import basetest
-import css_parser.stylesheets
-
-
-class MediaQueryTestCase(basetest.BaseTestCase):
-
-    def setUp(self):
-        super(MediaQueryTestCase, self).setUp()
-        self.r = css_parser.stylesheets.MediaQuery()
-
-    def test_mediaText(self):
-        "MediaQuery.mediaText"
-        tests = {
-            'all': None,
-            'braille': None,
-            'embossed': None,
-            'handheld': None,
-            'print': None,
-            'projection': None,
-            'screen': None,
-            'speech': None,
-            'tty': None,
-            'tv': None,
-            'ALL': None,
-            'a\\ll': None,
-            'not tv': None,
-            'n\\ot t\\v': None,
-            'only tv': None,
-            '\\only \\tv': None,
-            'PRINT': None,
-            'NOT PRINT': None,
-            'ONLY PRINT': None,
-            'tv and (color)': None,
-            'not tv and (color)': None,
-            'only tv and (color)': None,
-            'print and(color)': 'print and (color)',
-            'aural': None  # xml.dom.SyntaxErr in cssutils
-        }
-        self.do_equal_r(tests, att='mediaText')
-
-        tests = {
-            '': xml.dom.SyntaxErr,
-            'two values': xml.dom.SyntaxErr,
-            'or even three': xml.dom.SyntaxErr,
-            '3d': xml.dom.SyntaxErr,  # a dimension
-        }
-        self.do_raise_r(tests, att='_setMediaText')
-
-    def test_mediaType(self):
-        "MediaQuery.mediaType"
-        mq = css_parser.stylesheets.MediaQuery()
-
-        self.assertEqual('', mq.mediaText)
-
-        for mt in css_parser.stylesheets.MediaQuery.MEDIA_TYPES:
-            mq.mediaType = mt
-            self.assertEqual(mq.mediaType, mt)
-            mq.mediaType = mt.upper()
-            self.assertEqual(mq.mediaType, mt.upper())
-
-        mt = '3D-UNKOwn-MEDIAtype0123'
-        #mq.mediaType = mt
-        self.assertEqual(self.captureLog(logging.WARNING, mq._setMediaType, mt),
-                         'WARNING    MediaQuery: Unknown media type: "3D-UNKOwn-MEDIAtype0123".\n')
-        #self.assertRaises(xml.dom.InvalidCharacterErr, mq._setMediaType, mt)
-
-    def test_comments(self):
-        "MediaQuery.mediaText comments"
-        tests = {
-            'all': None,
-            'print': None,
-            'not print': None,
-            'only print': None,
-            'print and (color)': None,
-            'print and (color) and (width)': None,
-            'print and (color: 2)': None,
-            'print and (min-width: 100px)': None,
-            'print and (min-width: 100px) and (color: red)': None,
-            'not print and (min-width: 100px)': None,
-            'only print and (min-width: 100px)': None,
-            '/*1*/ tv /*2*/': None,
-            '/*0*/ only /*1*/ tv /*2*/': None,
-            '/*0* /not /*1*/ tv /*2*/': None,
-            '/*x*/ only /*x*/ print /*x*/ and /*x*/ (/*x*/ min-width /*x*/: /*x*/ 100px /*x*/)': None,
-            'print and/*1*/(color)': 'print and /*1*/ (color)'
-        }
-        self.do_equal_r(tests, att='mediaText')
-
-    def test_reprANDstr(self):
-        "MediaQuery.__repr__(), .__str__()"
-        mediaText = 'tv and (color)'
-        s = css_parser.stylesheets.MediaQuery(mediaText=mediaText)
-        self.assertTrue(mediaText in str(s))
-        s2 = eval(repr(s))
-        self.assertEqual(mediaText, s2.mediaText)
-        self.assertTrue(isinstance(s2, s.__class__))
-
-
-if __name__ == '__main__':
-    import unittest
-    unittest.main()
+# -*- coding: iso-8859-1 -*-
+"""Testcases for css_parser.stylesheets.MediaQuery"""
+
+from __future__ import absolute_import
+from __future__ import unicode_literals
+import xml.dom
+import logging
+from . import basetest
+import css_parser.stylesheets
+
+
+class MediaQueryTestCase(basetest.BaseTestCase):
+
+    def setUp(self):
+        super(MediaQueryTestCase, self).setUp()
+        self.r = css_parser.stylesheets.MediaQuery()
+
+    def test_mediaText(self):
+        "MediaQuery.mediaText"
+        tests = {
+            'all': None,
+            'braille': None,
+            'embossed': None,
+            'handheld': None,
+            'print': None,
+            'projection': None,
+            'screen': None,
+            'speech': None,
+            'tty': None,
+            'tv': None,
+            'ALL': None,
+            'a\\ll': None,
+            'not tv': None,
+            'n\\ot t\\v': None,
+            'only tv': None,
+            '\\only \\tv': None,
+            'PRINT': None,
+            'NOT PRINT': None,
+            'ONLY PRINT': None,
+            'tv and (color)': None,
+            'not tv and (color)': None,
+            'only tv and (color)': None,
+            'print and(color)': 'print and (color)',
+            'aural': None  # xml.dom.SyntaxErr in cssutils
+        }
+        self.do_equal_r(tests, att='mediaText')
+
+        tests = {
+            '': xml.dom.SyntaxErr,
+            'two values': xml.dom.SyntaxErr,
+            'or even three': xml.dom.SyntaxErr,
+            '3d': xml.dom.SyntaxErr,  # a dimension
+        }
+        self.do_raise_r(tests, att='_setMediaText')
+
+    def test_mediaType(self):
+        "MediaQuery.mediaType"
+        mq = css_parser.stylesheets.MediaQuery()
+
+        self.assertEqual('', mq.mediaText)
+
+        for mt in css_parser.stylesheets.MediaQuery.MEDIA_TYPES:
+            mq.mediaType = mt
+            self.assertEqual(mq.mediaType, mt)
+            mq.mediaType = mt.upper()
+            self.assertEqual(mq.mediaType, mt.upper())
+
+        mt = '3D-UNKOwn-MEDIAtype0123'
+        #mq.mediaType = mt
+        self.assertEqual(self.captureLog(logging.WARNING, mq._setMediaType, mt),
+                         'WARNING    MediaQuery: Unknown media type: "3D-UNKOwn-MEDIAtype0123".\n')
+        #self.assertRaises(xml.dom.InvalidCharacterErr, mq._setMediaType, mt)
+
+    def test_comments(self):
+        "MediaQuery.mediaText comments"
+        tests = {
+            'all': None,
+            'print': None,
+            'not print': None,
+            'only print': None,
+            'print and (color)': None,
+            'print and (color) and (width)': None,
+            'print and (color: 2)': None,
+            'print and (min-width: 100px)': None,
+            'print and (min-width: 100px) and (color: red)': None,
+            'not print and (min-width: 100px)': None,
+            'only print and (min-width: 100px)': None,
+            '/*1*/ tv /*2*/': None,
+            '/*0*/ only /*1*/ tv /*2*/': None,
+            '/*0* /not /*1*/ tv /*2*/': None,
+            '/*x*/ only /*x*/ print /*x*/ and /*x*/ (/*x*/ min-width /*x*/: /*x*/ 100px /*x*/)': None,
+            'print and/*1*/(color)': 'print and /*1*/ (color)'
+        }
+        self.do_equal_r(tests, att='mediaText')
+
+    def test_reprANDstr(self):
+        "MediaQuery.__repr__(), .__str__()"
+        mediaText = 'tv and (color)'
+        s = css_parser.stylesheets.MediaQuery(mediaText=mediaText)
+        self.assertIn(mediaText, str(s))
+        s2 = eval(repr(s))
+        self.assertEqual(mediaText, s2.mediaText)
+        self.assertIsInstance(s2, s.__class__)
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()
diff --git a/css_parser_tests/test_property.py b/css_parser_tests/test_property.py
index 561a5eb..ad99103 100644
--- a/css_parser_tests/test_property.py
+++ b/css_parser_tests/test_property.py
@@ -259,15 +259,15 @@ def test_reprANDstr(self):
 
         s = css_parser.css.property.Property(name=name, value=value, priority=priority)
 
-        self.assertTrue(name in str(s))
-        self.assertTrue(value in str(s))
-        self.assertTrue(priority in str(s))
+        self.assertIn(name, str(s))
+        self.assertIn(value, str(s))
+        self.assertIn(priority, str(s))
 
         s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
-        self.assertTrue(name == s2.name)
-        self.assertTrue(value == s2.value)
-        self.assertTrue(priority == s2.priority)
+        self.assertIsInstance(s2, s.__class__)
+        self.assertEqual(name, s2.name)
+        self.assertEqual(value, s2.value)
+        self.assertEqual(priority, s2.priority)
 
 
 if __name__ == '__main__':
diff --git a/css_parser_tests/test_selector.py b/css_parser_tests/test_selector.py
index f2746d8..70a9559 100644
--- a/css_parser_tests/test_selector.py
+++ b/css_parser_tests/test_selector.py
@@ -486,11 +486,11 @@ def test_reprANDstr(self):
 
         s = css_parser.css.Selector(selectorText=sel)
 
-        self.assertTrue(sel in str(s))
+        self.assertIn(sel, str(s))
 
         s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
-        self.assertTrue(sel == s2.selectorText)
+        self.assertIsInstance(s2, s.__class__)
+        self.assertEqual(sel, s2.selectorText)
 
 
 if __name__ == '__main__':
diff --git a/css_parser_tests/test_selectorlist.py b/css_parser_tests/test_selectorlist.py
index 54c945a..4bb256c 100644
--- a/css_parser_tests/test_selectorlist.py
+++ b/css_parser_tests/test_selectorlist.py
@@ -139,10 +139,10 @@ def test_reprANDstr(self):
 
         s = css_parser.css.SelectorList(selectorText=sel)
 
-        self.assertTrue(sel[0] in str(s))
+        self.assertIn(sel[0], str(s))
 
         s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
+        self.assertIsInstance(s2, s.__class__)
         self.assertEqual(sel[0], s2.selectorText)
 
 
diff --git a/css_parser_tests/test_value.py b/css_parser_tests/test_value.py
index 2dcd912..252cfcf 100644
--- a/css_parser_tests/test_value.py
+++ b/css_parser_tests/test_value.py
@@ -358,10 +358,10 @@ def test_incomplete(self):
     def test_readonly(self):
         "PropertyValue._readonly"
         v = css_parser.css.PropertyValue(cssText='inherit')
-        self.assertTrue(False is v._readonly)
+        self.assertIs(False, v._readonly)
 
         v = css_parser.css.PropertyValue(cssText='inherit', readonly=True)
-        self.assertTrue(True is v._readonly)
+        self.assertIs(True, v._readonly)
         self.assertTrue('inherit', v.cssText)
         self.assertRaises(xml.dom.NoModificationAllowedErr, v._setCssText, 'x')
         self.assertTrue('inherit', v.cssText)
@@ -372,11 +372,11 @@ def test_reprANDstr(self):
 
         s = css_parser.css.PropertyValue(cssText=cssText)
 
-        self.assertTrue(cssText in str(s))
+        self.assertIn(cssText, str(s))
 
         s2 = eval(repr(s))
-        self.assertTrue(isinstance(s2, s.__class__))
-        self.assertTrue(cssText == s2.cssText)
+        self.assertIsInstance(s2, s.__class__)
+        self.assertEqual(cssText, s2.cssText)
 
 
 class ValueTestCase(basetest.BaseTestCase):
@@ -384,9 +384,9 @@ class ValueTestCase(basetest.BaseTestCase):
     def test_init(self):
         "Value.__init__()"
         v = css_parser.css.Value()
-        self.assertTrue('' == v.cssText)
-        self.assertTrue('' == v.value)
-        self.assertTrue(None is v.type)
+        self.assertEqual('', v.cssText)
+        self.assertEqual('', v.value)
+        self.assertIs(None, v.type)
 
     def test_cssText(self):
         "Value.cssText"
@@ -425,8 +425,8 @@ def test_init(self):
         "ColorValue.__init__()"
         v = css_parser.css.ColorValue()
         self.assertEqual(v.COLOR_VALUE, v.type)
-        self.assertTrue('' == v.cssText)
-        self.assertTrue('' == v.value)
+        self.assertEqual('', v.cssText)
+        self.assertEqual('', v.value)
         self.assertEqual('transparent', v.name)
         self.assertEqual(None, v.colorType)
 
@@ -532,19 +532,19 @@ class URIValueTestCase(basetest.BaseTestCase):
     def test_init(self):
         "URIValue.__init__()"
         v = css_parser.css.URIValue()
-        self.assertTrue('url()' == v.cssText)
-        self.assertTrue('' == v.value)
-        self.assertTrue('' == v.uri)
-        self.assertTrue(v.URI is v.type)
+        self.assertEqual('url()', v.cssText)
+        self.assertEqual('', v.value)
+        self.assertEqual('', v.uri)
+        self.assertIs(v.URI, v.type)
 
         v.uri = '1'
-        self.assertTrue('1' == v.value)
-        self.assertTrue('1' == v.uri)
+        self.assertEqual('1', v.value)
+        self.assertEqual('1', v.uri)
         self.assertEqual('url(1)', v.cssText)
 
         v.value = '2'
-        self.assertTrue('2' == v.value)
-        self.assertTrue('2' == v.uri)
+        self.assertEqual('2', v.value)
+        self.assertEqual('2', v.uri)
         self.assertEqual('url(2)', v.cssText)
 
     def test_absoluteUri(self):
@@ -601,10 +601,10 @@ class DimensionValueTestCase(basetest.BaseTestCase):
     def test_init(self):
         "DimensionValue.__init__()"
         v = css_parser.css.DimensionValue()
-        self.assertTrue('' == v.cssText)
-        self.assertTrue('' == v.value)
-        self.assertTrue(None is v.type)
-        self.assertTrue(None is v.dimension)
+        self.assertEqual('', v.cssText)
+        self.assertEqual('', v.value)
+        self.assertIs(None, v.type)
+        self.assertIs(None, v.dimension)
 
     def test_cssText(self):
         "DimensionValue.cssText"
@@ -696,8 +696,8 @@ def test_init(self):
         v = css_parser.css.CSSVariable()
         self.assertEqual('', v.cssText)
         self.assertEqual('VARIABLE', v.type)
-        self.assertTrue(None is v.name)
-        self.assertTrue(None is v.value)
+        self.assertIs(None, v.name)
+        self.assertIs(None, v.value)
 
     def test_cssText(self):
         "CSSVariable.cssText"