Fixed #23768 -- Rewrote template tests as unit tests.

AUTHORS

@@ -554,6 +554,7 @@ answer newbie questions, and generally made Django that much better:
     polpak@yahoo.com
     pradeep.gowda@gmail.com
     Preston Holmes <preston@ptone.com>
+    Preston Timmons <prestontimmons@gmail.com>
     Rachel Willmer <http://www.willmer.com/kb/>
     Radek Švarz <http://www.svarz.cz/translate/>
     Rajesh Dhawan <rajesh.dhawan@gmail.com>

tests/template_tests/filters.py

@@ -11,24 +11,12 @@ from __future__ import unicode_literals
 from datetime import date, datetime, time, timedelta
 
 from django.test.utils import str_prefix, TZ_SUPPORT
-from django.utils.encoding import python_2_unicode_compatible
 from django.utils.safestring import mark_safe
 from django.utils import timezone
 
-# These two classes are used to test auto-escaping of __unicode__ output.
+from .syntax_tests.utils import SafeClass, UnsafeClass
 
 
-@python_2_unicode_compatible
-class UnsafeClass:
-    def __str__(self):
-        return 'you & me'
-
-
-@python_2_unicode_compatible
-class SafeClass:
-    def __str__(self):
-        return mark_safe('you > me')
-
 # RESULT SYNTAX --
 # 'template_name': ('template contents', 'context dict',
 #                   'expected string output' or Exception class)

tests/template_tests/syntax_tests/test_autoescape.py

+from django.template.base import TemplateSyntaxError
+from django.test import TestCase
+from django.utils.safestring import mark_safe
+
+from .utils import render, setup, SafeClass, UnsafeClass
+
+
+class AutoescapeTagTests(TestCase):
+
+    @setup({'autoescape-tag01': '{% autoescape off %}hello{% endautoescape %}'})
+    def test_autoescape_tag01(self):
+        output = render('autoescape-tag01')
+        self.assertEqual(output, 'hello')
+
+    @setup({'autoescape-tag02': '{% autoescape off %}{{ first }}{% endautoescape %}'})
+    def test_autoescape_tag02(self):
+        output = render('autoescape-tag02', {'first': '<b>hello</b>'})
+        self.assertEqual(output, '<b>hello</b>')
+
+    @setup({'autoescape-tag03': '{% autoescape on %}{{ first }}{% endautoescape %}'})
+    def test_autoescape_tag03(self):
+        output = render('autoescape-tag03', {'first': '<b>hello</b>'})
+        self.assertEqual(output, '&lt;b&gt;hello&lt;/b&gt;')
+
+    # Autoescape disabling and enabling nest in a predictable way.
+    @setup({'autoescape-tag04': '{% autoescape off %}'
+        '{{ first }} {% autoescape on %}{{ first }}{% endautoescape %}{% endautoescape %}'})
+    def test_autoescape_tag04(self):
+        output = render('autoescape-tag04', {'first': '<a>'})
+        self.assertEqual(output, '<a> &lt;a&gt;')
+
+    @setup({'autoescape-tag05': '{% autoescape on %}{{ first }}{% endautoescape %}'})
+    def test_autoescape_tag05(self):
+        output = render('autoescape-tag05', {'first': '<b>first</b>'})
+        self.assertEqual(output, '&lt;b&gt;first&lt;/b&gt;')
+
+    # Strings (ASCII or unicode) already marked as "safe" are not
+    # auto-escaped
+    @setup({'autoescape-tag06': '{{ first }}'})
+    def test_autoescape_tag06(self):
+        output = render('autoescape-tag06', {'first': mark_safe('<b>first</b>')})
+        self.assertEqual(output, '<b>first</b>')
+
+    @setup({'autoescape-tag07': '{% autoescape on %}{{ first }}{% endautoescape %}'})
+    def test_autoescape_tag07(self):
+        output = render('autoescape-tag07', {'first': mark_safe('<b>Apple</b>')})
+        self.assertEqual(output, '<b>Apple</b>')
+
+    @setup({'autoescape-tag08': r'{% autoescape on %}'
+        r'{{ var|default_if_none:" endquote\" hah" }}{% endautoescape %}'})
+    def test_autoescape_tag08(self):
+        """
+        Literal string arguments to filters, if used in the result, are safe.
+        """
+        output = render('autoescape-tag08', {"var": None})
+        self.assertEqual(output, ' endquote" hah')
+
+    # Objects which return safe strings as their __str__ method
+    # won't get double-escaped.
+    @setup({'autoescape-tag09': r'{{ unsafe }}'})
+    def test_autoescape_tag09(self):
+        output = render('autoescape-tag09', {'unsafe': UnsafeClass()})
+        self.assertEqual(output, 'you &amp; me')
+
+    @setup({'autoescape-tag10': r'{{ safe }}'})
+    def test_autoescape_tag10(self):
+        output = render('autoescape-tag10', {'safe': SafeClass()})
+        self.assertEqual(output, 'you &gt; me')
+
+    @setup({'autoescape-filtertag01': '{{ first }}{% filter safe %}{{ first }} x<y{% endfilter %}'})
+    def test_autoescape_filtertag01(self):
+        """
+        The "safe" and "escape" filters cannot work due to internal
+        implementation details (fortunately, the (no)autoescape block
+        tags can be used in those cases)
+        """
+        with self.assertRaises(TemplateSyntaxError):
+            render('autoescape-filtertag01', {'first': '<a>'})
+
+    @setup({'autoescape-ifequal01': '{% ifequal var "this & that" %}yes{% endifequal %}'})
+    def test_autoescape_ifequal01(self):
+        """
+        ifequal compares unescaped vales.
+        """
+        output = render('autoescape-ifequal01', {'var': 'this & that'})
+        self.assertEqual(output, 'yes')
+
+    # Arguments to filters are 'safe' and manipulate their input unescaped.
+    @setup({'autoescape-filters01': '{{ var|cut:"&" }}'})
+    def test_autoescape_filters01(self):
+        output = render('autoescape-filters01', {'var': 'this & that'})
+        self.assertEqual(output, 'this  that')
+
+    @setup({'autoescape-filters02': '{{ var|join:" & " }}'})
+    def test_autoescape_filters02(self):
+        output = render('autoescape-filters02', {'var': ('Tom', 'Dick', 'Harry')})
+        self.assertEqual(output, 'Tom & Dick & Harry')
+
+    @setup({'autoescape-literals01': '{{ "this & that" }}'})
+    def test_autoescape_literals01(self):
+        """
+        Literal strings are safe.
+        """
+        output = render('autoescape-literals01')
+        self.assertEqual(output, 'this & that')
+
+    @setup({'autoescape-stringiterations01': '{% for l in var %}{{ l }},{% endfor %}'})
+    def test_autoescape_stringiterations01(self):
+        """
+        Iterating over strings outputs safe characters.
+        """
+        output = render('autoescape-stringiterations01', {'var': 'K&R'})
+        self.assertEqual(output, 'K,&amp;,R,')
+
+    @setup({'autoescape-lookup01': '{{ var.key }}'})
+    def test_autoescape_lookup01(self):
+        """
+        Escape requirement survives lookup.
+        """
+        output = render('autoescape-lookup01', {'var': {'key': 'this & that'}})
+        self.assertEqual(output, 'this &amp; that')

tests/template_tests/syntax_tests/test_builtins.py

+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class BuiltinsTests(TestCase):
+
+    @setup({'builtins01': '{{ True }}'})
+    def test_builtins01(self):
+        self.assertEqual(render('builtins01'), 'True')
+
+    @setup({'builtins02': '{{ False }}'})
+    def test_builtins02(self):
+        self.assertEqual(render('builtins02'), 'False')
+
+    @setup({'builtins03': '{{ None }}'})
+    def test_builtins03(self):
+        self.assertEqual(render('builtins03'), 'None')

tests/template_tests/syntax_tests/test_cache.py

