<h2>Editing File: /lib64/python3.6/site-packages/markupsafe/tests.py</h2><form method='post'><textarea name='content' class='file-edit'># -*- coding: utf-8 -*-
import gc
import sys
import unittest
from markupsafe import Markup, escape, escape_silent
from markupsafe._compat import text_type


class MarkupTestCase(unittest.TestCase):

    def test_adding(self):
        # adding two strings should escape the unsafe one
        unsafe = '&lt;script type=&quot;application/x-some-script&quot;&gt;alert(&quot;foo&quot;);&lt;/script&gt;'
        safe = Markup('&lt;em&gt;username&lt;/em&gt;')
        assert unsafe + safe == text_type(escape(unsafe)) + text_type(safe)

    def test_string_interpolation(self):
        # string interpolations are safe to use too
        assert Markup('&lt;em&gt;%s&lt;/em&gt;') % '&lt;bad user&gt;' == \
               '&lt;em&gt;&amp;lt;bad user&amp;gt;&lt;/em&gt;'
        assert Markup('&lt;em&gt;%(username)s&lt;/em&gt;') % {
            'username': '&lt;bad user&gt;'
        } == '&lt;em&gt;&amp;lt;bad user&amp;gt;&lt;/em&gt;'

        assert Markup('%i') % 3.14 == '3'
        assert Markup('%.2f') % 3.14 == '3.14'

    def test_type_behavior(self):
        # an escaped object is markup too
        assert type(Markup('foo') + 'bar') is Markup

        # and it implements __html__ by returning itself
        x = Markup(&quot;foo&quot;)
        assert x.__html__() is x

    def test_html_interop(self):
        # it also knows how to treat __html__ objects
        class Foo(object):
            def __html__(self):
                return '&lt;em&gt;awesome&lt;/em&gt;'
            def __unicode__(self):
                return 'awesome'
            __str__ = __unicode__
        assert Markup(Foo()) == '&lt;em&gt;awesome&lt;/em&gt;'
        assert Markup('&lt;strong&gt;%s&lt;/strong&gt;') % Foo() == \
            '&lt;strong&gt;&lt;em&gt;awesome&lt;/em&gt;&lt;/strong&gt;'

    def test_tuple_interpol(self):
        self.assertEqual(Markup('&lt;em&gt;%s:%s&lt;/em&gt;') % (
            '&lt;foo&gt;',
            '&lt;bar&gt;',
        ), Markup(u'&lt;em&gt;&amp;lt;foo&amp;gt;:&amp;lt;bar&amp;gt;&lt;/em&gt;'))

    def test_dict_interpol(self):
        self.assertEqual(Markup('&lt;em&gt;%(foo)s&lt;/em&gt;') % {
            'foo': '&lt;foo&gt;',
        }, Markup(u'&lt;em&gt;&amp;lt;foo&amp;gt;&lt;/em&gt;'))
        self.assertEqual(Markup('&lt;em&gt;%(foo)s:%(bar)s&lt;/em&gt;') % {
            'foo': '&lt;foo&gt;',
            'bar': '&lt;bar&gt;',
        }, Markup(u'&lt;em&gt;&amp;lt;foo&amp;gt;:&amp;lt;bar&amp;gt;&lt;/em&gt;'))

    def test_escaping(self):
        # escaping and unescaping
        assert escape('&quot;&lt;&gt;&amp;\'') == '&amp;#34;&amp;lt;&amp;gt;&amp;amp;&amp;#39;'
        assert Markup(&quot;&lt;em&gt;Foo &amp;amp; Bar&lt;/em&gt;&quot;).striptags() == &quot;Foo &amp; Bar&quot;
        assert Markup(&quot;&amp;lt;test&amp;gt;&quot;).unescape() == &quot;&lt;test&gt;&quot;

    def test_formatting(self):
        for actual, expected in (
            (Markup('%i') % 3.14, '3'),
            (Markup('%.2f') % 3.14159, '3.14'),
            (Markup('%s %s %s') % ('&lt;', 123, '&gt;'), '&amp;lt; 123 &amp;gt;'),
            (Markup('&lt;em&gt;{awesome}&lt;/em&gt;').format(awesome='&lt;awesome&gt;'),
             '&lt;em&gt;&amp;lt;awesome&amp;gt;&lt;/em&gt;'),
            (Markup('{0[1][bar]}').format([0, {'bar': '&lt;bar/&gt;'}]),
             '&amp;lt;bar/&amp;gt;'),
            (Markup('{0[1][bar]}').format([0, {'bar': Markup('&lt;bar/&gt;')}]),
             '&lt;bar/&gt;')):
            assert actual == expected, &quot;%r should be %r!&quot; % (actual, expected)

    # This is new in 2.7
    if sys.version_info &gt;= (2, 7):
        def test_formatting_empty(self):
            formatted = Markup('{}').format(0)
            assert formatted == Markup('0')

    def test_custom_formatting(self):
        class HasHTMLOnly(object):
            def __html__(self):
                return Markup('&lt;foo&gt;')

        class HasHTMLAndFormat(object):
            def __html__(self):
                return Markup('&lt;foo&gt;')
            def __html_format__(self, spec):
                return Markup('&lt;FORMAT&gt;')

        assert Markup('{0}').format(HasHTMLOnly()) == Markup('&lt;foo&gt;')
        assert Markup('{0}').format(HasHTMLAndFormat()) == Markup('&lt;FORMAT&gt;')

    def test_complex_custom_formatting(self):
        class User(object):
            def __init__(self, id, username):
                self.id = id
                self.username = username
            def __html_format__(self, format_spec):
                if format_spec == 'link':
                    return Markup('&lt;a href=&quot;/user/{0}&quot;&gt;{1}&lt;/a&gt;').format(
                        self.id,
                        self.__html__(),
                    )
                elif format_spec:
                    raise ValueError('Invalid format spec')
                return self.__html__()
            def __html__(self):
                return Markup('&lt;span class=user&gt;{0}&lt;/span&gt;').format(self.username)

        user = User(1, 'foo')
        assert Markup('&lt;p&gt;User: {0:link}').format(user) == \
            Markup('&lt;p&gt;User: &lt;a href=&quot;/user/1&quot;&gt;&lt;span class=user&gt;foo&lt;/span&gt;&lt;/a&gt;')

    def test_all_set(self):
        import markupsafe as markup
        for item in markup.__all__:
            getattr(markup, item)

    def test_escape_silent(self):
        assert escape_silent(None) == Markup()
        assert escape(None) == Markup(None)
        assert escape_silent('&lt;foo&gt;') == Markup(u'&amp;lt;foo&amp;gt;')

    def test_splitting(self):
        self.assertEqual(Markup('a b').split(), [
            Markup('a'),
            Markup('b')
        ])
        self.assertEqual(Markup('a b').rsplit(), [
            Markup('a'),
            Markup('b')
        ])
        self.assertEqual(Markup('a\nb').splitlines(), [
            Markup('a'),
            Markup('b')
        ])

    def test_mul(self):
        self.assertEqual(Markup('a') * 3, Markup('aaa'))


class MarkupLeakTestCase(unittest.TestCase):

    def test_markup_leaks(self):
        counts = set()
        for count in range(20):
            for item in range(1000):
                escape(&quot;foo&quot;)
                escape(&quot;&lt;foo&gt;&quot;)
                escape(u&quot;foo&quot;)
                escape(u&quot;&lt;foo&gt;&quot;)
            counts.add(len(gc.get_objects()))
        assert len(counts) == 1, 'ouch, c extension seems to leak objects'


def suite():
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(MarkupTestCase))

    # this test only tests the c extension
    if not hasattr(escape, 'func_code'):
        suite.addTest(unittest.makeSuite(MarkupLeakTestCase))

    return suite


if __name__ == '__main__':
    unittest.main(defaultTest='suite')

# vim:sts=4:sw=4:et:
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Flib64%2Fpython3.6%2Fsite-packages%2Fmarkupsafe'>Back to Directory</a>