This file is indexed.

/usr/lib/python2.7/dist-packages/cssutils/tests/test_csscharsetrule.py is in python-cssutils 1.0-4.1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
"""Testcases for cssutils.css.CSSCharsetRule"""

import re
import xml.dom
import test_cssrule
import cssutils.css

class CSSCharsetRuleTestCase(test_cssrule.CSSRuleTestCase):

    def setUp(self):
        super(CSSCharsetRuleTestCase, self).setUp()
        self.r = cssutils.css.CSSCharsetRule()
        self.rRO = cssutils.css.CSSCharsetRule(readonly=True)
        self.r_type = cssutils.css.CSSCharsetRule.CHARSET_RULE
        self.r_typeString = 'CHARSET_RULE'

    def test_init(self):
        "CSSCharsetRule.__init__()"      
        super(CSSCharsetRuleTestCase, self).test_init()
        self.assertEqual(None, self.r.encoding)
        self.assertEqual(u'', self.r.cssText)
        
        self.assertRaises(xml.dom.InvalidModificationErr, self.r._setCssText, u'xxx')

    def test_InvalidModificationErr(self):
        "CSSCharsetRule InvalidModificationErr"
        self._test_InvalidModificationErr(u'@charset')

    def test_init_encoding(self):
        "CSSCharsetRule.__init__(encoding)"
        for enc in (None, u'UTF-8', u'utf-8', u'iso-8859-1', u'ascii'):
            r = cssutils.css.CSSCharsetRule(enc)
            if enc is None:
                self.assertEqual(None, r.encoding)
                self.assertEqual(u'', r.cssText)
            else:
                self.assertEqual(enc.lower(), r.encoding)
                self.assertEqual(
                    u'@charset "%s";' % enc.lower(), r.cssText)

        for enc in (' ascii ', ' ascii', 'ascii '):
            self.assertRaisesEx(xml.dom.SyntaxErr,
                    cssutils.css.CSSCharsetRule, enc,
                    exc_pattern=re.compile("Syntax Error"))

        for enc in (u'unknown', ):
            self.assertRaisesEx(xml.dom.SyntaxErr,
                    cssutils.css.CSSCharsetRule, enc,
                    exc_pattern=re.compile("Unknown \(Python\) encoding"))

    def test_encoding(self):
        "CSSCharsetRule.encoding"
        for enc in (u'UTF-8', u'utf-8', u'iso-8859-1', u'ascii'):
            self.r.encoding = enc
            self.assertEqual(enc.lower(), self.r.encoding)
            self.assertEqual(
                u'@charset "%s";' % enc.lower(), self.r.cssText)

        for enc in (None,' ascii ', ' ascii', 'ascii '):
            self.assertRaisesEx(xml.dom.SyntaxErr,
                    self.r.__setattr__, 'encoding', enc,
                    exc_pattern=re.compile("Syntax Error"))

        for enc in (u'unknown', ):
            self.assertRaisesEx(xml.dom.SyntaxErr,
                    self.r.__setattr__, 'encoding', enc,
                    exc_pattern=re.compile("Unknown \(Python\) encoding"))

    def test_cssText(self):
        """CSSCharsetRule.cssText

        setting cssText is ok to use @CHARSET or other but a file
        using parse MUST use ``@charset "ENCODING";``
        """
        tests = {
            u'@charset "utf-8";': None,
            u"@charset 'utf-8';": u'@charset "utf-8";',
            }
        self.do_equal_r(tests)
        self.do_equal_p(tests) # also parse

        tests = {
            # token is "@charset " with space!
            u'@charset;"': xml.dom.InvalidModificationErr,
            u'@CHARSET "UTF-8";': xml.dom.InvalidModificationErr,
            u'@charset "";': xml.dom.SyntaxErr,
            u'''@charset /*1*/"utf-8"/*2*/;''': xml.dom.SyntaxErr,
            u'''@charset /*1*/"utf-8";''': xml.dom.SyntaxErr,
            u'''@charset "utf-8"/*2*/;''': xml.dom.SyntaxErr,
            u'@charset { utf-8 }': xml.dom.SyntaxErr,
            u'@charset "utf-8"': xml.dom.SyntaxErr,
            u'@charset a;': xml.dom.SyntaxErr,
            u'@charset /**/;': xml.dom.SyntaxErr,
            # trailing content
            u'@charset "utf-8";s': xml.dom.SyntaxErr,
            u'@charset "utf-8";/**/': xml.dom.SyntaxErr,
            u'@charset "utf-8"; ': xml.dom.SyntaxErr,
            
            # comments do not work in this rule!
            u'@charset "utf-8"/*1*//*2*/;': xml.dom.SyntaxErr
            }
        self.do_raise_r(tests)

    def test_repr(self):
        "CSSCharsetRule.__repr__()"
        self.r.encoding = 'utf-8'
        self.assertTrue('utf-8' in repr(self.r))

    def test_reprANDstr(self):
        "CSSCharsetRule.__repr__(), .__str__()"
        encoding='utf-8'

        s = cssutils.css.CSSCharsetRule(encoding=encoding)

        self.assertTrue(encoding in str(s))

        s2 = eval(repr(s))
        self.assertTrue(isinstance(s2, s.__class__))
        self.assertTrue(encoding == s2.encoding)

if __name__ == '__main__':
    import unittest
    unittest.main()