+from django.core.cache import cache
+from django.template.base import TemplateSyntaxError
+from django.template.loader import get_template
+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class CacheTagTests(TestCase):
+
+    def tearDown(self):
+        cache.clear()
+
+    @setup({'cache03': '{% load cache %}{% cache 2 test %}cache03{% endcache %}'})
+    def test_cache03(self):
+        output = render('cache03')
+        self.assertEqual(output, 'cache03')
+
+    @setup({
+        'cache03': '{% load cache %}{% cache 2 test %}cache03{% endcache %}',
+        'cache04': '{% load cache %}{% cache 2 test %}cache04{% endcache %}',
+    })
+    def test_cache04(self):
+        render('cache03')
+        output = render('cache04')
+        self.assertEqual(output, 'cache03')
+
+    @setup({'cache05': '{% load cache %}{% cache 2 test foo %}cache05{% endcache %}'})
+    def test_cache05(self):
+        output = render('cache05', {'foo': 1})
+        self.assertEqual(output, 'cache05')
+
+    @setup({'cache06': '{% load cache %}{% cache 2 test foo %}cache06{% endcache %}'})
+    def test_cache06(self):
+        output = render('cache06', {'foo': 2})
+        self.assertEqual(output, 'cache06')
+
+    @setup({
+        'cache05': '{% load cache %}{% cache 2 test foo %}cache05{% endcache %}',
+        'cache07': '{% load cache %}{% cache 2 test foo %}cache07{% endcache %}',
+    })
+    def test_cache07(self):
+        context = {'foo': 1}
+        render('cache05', context)
+        output = render('cache07', context)
+        self.assertEqual(output, 'cache05')
+
+    @setup({
+        'cache06': '{% load cache %}{% cache 2 test foo %}cache06{% endcache %}',
+        'cache08': '{% load cache %}{% cache time test foo %}cache08{% endcache %}',
+    })
+    def test_cache08(self):
+        """
+        Allow first argument to be a variable.
+        """
+        context = {'foo': 2, 'time': 2}
+        render('cache06', context)
+        output = render('cache08', context)
+        self.assertEqual(output, 'cache06')
+
+    # Raise exception if we don't have at least 2 args, first one integer.
+    @setup({'cache11': '{% load cache %}{% cache %}{% endcache %}'})
+    def test_cache11(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('cache11')
+
+    @setup({'cache12': '{% load cache %}{% cache 1 %}{% endcache %}'})
+    def test_cache12(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('cache12')
+
+    @setup({'cache13': '{% load cache %}{% cache foo bar %}{% endcache %}'})
+    def test_cache13(self):
+        with self.assertRaises(TemplateSyntaxError):
+            render('cache13')
+
+    @setup({'cache14': '{% load cache %}{% cache foo bar %}{% endcache %}'})
+    def test_cache14(self):
+        with self.assertRaises(TemplateSyntaxError):
+            render('cache14', {'foo': 'fail'})
+
+    @setup({'cache15': '{% load cache %}{% cache foo bar %}{% endcache %}'})
+    def test_cache15(self):
+        with self.assertRaises(TemplateSyntaxError):
+            render('cache15', {'foo': []})
+
+    @setup({'cache16': '{% load cache %}{% cache 1 foo bar %}{% endcache %}'})
+    def test_cache16(self):
+        """
+        Regression test for #7460.
+        """
+        output = render('cache16', {'foo': 'foo', 'bar': 'with spaces'})
+        self.assertEqual(output, '')
+
+    @setup({'cache17': '{% load cache %}{% cache 10 long_cache_key poem %}Some Content{% endcache %}'})
+    def test_cache17(self):
+        """
+        Regression test for #11270.
+        """
+        output = render('cache17', {'poem': 'Oh freddled gruntbuggly/'
+                                            'Thy micturations are to me/'
+                                            'As plurdled gabbleblotchits/'
+                                            'On a lurgid bee/'
+                                            'That mordiously hath bitled out/'
+                                            'Its earted jurtles/'
+                                            'Into a rancid festering/'
+                                            'Or else I shall rend thee in the gobberwarts'
+                                            'with my blurglecruncheon/'
+                                            'See if I dont.'})
+        self.assertEqual(output, 'Some Content')
+
+    @setup({'cache18': '{% load cache custom %}{% cache 2|noop:"x y" cache18 %}cache18{% endcache %}'})
+    def test_cache18(self):
+        """
+        Test whitespace in filter arguments
+        """
+        output = render('cache18')
+        self.assertEqual(output, 'cache18')

tests/template_tests/syntax_tests/test_comment.py

+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class CommentSyntaxTests(TestCase):
+
+    @setup({'comment-syntax01': '{# this is hidden #}hello'})
+    def test_comment_syntax01(self):
+        output = render('comment-syntax01')
+        self.assertEqual(output, 'hello')
+
+    @setup({'comment-syntax02': '{# this is hidden #}hello{# foo #}'})
+    def test_comment_syntax02(self):
+        output = render('comment-syntax02')
+        self.assertEqual(output, 'hello')
+
+    @setup({'comment-syntax03': 'foo{#  {% if %}  #}'})
+    def test_comment_syntax03(self):
+        output = render('comment-syntax03')
+        self.assertEqual(output, 'foo')
+
+    @setup({'comment-syntax04': 'foo{#  {% endblock %}  #}'})
+    def test_comment_syntax04(self):
+        output = render('comment-syntax04')
+        self.assertEqual(output, 'foo')
+
+    @setup({'comment-syntax05': 'foo{#  {% somerandomtag %}  #}'})
+    def test_comment_syntax05(self):
+        output = render('comment-syntax05')
+        self.assertEqual(output, 'foo')
+
+    @setup({'comment-syntax06': 'foo{# {% #}'})
+    def test_comment_syntax06(self):
+        output = render('comment-syntax06')
+        self.assertEqual(output, 'foo')
+
+    @setup({'comment-syntax07': 'foo{# %} #}'})
+    def test_comment_syntax07(self):
+        output = render('comment-syntax07')
+        self.assertEqual(output, 'foo')
+
+    @setup({'comment-syntax08': 'foo{# %} #}bar'})
+    def test_comment_syntax08(self):
+        output = render('comment-syntax08')
+        self.assertEqual(output, 'foobar')
+
+    @setup({'comment-syntax09': 'foo{# {{ #}'})
+    def test_comment_syntax09(self):
+        output = render('comment-syntax09')
+        self.assertEqual(output, 'foo')
+
+    @setup({'comment-syntax10': 'foo{# }} #}'})
+    def test_comment_syntax10(self):
+        output = render('comment-syntax10')
+        self.assertEqual(output, 'foo')
+
+    @setup({'comment-syntax11': 'foo{# { #}'})
+    def test_comment_syntax11(self):
+        output = render('comment-syntax11')
+        self.assertEqual(output, 'foo')
+
+    @setup({'comment-syntax12': 'foo{# } #}'})
+    def test_comment_syntax12(self):
+        output = render('comment-syntax12')
+        self.assertEqual(output, 'foo')
+
+    @setup({'comment-tag01': '{% comment %}this is hidden{% endcomment %}hello'})
+    def test_comment_tag01(self):
+        output = render('comment-tag01')
+        self.assertEqual(output, 'hello')
+
+    @setup({'comment-tag02': '{% comment %}this is hidden{% endcomment %}'
+                             'hello{% comment %}foo{% endcomment %}'})
+    def test_comment_tag02(self):
+        output = render('comment-tag02')
+        self.assertEqual(output, 'hello')
+
+    @setup({'comment-tag03': 'foo{% comment %} {% if %} {% endcomment %}'})
+    def test_comment_tag03(self):
+        output = render('comment-tag03')
+        self.assertEqual(output, 'foo')
+
+    @setup({'comment-tag04': 'foo{% comment %} {% endblock %} {% endcomment %}'})
+    def test_comment_tag04(self):
+        output = render('comment-tag04')
+        self.assertEqual(output, 'foo')
+
+    @setup({'comment-tag05': 'foo{% comment %} {% somerandomtag %} {% endcomment %}'})
+    def test_comment_tag05(self):
+        output = render('comment-tag05')
+        self.assertEqual(output, 'foo')

tests/template_tests/syntax_tests/test_cycle.py

+import warnings
+
+from django.template.base import TemplateSyntaxError
+from django.template.loader import get_template
+from django.test import TestCase
+from django.utils.deprecation import RemovedInDjango20Warning
+
+from .utils import render, setup
+
+
+class CycleTagTests(TestCase):
+
+    @setup({'cycle01': '{% cycle a %}'})
+    def test_cycle01(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('cycle01')
+
+    @setup({'cycle02': '{% cycle a,b,c as abc %}{% cycle abc %}'})
+    def test_cycle02(self):
+        output = render('cycle02')
+        self.assertEqual(output, 'ab')
+
+    @setup({'cycle03': '{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}'})
+    def test_cycle03(self):
+        output = render('cycle03')
+        self.assertEqual(output, 'abc')
+
+    @setup({'cycle04': '{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}'})
+    def test_cycle04(self):
+        output = render('cycle04')
+        self.assertEqual(output, 'abca')
+
+    @setup({'cycle05': '{% cycle %}'})
+    def test_cycle05(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('cycle05')
+
+    @setup({'cycle06': '{% cycle a %}'})
+    def test_cycle06(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('cycle06')
+
+    @setup({'cycle07': '{% cycle a,b,c as foo %}{% cycle bar %}'})
+    def test_cycle07(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('cycle07')
+
+    @setup({'cycle08': '{% cycle a,b,c as foo %}{% cycle foo %}{{ foo }}{{ foo }}{% cycle foo %}{{ foo }}'})
+    def test_cycle08(self):
+        output = render('cycle08')
+        self.assertEqual(output, 'abbbcc')
+
+    @setup({'cycle09': '{% for i in test %}{% cycle a,b %}{{ i }},{% endfor %}'})
+    def test_cycle09(self):
+        output = render('cycle09', {'test': list(range(5))})
+        self.assertEqual(output, 'a0,b1,a2,b3,a4,')
+
+    @setup({'cycle10': "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}"})
+    def test_cycle10(self):
+        output = render('cycle10')
+        self.assertEqual(output, 'ab')
+
+    @setup({'cycle11': "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}"})
+    def test_cycle11(self):
+        output = render('cycle11')
+        self.assertEqual(output, 'abc')
+
+    @setup({'cycle12': "{% cycle 'a' 'b' 'c' as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"})
+    def test_cycle12(self):
+        output = render('cycle12')
+        self.assertEqual(output, 'abca')
+
+    @setup({'cycle13': "{% for i in test %}{% cycle 'a' 'b' %}{{ i }},{% endfor %}"})
+    def test_cycle13(self):
+        output = render('cycle13', {'test': list(range(5))})
+        self.assertEqual(output, 'a0,b1,a2,b3,a4,')
+
+    @setup({'cycle14': '{% cycle one two as foo %}{% cycle foo %}'})
+    def test_cycle14(self):
+        output = render('cycle14', {'one': '1', 'two': '2'})
+        self.assertEqual(output, '12')
+
+    @setup({'cycle15': '{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}'})
+    def test_cycle15(self):
+        output = render('cycle15', {'test': list(range(5)), 'aye': 'a', 'bee': 'b'})
+        self.assertEqual(output, 'a0,b1,a2,b3,a4,')
+
+    @setup({'cycle16': '{% cycle one|lower two as foo %}{% cycle foo %}'})
+    def test_cycle16(self):
+        output = render('cycle16', {'one': 'A', 'two': '2'})
+        self.assertEqual(output, 'a2')
+
+    @setup({'cycle17': "{% cycle 'a' 'b' 'c' as abc silent %}"
+                       "{% cycle abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}"})
+    def test_cycle17(self):
+        output = render('cycle17')
+        self.assertEqual(output, '')
+
+    @setup({'cycle18': "{% cycle 'a' 'b' 'c' as foo invalid_flag %}"})
+    def test_cycle18(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('cycle18')
+
+    @setup({'cycle19': "{% cycle 'a' 'b' as silent %}{% cycle silent %}"})
+    def test_cycle19(self):
+        output = render('cycle19')
+        self.assertEqual(output, 'ab')
+
+    @setup({'cycle20': '{% cycle one two as foo %} & {% cycle foo %}'})
+    def test_cycle20(self):
+        output = render('cycle20', {'two': 'C & D', 'one': 'A & B'})
+        self.assertEqual(output, 'A & B & C & D')
+
+    @setup({'cycle21': '{% filter force_escape %}'
+                       '{% cycle one two as foo %} & {% cycle foo %}{% endfilter %}'})
+    def test_cycle21(self):
+        output = render('cycle21', {'two': 'C & D', 'one': 'A & B'})
+        self.assertEqual(output, 'A & B & C & D')
+
+    @setup({'cycle22': "{% for x in values %}{% cycle 'a' 'b' 'c' as abc silent %}{{ x }}{% endfor %}"})
+    def test_cycle22(self):
+        output = render('cycle22', {'values': [1, 2, 3, 4]})
+        self.assertEqual(output, '1234')
+
+    @setup({'cycle23': "{% for x in values %}"
+                       "{% cycle 'a' 'b' 'c' as abc silent %}{{ abc }}{{ x }}{% endfor %}"})
+    def test_cycle23(self):
+        output = render('cycle23', {'values': [1, 2, 3, 4]})
+        self.assertEqual(output, 'a1b2c3a4')
+
+    @setup({
+        'cycle24': "{% for x in values %}"
+                   "{% cycle 'a' 'b' 'c' as abc silent %}{% include 'included-cycle' %}{% endfor %}",
+        'included-cycle': '{{ abc }}',
+    })
+    def test_cycle24(self):
+        output = render('cycle24', {'values': [1, 2, 3, 4]})
+        self.assertEqual(output, 'abca')
+
+    @setup({'cycle25': '{% cycle a as abc %}'})
+    def test_cycle25(self):
+        output = render('cycle25', {'a': '<'})
+        self.assertEqual(output, '&lt;')
+
+    @setup({'cycle26': '{% load cycle from future %}{% cycle a b as ab %}{% cycle ab %}'})
+    def test_cycle26(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RemovedInDjango20Warning)
+            output = render('cycle26', {'a': '<', 'b': '>'})
+        self.assertEqual(output, '&lt;&gt;')
+
+    @setup({'cycle27': '{% load cycle from future %}'
+                       '{% autoescape off %}{% cycle a b as ab %}{% cycle ab %}{% endautoescape %}'})
+    def test_cycle27(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RemovedInDjango20Warning)
+            output = render('cycle27', {'a': '<', 'b': '>'})
+        self.assertEqual(output, '<>')
+
+    @setup({'cycle28': '{% load cycle from future %}{% cycle a|safe b as ab %}{% cycle ab %}'})
+    def test_cycle28(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RemovedInDjango20Warning)
+            output = render('cycle28', {'a': '<', 'b': '>'})
+        self.assertEqual(output, '<&gt;')

tests/template_tests/syntax_tests/test_exceptions.py

+from django.conf import settings
+from django.template.base import TemplateDoesNotExist, TemplateSyntaxError
+from django.template.loader import get_template
+from django.test import TestCase
+
+from .test_extends import inheritance_templates
+from .utils import render, setup
+
+
+class ExceptionsTests(TestCase):
+
+    @setup({'exception01': "{% extends 'nonexistent' %}"})
+    def test_exception01(self):
+        """
+        Raise exception for invalid template name
+        """
+        with self.assertRaises(TemplateDoesNotExist):
+            render('exception01')
+
+    @setup({'exception02': '{% extends nonexistent %}'})
+    def test_exception02(self):
+        """
+        Raise exception for invalid variable template name
+        """
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            with self.assertRaises(TemplateDoesNotExist):
+                render('exception02')
+        else:
+            with self.assertRaises(TemplateSyntaxError):
+                render('exception02')
+
+    @setup(
+        {'exception03': "{% extends 'inheritance01' %}"
+                        "{% block first %}2{% endblock %}{% extends 'inheritance16' %}"},
+        inheritance_templates,
+    )
+    def test_exception03(self):
+        """
+        Raise exception for extra {% extends %} tags
+        """
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('exception03')
+
+    @setup(
+        {'exception04': "{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}"},
+        inheritance_templates,
+    )
+    def test_exception04(self):
+        """
+        Raise exception for custom tags used in child with {% load %} tag in parent, not in child
+        """
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('exception04')
+
+    @setup({'exception05': '{% block first %}{{ block.super }}{% endblock %}'})
+    def test_exception05(self):
+        """
+        Raise exception for block.super used in base template
+        """
+        with self.assertRaises(TemplateSyntaxError):
+            render('exception05')

tests/template_tests/syntax_tests/test_filter_syntax.py

+# coding: utf-8
+from __future__ import unicode_literals
+import warnings
+
+from django.conf import settings
+from django.template.base import TemplateSyntaxError
+from django.template.loader import get_template
+from django.test import TestCase
+from django.utils.deprecation import RemovedInDjango20Warning
+
+from .utils import render, setup, SomeClass, SomeOtherException, UTF8Class
+
+
+class FilterSyntaxTests(TestCase):
+
+    @setup({'filter-syntax01': '{{ var|upper }}'})
+    def test_filter_syntax01(self):
+        """
+        Basic filter usage
+        """
+        output = render('filter-syntax01', {"var": "Django is the greatest!"})
+        self.assertEqual(output, "DJANGO IS THE GREATEST!")
+
+    @setup({'filter-syntax02': '{{ var|upper|lower }}'})
+    def test_filter_syntax02(self):
+        """
+        Chained filters
+        """
+        output = render('filter-syntax02', {"var": "Django is the greatest!"})
+        self.assertEqual(output, "django is the greatest!")
+
+    @setup({'filter-syntax03': '{{ var |upper }}'})
+    def test_filter_syntax03(self):
+        """
+        Allow spaces before the filter pipe
+        """
+        output = render('filter-syntax03', {'var': 'Django is the greatest!'})
+        self.assertEqual(output, 'DJANGO IS THE GREATEST!')
+
+    @setup({'filter-syntax04': '{{ var| upper }}'})
+    def test_filter_syntax04(self):
+        """
+        Allow spaces after the filter pipe
+        """
+        output = render('filter-syntax04', {'var': 'Django is the greatest!'})
+        self.assertEqual(output, 'DJANGO IS THE GREATEST!')
+
+    @setup({'filter-syntax05': '{{ var|does_not_exist }}'})
+    def test_filter_syntax05(self):
+        """
+        Raise TemplateSyntaxError for a nonexistent filter
+        """
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('filter-syntax05')
+
+    @setup({'filter-syntax06': '{{ var|fil(ter) }}'})
+    def test_filter_syntax06(self):
+        """
+        Raise TemplateSyntaxError when trying to access a filter containing
+        an illegal character
+        """
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('filter-syntax06')
+
+    @setup({'filter-syntax07': "{% nothing_to_see_here %}"})
+    def test_filter_syntax07(self):
+        """
+        Raise TemplateSyntaxError for invalid block tags
+        """
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('filter-syntax07')
+
+    @setup({'filter-syntax08': "{% %}"})
+    def test_filter_syntax08(self):
+        """
+        Raise TemplateSyntaxError for empty block tags
+        """
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('filter-syntax08')
+
+    @setup({'filter-syntax09': '{{ var|removetags:"b i"|upper|lower }}'})
+    def test_filter_syntax09(self):
+        """
+        Chained filters, with an argument to the first one
+        """
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RemovedInDjango20Warning)
+            output = render('filter-syntax09', {'var': '<b><i>Yes</i></b>'})
+        self.assertEqual(output, 'yes')
+
+    @setup({'filter-syntax10': r'{{ var|default_if_none:" endquote\" hah" }}'})
+    def test_filter_syntax10(self):
+        """
+        Literal string as argument is always "safe" from auto-escaping.
+        """
+        output = render('filter-syntax10', {"var": None})
+        self.assertEqual(output, ' endquote" hah')
+
+    @setup({'filter-syntax11': r'{{ var|default_if_none:var2 }}'})
+    def test_filter_syntax11(self):
+        """
+        Variable as argument
+        """
+        output = render('filter-syntax11', {"var": None, "var2": "happy"})
+        self.assertEqual(output, 'happy')
+
+    @setup({'filter-syntax12': r'{{ var|yesno:"yup,nup,mup" }} {{ var|yesno }}'})
+    def test_filter_syntax12(self):
+        """
+        Default argument testing
+        """
+        output = render('filter-syntax12', {"var": True})
+        self.assertEqual(output, 'yup yes')
+
+    @setup({'filter-syntax13': r'1{{ var.method3 }}2'})
+    def test_filter_syntax13(self):
+        """
+        Fail silently for methods that raise an exception with a
+        `silent_variable_failure` attribute
+        """
+        output = render('filter-syntax13', {"var": SomeClass()})
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, "1INVALID2")
+        else:
+            self.assertEqual(output, "12")
+
+    @setup({'filter-syntax14': r'1{{ var.method4 }}2'})
+    def test_filter_syntax14(self):
+        """
+        In methods that raise an exception without a
+        `silent_variable_attribute` set to True, the exception propagates
+        """
+        with self.assertRaises(SomeOtherException):
+            render('filter-syntax14', {"var": SomeClass()})
+
+    @setup({'filter-syntax15': r'{{ var|default_if_none:"foo\bar" }}'})
+    def test_filter_syntax15(self):
+        """
+        Escaped backslash in argument
+        """
+        output = render('filter-syntax15', {"var": None})
+        self.assertEqual(output, r'foo\bar')
+
+    @setup({'filter-syntax16': r'{{ var|default_if_none:"foo\now" }}'})
+    def test_filter_syntax16(self):
+        """
+        Escaped backslash using known escape char
+        """
+        output = render('filter-syntax16', {"var": None})
+        self.assertEqual(output, r'foo\now')
+
+    @setup({'filter-syntax17': r'{{ var|join:"" }}'})
+    def test_filter_syntax17(self):
+        """
+        Empty strings can be passed as arguments to filters
+        """
+        output = render('filter-syntax17', {'var': ['a', 'b', 'c']})
+        self.assertEqual(output, 'abc')
+
+    @setup({'filter-syntax18': r'{{ var }}'})
+    def test_filter_syntax18(self):
+        """
+        Make sure that any unicode strings are converted to bytestrings
+        in the final output.
+        """
+        output = render('filter-syntax18', {'var': UTF8Class()})
+        self.assertEqual(output, '\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111')
+
+    @setup({'filter-syntax19': '{{ var|truncatewords:1 }}'})
+    def test_filter_syntax19(self):
+        """
+        Numbers as filter arguments should work
+        """
+        output = render('filter-syntax19', {"var": "hello world"})
+        self.assertEqual(output, "hello ...")
+
+    @setup({'filter-syntax20': '{{ ""|default_if_none:"was none" }}'})
+    def test_filter_syntax20(self):
+        """
+        Filters should accept empty string constants
+        """
+        output = render('filter-syntax20')
+        self.assertEqual(output, "")
+
+    @setup({'filter-syntax21': r'1{{ var.silent_fail_key }}2'})
+    def test_filter_syntax21(self):
+        """
+        Fail silently for non-callable attribute and dict lookups which
+        raise an exception with a "silent_variable_failure" attribute
+        """
+        output = render('filter-syntax21', {"var": SomeClass()})
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, "1INVALID2")
+        else:
+            self.assertEqual(output, "12")
+
+    @setup({'filter-syntax22': r'1{{ var.silent_fail_attribute }}2'})
+    def test_filter_syntax22(self):
+        """
+        Fail silently for non-callable attribute and dict lookups which
+        raise an exception with a `silent_variable_failure` attribute
+        """
+        output = render('filter-syntax22', {"var": SomeClass()})
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, "1INVALID2")
+        else:
+            self.assertEqual(output, "12")
+
+    @setup({'filter-syntax23': r'1{{ var.noisy_fail_key }}2'})
+    def test_filter_syntax23(self):
+        """
+        In attribute and dict lookups that raise an unexpected exception
+        without a `silent_variable_attribute` set to True, the exception
+        propagates
+        """
+        with self.assertRaises(SomeOtherException):
+            render('filter-syntax23', {"var": SomeClass()})
+
+    @setup({'filter-syntax24': r'1{{ var.noisy_fail_attribute }}2'})
+    def test_filter_syntax24(self):
+        """
+        In attribute and dict lookups that raise an unexpected exception
+        without a `silent_variable_attribute` set to True, the exception
+        propagates
+        """
+        with self.assertRaises(SomeOtherException):
+            render('filter-syntax24', {"var": SomeClass()})
+
+    @setup({'filter-syntax25': '{{ var.attribute_error_attribute }}'})
+    def test_filter_syntax25(self):
+        """
+        #16383 - Attribute errors from an @property value should be
+        reraised.
+        """
+        with self.assertRaises(AttributeError):
+            render('filter-syntax25', {'var': SomeClass()})

tests/template_tests/syntax_tests/test_filter_tag.py

+from django.template.base import TemplateSyntaxError
+from django.template.loader import get_template
+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class FilterTagTests(TestCase):
+
+    @setup({'filter01': '{% filter upper %}{% endfilter %}'})
+    def test_filter01(self):
+        output = render('filter01')
+        self.assertEqual(output, '')
+
+    @setup({'filter02': '{% filter upper %}django{% endfilter %}'})
+    def test_filter02(self):
+        output = render('filter02')
+        self.assertEqual(output, 'DJANGO')
+
+    @setup({'filter03': '{% filter upper|lower %}django{% endfilter %}'})
+    def test_filter03(self):
+        output = render('filter03')
+        self.assertEqual(output, 'django')
+
+    @setup({'filter04': '{% filter cut:remove %}djangospam{% endfilter %}'})
+    def test_filter04(self):
+        output = render('filter04', {'remove': 'spam'})
+        self.assertEqual(output, 'django')
+
+    @setup({'filter05': '{% filter safe %}fail{% endfilter %}'})
+    def test_filter05(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('filter05')
+
+    @setup({'filter05bis': '{% filter upper|safe %}fail{% endfilter %}'})
+    def test_filter05bis(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('filter05bis')
+
+    @setup({'filter06': '{% filter escape %}fail{% endfilter %}'})
+    def test_filter06(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('filter06')
+
+    @setup({'filter06bis': '{% filter upper|escape %}fail{% endfilter %}'})
+    def test_filter06bis(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('filter06bis')

tests/template_tests/syntax_tests/test_firstof.py

+import warnings
+
+from django.template.base import TemplateSyntaxError
+from django.template.loader import get_template
+from django.test import TestCase
+from django.utils.deprecation import RemovedInDjango20Warning
+
+from .utils import render, setup
+
+
+class FirstOfTagTests(TestCase):
+
+    @setup({'firstof01': '{% firstof a b c %}'})
+    def test_firstof01(self):
+        output = render('firstof01', {'a': 0, 'c': 0, 'b': 0})
+        self.assertEqual(output, '')
+
+    @setup({'firstof02': '{% firstof a b c %}'})
+    def test_firstof02(self):
+        output = render('firstof02', {'a': 1, 'c': 0, 'b': 0})
+        self.assertEqual(output, '1')
+
+    @setup({'firstof03': '{% firstof a b c %}'})
+    def test_firstof03(self):
+        output = render('firstof03', {'a': 0, 'c': 0, 'b': 2})
+        self.assertEqual(output, '2')
+
+    @setup({'firstof04': '{% firstof a b c %}'})
+    def test_firstof04(self):
+        output = render('firstof04', {'a': 0, 'c': 3, 'b': 0})
+        self.assertEqual(output, '3')
+
+    @setup({'firstof05': '{% firstof a b c %}'})
+    def test_firstof05(self):
+        output = render('firstof05', {'a': 1, 'c': 3, 'b': 2})
+        self.assertEqual(output, '1')
+
+    @setup({'firstof06': '{% firstof a b c %}'})
+    def test_firstof06(self):
+        output = render('firstof06', {'c': 3, 'b': 0})
+        self.assertEqual(output, '3')
+
+    @setup({'firstof07': '{% firstof a b "c" %}'})
+    def test_firstof07(self):
+        output = render('firstof07', {'a': 0})
+        self.assertEqual(output, 'c')
+
+    @setup({'firstof08': '{% firstof a b "c and d" %}'})
+    def test_firstof08(self):
+        output = render('firstof08', {'a': 0, 'b': 0})
+        self.assertEqual(output, 'c and d')
+
+    @setup({'firstof09': '{% firstof %}'})
+    def test_firstof09(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('firstof09')
+
+    @setup({'firstof10': '{% firstof a %}'})
+    def test_firstof10(self):
+        output = render('firstof10', {'a': '<'})
+        self.assertEqual(output, '&lt;')
+
+    @setup({'firstof11': '{% load firstof from future %}{% firstof a b %}'})
+    def test_firstof11(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RemovedInDjango20Warning)
+            output = render('firstof11', {'a': '<', 'b': '>'})
+        self.assertEqual(output, '&lt;')
+
+    @setup({'firstof12': '{% load firstof from future %}{% firstof a b %}'})
+    def test_firstof12(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RemovedInDjango20Warning)
+            output = render('firstof12', {'a': '', 'b': '>'})
+        self.assertEqual(output, '&gt;')
+
+    @setup({'firstof13': '{% load firstof from future %}'
+                         '{% autoescape off %}{% firstof a %}{% endautoescape %}'})
+    def test_firstof13(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RemovedInDjango20Warning)
+            output = render('firstof13', {'a': '<'})
+        self.assertEqual(output, '<')
+
+    @setup({'firstof14': '{% load firstof from future %}{% firstof a|safe b %}'})
+    def test_firstof14(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RemovedInDjango20Warning)
+            output = render('firstof14', {'a': '<'})
+        self.assertEqual(output, '<')

tests/template_tests/syntax_tests/test_for.py

+import warnings
+
+from django.conf import settings
+from django.template.base import TemplateSyntaxError
+from django.test import TestCase
+from django.utils.deprecation import RemovedInDjango20Warning
+
+from .utils import render, setup
+
+
+class ForTagTests(TestCase):
+
+    @setup({'for-tag01': '{% for val in values %}{{ val }}{% endfor %}'})
+    def test_for_tag01(self):
+        output = render('for-tag01', {'values': [1, 2, 3]})
+        self.assertEqual(output, '123')
+
+    @setup({'for-tag02': '{% for val in values reversed %}{{ val }}{% endfor %}'})
+    def test_for_tag02(self):
+        output = render('for-tag02', {'values': [1, 2, 3]})
+        self.assertEqual(output, '321')
+
+    @setup({'for-tag-vars01': '{% for val in values %}{{ forloop.counter }}{% endfor %}'})
+    def test_for_tag_vars01(self):
+        output = render('for-tag-vars01', {'values': [6, 6, 6]})
+        self.assertEqual(output, '123')
+
+    @setup({'for-tag-vars02': '{% for val in values %}{{ forloop.counter0 }}{% endfor %}'})
+    def test_for_tag_vars02(self):
+        output = render('for-tag-vars02', {'values': [6, 6, 6]})
+        self.assertEqual(output, '012')
+
+    @setup({'for-tag-vars03': '{% for val in values %}{{ forloop.revcounter }}{% endfor %}'})
+    def test_for_tag_vars03(self):
+        output = render('for-tag-vars03', {'values': [6, 6, 6]})
+        self.assertEqual(output, '321')
+
+    @setup({'for-tag-vars04': '{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}'})
+    def test_for_tag_vars04(self):
+        output = render('for-tag-vars04', {'values': [6, 6, 6]})
+        self.assertEqual(output, '210')
+
+    @setup({'for-tag-vars05': '{% for val in values %}'
+                              '{% if forloop.first %}f{% else %}x{% endif %}{% endfor %}'})
+    def test_for_tag_vars05(self):
+        output = render('for-tag-vars05', {'values': [6, 6, 6]})
+        self.assertEqual(output, 'fxx')
+
+    @setup({'for-tag-vars06': '{% for val in values %}'
+                              '{% if forloop.last %}l{% else %}x{% endif %}{% endfor %}'})
+    def test_for_tag_vars06(self):
+        output = render('for-tag-vars06', {'values': [6, 6, 6]})
+        self.assertEqual(output, 'xxl')
+
+    @setup({'for-tag-unpack01': '{% for key,value in items %}{{ key }}:{{ value }}/{% endfor %}'})
+    def test_for_tag_unpack01(self):
+        output = render('for-tag-unpack01', {'items': (('one', 1), ('two', 2))})
+        self.assertEqual(output, 'one:1/two:2/')
+
+    @setup({'for-tag-unpack03': '{% for key, value in items %}{{ key }}:{{ value }}/{% endfor %}'})
+    def test_for_tag_unpack03(self):
+        output = render('for-tag-unpack03', {'items': (('one', 1), ('two', 2))})
+        self.assertEqual(output, 'one:1/two:2/')
+
+    @setup({'for-tag-unpack04': '{% for key , value in items %}{{ key }}:{{ value }}/{% endfor %}'})
+    def test_for_tag_unpack04(self):
+        output = render('for-tag-unpack04', {'items': (('one', 1), ('two', 2))})
+        self.assertEqual(output, 'one:1/two:2/')
+
+    @setup({'for-tag-unpack05': '{% for key ,value in items %}{{ key }}:{{ value }}/{% endfor %}'})
+    def test_for_tag_unpack05(self):
+        output = render('for-tag-unpack05', {'items': (('one', 1), ('two', 2))})
+        self.assertEqual(output, 'one:1/two:2/')
+
+    @setup({'for-tag-unpack06': '{% for key value in items %}{{ key }}:{{ value }}/{% endfor %}'})
+    def test_for_tag_unpack06(self):
+        with self.assertRaises(TemplateSyntaxError):
+            render('for-tag-unpack06', {'items': (('one', 1), ('two', 2))})
+
+    @setup({'for-tag-unpack07': '{% for key,,value in items %}{{ key }}:{{ value }}/{% endfor %}'})
+    def test_for_tag_unpack07(self):
+        with self.assertRaises(TemplateSyntaxError):
+            render('for-tag-unpack07', {'items': (('one', 1), ('two', 2))})
+
+    @setup({'for-tag-unpack08': '{% for key,value, in items %}{{ key }}:{{ value }}/{% endfor %}'})
+    def test_for_tag_unpack08(self):
+        with self.assertRaises(TemplateSyntaxError):
+            render('for-tag-unpack08', {'items': (('one', 1), ('two', 2))})
+
+    @setup({'for-tag-unpack09': '{% for val in items %}{{ val.0 }}:{{ val.1 }}/{% endfor %}'})
+    def test_for_tag_unpack09(self):
+        """
+        Ensure that a single loopvar doesn't truncate the list in val.
+        """
+        output = render('for-tag-unpack09', {'items': (('one', 1), ('two', 2))})
+        self.assertEqual(output, 'one:1/two:2/')
+
+    @setup({'for-tag-unpack13': '{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}'})
+    def test_for_tag_unpack13(self):
+        output = render('for-tag-unpack13', {'items': (('one', 1, 'carrot'), ('two', 2, 'cheese'))})
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'one:1,carrot/two:2,cheese/')
+        else:
+            self.assertEqual(output, 'one:1,carrot/two:2,cheese/')
+
+    @setup({'for-tag-empty01': '{% for val in values %}{{ val }}{% empty %}empty text{% endfor %}'})
+    def test_for_tag_empty01(self):
+        output = render('for-tag-empty01', {'values': [1, 2, 3]})
+        self.assertEqual(output, '123')
+
+    @setup({'for-tag-empty02': '{% for val in values %}{{ val }}{% empty %}values array empty{% endfor %}'})
+    def test_for_tag_empty02(self):
+        output = render('for-tag-empty02', {'values': []})
+        self.assertEqual(output, 'values array empty')
+
+    @setup({'for-tag-empty03': '{% for val in values %}'
+                               '{{ val }}{% empty %}values array not found{% endfor %}'})
+    def test_for_tag_empty03(self):
+        output = render('for-tag-empty03')
+        self.assertEqual(output, 'values array not found')
+
+    @setup({'for-tag-filter-ws': "{% load custom %}{% for x in s|noop:'x y' %}{{ x }}{% endfor %}"})
+    def test_for_tag_filter_ws(self):
+        """
+        #19882
+        """
+        output = render('for-tag-filter-ws', {'s': 'abc'})
+        self.assertEqual(output, 'abc')
+
+    # These tests raise deprecation warnings and will raise an exception
+    # in Django 2.0. The existing behavior is silent truncation if the
+    # length of loopvars differs to the length of each set of items.
+    @setup({'for-tag-unpack10': '{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}'})
+    def test_for_tag_unpack10(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RemovedInDjango20Warning)
+            output = render(
+                'for-tag-unpack10',
+                {'items': (('one', 1, 'carrot'), ('two', 2, 'orange'))},
+            )
+        self.assertEqual(output, 'one:1/two:2/')
+
+    @setup({'for-tag-unpack11': '{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}'})
+    def test_for_tag_unpack11(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RemovedInDjango20Warning)
+            output = render(
+                'for-tag-unpack11',
+                {'items': (('one', 1), ('two', 2))},
+            )
+
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'one:1,INVALID/two:2,INVALID/')
+        else:
+            self.assertEqual(output, 'one:1,/two:2,/')
+
+    @setup({'for-tag-unpack12': '{% for x,y,z in items %}{{ x }}:{{ y }},{{ z }}/{% endfor %}'})
+    def test_for_tag_unpack12(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RemovedInDjango20Warning)
+            output = render(
+                'for-tag-unpack12',
+                {'items': (('one', 1, 'carrot'), ('two', 2))}
+            )
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'one:1,carrot/two:2,INVALID/')
+        else:
+            self.assertEqual(output, 'one:1,carrot/two:2,/')
+
+    @setup({'for-tag-unpack14': '{% for x,y in items %}{{ x }}:{{ y }}/{% endfor %}'})
+    def test_for_tag_unpack14(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RemovedInDjango20Warning)
+            output = render('for-tag-unpack14', {'items': (1, 2)})
+
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'INVALID:INVALID/INVALID:INVALID/')
+        else:
+            self.assertEqual(output, ':/:/')

tests/template_tests/syntax_tests/test_if_changed.py

+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class IfChangedTagTests(TestCase):
+
+    @setup({'ifchanged01': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}'})
+    def test_ifchanged01(self):
+        output = render('ifchanged01', {'num': (1, 2, 3)})
+        self.assertEqual(output, '123')
+
+    @setup({'ifchanged02': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}'})
+    def test_ifchanged02(self):
+        output = render('ifchanged02', {'num': (1, 1, 3)})
+        self.assertEqual(output, '13')
+
+    @setup({'ifchanged03': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}'})
+    def test_ifchanged03(self):
+        output = render('ifchanged03', {'num': (1, 1, 1)})
+        self.assertEqual(output, '1')
+
+    @setup({'ifchanged04': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}'
+                           '{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}'
+                           '{% endfor %}{% endfor %}'})
+    def test_ifchanged04(self):
+        output = render('ifchanged04', {'num': (1, 2, 3), 'numx': (2, 2, 2)})
+        self.assertEqual(output, '122232')
+
+    @setup({'ifchanged05': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}'
+                           '{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}'
+                           '{% endfor %}{% endfor %}'})
+    def test_ifchanged05(self):
+        output = render('ifchanged05', {'num': (1, 1, 1), 'numx': (1, 2, 3)})
+        self.assertEqual(output, '1123123123')
+
+    @setup({'ifchanged06': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}'
+                           '{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}'
+                           '{% endfor %}{% endfor %}'})
+    def test_ifchanged06(self):
+        output = render('ifchanged06', {'num': (1, 1, 1), 'numx': (2, 2, 2)})
+        self.assertEqual(output, '1222')
+
+    @setup({'ifchanged07': '{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}'
+                           '{% for x in numx %}{% ifchanged %}{{ x }}{% endifchanged %}'
+                           '{% for y in numy %}{% ifchanged %}{{ y }}{% endifchanged %}'
+                           '{% endfor %}{% endfor %}{% endfor %}'})
+    def test_ifchanged07(self):
+        output = render('ifchanged07', {'num': (1, 1, 1), 'numx': (2, 2, 2), 'numy': (3, 3, 3)})
+        self.assertEqual(output, '1233323332333')
+
+    @setup({'ifchanged08': '{% for data in datalist %}{% for c,d in data %}'
+                           '{% if c %}{% ifchanged %}{{ d }}{% endifchanged %}'
+                           '{% endif %}{% endfor %}{% endfor %}'})
+    def test_ifchanged08(self):
+        output = render('ifchanged08', {'datalist': [
+            [(1, 'a'), (1, 'a'), (0, 'b'), (1, 'c')],
+            [(0, 'a'), (1, 'c'), (1, 'd'), (1, 'd'), (0, 'e')]
+        ]})
+        self.assertEqual(output, 'accd')
+
+    @setup({'ifchanged-param01': '{% for n in num %}{% ifchanged n %}..{% endifchanged %}'
+                                 '{{ n }}{% endfor %}'})
+    def test_ifchanged_param01(self):
+        """
+        Test one parameter given to ifchanged.
+        """
+        output = render('ifchanged-param01', {'num': (1, 2, 3)})
+        self.assertEqual(output, '..1..2..3')
+
+    @setup({'ifchanged-param02': '{% for n in num %}{% for x in numx %}{% ifchanged n %}..{% endifchanged %}'
+                                 '{{ x }}{% endfor %}{% endfor %}'})
+    def test_ifchanged_param02(self):
+        output = render('ifchanged-param02', {'num': (1, 2, 3), 'numx': (5, 6, 7)})
+        self.assertEqual(output, '..567..567..567')
+
+    @setup({'ifchanged-param03': '{% for n in num %}{{ n }}{% for x in numx %}'
+                                 '{% ifchanged x n %}{{ x }}{% endifchanged %}'
+                                 '{% endfor %}{% endfor %}'})
+    def test_ifchanged_param03(self):
+        """
+        Test multiple parameters to ifchanged.
+        """
+        output = render('ifchanged-param03', {'num': (1, 1, 2), 'numx': (5, 6, 6)})
+        self.assertEqual(output, '156156256')
+
+    @setup({'ifchanged-param04': '{% for d in days %}{% ifchanged %}{{ d.day }}{% endifchanged %}'
+                                 '{% for h in d.hours %}{% ifchanged d h %}{{ h }}{% endifchanged %}'
+                                 '{% endfor %}{% endfor %}'})
+    def test_ifchanged_param04(self):
+        """
+        Test a date+hour like construct, where the hour of the last day is
+        the same but the date had changed, so print the hour anyway.
+        """
+        output = render(
+            'ifchanged-param04',
+            {'days': [{'hours': [1, 2, 3], 'day': 1}, {'hours': [3], 'day': 2}]},
+        )
+        self.assertEqual(output, '112323')
+
+    @setup({'ifchanged-param05': '{% for d in days %}{% ifchanged d.day %}{{ d.day }}{% endifchanged %}'
+                                 '{% for h in d.hours %}{% ifchanged d.day h %}{{ h }}{% endifchanged %}'
+                                 '{% endfor %}{% endfor %}'})
+    def test_ifchanged_param05(self):
+        """
+        Logically the same as above, just written with explicit ifchanged
+        for the day.
+        """
+        output = render(
+            'ifchanged-param05',
+            {'days': [{'hours': [1, 2, 3], 'day': 1}, {'hours': [3], 'day': 2}]},
+        )
+        self.assertEqual(output, '112323')
+
+    @setup({'ifchanged-else01': '{% for id in ids %}{{ id }}'
+                                '{% ifchanged id %}-first{% else %}-other{% endifchanged %}'
+                                ',{% endfor %}'})
+    def test_ifchanged_else01(self):
+        """
+        Test the else clause of ifchanged.
+        """
+        output = render('ifchanged-else01', {'ids': [1, 1, 2, 2, 2, 3]})
+        self.assertEqual(output, '1-first,1-other,2-first,2-other,2-other,3-first,')
+
+    @setup({'ifchanged-else02': '{% for id in ids %}{{ id }}-'
+                                '{% ifchanged id %}{% cycle red,blue %}{% else %}grey{% endifchanged %}'
+                                ',{% endfor %}'})
+    def test_ifchanged_else02(self):
+        output = render('ifchanged-else02', {'ids': [1, 1, 2, 2, 2, 3]})
+        self.assertEqual(output, '1-red,1-grey,2-blue,2-grey,2-grey,3-red,')
+
+    @setup({'ifchanged-else03': '{% for id in ids %}{{ id }}'
+                                '{% ifchanged id %}-{% cycle red,blue %}{% else %}{% endifchanged %}'
+                                ',{% endfor %}'})
+    def test_ifchanged_else03(self):
+        output = render('ifchanged-else03', {'ids': [1, 1, 2, 2, 2, 3]})
+        self.assertEqual(output, '1-red,1,2-blue,2,2,3-red,')
+
+    @setup({'ifchanged-else04': '{% for id in ids %}'
+                                '{% ifchanged %}***{{ id }}*{% else %}...{% endifchanged %}'
+                                '{{ forloop.counter }}{% endfor %}'})
+    def test_ifchanged_else04(self):
+        output = render('ifchanged-else04', {'ids': [1, 1, 2, 2, 2, 3, 4]})
+        self.assertEqual(output, '***1*1...2***2*3...4...5***3*6***4*7')
+
+    @setup({'ifchanged-filter-ws': '{% load custom %}{% for n in num %}'
+                                   '{% ifchanged n|noop:"x y" %}..{% endifchanged %}{{ n }}'
+                                   '{% endfor %}'})
+    def test_ifchanged_filter_ws(self):
+        """
+        Test whitespace in filter arguments
+        """
+        output = render('ifchanged-filter-ws', {'num': (1, 2, 3)})
+        self.assertEqual(output, '..1..2..3')

tests/template_tests/syntax_tests/test_if_equal.py

+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class IfEqualTagTests(TestCase):
+
+    @setup({'ifequal01': '{% ifequal a b %}yes{% endifequal %}'})
+    def test_ifequal01(self):
+        output = render('ifequal01', {'a': 1, 'b': 2})
+        self.assertEqual(output, '')
+
+    @setup({'ifequal02': '{% ifequal a b %}yes{% endifequal %}'})
+    def test_ifequal02(self):
+        output = render('ifequal02', {'a': 1, 'b': 1})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifequal03': '{% ifequal a b %}yes{% else %}no{% endifequal %}'})
+    def test_ifequal03(self):
+        output = render('ifequal03', {'a': 1, 'b': 2})
+        self.assertEqual(output, 'no')
+
+    @setup({'ifequal04': '{% ifequal a b %}yes{% else %}no{% endifequal %}'})
+    def test_ifequal04(self):
+        output = render('ifequal04', {'a': 1, 'b': 1})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifequal05': '{% ifequal a \'test\' %}yes{% else %}no{% endifequal %}'})
+    def test_ifequal05(self):
+        output = render('ifequal05', {'a': 'test'})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifequal06': '{% ifequal a \'test\' %}yes{% else %}no{% endifequal %}'})
+    def test_ifequal06(self):
+        output = render('ifequal06', {'a': 'no'})
+        self.assertEqual(output, 'no')
+
+    @setup({'ifequal07': '{% ifequal a "test" %}yes{% else %}no{% endifequal %}'})
+    def test_ifequal07(self):
+        output = render('ifequal07', {'a': 'test'})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifequal08': '{% ifequal a "test" %}yes{% else %}no{% endifequal %}'})
+    def test_ifequal08(self):
+        output = render('ifequal08', {'a': 'no'})
+        self.assertEqual(output, 'no')
+
+    @setup({'ifequal09': '{% ifequal a "test" %}yes{% else %}no{% endifequal %}'})
+    def test_ifequal09(self):
+        output = render('ifequal09')
+        self.assertEqual(output, 'no')
+
+    @setup({'ifequal10': '{% ifequal a b %}yes{% else %}no{% endifequal %}'})
+    def test_ifequal10(self):
+        output = render('ifequal10')
+        self.assertEqual(output, 'yes')
+
+    # SMART SPLITTING
+    @setup({'ifequal-split01': '{% ifequal a "test man" %}yes{% else %}no{% endifequal %}'})
+    def test_ifequal_split01(self):
+        output = render('ifequal-split01')
+        self.assertEqual(output, 'no')
+
+    @setup({'ifequal-split02': '{% ifequal a "test man" %}yes{% else %}no{% endifequal %}'})
+    def test_ifequal_split02(self):
+        output = render('ifequal-split02', {'a': 'foo'})
+        self.assertEqual(output, 'no')
+
+    @setup({'ifequal-split03': '{% ifequal a "test man" %}yes{% else %}no{% endifequal %}'})
+    def test_ifequal_split03(self):
+        output = render('ifequal-split03', {'a': 'test man'})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifequal-split04': '{% ifequal a \'test man\' %}yes{% else %}no{% endifequal %}'})
+    def test_ifequal_split04(self):
+        output = render('ifequal-split04', {'a': 'test man'})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifequal-split05': '{% ifequal a \'i "love" you\' %}yes{% else %}no{% endifequal %}'})
+    def test_ifequal_split05(self):
+        output = render('ifequal-split05', {'a': ''})
+        self.assertEqual(output, 'no')
+
+    @setup({'ifequal-split06': '{% ifequal a \'i "love" you\' %}yes{% else %}no{% endifequal %}'})
+    def test_ifequal_split06(self):
+        output = render('ifequal-split06', {'a': 'i "love" you'})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifequal-split07': '{% ifequal a \'i "love" you\' %}yes{% else %}no{% endifequal %}'})
+    def test_ifequal_split07(self):
+        output = render('ifequal-split07', {'a': 'i love you'})
+        self.assertEqual(output, 'no')
+
+    @setup({'ifequal-split08': r"{% ifequal a 'I\'m happy' %}yes{% else %}no{% endifequal %}"})
+    def test_ifequal_split08(self):
+        output = render('ifequal-split08', {'a': "I'm happy"})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifequal-split09': r"{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"})
+    def test_ifequal_split09(self):
+        output = render('ifequal-split09', {'a': 'slash\man'})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifequal-split10': r"{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}"})
+    def test_ifequal_split10(self):
+        output = render('ifequal-split10', {'a': 'slashman'})
+        self.assertEqual(output, 'no')
+
+    # NUMERIC RESOLUTION
+    @setup({'ifequal-numeric01': '{% ifequal x 5 %}yes{% endifequal %}'})
+    def test_ifequal_numeric01(self):
+        output = render('ifequal-numeric01', {'x': '5'})
+        self.assertEqual(output, '')
+
+    @setup({'ifequal-numeric02': '{% ifequal x 5 %}yes{% endifequal %}'})
+    def test_ifequal_numeric02(self):
+        output = render('ifequal-numeric02', {'x': 5})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifequal-numeric03': '{% ifequal x 5.2 %}yes{% endifequal %}'})
+    def test_ifequal_numeric03(self):
+        output = render('ifequal-numeric03', {'x': 5})
+        self.assertEqual(output, '')
+
+    @setup({'ifequal-numeric04': '{% ifequal x 5.2 %}yes{% endifequal %}'})
+    def test_ifequal_numeric04(self):
+        output = render('ifequal-numeric04', {'x': 5.2})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifequal-numeric05': '{% ifequal x 0.2 %}yes{% endifequal %}'})
+    def test_ifequal_numeric05(self):
+        output = render('ifequal-numeric05', {'x': 0.2})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifequal-numeric06': '{% ifequal x .2 %}yes{% endifequal %}'})
+    def test_ifequal_numeric06(self):
+        output = render('ifequal-numeric06', {'x': 0.2})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifequal-numeric07': '{% ifequal x 2. %}yes{% endifequal %}'})
+    def test_ifequal_numeric07(self):
+        output = render('ifequal-numeric07', {'x': 2})
+        self.assertEqual(output, '')
+
+    @setup({'ifequal-numeric08': '{% ifequal x "5" %}yes{% endifequal %}'})
+    def test_ifequal_numeric08(self):
+        output = render('ifequal-numeric08', {'x': 5})
+        self.assertEqual(output, '')
+
+    @setup({'ifequal-numeric09': '{% ifequal x "5" %}yes{% endifequal %}'})
+    def test_ifequal_numeric09(self):
+        output = render('ifequal-numeric09', {'x': '5'})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifequal-numeric10': '{% ifequal x -5 %}yes{% endifequal %}'})
+    def test_ifequal_numeric10(self):
+        output = render('ifequal-numeric10', {'x': -5})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifequal-numeric11': '{% ifequal x -5.2 %}yes{% endifequal %}'})
+    def test_ifequal_numeric11(self):
+        output = render('ifequal-numeric11', {'x': -5.2})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifequal-numeric12': '{% ifequal x +5 %}yes{% endifequal %}'})
+    def test_ifequal_numeric12(self):
+        output = render('ifequal-numeric12', {'x': 5})
+        self.assertEqual(output, 'yes')
+
+    # FILTER EXPRESSIONS AS ARGUMENTS
+    @setup({'ifequal-filter01': '{% ifequal a|upper "A" %}x{% endifequal %}'})
+    def test_ifequal_filter01(self):
+        output = render('ifequal-filter01', {'a': 'a'})
+        self.assertEqual(output, 'x')
+
+    @setup({'ifequal-filter02': '{% ifequal "A" a|upper %}x{% endifequal %}'})
+    def test_ifequal_filter02(self):
+        output = render('ifequal-filter02', {'a': 'a'})
+        self.assertEqual(output, 'x')
+
+    @setup({'ifequal-filter03': '{% ifequal a|upper b|upper %}x{% endifequal %}'})
+    def test_ifequal_filter03(self):
+        output = render('ifequal-filter03', {'a': 'x', 'b': 'X'})
+        self.assertEqual(output, 'x')
+
+    @setup({'ifequal-filter04': '{% ifequal x|slice:"1" "a" %}x{% endifequal %}'})
+    def test_ifequal_filter04(self):
+        output = render('ifequal-filter04', {'x': 'aaa'})
+        self.assertEqual(output, 'x')
+
+    @setup({'ifequal-filter05': '{% ifequal x|slice:"1"|upper "A" %}x{% endifequal %}'})
+    def test_ifequal_filter05(self):
+        output = render('ifequal-filter05', {'x': 'aaa'})
+        self.assertEqual(output, 'x')
+
+
+class IfNotEqualTagTests(TestCase):
+
+    @setup({'ifnotequal01': '{% ifnotequal a b %}yes{% endifnotequal %}'})
+    def test_ifnotequal01(self):
+        output = render('ifnotequal01', {'a': 1, 'b': 2})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifnotequal02': '{% ifnotequal a b %}yes{% endifnotequal %}'})
+    def test_ifnotequal02(self):
+        output = render('ifnotequal02', {'a': 1, 'b': 1})
+        self.assertEqual(output, '')
+
+    @setup({'ifnotequal03': '{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}'})
+    def test_ifnotequal03(self):
+        output = render('ifnotequal03', {'a': 1, 'b': 2})
+        self.assertEqual(output, 'yes')
+
+    @setup({'ifnotequal04': '{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}'})
+    def test_ifnotequal04(self):
+        output = render('ifnotequal04', {'a': 1, 'b': 1})
+        self.assertEqual(output, 'no')

