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