tests/template_tests/syntax_tests/test_include.py

+from django.conf import settings
+from django.template.base import Context, TemplateDoesNotExist, TemplateSyntaxError
+from django.template.loader import get_template
+from django.test import TestCase
+
+from .test_basic import basic_templates
+from .utils import render, setup
+
+
+include_fail_templates = {
+    'include-fail1': '{% load bad_tag %}{% badtag %}',
+    'include-fail2': '{% load broken_tag %}',
+}
+
+
+class IncludeTagTests(TestCase):
+
+    @setup({'include01': '{% include "basic-syntax01" %}'}, basic_templates)
+    def test_include01(self):
+        output = render('include01')
+        self.assertEqual(output, 'something cool')
+
+    @setup({'include02': '{% include "basic-syntax02" %}'}, basic_templates)
+    def test_include02(self):
+        output = render('include02', {'headline': 'Included'})
+        self.assertEqual(output, 'Included')
+
+    @setup({'include03': '{% include template_name %}'}, basic_templates)
+    def test_include03(self):
+        output = render(
+            'include03',
+            {'template_name': 'basic-syntax02', 'headline': 'Included'},
+        )
+        self.assertEqual(output, 'Included')
+
+    @setup({'include04': 'a{% include "nonexistent" %}b'})
+    def test_include04(self):
+        template = get_template('include04')
+
+        if settings.TEMPLATE_DEBUG:
+            with self.assertRaises(TemplateDoesNotExist):
+                template.render(Context({}))
+        else:
+            output = template.render(Context({}))
+            self.assertEqual(output, "ab")
+
+    @setup({
+        'include 05': 'template with a space',
+        'include06': '{% include "include 05"%}',
+    })
+    def test_include06(self):
+        output = render('include06')
+        self.assertEqual(output, "template with a space")
+
+    @setup({'include07': '{% include "basic-syntax02" with headline="Inline" %}'}, basic_templates)
+    def test_include07(self):
+        output = render('include07', {'headline': 'Included'})
+        self.assertEqual(output, 'Inline')
+
+    @setup({'include08': '{% include headline with headline="Dynamic" %}'}, basic_templates)
+    def test_include08(self):
+        output = render('include08', {'headline': 'basic-syntax02'})
+        self.assertEqual(output, 'Dynamic')
+
+    @setup(
+        {'include09': '{{ first }}--'
+                      '{% include "basic-syntax03" with first=second|lower|upper second=first|upper %}'
+                      '--{{ second }}'},
+        basic_templates,
+    )
+    def test_include09(self):
+        output = render('include09', {'first': 'Ul', 'second': 'lU'})
+        self.assertEqual(output, 'Ul--LU --- UL--lU')
+
+    @setup({'include10': '{% include "basic-syntax03" only %}'}, basic_templates)
+    def test_include10(self):
+        output = render('include10', {'first': '1'})
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'INVALID --- INVALID')
+        else:
+            self.assertEqual(output, ' --- ')
+
+    @setup({'include11': '{% include "basic-syntax03" only with second=2 %}'}, basic_templates)
+    def test_include11(self):
+        output = render('include11', {'first': '1'})
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'INVALID --- 2')
+        else:
+            self.assertEqual(output, ' --- 2')
+
+    @setup({'include12': '{% include "basic-syntax03" with first=1 only %}'}, basic_templates)
+    def test_include12(self):
+        output = render('include12', {'second': '2'})
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, '1 --- INVALID')
+        else:
+            self.assertEqual(output, '1 --- ')
+
+    @setup(
+        {'include13': '{% autoescape off %}{% include "basic-syntax03" %}{% endautoescape %}'},
+        basic_templates,
+    )
+    def test_include13(self):
+        output = render('include13', {'first': '&'})
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, '& --- INVALID')
+        else:
+            self.assertEqual(output, '& --- ')
+
+    @setup(
+        {'include14': '{% autoescape off %}'
+                      '{% include "basic-syntax03" with first=var1 only %}'
+                      '{% endautoescape %}'},
+        basic_templates,
+    )
+    def test_include14(self):
+        output = render('include14', {'var1': '&'})
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, '& --- INVALID')
+        else:
+            self.assertEqual(output, '& --- ')
+
+    # Include syntax errors
+    @setup({'include-error01': '{% include "basic-syntax01" with %}'})
+    def test_include_error01(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('include-error01')
+
+    @setup({'include-error02': '{% include "basic-syntax01" with "no key" %}'})
+    def test_include_error02(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('include-error02')
+
+    @setup({'include-error03': '{% include "basic-syntax01" with dotted.arg="error" %}'})
+    def test_include_error03(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('include-error03')
+
+    @setup({'include-error04': '{% include "basic-syntax01" something_random %}'})
+    def test_include_error04(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('include-error04')
+
+    @setup({'include-error05': '{% include "basic-syntax01" foo="duplicate" foo="key" %}'})
+    def test_include_error05(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('include-error05')
+
+    @setup({'include-error06': '{% include "basic-syntax01" only only %}'})
+    def test_include_error06(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('include-error06')
+
+    @setup(include_fail_templates)
+    def test_include_fail1(self):
+        with self.assertRaises(RuntimeError):
+            get_template('include-fail1')
+
+    @setup(include_fail_templates)
+    def test_include_fail2(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('include-fail2')
+
+    @setup({'include-error07': '{% include "include-fail1" %}'}, include_fail_templates)
+    def test_include_error07(self):
+        t = get_template('include-error07')
+
+        if settings.TEMPLATE_DEBUG:
+            with self.assertRaises(RuntimeError):
+                t.render(Context())
+        else:
+            self.assertEqual(t.render(Context()), '')
+
+    @setup({'include-error08': '{% include "include-fail2" %}'}, include_fail_templates)
+    def test_include_error08(self):
+        t = get_template('include-error08')
+
+        if settings.TEMPLATE_DEBUG:
+            with self.assertRaises(TemplateSyntaxError):
+                t.render(Context())
+        else:
+            self.assertEqual(t.render(Context()), '')
+
+    @setup({'include-error09': '{% include failed_include %}'}, include_fail_templates)
+    def test_include_error09(self):
+        c = Context({'failed_include': 'include-fail1'})
+        t = get_template('include-error09')
+
+        if settings.TEMPLATE_DEBUG:
+            with self.assertRaises(RuntimeError):
+                t.render(c)
+        else:
+            self.assertEqual(t.render(c), '')
+
+    @setup({'include-error10': '{% include failed_include %}'}, include_fail_templates)
+    def test_include_error10(self):
+        c = Context({'failed_include': 'include-fail2'})
+        t = get_template('include-error10')
+
+        if settings.TEMPLATE_DEBUG:
+            with self.assertRaises(TemplateSyntaxError):
+                t.render(c)
+        else:
+            self.assertEqual(t.render(c), '')

tests/template_tests/syntax_tests/test_invalid_string.py

+from django.conf import settings
+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class InvalidStringTests(TestCase):
+
+    @setup({'invalidstr01': '{{ var|default:"Foo" }}'})
+    def test_invalidstr01(self):
+        output = render('invalidstr01')
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'INVALID')
+        else:
+            self.assertEqual(output, 'Foo')
+
+    @setup({'invalidstr02': '{{ var|default_if_none:"Foo" }}'})
+    def test_invalidstr02(self):
+        output = render('invalidstr02')
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'INVALID')
+        else:
+            self.assertEqual(output, '')
+
+    @setup({'invalidstr03': '{% for v in var %}({{ v }}){% endfor %}'})
+    def test_invalidstr03(self):
+        output = render('invalidstr03')
+        self.assertEqual(output, '')
+
+    @setup({'invalidstr04': '{% if var %}Yes{% else %}No{% endif %}'})
+    def test_invalidstr04(self):
+        output = render('invalidstr04')
+        self.assertEqual(output, 'No')
+
+    @setup({'invalidstr04_2': '{% if var|default:"Foo" %}Yes{% else %}No{% endif %}'})
+    def test_invalidstr04_2(self):
+        output = render('invalidstr04_2')
+        self.assertEqual(output, 'Yes')
+
+    @setup({'invalidstr05': '{{ var }}'})
+    def test_invalidstr05(self):
+        output = render('invalidstr05')
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'INVALID')
+        else:
+            self.assertEqual(output, '')
+
+    @setup({'invalidstr06': '{{ var.prop }}'})
+    def test_invalidstr06(self):
+        output = render('invalidstr06')
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'INVALID')
+        else:
+            self.assertEqual(output, '')
+
+    @setup({'invalidstr07': '{% load i18n %}{% blocktrans %}{{ var }}{% endblocktrans %}'})
+    def test_invalidstr07(self):
+        output = render('invalidstr07')
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'INVALID')
+        else:
+            self.assertEqual(output, '')

tests/template_tests/syntax_tests/test_list_index.py

+from django.conf import settings
+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class ListIndexTests(TestCase):
+
+    @setup({'list-index01': '{{ var.1 }}'})
+    def test_list_index01(self):
+        """
+        List-index syntax allows a template to access a certain item of a
+        subscriptable object.
+        """
+        output = render('list-index01', {'var': ['first item', 'second item']})
+        self.assertEqual(output, 'second item')
+
+    @setup({'list-index02': '{{ var.5 }}'})
+    def test_list_index02(self):
+        """
+        Fail silently when the list index is out of range.
+        """
+        output = render('list-index02', {'var': ['first item', 'second item']})
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'INVALID')
+        else:
+            self.assertEqual(output, '')
+
+    @setup({'list-index03': '{{ var.1 }}'})
+    def test_list_index03(self):
+        """
+        Fail silently when the list index is out of range.
+        """
+        output = render('list-index03', {'var': None})
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'INVALID')
+        else:
+            self.assertEqual(output, '')
+
+    @setup({'list-index04': '{{ var.1 }}'})
+    def test_list_index04(self):
+        """
+        Fail silently when variable is a dict without the specified key.
+        """
+        output = render('list-index04', {'var': {}})
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'INVALID')
+        else:
+            self.assertEqual(output, '')
+
+    @setup({'list-index05': '{{ var.1 }}'})
+    def test_list_index05(self):
+        """
+        Dictionary lookup wins out when dict's key is a string.
+        """
+        output = render('list-index05', {'var': {'1': "hello"}})
+        self.assertEqual(output, 'hello')
+
+    @setup({'list-index06': '{{ var.1 }}'})
+    def test_list_index06(self):
+        """
+        But list-index lookup wins out when dict's key is an int, which
+        behind the scenes is really a dictionary lookup (for a dict)
+        after converting the key to an int.
+        """
+        output = render('list-index06', {"var": {1: "hello"}})
+        self.assertEqual(output, 'hello')
+
+    @setup({'list-index07': '{{ var.1 }}'})
+    def test_list_index07(self):
+        """
+        Dictionary lookup wins out when there is a string and int version
+        of the key.
+        """
+        output = render('list-index07', {"var": {'1': "hello", 1: "world"}})
+        self.assertEqual(output, 'hello')

tests/template_tests/syntax_tests/test_load.py

+from django.template.base import TemplateSyntaxError
+from django.template.loader import get_template
+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class LoadTagTests(TestCase):
+
+    @setup({'load01': '{% load testtags subpackage.echo %}{% echo test %} {% echo2 "test" %}'})
+    def test_load01(self):
+        output = render('load01')
+        self.assertEqual(output, 'test test')
+
+    @setup({'load02': '{% load subpackage.echo %}{% echo2 "test" %}'})
+    def test_load02(self):
+        output = render('load02')
+        self.assertEqual(output, 'test')
+
+    # {% load %} tag, importing individual tags
+    @setup({'load03': '{% load echo from testtags %}{% echo this that theother %}'})
+    def test_load03(self):
+        output = render('load03')
+        self.assertEqual(output, 'this that theother')
+
+    @setup({'load04': '{% load echo other_echo from testtags %}'
+                      '{% echo this that theother %} {% other_echo and another thing %}'})
+    def test_load04(self):
+        output = render('load04')
+        self.assertEqual(output, 'this that theother and another thing')
+
+    @setup({'load05': '{% load echo upper from testtags %}'
+                      '{% echo this that theother %} {{ statement|upper }}'})
+    def test_load05(self):
+        output = render('load05', {'statement': 'not shouting'})
+        self.assertEqual(output, 'this that theother NOT SHOUTING')
+
+    @setup({'load06': '{% load echo2 from subpackage.echo %}{% echo2 "test" %}'})
+    def test_load06(self):
+        output = render('load06')
+        self.assertEqual(output, 'test')
+
+    # {% load %} tag errors
+    @setup({'load07': '{% load echo other_echo bad_tag from testtags %}'})
+    def test_load07(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('load07')
+
+    @setup({'load08': '{% load echo other_echo bad_tag from %}'})
+    def test_load08(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('load08')
+
+    @setup({'load09': '{% load from testtags %}'})
+    def test_load09(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('load09')
+
+    @setup({'load10': '{% load echo from bad_library %}'})
+    def test_load10(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('load10')
+
+    @setup({'load11': '{% load subpackage.echo_invalid %}'})
+    def test_load11(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('load11')
+
+    @setup({'load12': '{% load subpackage.missing %}'})
+    def test_load12(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('load12')

tests/template_tests/syntax_tests/test_lorem.py

+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class LoremTagTests(TestCase):
+
+    @setup({'lorem1': '{% lorem 3 w %}'})
+    def test_lorem1(self):
+        output = render('lorem1')
+        self.assertEqual(output, 'lorem ipsum dolor')

tests/template_tests/syntax_tests/test_multiline.py

+from django.test import TestCase
+
+from .utils import render, setup
+
+
+multiline_string = """
+Hello,
+boys.
+How
+are
+you
+gentlemen.
+"""
+
+
+class MultilineTests(TestCase):
+
+    @setup({'multiline01': multiline_string})
+    def test_multiline01(self):
+        output = render('multiline01')
+        self.assertEqual(output, multiline_string)

tests/template_tests/syntax_tests/test_named_endblock.py

+from django.template.base import TemplateSyntaxError
+from django.template.loader import get_template
+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class NamedEndblockTests(TestCase):
+
+    @setup({'namedendblocks01': '1{% block first %}_{% block second %}'
+                                '2{% endblock second %}_{% endblock first %}3'})
+    def test_namedendblocks01(self):
+        output = render('namedendblocks01')
+        self.assertEqual(output, '1_2_3')
+
+    # Unbalanced blocks
+    @setup({'namedendblocks02': '1{% block first %}_{% block second %}'
+                                '2{% endblock first %}_{% endblock second %}3'})
+    def test_namedendblocks02(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('namedendblocks02')
+
+    @setup({'namedendblocks03': '1{% block first %}_{% block second %}'
+                                '2{% endblock %}_{% endblock second %}3'})
+    def test_namedendblocks03(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('namedendblocks03')
+
+    @setup({'namedendblocks04': '1{% block first %}_{% block second %}'
+                                '2{% endblock second %}_{% endblock third %}3'})
+    def test_namedendblocks04(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('namedendblocks04')
+
+    @setup({'namedendblocks05': '1{% block first %}_{% block second %}2{% endblock first %}'})
+    def test_namedendblocks05(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('namedendblocks05')
+
+    # Mixed named and unnamed endblocks
+    @setup({'namedendblocks06': '1{% block first %}_{% block second %}'
+                                '2{% endblock %}_{% endblock first %}3'})
+    def test_namedendblocks06(self):
+        """
+        Mixed named and unnamed endblocks
+        """
+        output = render('namedendblocks06')
+        self.assertEqual(output, '1_2_3')
+
+    @setup({'namedendblocks07': '1{% block first %}_{% block second %}'
+                                '2{% endblock second %}_{% endblock %}3'})
+    def test_namedendblocks07(self):
+        output = render('namedendblocks07')
+        self.assertEqual(output, '1_2_3')

tests/template_tests/syntax_tests/test_now.py

+from datetime import datetime
+
+from django.test import TestCase
+from django.utils.formats import date_format
+
+from .utils import render, setup
+
+
+class NowTagTests(TestCase):
+
+    @setup({'now01': '{% now "j n Y" %}'})
+    def test_now01(self):
+        """
+        Simple case
+        """
+        output = render('now01')
+        self.assertEqual(output, "%d %d %d" % (
+            datetime.now().day, datetime.now().month, datetime.now().year,
+        ))
+
+    # Check parsing of locale strings
+    @setup({'now02': '{% now "DATE_FORMAT" %}'})
+    def test_now02(self):
+        output = render('now02')
+        self.assertEqual(output, date_format(datetime.now()))
+
+    @setup({'now03': '{% now \'j n Y\' %}'})
+    def test_now03(self):
+        """
+        #15092 - Also accept simple quotes
+        """
+        output = render('now03')
+        self.assertEqual(output, "%d %d %d" % (
+            datetime.now().day, datetime.now().month, datetime.now().year,
+        ))
+
+    @setup({'now04': '{% now \'DATE_FORMAT\' %}'})
+    def test_now04(self):
+        output = render('now04')
+        self.assertEqual(output, date_format(datetime.now()))
+
+    @setup({'now05': '{% now \'j "n" Y\'%}'})
+    def test_now05(self):
+        output = render('now05')
+        self.assertEqual(output, '%d "%d" %d' % (
+            datetime.now().day, datetime.now().month, datetime.now().year,
+        ))
+
+    @setup({'now06': '{% now "j \'n\' Y"%}'})
+    def test_now06(self):
+        output = render('now06')
+        self.assertEqual(output, "%d '%d' %d" % (
+            datetime.now().day, datetime.now().month, datetime.now().year,
+        ))
+
+    @setup({'now07': '{% now "j n Y" as N %}-{{N}}-'})
+    def test_now07(self):
+        output = render('now07')
+        self.assertEqual(output, '-%d %d %d-' % (
+            datetime.now().day, datetime.now().month, datetime.now().year,
+        ))

tests/template_tests/syntax_tests/test_numpy.py

+from unittest import skipIf
+
+from django.conf import settings
+from django.test import TestCase
+
+from .utils import render, setup
+
+try:
+    import numpy
+except ImportError:
+    numpy = False
+
+
+@skipIf(numpy is False, "Numpy must be installed to run these tests.")
+class NumpyTests(TestCase):
+
+    @setup({'numpy-array-index01': '{{ var.1 }}'})
+    def test_numpy_array_index01(self):
+        """
+        Numpy's array-index syntax allows a template to access a certain
+        item of a subscriptable object.
+        """
+        output = render(
+            'numpy-array-index01',
+            {'var': numpy.array(["first item", "second item"])},
+        )
+        self.assertEqual(output, 'second item')
+
+    @setup({'numpy-array-index02': '{{ var.5 }}'})
+    def test_numpy_array_index02(self):
+        """
+        Fail silently when the array index is out of range.
+        """
+        output = render(
+            'numpy-array-index02',
+            {'var': numpy.array(["first item", "second item"])},
+        )
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'INVALID')
+        else:
+            self.assertEqual(output, '')

tests/template_tests/syntax_tests/test_regroup.py

+from datetime import date
+
+from django.template.base import TemplateSyntaxError
+from django.template.loader import get_template
+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class RegroupTagTests(TestCase):
+
+    @setup({'regroup01': ''
+                         '{% regroup data by bar as grouped %}'
+                         '{% for group in grouped %}'
+                         '{{ group.grouper }}:'
+                         '{% for item in group.list %}'
+                         '{{ item.foo }}'
+                         '{% endfor %},'
+                         '{% endfor %}'})
+    def test_regroup01(self):
+        output = render('regroup01', {
+            'data': [{'foo': 'c', 'bar': 1},
+                     {'foo': 'd', 'bar': 1},
+                     {'foo': 'a', 'bar': 2},
+                     {'foo': 'b', 'bar': 2},
+                     {'foo': 'x', 'bar': 3}],
+        })
+        self.assertEqual(output, '1:cd,2:ab,3:x,')
+
+    @setup({'regroup02': ''
+                         '{% regroup data by bar as grouped %}'
+                         '{% for group in grouped %}'
+                         '{{ group.grouper }}:'
+                         '{% for item in group.list %}'
+                         '{{ item.foo }}'
+                         '{% endfor %}'
+                         '{% endfor %}'})
+    def test_regroup02(self):
+        """
+        Test for silent failure when target variable isn't found
+        """
+        output = render('regroup02', {})
+        self.assertEqual(output, '')
+
+    @setup({'regroup03': ''
+                         '{% regroup data by at|date:"m" as grouped %}'
+                         '{% for group in grouped %}'
+                         '{{ group.grouper }}:'
+                         '{% for item in group.list %}'
+                         '{{ item.at|date:"d" }}'
+                         '{% endfor %},'
+                         '{% endfor %}'})
+    def test_regroup03(self):
+        """
+        Regression tests for #17675
+        The date template filter has expects_localtime = True
+        """
+        output = render('regroup03', {
+            'data': [{'at': date(2012, 2, 14)},
+                     {'at': date(2012, 2, 28)},
+                     {'at': date(2012, 7, 4)}],
+        })
+        self.assertEqual(output, '02:1428,07:04,')
+
+    @setup({'regroup04': ''
+                         '{% regroup data by bar|join:"" as grouped %}'
+                         '{% for group in grouped %}'
+                         '{{ group.grouper }}:'
+                         '{% for item in group.list %}'
+                         '{{ item.foo|first }}'
+                         '{% endfor %},'
+                         '{% endfor %}'})
+    def test_regroup04(self):
+        """
+        The join template filter has needs_autoescape = True
+        """
+        output = render('regroup04', {
+            'data': [{'foo': 'x', 'bar': ['ab', 'c']},
+                     {'foo': 'y', 'bar': ['a', 'bc']},
+                     {'foo': 'z', 'bar': ['a', 'd']}],
+        })
+        self.assertEqual(output, 'abc:xy,ad:z,')
+
+    # Test syntax errors
+    @setup({'regroup05': '{% regroup data by bar as %}'})
+    def test_regroup05(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('regroup05')
+
+    @setup({'regroup06': '{% regroup data by bar thisaintright grouped %}'})
+    def test_regroup06(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('regroup06')
+
+    @setup({'regroup07': '{% regroup data thisaintright bar as grouped %}'})
+    def test_regroup07(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('regroup07')
+
+    @setup({'regroup08': '{% regroup data by bar as grouped toomanyargs %}'})
+    def test_regroup08(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('regroup08')

tests/template_tests/syntax_tests/test_setup.py

+from django.conf import settings
+from django.test import TestCase
+
+from .utils import setup
+
+
+class SetupTests(TestCase):
+
+    def test_setup(self):
+        """
+        Let's just make sure setup runs cases in the right order.
+        """
+        cases = []
+
+        @setup({})
+        def method(self):
+            cases.append([
+                settings.TEMPLATE_STRING_IF_INVALID,
+                settings.TEMPLATE_DEBUG,
+            ])
+
+        method(self)
+
+        self.assertEqual(cases[0], ['', False])
+        self.assertEqual(cases[1], ['', False])
+        self.assertEqual(cases[2], ['INVALID', False])
+        self.assertEqual(cases[3], ['INVALID', False])
+        self.assertEqual(cases[4], ['', True])
+        self.assertEqual(cases[5], ['', True])

tests/template_tests/syntax_tests/test_simple_tag.py

+from django.template.base import TemplateSyntaxError
+from django.template.loader import get_template
+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class SimpleTagTests(TestCase):
+
+    @setup({'simpletag-renamed01': '{% load custom %}{% minusone 7 %}'})
+    def test_simpletag_renamed01(self):
+        output = render('simpletag-renamed01')
+        self.assertEqual(output, '6')
+
+    @setup({'simpletag-renamed02': '{% load custom %}{% minustwo 7 %}'})
+    def test_simpletag_renamed02(self):
+        output = render('simpletag-renamed02')
+        self.assertEqual(output, '5')
+
+    @setup({'simpletag-renamed03': '{% load custom %}{% minustwo_overridden_name 7 %}'})
+    def test_simpletag_renamed03(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('simpletag-renamed03')

tests/template_tests/syntax_tests/test_spaceless.py

+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class SpacelessTagTests(TestCase):
+
+    @setup({'spaceless01': "{% spaceless %} <b>    <i> text </i>    </b> {% endspaceless %}"})
+    def test_spaceless01(self):
+        output = render('spaceless01')
+        self.assertEqual(output, "<b><i> text </i></b>")
+
+    @setup({'spaceless02': "{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}"})
+    def test_spaceless02(self):
+        output = render('spaceless02')
+        self.assertEqual(output, "<b><i> text </i></b>")
+
+    @setup({'spaceless03': "{% spaceless %}<b><i>text</i></b>{% endspaceless %}"})
+    def test_spaceless03(self):
+        output = render('spaceless03')
+        self.assertEqual(output, "<b><i>text</i></b>")
+
+    @setup({'spaceless04': "{% spaceless %}<b>   <i>{{ text }}</i>  </b>{% endspaceless %}"})
+    def test_spaceless04(self):
+        output = render('spaceless04', {'text': 'This & that'})
+        self.assertEqual(output, "<b><i>This &amp; that</i></b>")
+
+    @setup({'spaceless05': "{% autoescape off %}{% spaceless %}"
+                           "<b>   <i>{{ text }}</i>  </b>{% endspaceless %}"
+                           "{% endautoescape %}"})
+    def test_spaceless05(self):
+        output = render('spaceless05', {'text': 'This & that'})
+        self.assertEqual(output, "<b><i>This & that</i></b>")
+
+    @setup({'spaceless06': "{% spaceless %}<b>   <i>{{ text|safe }}</i>  </b>{% endspaceless %}"})
+    def test_spaceless06(self):
+        output = render('spaceless06', {'text': 'This & that'})
+        self.assertEqual(output, "<b><i>This & that</i></b>")

tests/template_tests/syntax_tests/test_ssi.py

+import os
+import warnings
+
+from django.test import override_settings, TestCase
+from django.utils._os import upath
+from django.utils.deprecation import RemovedInDjango19Warning
+
+from .utils import render, setup
+
+
+cwd = os.path.dirname(os.path.abspath(upath(__file__)))
+root = os.path.abspath(os.path.join(cwd, ".."))
+
+
+@override_settings(ALLOWED_INCLUDE_ROOTS=(root))
+class SsiTagTests(TestCase):
+
+    # Test normal behavior
+    @setup({'ssi01': '{%% ssi "%s" %%}' % os.path.join(
+        root, 'templates', 'ssi_include.html',
+    )})
+    def test_ssi01(self):
+        output = render('ssi01')
+        self.assertEqual(output, 'This is for testing an ssi include. {{ test }}\n')
+
+    @setup({'ssi02': '{%% ssi "%s" %%}' % os.path.join(
+        root, 'not_here',
+    )})
+    def test_ssi02(self):
+        output = render('ssi02')
+        self.assertEqual(output, ''),
+
+    @setup({'ssi03': "{%% ssi '%s' %%}" % os.path.join(
+        root, 'not_here',
+    )})
+    def test_ssi03(self):
+        output = render('ssi03')
+        self.assertEqual(output, ''),
+
+    # Test passing as a variable
+    @setup({'ssi04': '{% load ssi from future %}{% ssi ssi_file %}'})
+    def test_ssi04(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RemovedInDjango19Warning)
+            output = render('ssi04', {
+                'ssi_file': os.path.join(root, 'templates', 'ssi_include.html')
+            })
+        self.assertEqual(output, 'This is for testing an ssi include. {{ test }}\n')
+
+    @setup({'ssi05': '{% load ssi from future %}{% ssi ssi_file %}'})
+    def test_ssi05(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RemovedInDjango19Warning)
+            output = render('ssi05', {'ssi_file': 'no_file'})
+        self.assertEqual(output, '')
+
+    # Test parsed output
+    @setup({'ssi06': '{%% ssi "%s" parsed %%}' % os.path.join(
+        root, 'templates', 'ssi_include.html',
+    )})
+    def test_ssi06(self):
+        output = render('ssi06', {'test': 'Look ma! It parsed!'})
+        self.assertEqual(output, 'This is for testing an ssi include. '
+                                 'Look ma! It parsed!\n')
+
+    @setup({'ssi07': '{%% ssi "%s" parsed %%}' % os.path.join(
+        root, 'not_here',
+    )})
+    def test_ssi07(self):
+        output = render('ssi07', {'test': 'Look ma! It parsed!'})
+        self.assertEqual(output, '')
+
+    # Test space in file name
+    @setup({'ssi08': '{%% ssi "%s" %%}' % os.path.join(
+        root, 'templates', 'ssi include with spaces.html',
+    )})
+    def test_ssi08(self):
+        output = render('ssi08')
+        self.assertEqual(output, 'This is for testing an ssi include '
+                                 'with spaces in its name. {{ test }}\n')
+
+    @setup({'ssi09': '{%% ssi "%s" parsed %%}' % os.path.join(
+        root, 'templates', 'ssi include with spaces.html',
+    )})
+    def test_ssi09(self):
+        output = render('ssi09', {'test': 'Look ma! It parsed!'})
+        self.assertEqual(output, 'This is for testing an ssi include '
+                                 'with spaces in its name. Look ma! It parsed!\n')

tests/template_tests/syntax_tests/test_static.py

+from django.conf import settings
+from django.test import override_settings, TestCase
+from django.utils.six.moves.urllib.parse import urljoin
+
+from .utils import render, setup
+
+
+@override_settings(MEDIA_URL="/media/", STATIC_URL="/static/")
+class StaticTagTests(TestCase):
+
+    @setup({'static-prefixtag01': '{% load static %}{% get_static_prefix %}'})
+    def test_static_prefixtag01(self):
+        output = render('static-prefixtag01')
+        self.assertEqual(output, settings.STATIC_URL)
+
+    @setup({'static-prefixtag02': '{% load static %}'
+                                  '{% get_static_prefix as static_prefix %}{{ static_prefix }}'})
+    def test_static_prefixtag02(self):
+        output = render('static-prefixtag02')
+        self.assertEqual(output, settings.STATIC_URL)
+
+    @setup({'static-prefixtag03': '{% load static %}{% get_media_prefix %}'})
+    def test_static_prefixtag03(self):
+        output = render('static-prefixtag03')
+        self.assertEqual(output, settings.MEDIA_URL)
+
+    @setup({'static-prefixtag04': '{% load static %}'
+                                  '{% get_media_prefix as media_prefix %}{{ media_prefix }}'})
+    def test_static_prefixtag04(self):
+        output = render('static-prefixtag04')
+        self.assertEqual(output, settings.MEDIA_URL)
+
+    @setup({'static-statictag01': '{% load static %}{% static "admin/base.css" %}'})
+    def test_static_statictag01(self):
+        output = render('static-statictag01')
+        self.assertEqual(output, urljoin(settings.STATIC_URL, 'admin/base.css'))
+
+    @setup({'static-statictag02': '{% load static %}{% static base_css %}'})
+    def test_static_statictag02(self):
+        output = render('static-statictag02', {'base_css': 'admin/base.css'})
+        self.assertEqual(output, urljoin(settings.STATIC_URL, 'admin/base.css'))
+
+    @setup({'static-statictag03': '{% load static %}{% static "admin/base.css" as foo %}{{ foo }}'})
+    def test_static_statictag03(self):
+        output = render('static-statictag03')
+        self.assertEqual(output, urljoin(settings.STATIC_URL, 'admin/base.css'))
+
+    @setup({'static-statictag04': '{% load static %}{% static base_css as foo %}{{ foo }}'})
+    def test_static_statictag04(self):
+        output = render('static-statictag04', {'base_css': 'admin/base.css'})
+        self.assertEqual(output, urljoin(settings.STATIC_URL, 'admin/base.css'))

tests/template_tests/syntax_tests/test_template_tag.py

+from django.template.base import TemplateSyntaxError
+from django.template.loader import get_template
+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class TemplateTagTests(TestCase):
+
+    @setup({'templatetag01': '{% templatetag openblock %}'})
+    def test_templatetag01(self):
+        output = render('templatetag01')
+        self.assertEqual(output, '{%')
+
+    @setup({'templatetag02': '{% templatetag closeblock %}'})
+    def test_templatetag02(self):
+        output = render('templatetag02')
+        self.assertEqual(output, '%}')
+
+    @setup({'templatetag03': '{% templatetag openvariable %}'})
+    def test_templatetag03(self):
+        output = render('templatetag03')
+        self.assertEqual(output, '{{')
+
+    @setup({'templatetag04': '{% templatetag closevariable %}'})
+    def test_templatetag04(self):
+        output = render('templatetag04')
+        self.assertEqual(output, '}}')
+
+    @setup({'templatetag05': '{% templatetag %}'})
+    def test_templatetag05(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('templatetag05')
+
+    @setup({'templatetag06': '{% templatetag foo %}'})
+    def test_templatetag06(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('templatetag06')
+
+    @setup({'templatetag07': '{% templatetag openbrace %}'})
+    def test_templatetag07(self):
+        output = render('templatetag07')
+        self.assertEqual(output, '{')
+
+    @setup({'templatetag08': '{% templatetag closebrace %}'})
+    def test_templatetag08(self):
+        output = render('templatetag08')
+        self.assertEqual(output, '}')
+
+    @setup({'templatetag09': '{% templatetag openbrace %}{% templatetag openbrace %}'})
+    def test_templatetag09(self):
+        output = render('templatetag09')
+        self.assertEqual(output, '{{')
+
+    @setup({'templatetag10': '{% templatetag closebrace %}{% templatetag closebrace %}'})
+    def test_templatetag10(self):
+        output = render('templatetag10')
+        self.assertEqual(output, '}}')
+
+    @setup({'templatetag11': '{% templatetag opencomment %}'})
+    def test_templatetag11(self):
+        output = render('templatetag11')
+        self.assertEqual(output, '{#')
+
+    @setup({'templatetag12': '{% templatetag closecomment %}'})
+    def test_templatetag12(self):
+        output = render('templatetag12')
+        self.assertEqual(output, '#}')

tests/template_tests/syntax_tests/test_verbatim.py

+from django.template.base import TemplateSyntaxError
+from django.template.loader import get_template
+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class VerbatimTagTests(TestCase):
+
+    @setup({'verbatim-tag01': '{% verbatim %}{{bare   }}{% endverbatim %}'})
+    def test_verbatim_tag01(self):
+        output = render('verbatim-tag01')
+        self.assertEqual(output, '{{bare   }}')
+
+    @setup({'verbatim-tag02': '{% verbatim %}{% endif %}{% endverbatim %}'})
+    def test_verbatim_tag02(self):
+        output = render('verbatim-tag02')
+        self.assertEqual(output, '{% endif %}')
+
+    @setup({'verbatim-tag03': '{% verbatim %}It\'s the {% verbatim %} tag{% endverbatim %}'})
+    def test_verbatim_tag03(self):
+        output = render('verbatim-tag03')
+        self.assertEqual(output, 'It\'s the {% verbatim %} tag')
+
+    @setup({'verbatim-tag04': '{% verbatim %}{% verbatim %}{% endverbatim %}{% endverbatim %}'})
+    def test_verbatim_tag04(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('verbatim-tag04')
+
+    @setup({'verbatim-tag05': '{% verbatim %}{% endverbatim %}{% verbatim %}{% endverbatim %}'})
+    def test_verbatim_tag05(self):
+        output = render('verbatim-tag05')
+        self.assertEqual(output, '')
+
+    @setup({'verbatim-tag06': '{% verbatim special %}'
+                              'Don\'t {% endverbatim %} just yet{% endverbatim special %}'})
+    def test_verbatim_tag06(self):
+        output = render('verbatim-tag06')
+        self.assertEqual(output, 'Don\'t {% endverbatim %} just yet')

tests/template_tests/syntax_tests/test_width_ratio.py

+from django.template.base import TemplateSyntaxError
+from django.template.loader import get_template
+from django.test import TestCase
+from django.utils import six
+
+from .utils import render, setup
+
+
+class WidthRatioTagTests(TestCase):
+
+    @setup({'widthratio01': '{% widthratio a b 0 %}'})
+    def test_widthratio01(self):
+        output = render('widthratio01', {'a': 50, 'b': 100})
+        self.assertEqual(output, '0')
+
+    @setup({'widthratio02': '{% widthratio a b 100 %}'})
+    def test_widthratio02(self):
+        output = render('widthratio02', {'a': 0, 'b': 0})
+        self.assertEqual(output, '0')
+
+    @setup({'widthratio03': '{% widthratio a b 100 %}'})
+    def test_widthratio03(self):
+        output = render('widthratio03', {'a': 0, 'b': 100})
+        self.assertEqual(output, '0')
+
+    @setup({'widthratio04': '{% widthratio a b 100 %}'})
+    def test_widthratio04(self):
+        output = render('widthratio04', {'a': 50, 'b': 100})
+        self.assertEqual(output, '50')
+
+    @setup({'widthratio05': '{% widthratio a b 100 %}'})
+    def test_widthratio05(self):
+        output = render('widthratio05', {'a': 100, 'b': 100})
+        self.assertEqual(output, '100')
+
+    @setup({'widthratio06': '{% widthratio a b 100 %}'})
+    def test_widthratio06(self):
+        """
+        62.5 should round to 63 on Python 2 and 62 on Python 3
+        See http://docs.python.org/py3k/whatsnew/3.0.html
+        """
+        output = render('widthratio06', {'a': 50, 'b': 80})
+        self.assertEqual(output, '62' if six.PY3 else '63')
+
+    @setup({'widthratio07': '{% widthratio a b 100 %}'})
+    def test_widthratio07(self):
+        """
+        71.4 should round to 71
+        """
+        output = render('widthratio07', {'a': 50, 'b': 70})
+        self.assertEqual(output, '71')
+
+    # Raise exception if we don't have 3 args, last one an integer
+    @setup({'widthratio08': '{% widthratio %}'})
+    def test_widthratio08(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('widthratio08')
+
+    @setup({'widthratio09': '{% widthratio a b %}'})
+    def test_widthratio09(self):
+        with self.assertRaises(TemplateSyntaxError):
+            render('widthratio09', {'a': 50, 'b': 100})
+
+    @setup({'widthratio10': '{% widthratio a b 100.0 %}'})
+    def test_widthratio10(self):
+        output = render('widthratio10', {'a': 50, 'b': 100})
+        self.assertEqual(output, '50')
+
+    @setup({'widthratio11': '{% widthratio a b c %}'})
+    def test_widthratio11(self):
+        """
+        #10043: widthratio should allow max_width to be a variable
+        """
+        output = render('widthratio11', {'a': 50, 'c': 100, 'b': 100})
+        self.assertEqual(output, '50')
+
+    # #18739: widthratio should handle None args consistently with
+    # non-numerics
+    @setup({'widthratio12a': '{% widthratio a b c %}'})
+    def test_widthratio12a(self):
+        output = render('widthratio12a', {'a': 'a', 'c': 100, 'b': 100})
+        self.assertEqual(output, '')
+
+    @setup({'widthratio12b': '{% widthratio a b c %}'})
+    def test_widthratio12b(self):
+        output = render('widthratio12b', {'a': None, 'c': 100, 'b': 100})
+        self.assertEqual(output, '')
+
+    @setup({'widthratio13a': '{% widthratio a b c %}'})
+    def test_widthratio13a(self):
+        output = render('widthratio13a', {'a': 0, 'c': 100, 'b': 'b'})
+        self.assertEqual(output, '')
+
+    @setup({'widthratio13b': '{% widthratio a b c %}'})
+    def test_widthratio13b(self):
+        output = render('widthratio13b', {'a': 0, 'c': 100, 'b': None})
+        self.assertEqual(output, '')
+
+    @setup({'widthratio14a': '{% widthratio a b c %}'})
+    def test_widthratio14a(self):
+        with self.assertRaises(TemplateSyntaxError):
+            render('widthratio14a', {'a': 0, 'c': 'c', 'b': 100})
+
+    @setup({'widthratio14b': '{% widthratio a b c %}'})
+    def test_widthratio14b(self):
+        with self.assertRaises(TemplateSyntaxError):
+            render('widthratio14b', {'a': 0, 'c': None, 'b': 100})
+
+    @setup({'widthratio15': '{% load custom %}{% widthratio a|noop:"x y" b 0 %}'})
+    def test_widthratio15(self):
+        """
+        Test whitespace in filter argument
+        """
+        output = render('widthratio15', {'a': 50, 'b': 100})
+        self.assertEqual(output, '0')
+
+    # Widthratio with variable assignment
+    @setup({'widthratio16': '{% widthratio a b 100 as variable %}-{{ variable }}-'})
+    def test_widthratio16(self):
+        output = render('widthratio16', {'a': 50, 'b': 100})
+        self.assertEqual(output, '-50-')
+
+    @setup({'widthratio17': '{% widthratio a b 100 as variable %}-{{ variable }}-'})
+    def test_widthratio17(self):
+        output = render('widthratio17', {'a': 100, 'b': 100})
+        self.assertEqual(output, '-100-')
+
+    @setup({'widthratio18': '{% widthratio a b 100 as %}'})
+    def test_widthratio18(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('widthratio18')
+
+    @setup({'widthratio19': '{% widthratio a b 100 not_as variable %}'})
+    def test_widthratio19(self):
+        with self.assertRaises(TemplateSyntaxError):
+            get_template('widthratio19')
+
+    @setup({'widthratio20': '{% widthratio a b 100 %}'})
+    def test_widthratio20(self):
+        output = render('widthratio20', {'a': float('inf'), 'b': float('inf')})
+        self.assertEqual(output, '')
+
+    @setup({'widthratio21': '{% widthratio a b 100 %}'})
+    def test_widthratio21(self):
+        output = render('widthratio21', {'a': float('inf'), 'b': 2})
+        self.assertEqual(output, '')

tests/template_tests/syntax_tests/test_with.py

+from django.conf import settings
+from django.template.base import TemplateSyntaxError
+from django.test import TestCase
+
+from .utils import render, setup
+
+
+class WithTagTests(TestCase):
+
+    @setup({'with01': '{% with key=dict.key %}{{ key }}{% endwith %}'})
+    def test_with01(self):
+        output = render('with01', {'dict': {'key': 50}})
+        self.assertEqual(output, '50')
+
+    @setup({'legacywith01': '{% with dict.key as key %}{{ key }}{% endwith %}'})
+    def test_legacywith01(self):
+        output = render('legacywith01', {'dict': {'key': 50}})
+        self.assertEqual(output, '50')
+
+    @setup({'with02': '{{ key }}{% with key=dict.key %}'
+                      '{{ key }}-{{ dict.key }}-{{ key }}'
+                      '{% endwith %}{{ key }}'})
+    def test_with02(self):
+        output = render('with02', {'dict': {'key': 50}})
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'INVALID50-50-50INVALID')
+        else:
+            self.assertEqual(output, '50-50-50')
+
+    @setup({'legacywith02': '{{ key }}{% with dict.key as key %}'
+                            '{{ key }}-{{ dict.key }}-{{ key }}'
+                            '{% endwith %}{{ key }}'})
+    def test_legacywith02(self):
+        output = render('legacywith02', {'dict': {'key': 50}})
+        if settings.TEMPLATE_STRING_IF_INVALID:
+            self.assertEqual(output, 'INVALID50-50-50INVALID')
+        else:
+            self.assertEqual(output, '50-50-50')
+
+    @setup({'with03': '{% with a=alpha b=beta %}{{ a }}{{ b }}{% endwith %}'})
+    def test_with03(self):
+        output = render('with03', {'alpha': 'A', 'beta': 'B'})
+        self.assertEqual(output, 'AB')
+
+    @setup({'with-error01': '{% with dict.key xx key %}{{ key }}{% endwith %}'})
+    def test_with_error01(self):
+        with self.assertRaises(TemplateSyntaxError):
+            render('with-error01', {'dict': {'key': 50}})
+
+    @setup({'with-error02': '{% with dict.key as %}{{ key }}{% endwith %}'})
+    def test_with_error02(self):
+        with self.assertRaises(TemplateSyntaxError):
+            render('with-error02', {'dict': {'key': 50}})

tests/template_tests/syntax_tests/utils.py

+# coding: utf-8
+
+from __future__ import unicode_literals
+
+import functools
+
+from django import template
+from django.template import Library
+from django.template.base import Context
+from django.template.engine import Engine
+from django.template.loader import get_template
+from django.test.utils import override_settings
+from django.utils import translation
+from django.utils.encoding import python_2_unicode_compatible
+from django.utils.safestring import mark_safe
+
+
+def render(template_name, context=None):
+    if context is None:
+        context = {}
+
+    t = get_template(template_name)
+    with translation.override(context.get('LANGUAGE_CODE', 'en-us')):
+        return t.render(Context(context))
+
+
+def setup(templates, *args):
+    """
+    Runs test method multiple times in the following order:
+
+    TEMPLATE_DEBUG      CACHED      TEMPLATE_STRING_IF_INVALID
+    --------------      ------      --------------------------
+    False               False
+    False               True
+    False               False       INVALID
+    False               True        INVALID
+    True                False
+    True                True
+    """
+
+    for arg in args:
+        templates.update(arg)
+
+    # numerous tests make use of an inclusion tag
+    # add this in here for simplicity
+    templates["inclusion.html"] = "{{ result }}"
+
+    def decorator(func):
+        @register_test_tags
+        @override_settings(TEMPLATE_LOADERS=[
+            ('django.template.loaders.cached.Loader', [
+                ('django.template.loaders.locmem.Loader', templates),
+            ]),
+        ])
+        def inner(self):
+            loader = Engine.get_default().template_loaders[0]
+
+            func(self)
+            func(self)
+            loader.reset()
+
+            with override_settings(TEMPLATE_STRING_IF_INVALID='INVALID'):
+                func(self)
+                func(self)
+                loader.reset()
+
+            with override_settings(TEMPLATE_DEBUG=True):
+                func(self)
+                func(self)
+                loader.reset()
+        return inner
+    return decorator
+
+
+# Custom template tag for tests
+
+register = Library()
+
+
+class EchoNode(template.Node):
+    def __init__(self, contents):
+        self.contents = contents
+
+    def render(self, context):
+        return ' '.join(self.contents)
+
+
+@register.tag
+def echo(parser, token):
+    return EchoNode(token.contents.split()[1:])
+register.tag('other_echo', echo)
+
+
+@register.filter
+def upper(value):
+    return value.upper()
+
+
+def register_test_tags(func):
+    @functools.wraps(func)
+    def inner(self):
+        template.libraries['testtags'] = register
+        func(self)
+        del template.libraries['testtags']
+    return inner
+
+
+# Helper objects
+
+class SomeException(Exception):
+    silent_variable_failure = True
+
+
+class SomeOtherException(Exception):
+    pass
+
+
+class ShouldNotExecuteException(Exception):
+    pass
+
+
+class SomeClass:
+    def __init__(self):
+        self.otherclass = OtherClass()
+
+    def method(self):
+        return 'SomeClass.method'
+
+    def method2(self, o):
+        return o
+
+    def method3(self):
+        raise SomeException
+
+    def method4(self):
+        raise SomeOtherException
+
+    def method5(self):
+        raise TypeError
+
+    def __getitem__(self, key):
+        if key == 'silent_fail_key':
+            raise SomeException
+        elif key == 'noisy_fail_key':
+            raise SomeOtherException
+        raise KeyError
+
+    @property
+    def silent_fail_attribute(self):
+        raise SomeException
+
+    @property
+    def noisy_fail_attribute(self):
+        raise SomeOtherException
+
+    @property
+    def attribute_error_attribute(self):
+        raise AttributeError
+
+
+class OtherClass:
+    def method(self):
+        return 'OtherClass.method'
+
+
+class TestObj(object):
+    def is_true(self):
+        return True
+
+    def is_false(self):
+        return False
+
+    def is_bad(self):
+        raise ShouldNotExecuteException()
+
+
+class SilentGetItemClass(object):
+    def __getitem__(self, key):
+        raise SomeException
+
+
+class SilentAttrClass(object):
+    def b(self):
+        raise SomeException
+    b = property(b)
+
+
+@python_2_unicode_compatible
+class UTF8Class:
+    "Class whose __str__ returns non-ASCII data on Python 2"
+    def __str__(self):
+        return 'ŠĐĆŽćžšđ'
+
+
+# These two classes are used to test auto-escaping of unicode output.
+@python_2_unicode_compatible
+class UnsafeClass:
+    def __str__(self):
+        return 'you & me'
+
+
+@python_2_unicode_compatible
+class SafeClass:
+    def __str__(self):
+        return mark_safe('you > me')