Context Navigation

Back to Ticket #2333

Ticket #2333: revised-tests.patch

File revised-tests.patch, 164.4 KB (added by Russell Keith-Magee, 18 years ago)
Combined version of previous patches to tests directory, with some minor revisions and cleanup

tests/modeltests/basic/models.py

     def __str__(self):
         return self.headline
+API_TESTS = """
+__test__ = {'API_TESTS': """
 # No articles are in the system yet.
 >>> Article.objects.all()
 []
 …
 >>> Article.objects.all()
 [<Article: Article 6>, <Article: Default headline>, <Article: Article 7>, <Article: Updated article 8>]
 """
+"""}
 from django.conf import settings
 building_docs = getattr(settings, 'BUILDING_DOCS', False)
 if building_docs or settings.DATABASE_ENGINE == 'postgresql':
     API_TESTS += """
+    __test__['API_TESTS'] += """
 # In PostgreSQL, microsecond-level precision is available.
 >>> a9 = Article(headline='Article 9', pub_date=datetime(2005, 7, 31, 12, 30, 45, 180))
 >>> a9.save()
 …
 """
 if building_docs or settings.DATABASE_ENGINE == 'mysql':
     API_TESTS += """
+    __test__['API_TESTS'] += """
 # In MySQL, microsecond-level precision isn't available. You'll lose
 # microsecond-level precision once the data is saved.
 >>> a9 = Article(headline='Article 9', pub_date=datetime(2005, 7, 31, 12, 30, 45, 180))
 …
 datetime.datetime(2005, 7, 31, 12, 30, 45)
 """
 API_TESTS += """
+__test__['API_TESTS'] += """
 # You can manually specify the primary key when creating a new object.
 >>> a101 = Article(id=101, headline='Article 101', pub_date=datetime(2005, 7, 31, 12, 30, 45))

tests/modeltests/m2m_recursive/models.py

     def __str__(self):
         return self.name
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 >>> a = Person(name='Anne')
 >>> a.save()
 >>> b = Person(name='Bill')
 …
 >>> d.stalkers.all()
 [<Person: Chuck>]
 """
+"""}

tests/modeltests/one_to_one/models.py

     def __str__(self):
         return "%s the waiter at %s" % (self.name, self.restaurant)
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Create a couple of Places.
 >>> p1 = Place(name='Demon Dogs', address='944 W. Fullerton')
 >>> p1.save()
 …
 # Delete the restaurant; the waiter should also be removed
 >>> r = Restaurant.objects.get(pk=1)
 >>> r.delete()
 """
+"""}

tests/modeltests/m2o_recursive/models.py

     def __str__(self):
         return self.name
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Create a few Category objects.
 >>> r = Category(id=None, name='Root category', parent=None)
 >>> r.save()
 …
 []
 >>> c.parent
 <Category: Root category>
 """
+"""}

tests/modeltests/custom_managers/models.py

     def __str__(self):
         return self.name
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 >>> p1 = Person(first_name='Bugs', last_name='Bunny', fun=True)
 >>> p1.save()
 >>> p2 = Person(first_name='Droopy', last_name='Dog', fun=False)
 …
 # to the first manager defined in the class. In this case, it's "cars".
 >>> Car._default_manager.order_by('name')
 [<Car: Corvette>, <Car: Neon>]
 """
+"""}

tests/modeltests/invalid_models/models.py

 error_log = """invalid_models.fielderrors: "charfield": CharFields require a "maxlength" attribute.
+model_errors = """invalid_models.fielderrors: "charfield": CharFields require a "maxlength" attribute.
 invalid_models.fielderrors: "floatfield": FloatFields require a "decimal_places" attribute.
 invalid_models.fielderrors: "floatfield": FloatFields require a "max_digits" attribute.
 invalid_models.fielderrors: "filefield": FileFields require an "upload_to" attribute.

tests/modeltests/many_to_many/models.py

     class Meta:
         ordering = ('headline',)
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Create a couple of Publications.
 >>> p1 = Publication(id=None, title='The Python Journal')
 >>> p1.save()
 …
 >>> p1.article_set.all()
 [<Article: NASA uses Python>]
 """
+"""}

tests/modeltests/m2m_and_m2o/models.py

         ordering = ('num',)
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 >>> Issue.objects.all()
 []
 >>> r = User(username='russell')
 …
 [<Issue: 1>, <Issue: 2>, <Issue: 3>]
 >>> Issue.objects.filter(Q(client=r.id) | Q(cc__id__exact=r.id))
 [<Issue: 1>, <Issue: 2>, <Issue: 3>]
 """
+"""}

tests/modeltests/validation/models.py

     def __str__(self):
         return self.name
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 >>> import datetime
 >>> valid_params = {
 …
 >>> p.validate()
 {'email': ['Enter a valid e-mail address.']}
 """
+"""}

tests/modeltests/or_lookups/models.py

     def __str__(self):
         return self.headline
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 >>> from datetime import datetime
 >>> from django.db.models import Q
 …
 [<Article: Hello>]
 >>> Article.objects.complex_filter(Q(pk=1) | Q(pk=2))
 [<Article: Hello>, <Article: Goodbye>]
 """
+"""}

tests/modeltests/mutually_referential/models.py

     name = CharField(maxlength=100)
     parent = ForeignKey(Parent)
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Create a Parent
 >>> q = Parent(name='Elizabeth')
 >>> q.save()
 …
 >>> q.delete()
 """
  No newline at end of file
+"""}
+ No newline at end of file

tests/modeltests/custom_methods/models.py

         # positional arguments to Article().
         return [self.__class__(*row) for row in cursor.fetchall()]
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Create a couple of Articles.
 >>> from datetime import date
 >>> a = Article(id=None, headline='Area man programs in Python', pub_date=date(2005, 7, 27))
 …
 [<Article: Area man programs in Python>]
 >>> b.articles_from_same_day_2()
 [<Article: Area man programs in Python>]
 """
+"""}

tests/modeltests/empty/models.py

 class Empty(models.Model):
     pass
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 >>> m = Empty()
 >>> m.id
 >>> m.save()
 …
 >>> existing = Empty(m.id)
 >>> existing.save()
 """
+"""}

tests/modeltests/many_to_one_null/models.py

     def __str__(self):
         return self.headline
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Create a Reporter.
 >>> r = Reporter(name='John Smith')
 >>> r.save()
 …
 >>> Article.objects.filter(reporter__isnull=True)
 [<Article: First>, <Article: Fourth>]
 """
+"""}

tests/modeltests/get_or_create/models.py

     def __str__(self):
         return '%s %s' % (self.first_name, self.last_name)
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Acting as a divine being, create an Person.
 >>> from datetime import date
 >>> p = Person(first_name='John', last_name='Lennon', birthday=date(1940, 10, 9))
 …
 False
 >>> Person.objects.count()
 """
+"""}

tests/modeltests/custom_pk/models.py

     def __str__(self):
         return self.name
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 >>> dan = Employee(employee_code='ABC123', first_name='Dan', last_name='Jones')
 >>> dan.save()
 >>> Employee.objects.all()
 …
 >>> Business.objects.filter(employees__first_name__startswith='Fran')
 [<Business: Sears>]
 """
+"""}

tests/modeltests/reverse_lookup/models.py

     def __str(self):
         return self.name
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 >>> john = User(name="John Doe")
 >>> john.save()
 >>> jim = User(name="Jim Bo")
 …
 Traceback (most recent call last):
     ...
 TypeError: Cannot resolve keyword 'choice' into field
 """
+"""}

tests/modeltests/m2o_recursive2/models.py

     def __str__(self):
         return self.full_name
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Create two Person objects -- the mom and dad in our family.
 >>> dad = Person(full_name='John Smith Senior', mother=None, father=None)
 >>> dad.save()
 …
 []
 >>> kid.fathers_child_set.all()
 []
 """
+"""}

tests/modeltests/m2m_multiple/models.py

     def __str__(self):
         return self.headline
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 >>> from datetime import datetime
 >>> c1 = Category(name='Sports')
 …
 []
 >>> c4.secondary_article_set.all()
 [<Article: Area man steals>, <Article: Area man runs>]
 """
+"""}

tests/modeltests/m2m_intermediary/models.py

     def __str__(self):
         return '%s (%s)' % (self.reporter, self.position)
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Create a few Reporters.
 >>> r1 = Reporter(first_name='John', last_name='Smith')
 >>> r1.save()
 …
 <Article: This is a test>
 >>> r1.writer_set.all()
 [<Writer: John Smith (Main writer)>]
 """
+"""}

tests/modeltests/str/models.py

     def __str__(self):
         return self.headline
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Create an Article.
 >>> from datetime import datetime
 >>> a = Article(headline='Area man programs in Python', pub_date=datetime(2005, 7, 28))
 …
 >>> a
 <Article: Area man programs in Python>
 """
+"""}

tests/modeltests/transactions/models.py

     def __str__(self):
         return "%s %s" % (self.first_name, self.last_name)
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 >>> from django.db import connection, transaction
 """
+"""}
 from django.conf import settings
 building_docs = getattr(settings, 'BUILDING_DOCS', False)
 if building_docs or settings.DATABASE_ENGINE != 'mysql':
     API_TESTS += """
+    __test__['API_TESTS'] += """
 # the default behavior is to autocommit after each save() action
 >>> def create_a_reporter_then_fail(first, last):
 ...     a = Reporter(first_name=first, last_name=last)

tests/modeltests/model_inheritance/models.py

     def __str__(self):
         return "%s the italian restaurant" % self.name
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Make sure Restaurant has the right fields in the right order.
 >>> [f.name for f in Restaurant._meta.fields]
 ['id', 'name', 'address', 'serves_hot_dogs', 'serves_pizza']
 …
 >>> ir.save()
 """
+"""}

tests/modeltests/lookup/models.py

     def __str__(self):
         return self.headline
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Create a couple of Articles.
 >>> from datetime import datetime
 >>> a1 = Article(headline='Article 1', pub_date=datetime(2005, 7, 26))
 …
 [<Article: Article% with percent sign>, <Article: Article 5>, <Article: Article 6>, <Article: Article 4>, <Article: Article 2>, <Article: Article 3>, <Article: Article 7>, <Article: Article 1>]
 >>> Article.objects.exclude(headline="Article 7")
 [<Article: Article% with percent sign>, <Article: Article_ with underscore>, <Article: Article 5>, <Article: Article 6>, <Article: Article 4>, <Article: Article 2>, <Article: Article 3>, <Article: Article 1>]
 """
+"""}

tests/modeltests/choices/models.py

     def __str__(self):
         return self.name
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 >>> a = Person(name='Adrian', gender='M')
 >>> a.save()
 >>> s = Person(name='Sara', gender='F')
 …
 'Male'
 >>> s.get_gender_display()
 'Female'
 """
+"""}

tests/modeltests/save_delete_hooks/models.py

         super(Person, self).delete() # Call the "real" delete() method
         print "After deletion"
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 >>> p1 = Person(first_name='John', last_name='Smith')
 >>> p1.save()
 Before save
 …
 >>> Person.objects.all()
 []
 """
+"""}

tests/modeltests/pagination/models.py

     def __str__(self):
         return self.headline
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # prepare a list of objects for pagination
 >>> from datetime import datetime
 >>> for x in range(1, 10):
 …
 >>> paginator.last_on_page(1)
 """
+"""}

tests/modeltests/get_latest/models.py

     def __str__(self):
         return self.name
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Because no Articles exist yet, get_latest() raises ArticleDoesNotExist.
 >>> Article.objects.latest()
 Traceback (most recent call last):
 …
 >>> Person.objects.latest('birthday')
 <Person: Stephanie>
 """
+"""}

tests/modeltests/properties/models.py

     full_name_2 = property(_get_full_name, _set_full_name)
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 >>> a = Person(first_name='John', last_name='Lennon')
 >>> a.save()
 >>> a.full_name
 …
 >>> a2.save()
 >>> a2.first_name
 'Paul'
 """
+"""}

tests/modeltests/generic_relations/models.py

     def __str__(self):
         return self.name
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Create the world in 7 lines of code...
 >>> lion = Animal(common_name="Lion", latin_name="Panthera leo")
 >>> platypus = Animal(common_name="Platypus", latin_name="Ornithorhynchus anatinus")
 …
 [<TaggedItem: shiny>]
 >>> TaggedItem.objects.filter(content_type__pk=ctype.id, object_id=quartz.id)
 [<TaggedItem: clearish>]
 """
+"""}

tests/modeltests/serializers/models.py

     def __str__(self):
         return self.headline
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Create some data:
 >>> from datetime import datetime
 >>> sports = Category(name="Sports")
 …
 >>> Article.objects.all()
 [<Article: Just kidding; I love TV poker>, <Article: Time to reform copyright>]
 """
+"""}

tests/modeltests/reserved_names/models.py

     def __str__(self):
         return self.when
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 >>> import datetime
 >>> day1 = datetime.date(2005, 1, 1)
 >>> day2 = datetime.date(2006, 2, 2)
 …
 >>> Thing.objects.filter(where__month=1)
 [<Thing: a>]
 """
+"""}

tests/modeltests/many_to_one/models.py

     class Meta:
         ordering = ('headline',)
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Create a few Reporters.
 >>> r = Reporter(first_name='John', last_name='Smith', email='john@example.com')
 >>> r.save()
 …
 >>> Article.objects.all()
 []
 """
+"""}

tests/modeltests/ordering/models.py

     def __str__(self):
         return self.headline
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Create a couple of Articles.
 >>> from datetime import datetime
 >>> a1 = Article(headline='Article 1', pub_date=datetime(2005, 7, 26))
 …
 # don't know what order the output will be in.
 >>> Article.objects.order_by('?')
 [...]
 """
+"""}

tests/modeltests/custom_columns/models.py

     def __str__(self):
         return '%s %s' % (self.first_name, self.last_name)
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Create a Person.
 >>> p = Person(first_name='John', last_name='Smith')
 >>> p.save()
 …
 Traceback (most recent call last):
     ...
 AttributeError: 'Person' object has no attribute 'last'
 """
+"""}

tests/modeltests/field_defaults/models.py

     def __str__(self):
         return self.headline
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 >>> from datetime import datetime
 # No articles are in the system yet.
 …
 >>> d = now - a.pub_date
 >>> d.seconds < 5
 True
 """
+"""}

tests/modeltests/manipulators/models.py

     def __str__(self):
         return self.name
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 >>> from django.utils.datastructures import MultiValueDict
 # Create a Musician object via the default AddManipulator.
 …
 <Album: Ultimate Ella>
 >>> a2.release_date
 datetime.date(2005, 2, 13)
 """
+"""}

tests/regressiontests/string_lookup/models.py

     def __str__(self):
         return "Base %s" % self.name
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Regression test for #1661 and #1662: Check that string form referencing of models works,
 # both as pre and post reference, on all RelatedField types.
 …
 >>> child1.parent
 <Base: Base Base1>
 """
+"""}

tests/regressiontests/markup/tests.py

+# Quick tests for the markup templatetags (django.contrib.markup)
+from django.template import Template, Context, add_to_builtins
+import re
+import unittest
+add_to_builtins('django.contrib.markup.templatetags.markup')
+class Templates(unittest.TestCase):
+    def test_textile(self):
+        try:
+            import textile
+        except ImportError:
+            textile = None
+        ### test textile
+        textile_content = """Paragraph 1
+Paragraph 2 with "quotes" and @code@"""
+        t = Template("{{ textile_content|textile }}")
+        rendered = t.render(Context(locals())).strip()
+        if textile:
+            self.assertEqual(rendered,"""<p>Paragraph 1</p>
+<p>Paragraph 2 with &#8220;quotes&#8221; and <code>code</code></p>""")
+        else:
+            self.assertEqual(rendered, textile_content)
+    def test_markdown(self):
+        try:
+            import markdown
+        except ImportError:
+            markdown = None
+        ### test markdown
+        markdown_content = """Paragraph 1
+## An h2"""
+        t = Template("{{ markdown_content|markdown }}")
+        rendered = t.render(Context(locals())).strip()
+        if markdown:
+            pattern = re.compile("""<p>Paragraph 1\s*</p>\s*<h2>\s*An h2</h2>""")
+            self.assert_(pattern.match(rendered))
+        else:
+            self.assertEqual(rendered, markdown_content)
+    def test_rest(self):
+        try:
+            import docutils
+        except ImportError:
+            docutils = None
+        ### test rest
+        rest_content = """Paragraph 1
+Paragraph 2 with a link_
+.. _link: http://www.example.com/"""
+        t = Template("{{ rest_content|restructuredtext }}")
+        rendered = t.render(Context(locals())).strip()
+        if docutils:
+            self.assertEqual(rendered, """<p>Paragraph 1</p>
+<p>Paragraph 2 with a <a class="reference" href="http://www.example.com/">link</a></p>""")
+        else:
+            self.assertEqual(rendered, rest_content)
+if __name__ == '__main__':
+    unittest.main()

tests/regressiontests/many_to_one_regress/models.py


10	10	# created (the field names being lower-cased versions of their opposite
11	11	# classes is important here).
12	12
13		API_TESTS = ""
	13	__test__ = {'API_TESTS':""}

tests/regressiontests/initial_sql_regress/models.py

 class Simple(models.Model):
     name = models.CharField(maxlength = 50)
+API_TESTS = ""
+__test__ = {'API_TESTS':""}
 # NOTE: The format of the included SQL file for this test suite is important.
 # It must end with a trailing newline in order to test the fix for #2161.

tests/regressiontests/cache/tests.py

+# Unit tests for cache framework
+# Uses whatever cache backend is set in the test settings file.
+from django.core.cache import cache
+import time, unittest
+# functions/classes for complex data type tests
+def f():
+    return 42
+class C:
+    def m(n):
+        return 24
+class Cache(unittest.TestCase):
+    def test_simple(self):
+        # simple set/get
+        cache.set("key", "value")
+        self.assertEqual(cache.get("key"), "value")
+    def test_non_existent(self):
+        # get with non-existent keys
+        self.assertEqual(cache.get("does not exist"), None)
+        self.assertEqual(cache.get("does not exist", "bang!"), "bang!")
+    def test_get_many(self):
+        # get_many
+        cache.set('a', 'a')
+        cache.set('b', 'b')
+        cache.set('c', 'c')
+        cache.set('d', 'd')
+        self.assertEqual(cache.get_many(['a', 'c', 'd']), {'a' : 'a', 'c' : 'c', 'd' : 'd'})
+        self.assertEqual(cache.get_many(['a', 'b', 'e']), {'a' : 'a', 'b' : 'b'})
+    def test_delete(self):
+        # delete
+        cache.set("key1", "spam")
+        cache.set("key2", "eggs")
+        self.assertEqual(cache.get("key1"), "spam")
+        cache.delete("key1")
+        self.assertEqual(cache.get("key1"), None)
+        self.assertEqual(cache.get("key2"), "eggs")
+    def test_has_key(self):
+        # has_key
+        cache.set("hello", "goodbye")
+        self.assertEqual(cache.has_key("hello"), True)
+        self.assertEqual(cache.has_key("goodbye"), False)
+    def test_data_types(self):
+        # test data types
+        stuff = {
+            'string'    : 'this is a string',
+            'int'       : 42,
+            'list'      : [1, 2, 3, 4],
+            'tuple'     : (1, 2, 3, 4),
+            'dict'      : {'A': 1, 'B' : 2},
+            'function'  : f,
+            'class'     : C,
+        }
+        for (key, value) in stuff.items():
+            cache.set(key, value)
+            self.assertEqual(cache.get(key), value)
+        # expiration
+        cache.set('expire', 'very quickly', 1)
+        time.sleep(2)
+        self.assertEqual(cache.get("expire"), None)
+if __name__ == '__main__':
+    unittest.main()
+ No newline at end of file

tests/regressiontests/httpwrappers/tests.py

+"""
+###################
+# Empty QueryDict #
+###################
+>>> q = QueryDict('')
+>>> q['foo']
+Traceback (most recent call last):
+...
+MultiValueDictKeyError: "Key 'foo' not found in <MultiValueDict: {}>"
+>>> q['something'] = 'bar'
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.get('foo', 'default')
+'default'
+>>> q.getlist('foo')
+[]
+>>> q.setlist('foo', ['bar', 'baz'])
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.appendlist('foo', ['bar'])
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.has_key('foo')
+False
+>>> q.items()
+[]
+>>> q.lists()
+[]
+>>> q.keys()
+[]
+>>> q.values()
+[]
+>>> len(q)
+>>> q.update({'foo': 'bar'})
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.pop('foo')
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.popitem()
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.clear()
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.setdefault('foo', 'bar')
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.urlencode()
+''
+###################################
+# Mutable copy of empty QueryDict #
+###################################
+>>> q = q.copy()
+>>> q['foo']
+Traceback (most recent call last):
+...
+MultiValueDictKeyError: "Key 'foo' not found in <MultiValueDict: {}>"
+>>> q['name'] = 'john'
+>>> q['name']
+'john'
+>>> q.get('foo', 'default')
+'default'
+>>> q.get('name', 'default')
+'john'
+>>> q.getlist('name')
+['john']
+>>> q.getlist('foo')
+[]
+>>> q.setlist('foo', ['bar', 'baz'])
+>>> q.get('foo', 'default')
+'baz'
+>>> q.getlist('foo')
+['bar', 'baz']
+>>> q.appendlist('foo', 'another')
+>>> q.getlist('foo')
+['bar', 'baz', 'another']
+>>> q['foo']
+'another'
+>>> q.has_key('foo')
+True
+>>> q.items()
+[('foo', 'another'), ('name', 'john')]
+>>> q.lists()
+[('foo', ['bar', 'baz', 'another']), ('name', ['john'])]
+>>> q.keys()
+['foo', 'name']
+>>> q.values()
+['another', 'john']
+>>> len(q)
+>>> q.update({'foo': 'hello'})
+# Displays last value
+>>> q['foo']
+'hello'
+>>> q.get('foo', 'not available')
+'hello'
+>>> q.getlist('foo')
+['bar', 'baz', 'another', 'hello']
+>>> q.pop('foo')
+['bar', 'baz', 'another', 'hello']
+>>> q.get('foo', 'not there')
+'not there'
+>>> q.setdefault('foo', 'bar')
+'bar'
+>>> q['foo']
+'bar'
+>>> q.getlist('foo')
+['bar']
+>>> q.urlencode()
+'foo=bar&name=john'
+>>> q.clear()
+>>> len(q)
+#####################################
+# QueryDict with one key/value pair #
+#####################################
+>>> q = QueryDict('foo=bar')
+>>> q['foo']
+'bar'
+>>> q['bar']
+Traceback (most recent call last):
+...
+MultiValueDictKeyError: "Key 'bar' not found in <MultiValueDict: {'foo': ['bar']}>"
+>>> q['something'] = 'bar'
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.get('foo', 'default')
+'bar'
+>>> q.get('bar', 'default')
+'default'
+>>> q.getlist('foo')
+['bar']
+>>> q.getlist('bar')
+[]
+>>> q.setlist('foo', ['bar', 'baz'])
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.appendlist('foo', ['bar'])
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.has_key('foo')
+True
+>>> q.has_key('bar')
+False
+>>> q.items()
+[('foo', 'bar')]
+>>> q.lists()
+[('foo', ['bar'])]
+>>> q.keys()
+['foo']
+>>> q.values()
+['bar']
+>>> len(q)
+>>> q.update({'foo': 'bar'})
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.pop('foo')
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.popitem()
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.clear()
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.setdefault('foo', 'bar')
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.urlencode()
+'foo=bar'
+#####################################################
+# QueryDict with two key/value pairs with same keys #
+#####################################################
+>>> q = QueryDict('vote=yes&vote=no')
+>>> q['vote']
+'no'
+>>> q['something'] = 'bar'
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.get('vote', 'default')
+'no'
+>>> q.get('foo', 'default')
+'default'
+>>> q.getlist('vote')
+['yes', 'no']
+>>> q.getlist('foo')
+[]
+>>> q.setlist('foo', ['bar', 'baz'])
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.appendlist('foo', ['bar'])
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.has_key('vote')
+True
+>>> q.has_key('foo')
+False
+>>> q.items()
+[('vote', 'no')]
+>>> q.lists()
+[('vote', ['yes', 'no'])]
+>>> q.keys()
+['vote']
+>>> q.values()
+['no']
+>>> len(q)
+>>> q.update({'foo': 'bar'})
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.pop('foo')
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.popitem()
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.clear()
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.setdefault('foo', 'bar')
+Traceback (most recent call last):
+...
+AttributeError: This QueryDict instance is immutable
+>>> q.urlencode()
+'vote=yes&vote=no'
+"""
+from django.http import QueryDict
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()

tests/regressiontests/db_typecasts/tests.py

+# Unit tests for typecast functions in django.db.backends.util
+from django.db.backends import util as typecasts
+import datetime, unittest
+TEST_CASES = {
+    'typecast_date': (
+        ('', None),
+        (None, None),
+        ('2005-08-11', datetime.date(2005, 8, 11)),
+        ('1990-01-01', datetime.date(1990, 1, 1)),
+    ),
+    'typecast_time': (
+        ('', None),
+        (None, None),
+        ('0:00:00', datetime.time(0, 0)),
+        ('0:30:00', datetime.time(0, 30)),
+        ('8:50:00', datetime.time(8, 50)),
+        ('08:50:00', datetime.time(8, 50)),
+        ('12:00:00', datetime.time(12, 00)),
+        ('12:30:00', datetime.time(12, 30)),
+        ('13:00:00', datetime.time(13, 00)),
+        ('23:59:00', datetime.time(23, 59)),
+        ('00:00:12', datetime.time(0, 0, 12)),
+        ('00:00:12.5', datetime.time(0, 0, 12, 500000)),
+        ('7:22:13.312', datetime.time(7, 22, 13, 312000)),
+    ),
+    'typecast_timestamp': (
+        ('', None),
+        (None, None),
+        ('2005-08-11 0:00:00', datetime.datetime(2005, 8, 11)),
+        ('2005-08-11 0:30:00', datetime.datetime(2005, 8, 11, 0, 30)),
+        ('2005-08-11 8:50:30', datetime.datetime(2005, 8, 11, 8, 50, 30)),
+        ('2005-08-11 8:50:30.123', datetime.datetime(2005, 8, 11, 8, 50, 30, 123000)),
+        ('2005-08-11 8:50:30.9', datetime.datetime(2005, 8, 11, 8, 50, 30, 900000)),
+        ('2005-08-11 8:50:30.312-05', datetime.datetime(2005, 8, 11, 8, 50, 30, 312000)),
+        ('2005-08-11 8:50:30.312+02', datetime.datetime(2005, 8, 11, 8, 50, 30, 312000)),
+    ),
+    'typecast_boolean': (
+        (None, None),
+        ('', False),
+        ('t', True),
+        ('f', False),
+        ('x', False),
+    ),
+}
+class DBTypeCasts(unittest.TestCase):
+    def test_typeCasts(self):
+        for k, v in TEST_CASES.items():
+            for inpt, expected in v:
+                got = getattr(typecasts, k)(inpt)
+                self.assertEqual(got, expected, "In %s: %r doesn't match %r. Got %r instead." % (k, inpt, expected, got))
+if __name__ == '__main__':
+    unittest.main()
+ No newline at end of file

tests/regressiontests/dateformat/tests.py

+r"""
+>>> format(my_birthday, '')
+''
+>>> format(my_birthday, 'a')
+'p.m.'
+>>> format(my_birthday, 'A')
+'PM'
+>>> format(my_birthday, 'd')
+'08'
+>>> format(my_birthday, 'j')
+'8'
+>>> format(my_birthday, 'l')
+'Sunday'
+>>> format(my_birthday, 'L')
+'False'
+>>> format(my_birthday, 'm')
+'07'
+>>> format(my_birthday, 'M')
+'Jul'
+>>> format(my_birthday, 'n')
+'7'
+>>> format(my_birthday, 'N')
+'July'
+>>> format(my_birthday, 'O')
+'+0100'
+>>> format(my_birthday, 'P')
+'10 p.m.'
+>>> format(my_birthday, 'r')
+'Sun, 8 Jul 1979 22:00:00 +0100'
+>>> format(my_birthday, 's')
+'00'
+>>> format(my_birthday, 'S')
+'th'
+>>> format(my_birthday, 't')
+'31'
+>>> format(my_birthday, 'T')
+'CET'
+>>> format(my_birthday, 'U')
+'300531600'
+>>> format(my_birthday, 'w')
+'0'
+>>> format(my_birthday, 'W')
+'27'
+>>> format(my_birthday, 'y')
+'79'
+>>> format(my_birthday, 'Y')
+'1979'
+>>> format(my_birthday, 'z')
+'189'
+>>> format(my_birthday, 'Z')
+'3600'
+>>> format(summertime, 'I')
+'1'
+>>> format(summertime, 'O')
+'+0200'
+>>> format(wintertime, 'I')
+'0'
+>>> format(wintertime, 'O')
+'+0100'
+>>> format(my_birthday, r'Y z \C\E\T')
+'1979 189 CET'
+>>> format(my_birthday, r'jS o\f F')
+'8th of July'
+"""
+from django.utils import dateformat, translation
+import datetime, os, time
+format = dateformat.format
+os.environ['TZ'] = 'Europe/Copenhagen'
+translation.activate('en-us')
+#time.tzset()
+my_birthday = datetime.datetime(1979, 7, 8, 22, 00)
+summertime = datetime.datetime(2005, 10, 30, 1, 00)
+wintertime = datetime.datetime(2005, 10, 30, 4, 00)
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

tests/regressiontests/defaultfilters/tests.py

+r"""
+>>> floatformat(7.7)
+'7.7'
+>>> floatformat(7.0)
+'7'
+>>> floatformat(0.7)
+'0.7'
+>>> floatformat(0.07)
+'0.1'
+>>> floatformat(0.007)
+'0.0'
+>>> floatformat(0.0)
+'0'
+>>> addslashes('"double quotes" and \'single quotes\'')
+'\\"double quotes\\" and \\\'single quotes\\\''
+>>> capfirst('hello world')
+'Hello world'
+>>> fix_ampersands('Jack & Jill & Jeroboam')
+'Jack &amp; Jill &amp; Jeroboam'
+>>> linenumbers('line 1\nline 2')
+'1. line 1\n2. line 2'
+>>> linenumbers('\n'.join(['x'] * 10))
+'01. x\n02. x\n03. x\n04. x\n05. x\n06. x\n07. x\n08. x\n09. x\n10. x'
+>>> lower('TEST')
+'test'
+>>> lower(u'\xcb') # uppercase E umlaut
+u'\xeb'
+>>> make_list('abc')
+['a', 'b', 'c']
+>>> make_list(1234)
+['1', '2', '3', '4']
+>>> slugify(' Jack & Jill like numbers 1,2,3 and 4 and silly characters ?%.$!/')
+'jack-jill-like-numbers-123-and-4-and-silly-characters'
+>>> stringformat(1, '03d')
+'001'
+>>> stringformat(1, 'z')
+''
+>>> title('a nice title, isn\'t it?')
+"A Nice Title, Isn't It?"
+>>> truncatewords('A sentence with a few words in it', 1)
+'A ...'
+>>> truncatewords('A sentence with a few words in it', 5)
+'A sentence with a few ...'
+>>> truncatewords('A sentence with a few words in it', 100)
+'A sentence with a few words in it'
+>>> truncatewords('A sentence with a few words in it', 'not a number')
+'A sentence with a few words in it'
+>>> upper('Mixed case input')
+'MIXED CASE INPUT'
+>>> upper(u'\xeb') # lowercase e umlaut
+u'\xcb'
+>>> urlencode('jack & jill')
+'jack%20%26%20jill'
+>>> urlizetrunc('http://short.com/', 20)
+'<a href="http://short.com/" rel="nofollow">http://short.com/</a>'
+>>> urlizetrunc('http://www.google.co.uk/search?hl=en&q=some+long+url&btnG=Search&meta=', 20)
+'<a href="http://www.google.co.uk/search?hl=en&q=some+long+url&btnG=Search&meta=" rel="nofollow">http://www.google.co...</a>'
+>>> wordcount('')
+>>> wordcount('oneword')
+>>> wordcount('lots of words')
+>>> wordwrap('this is a long paragraph of text that really needs to be wrapped I\'m afraid', 14)
+"this is a long\nparagraph of\ntext that\nreally needs\nto be wrapped\nI'm afraid"
+>>> ljust('test', 10)
+'test      '
+>>> ljust('test', 3)
+'test'
+>>> rjust('test', 10)
+'      test'
+>>> rjust('test', 3)
+'test'
+>>> center('test', 6)
+' test '
+>>> cut('a string to be mangled', 'a')
+' string to be mngled'
+>>> cut('a string to be mangled', 'ng')
+'a stri to be maled'
+>>> cut('a string to be mangled', 'strings')
+'a string to be mangled'
+>>> escape('<some html & special characters > here')
+'&lt;some html &amp; special characters &gt; here'
+>>> linebreaks('line 1')
+'<p>line 1</p>'
+>>> linebreaks('line 1\nline 2')
+'<p>line 1<br />line 2</p>'
+>>> removetags('some <b>html</b> with <script>alert("You smell")</script> disallowed <img /> tags', 'script img')
+'some <b>html</b> with alert("You smell") disallowed  tags'
+>>> striptags('some <b>html</b> with <script>alert("You smell")</script> disallowed <img /> tags')
+'some html with alert("You smell") disallowed  tags'
+>>> dictsort([{'age': 23, 'name': 'Barbara-Ann'},
+...           {'age': 63, 'name': 'Ra Ra Rasputin'},
+...           {'name': 'Jonny B Goode', 'age': 18}], 'age')
+[{'age': 18, 'name': 'Jonny B Goode'}, {'age': 23, 'name': 'Barbara-Ann'}, {'age': 63, 'name': 'Ra Ra Rasputin'}]
+>>> dictsortreversed([{'age': 23, 'name': 'Barbara-Ann'},
+...           {'age': 63, 'name': 'Ra Ra Rasputin'},
+...           {'name': 'Jonny B Goode', 'age': 18}], 'age')
+[{'age': 63, 'name': 'Ra Ra Rasputin'}, {'age': 23, 'name': 'Barbara-Ann'}, {'age': 18, 'name': 'Jonny B Goode'}]
+>>> first([0,1,2])
+>>> first('')
+''
+>>> first('test')
+'t'
+>>> join([0,1,2], 'glue')
+'0glue1glue2'
+>>> length('1234')
+>>> length([1,2,3,4])
+>>> length_is([], 0)
+True
+>>> length_is([], 1)
+False
+>>> length_is('a', 1)
+True
+>>> length_is('a', 10)
+False
+>>> slice_('abcdefg', '0')
+''
+>>> slice_('abcdefg', '1')
+'a'
+>>> slice_('abcdefg', '-1')
+'abcdef'
+>>> slice_('abcdefg', '1:2')
+'b'
+>>> slice_('abcdefg', '1:3')
+'bc'
+>>> slice_('abcdefg', '0::2')
+'aceg'
+>>> unordered_list(['item 1', []])
+'\t<li>item 1</li>'
+>>> unordered_list(['item 1', [['item 1.1', []]]])
+'\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t</ul>\n\t</li>'
+>>> unordered_list(['item 1', [['item 1.1', []], ['item 1.2', []]]])
+'\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t\t<li>item 1.2</li>\n\t</ul>\n\t</li>'
+>>> add('1', '2')
+>>> get_digit(123, 1)
+>>> get_digit(123, 2)
+>>> get_digit(123, 3)
+>>> get_digit(123, 4)
+>>> get_digit(123, 0)
+>>> get_digit('xyz', 0)
+'xyz'
+# real testing of date() is in dateformat.py
+>>> date(datetime.datetime(2005, 12, 29), "d F Y")
+'29 December 2005'
+>>> date(datetime.datetime(2005, 12, 29), r'jS o\f F')
+'29th of December'
+# real testing of time() is done in dateformat.py
+>>> time(datetime.time(13), "h")
+'01'
+# real testing is done in timesince.py, where we can provide our own 'now'
+>>> timesince(datetime.datetime.now() - datetime.timedelta(1))
+'1 day'
+>>> default("val", "default")
+'val'
+>>> default(None, "default")
+'default'
+>>> default('', "default")
+'default'
+>>> default_if_none("val", "default")
+'val'
+>>> default_if_none(None, "default")
+'default'
+>>> default_if_none('', "default")
+''
+>>> divisibleby(4, 2)
+True
+>>> divisibleby(4, 3)
+False
+>>> yesno(True)
+'yes'
+>>> yesno(False)
+'no'
+>>> yesno(None)
+'maybe'
+>>> yesno(True, 'certainly,get out of town,perhaps')
+'certainly'
+>>> yesno(False, 'certainly,get out of town,perhaps')
+'get out of town'
+>>> yesno(None, 'certainly,get out of town,perhaps')
+'perhaps'
+>>> yesno(None, 'certainly,get out of town')
+'get out of town'
+>>> filesizeformat(1023)
+'1023 bytes'
+>>> filesizeformat(1024)
+'1.0 KB'
+>>> filesizeformat(10*1024)
+'10.0 KB'
+>>> filesizeformat(1024*1024-1)
+'1024.0 KB'
+>>> filesizeformat(1024*1024)
+'1.0 MB'
+>>> filesizeformat(1024*1024*50)
+'50.0 MB'
+>>> filesizeformat(1024*1024*1024-1)
+'1024.0 MB'
+>>> filesizeformat(1024*1024*1024)
+'1.0 GB'
+>>> pluralize(1)
+''
+>>> pluralize(0)
+'s'
+>>> pluralize(2)
+'s'
+>>> pluralize([1])
+''
+>>> pluralize([])
+'s'
+>>> pluralize([1,2,3])
+'s'
+>>> pluralize(1,'es')
+''
+>>> pluralize(0,'es')
+'es'
+>>> pluralize(2,'es')
+'es'
+>>> pluralize(1,'y,ies')
+'y'
+>>> pluralize(0,'y,ies')
+'ies'
+>>> pluralize(2,'y,ies')
+'ies'
+>>> pluralize(0,'y,ies,error')
+''
+>>> phone2numeric('0800 flowers')
+'0800 3569377'
+"""
+from django.template.defaultfilters import *
+import datetime
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

tests/regressiontests/one_to_one_regress/models.py

     def __str__(self):
         return "Favorites for %s" % self.name
 API_TESTS = """
+__test__ = {'API_TESTS':"""
 # Regression test for #1064 and #1506: Check that we create models via the m2m
 # relation if the remote model has a OneToOneField.
 >>> p1 = Place(name='Demon Dogs', address='944 W. Fullerton')
 …
 >>> f.restaurants = [r]
 >>> f.restaurants.all()
 [<Restaurant: Demon Dogs the restaurant>]
 """
+"""}

tests/regressiontests/templates/tests.py

+from django.conf import settings
+if __name__ == '__main__':
+    # When running this file in isolation, we need to set up the configuration
+    # before importing 'template'.
+    settings.configure()
+from django import template
+from django.template import loader
+from django.utils.translation import activate, deactivate, install
+from django.utils.tzinfo import LocalTimezone
+from datetime import datetime, timedelta
+import unittest
+#################################
+# Custom template tag for tests #
+#################################
+register = template.Library()
+class EchoNode(template.Node):
+    def __init__(self, contents):
+        self.contents = contents
+    def render(self, context):
+        return " ".join(self.contents)
+def do_echo(parser, token):
+    return EchoNode(token.contents.split()[1:])
+register.tag("echo", do_echo)
+template.libraries['django.templatetags.testtags'] = register
+#####################################
+# Helper objects for template tests #
+#####################################
+class SomeException(Exception):
+    silent_variable_failure = True
+class SomeOtherException(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
+class OtherClass:
+    def method(self):
+        return "OtherClass.method"
+class Templates(unittest.TestCase):
+    def test_templates(self):
+        # NOW and NOW_tz are used by timesince tag tests.
+        NOW = datetime.now()
+        NOW_tz = datetime.now(LocalTimezone(datetime.now()))
+        # SYNTAX --
+        # 'template_name': ('template contents', 'context dict', 'expected string output' or Exception class)
+        TEMPLATE_TESTS = {
+            ### BASIC SYNTAX ##########################################################
+            # Plain text should go through the template parser untouched
+            'basic-syntax01': ("something cool", {}, "something cool"),
+            # Variables should be replaced with their value in the current context
+            'basic-syntax02': ("{{ headline }}", {'headline':'Success'}, "Success"),
+            # More than one replacement variable is allowed in a template
+            'basic-syntax03': ("{{ first }} --- {{ second }}", {"first" : 1, "second" : 2}, "1 --- 2"),
+            # Fail silently when a variable is not found in the current context
+            'basic-syntax04': ("as{{ missing }}df", {}, "asINVALIDdf"),
+            # A variable may not contain more than one word
+            'basic-syntax06': ("{{ multi word variable }}", {}, template.TemplateSyntaxError),
+            # Raise TemplateSyntaxError for empty variable tags
+            'basic-syntax07': ("{{ }}",        {}, template.TemplateSyntaxError),
+            'basic-syntax08': ("{{        }}", {}, template.TemplateSyntaxError),
+            # Attribute syntax allows a template to call an object's attribute
+            'basic-syntax09': ("{{ var.method }}", {"var": SomeClass()}, "SomeClass.method"),
+            # Multiple levels of attribute access are allowed
+            'basic-syntax10': ("{{ var.otherclass.method }}", {"var": SomeClass()}, "OtherClass.method"),
+            # Fail silently when a variable's attribute isn't found
+            'basic-syntax11': ("{{ var.blech }}", {"var": SomeClass()}, "INVALID"),
+            # Raise TemplateSyntaxError when trying to access a variable beginning with an underscore
+            'basic-syntax12': ("{{ var.__dict__ }}", {"var": SomeClass()}, template.TemplateSyntaxError),
+            # Raise TemplateSyntaxError when trying to access a variable containing an illegal character
+            'basic-syntax13': ("{{ va>r }}", {}, template.TemplateSyntaxError),
+            'basic-syntax14': ("{{ (var.r) }}", {}, template.TemplateSyntaxError),
+            'basic-syntax15': ("{{ sp%am }}", {}, template.TemplateSyntaxError),
+            'basic-syntax16': ("{{ eggs! }}", {}, template.TemplateSyntaxError),
+            'basic-syntax17': ("{{ moo? }}", {}, template.TemplateSyntaxError),
+            # Attribute syntax allows a template to call a dictionary key's value
+            'basic-syntax18': ("{{ foo.bar }}", {"foo" : {"bar" : "baz"}}, "baz"),
+            # Fail silently when a variable's dictionary key isn't found
+            'basic-syntax19': ("{{ foo.spam }}", {"foo" : {"bar" : "baz"}}, "INVALID"),
+            # Fail silently when accessing a non-simple method
+            'basic-syntax20': ("{{ var.method2 }}", {"var": SomeClass()}, "INVALID"),
+            # Basic filter usage
+            'basic-syntax21': ("{{ var|upper }}", {"var": "Django is the greatest!"}, "DJANGO IS THE GREATEST!"),
+            # Chained filters
+            'basic-syntax22': ("{{ var|upper|lower }}", {"var": "Django is the greatest!"}, "django is the greatest!"),
+            # Raise TemplateSyntaxError for space between a variable and filter pipe
+            'basic-syntax23': ("{{ var |upper }}", {}, template.TemplateSyntaxError),
+            # Raise TemplateSyntaxError for space after a filter pipe
+            'basic-syntax24': ("{{ var| upper }}", {}, template.TemplateSyntaxError),
+            # Raise TemplateSyntaxError for a nonexistent filter
+            'basic-syntax25': ("{{ var|does_not_exist }}", {}, template.TemplateSyntaxError),
+            # Raise TemplateSyntaxError when trying to access a filter containing an illegal character
+            'basic-syntax26': ("{{ var|fil(ter) }}", {}, template.TemplateSyntaxError),
+            # Raise TemplateSyntaxError for invalid block tags
+            'basic-syntax27': ("{% nothing_to_see_here %}", {}, template.TemplateSyntaxError),
+            # Raise TemplateSyntaxError for empty block tags
+            'basic-syntax28': ("{% %}", {}, template.TemplateSyntaxError),
+            # Chained filters, with an argument to the first one
+            'basic-syntax29': ('{{ var|removetags:"b i"|upper|lower }}', {"var": "<b><i>Yes</i></b>"}, "yes"),
+            # Escaped string as argument
+            'basic-syntax30': (r'{{ var|default_if_none:" endquote\" hah" }}', {"var": None}, ' endquote" hah'),
+            # Variable as argument
+            'basic-syntax31': (r'{{ var|default_if_none:var2 }}', {"var": None, "var2": "happy"}, 'happy'),
+            # Default argument testing
+            'basic-syntax32': (r'{{ var|yesno:"yup,nup,mup" }} {{ var|yesno }}', {"var": True}, 'yup yes'),
+            # Fail silently for methods that raise an exception with a "silent_variable_failure" attribute
+            'basic-syntax33': (r'1{{ var.method3 }}2', {"var": SomeClass()}, "1INVALID2"),
+            # In methods that raise an exception without a "silent_variable_attribute" set to True,
+            # the exception propogates
+            'basic-syntax34': (r'1{{ var.method4 }}2', {"var": SomeClass()}, SomeOtherException),
+            # Escaped backslash in argument
+            'basic-syntax35': (r'{{ var|default_if_none:"foo\bar" }}', {"var": None}, r'foo\bar'),
+            # Escaped backslash using known escape char
+            'basic-syntax35': (r'{{ var|default_if_none:"foo\now" }}', {"var": None}, r'foo\now'),
+            ### COMMENT TAG ###########################################################
+            'comment-tag01': ("{% comment %}this is hidden{% endcomment %}hello", {}, "hello"),
+            'comment-tag02': ("{% comment %}this is hidden{% endcomment %}hello{% comment %}foo{% endcomment %}", {}, "hello"),
+            # Comment tag can contain invalid stuff.
+            'comment-tag03': ("foo{% comment %} {% if %} {% endcomment %}", {}, "foo"),
+            'comment-tag04': ("foo{% comment %} {% endblock %} {% endcomment %}", {}, "foo"),
+            'comment-tag05': ("foo{% comment %} {% somerandomtag %} {% endcomment %}", {}, "foo"),
+            ### CYCLE TAG #############################################################
+            'cycle01': ('{% cycle a %}', {}, template.TemplateSyntaxError),
+            'cycle02': ('{% cycle a,b,c as abc %}{% cycle abc %}', {}, 'ab'),
+            'cycle03': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}', {}, 'abc'),
+            'cycle04': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}', {}, 'abca'),
+            'cycle05': ('{% cycle %}', {}, template.TemplateSyntaxError),
+            'cycle06': ('{% cycle a %}', {}, template.TemplateSyntaxError),
+            'cycle07': ('{% cycle a,b,c as foo %}{% cycle bar %}', {}, template.TemplateSyntaxError),
+            ### EXCEPTIONS ############################################################
+            # Raise exception for invalid template name
+            'exception01': ("{% extends 'nonexistent' %}", {}, template.TemplateSyntaxError),
+            # Raise exception for invalid template name (in variable)
+            'exception02': ("{% extends nonexistent %}", {}, template.TemplateSyntaxError),
+            # Raise exception for extra {% extends %} tags
+            'exception03': ("{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% extends 'inheritance16' %}", {}, template.TemplateSyntaxError),
+            # Raise exception for custom tags used in child with {% load %} tag in parent, not in child
+            'exception04': ("{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}", {}, template.TemplateSyntaxError),
+            ### FILTER TAG ############################################################
+            'filter01': ('{% filter upper %}{% endfilter %}', {}, ''),
+            'filter02': ('{% filter upper %}django{% endfilter %}', {}, 'DJANGO'),
+            'filter03': ('{% filter upper|lower %}django{% endfilter %}', {}, 'django'),
+            ### FIRSTOF TAG ###########################################################
+            'firstof01': ('{% firstof a b c %}', {'a':0,'b':0,'c':0}, ''),
+            'firstof02': ('{% firstof a b c %}', {'a':1,'b':0,'c':0}, '1'),
+            'firstof03': ('{% firstof a b c %}', {'a':0,'b':2,'c':0}, '2'),
+            'firstof04': ('{% firstof a b c %}', {'a':0,'b':0,'c':3}, '3'),
+            'firstof05': ('{% firstof a b c %}', {'a':1,'b':2,'c':3}, '1'),
+            'firstof06': ('{% firstof %}', {}, template.TemplateSyntaxError),
+            ### FOR TAG ###############################################################
+            'for-tag01': ("{% for val in values %}{{ val }}{% endfor %}", {"values": [1, 2, 3]}, "123"),
+            'for-tag02': ("{% for val in values reversed %}{{ val }}{% endfor %}", {"values": [1, 2, 3]}, "321"),
+            'for-tag-vars01': ("{% for val in values %}{{ forloop.counter }}{% endfor %}", {"values": [6, 6, 6]}, "123"),
+            'for-tag-vars02': ("{% for val in values %}{{ forloop.counter0 }}{% endfor %}", {"values": [6, 6, 6]}, "012"),
+            'for-tag-vars03': ("{% for val in values %}{{ forloop.revcounter }}{% endfor %}", {"values": [6, 6, 6]}, "321"),
+            'for-tag-vars04': ("{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}", {"values": [6, 6, 6]}, "210"),
+            ### IF TAG ################################################################
+            'if-tag01': ("{% if foo %}yes{% else %}no{% endif %}", {"foo": True}, "yes"),
+            'if-tag02': ("{% if foo %}yes{% else %}no{% endif %}", {"foo": False}, "no"),
+            'if-tag03': ("{% if foo %}yes{% else %}no{% endif %}", {}, "no"),
+            # AND
+            'if-tag-and01': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'yes'),
+            'if-tag-and02': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'no'),
+            'if-tag-and03': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'no'),
+            'if-tag-and04': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'no'),
+            'if-tag-and05': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': False}, 'no'),
+            'if-tag-and06': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'bar': False}, 'no'),
+            'if-tag-and07': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': True}, 'no'),
+            'if-tag-and08': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'bar': True}, 'no'),
+            # OR
+            'if-tag-or01': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'yes'),
+            'if-tag-or02': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'yes'),
+            'if-tag-or03': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'yes'),
+            'if-tag-or04': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'no'),
+            'if-tag-or05': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': False}, 'no'),
+            'if-tag-or06': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'bar': False}, 'no'),
+            'if-tag-or07': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': True}, 'yes'),
+            'if-tag-or08': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'bar': True}, 'yes'),
+            # TODO: multiple ORs
+            # NOT
+            'if-tag-not01': ("{% if not foo %}no{% else %}yes{% endif %}", {'foo': True}, 'yes'),
+            'if-tag-not02': ("{% if not %}yes{% else %}no{% endif %}", {'foo': True}, 'no'),
+            'if-tag-not03': ("{% if not %}yes{% else %}no{% endif %}", {'not': True}, 'yes'),
+            'if-tag-not04': ("{% if not not %}no{% else %}yes{% endif %}", {'not': True}, 'yes'),
+            'if-tag-not05': ("{% if not not %}no{% else %}yes{% endif %}", {}, 'no'),
+            'if-tag-not06': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {}, 'no'),
+            'if-tag-not07': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'no'),
+            'if-tag-not08': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'yes'),
+            'if-tag-not09': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'no'),
+            'if-tag-not10': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'no'),
+            'if-tag-not11': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {}, 'no'),
+            'if-tag-not12': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'no'),
+            'if-tag-not13': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'no'),
+            'if-tag-not14': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'yes'),
+            'if-tag-not15': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'no'),
+            'if-tag-not16': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {}, 'yes'),
+            'if-tag-not17': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'yes'),
+            'if-tag-not18': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'yes'),
+            'if-tag-not19': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'no'),
+            'if-tag-not20': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'yes'),
+            'if-tag-not21': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {}, 'yes'),
+            'if-tag-not22': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'yes'),
+            'if-tag-not23': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'no'),
+            'if-tag-not24': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'yes'),
+            'if-tag-not25': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'yes'),
+            'if-tag-not26': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {}, 'yes'),
+            'if-tag-not27': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'no'),
+            'if-tag-not28': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'no'),
+            'if-tag-not29': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'no'),
+            'if-tag-not30': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'yes'),
+            'if-tag-not31': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {}, 'yes'),
+            'if-tag-not32': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'no'),
+            'if-tag-not33': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'yes'),
+            'if-tag-not34': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'yes'),
+            'if-tag-not35': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'yes'),
+            # AND and OR raises a TemplateSyntaxError
+            'if-tag-error01': ("{% if foo or bar and baz %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, template.TemplateSyntaxError),
+            'if-tag-error02': ("{% if foo and %}yes{% else %}no{% endif %}", {'foo': True}, template.TemplateSyntaxError),
+            'if-tag-error03': ("{% if foo or %}yes{% else %}no{% endif %}", {'foo': True}, template.TemplateSyntaxError),
+            'if-tag-error04': ("{% if not foo and %}yes{% else %}no{% endif %}", {'foo': True}, template.TemplateSyntaxError),
+            'if-tag-error05': ("{% if not foo or %}yes{% else %}no{% endif %}", {'foo': True}, template.TemplateSyntaxError),
+            ### IFCHANGED TAG #########################################################
+            'ifchanged01': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', { 'num': (1,2,3) }, '123'),
+            'ifchanged02': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', { 'num': (1,1,3) }, '13'),
+            'ifchanged03': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', { 'num': (1,1,1) }, '1'),
+            ### IFEQUAL TAG ###########################################################
+            'ifequal01': ("{% ifequal a b %}yes{% endifequal %}", {"a": 1, "b": 2}, ""),
+            'ifequal02': ("{% ifequal a b %}yes{% endifequal %}", {"a": 1, "b": 1}, "yes"),
+            'ifequal03': ("{% ifequal a b %}yes{% else %}no{% endifequal %}", {"a": 1, "b": 2}, "no"),
+            'ifequal04': ("{% ifequal a b %}yes{% else %}no{% endifequal %}", {"a": 1, "b": 1}, "yes"),
+            'ifequal05': ("{% ifequal a 'test' %}yes{% else %}no{% endifequal %}", {"a": "test"}, "yes"),
+            'ifequal06': ("{% ifequal a 'test' %}yes{% else %}no{% endifequal %}", {"a": "no"}, "no"),
+            'ifequal07': ('{% ifequal a "test" %}yes{% else %}no{% endifequal %}', {"a": "test"}, "yes"),
+            'ifequal08': ('{% ifequal a "test" %}yes{% else %}no{% endifequal %}', {"a": "no"}, "no"),
+            'ifequal09': ('{% ifequal a "test" %}yes{% else %}no{% endifequal %}', {}, "no"),
+            'ifequal10': ('{% ifequal a b %}yes{% else %}no{% endifequal %}', {}, "yes"),
+            # SMART SPLITTING
+            'ifequal-split01': ('{% ifequal a "test man" %}yes{% else %}no{% endifequal %}', {}, "no"),
+            'ifequal-split02': ('{% ifequal a "test man" %}yes{% else %}no{% endifequal %}', {'a': 'foo'}, "no"),
+            'ifequal-split03': ('{% ifequal a "test man" %}yes{% else %}no{% endifequal %}', {'a': 'test man'}, "yes"),
+            'ifequal-split04': ("{% ifequal a 'test man' %}yes{% else %}no{% endifequal %}", {'a': 'test man'}, "yes"),
+            'ifequal-split05': ("{% ifequal a 'i \"love\" you' %}yes{% else %}no{% endifequal %}", {'a': ''}, "no"),
+            'ifequal-split06': ("{% ifequal a 'i \"love\" you' %}yes{% else %}no{% endifequal %}", {'a': 'i "love" you'}, "yes"),
+            'ifequal-split07': ("{% ifequal a 'i \"love\" you' %}yes{% else %}no{% endifequal %}", {'a': 'i love you'}, "no"),
+            'ifequal-split08': (r"{% ifequal a 'I\'m happy' %}yes{% else %}no{% endifequal %}", {'a': "I'm happy"}, "yes"),
+            'ifequal-split09': (r"{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}", {'a': r"slash\man"}, "yes"),
+            'ifequal-split10': (r"{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}", {'a': r"slashman"}, "no"),
+            ### IFNOTEQUAL TAG ########################################################
+            'ifnotequal01': ("{% ifnotequal a b %}yes{% endifnotequal %}", {"a": 1, "b": 2}, "yes"),
+            'ifnotequal02': ("{% ifnotequal a b %}yes{% endifnotequal %}", {"a": 1, "b": 1}, ""),
+            'ifnotequal03': ("{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}", {"a": 1, "b": 2}, "yes"),
+            'ifnotequal04': ("{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}", {"a": 1, "b": 1}, "no"),
+            ### INCLUDE TAG ###########################################################
+            'include01': ('{% include "basic-syntax01" %}', {}, "something cool"),
+            'include02': ('{% include "basic-syntax02" %}', {'headline': 'Included'}, "Included"),
+            'include03': ('{% include template_name %}', {'template_name': 'basic-syntax02', 'headline': 'Included'}, "Included"),
+            'include04': ('a{% include "nonexistent" %}b', {}, "ab"),
+            ### INHERITANCE ###########################################################
+            # Standard template with no inheritance
+            'inheritance01': ("1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}", {}, '1_3_'),
+            # Standard two-level inheritance
+            'inheritance02': ("{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}", {}, '1234'),
+            # Three-level with no redefinitions on third level
+            'inheritance03': ("{% extends 'inheritance02' %}", {}, '1234'),
+            # Two-level with no redefinitions on second level
+            'inheritance04': ("{% extends 'inheritance01' %}", {}, '1_3_'),
+            # Two-level with double quotes instead of single quotes
+            'inheritance05': ('{% extends "inheritance02" %}', {}, '1234'),
+            # Three-level with variable parent-template name
+            'inheritance06': ("{% extends foo %}", {'foo': 'inheritance02'}, '1234'),
+            # Two-level with one block defined, one block not defined
+            'inheritance07': ("{% extends 'inheritance01' %}{% block second %}5{% endblock %}", {}, '1_35'),
+            # Three-level with one block defined on this level, two blocks defined next level
+            'inheritance08': ("{% extends 'inheritance02' %}{% block second %}5{% endblock %}", {}, '1235'),
+            # Three-level with second and third levels blank
+            'inheritance09': ("{% extends 'inheritance04' %}", {}, '1_3_'),
+            # Three-level with space NOT in a block -- should be ignored
+            'inheritance10': ("{% extends 'inheritance04' %}      ", {}, '1_3_'),
+            # Three-level with both blocks defined on this level, but none on second level
+            'inheritance11': ("{% extends 'inheritance04' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}", {}, '1234'),
+            # Three-level with this level providing one and second level providing the other
+            'inheritance12': ("{% extends 'inheritance07' %}{% block first %}2{% endblock %}", {}, '1235'),
+            # Three-level with this level overriding second level
+            'inheritance13': ("{% extends 'inheritance02' %}{% block first %}a{% endblock %}{% block second %}b{% endblock %}", {}, '1a3b'),
+            # A block defined only in a child template shouldn't be displayed
+            'inheritance14': ("{% extends 'inheritance01' %}{% block newblock %}NO DISPLAY{% endblock %}", {}, '1_3_'),
+            # A block within another block
+            'inheritance15': ("{% extends 'inheritance01' %}{% block first %}2{% block inner %}inner{% endblock %}{% endblock %}", {}, '12inner3_'),
+            # A block within another block (level 2)
+            'inheritance16': ("{% extends 'inheritance15' %}{% block inner %}out{% endblock %}", {}, '12out3_'),
+            # {% load %} tag (parent -- setup for exception04)
+            'inheritance17': ("{% load testtags %}{% block first %}1234{% endblock %}", {}, '1234'),
+            # {% load %} tag (standard usage, without inheritance)
+            'inheritance18': ("{% load testtags %}{% echo this that theother %}5678", {}, 'this that theother5678'),
+            # {% load %} tag (within a child template)
+            'inheritance19': ("{% extends 'inheritance01' %}{% block first %}{% load testtags %}{% echo 400 %}5678{% endblock %}", {}, '140056783_'),
+            # Two-level inheritance with {{ block.super }}
+            'inheritance20': ("{% extends 'inheritance01' %}{% block first %}{{ block.super }}a{% endblock %}", {}, '1_a3_'),
+            # Three-level inheritance with {{ block.super }} from parent
+            'inheritance21': ("{% extends 'inheritance02' %}{% block first %}{{ block.super }}a{% endblock %}", {}, '12a34'),
+            # Three-level inheritance with {{ block.super }} from grandparent
+            'inheritance22': ("{% extends 'inheritance04' %}{% block first %}{{ block.super }}a{% endblock %}", {}, '1_a3_'),
+            # Three-level inheritance with {{ block.super }} from parent and grandparent
+            'inheritance23': ("{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}", {}, '1_ab3_'),
+            # Inheritance from local context without use of template loader
+            'inheritance24': ("{% extends context_template %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}", {'context_template': template.Template("1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}")}, '1234'),
+            # Inheritance from local context with variable parent template
+            'inheritance25': ("{% extends context_template.1 %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}", {'context_template': [template.Template("Wrong"), template.Template("1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}")]}, '1234'),
+            ### I18N ##################################################################
+            # {% spaceless %} tag
+            'spaceless01': ("{% spaceless %} <b>    <i> text </i>    </b> {% endspaceless %}", {}, "<b> <i> text </i> </b>"),
+            'spaceless02': ("{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}", {}, "<b> <i> text </i> </b>"),
+            'spaceless03': ("{% spaceless %}<b><i>text</i></b>{% endspaceless %}", {}, "<b><i>text</i></b>"),
+            # simple translation of a string delimited by '
+            'i18n01': ("{% load i18n %}{% trans 'xxxyyyxxx' %}", {}, "xxxyyyxxx"),
+            # simple translation of a string delimited by "
+            'i18n02': ('{% load i18n %}{% trans "xxxyyyxxx" %}', {}, "xxxyyyxxx"),
+            # simple translation of a variable
+            'i18n03': ('{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}', {'anton': 'xxxyyyxxx'}, "xxxyyyxxx"),
+            # simple translation of a variable and filter
+            'i18n04': ('{% load i18n %}{% blocktrans with anton|lower as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'XXXYYYXXX'}, "xxxyyyxxx"),
+            # simple translation of a string with interpolation
+            'i18n05': ('{% load i18n %}{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}', {'anton': 'yyy'}, "xxxyyyxxx"),
+            # simple translation of a string to german
+            'i18n06': ('{% load i18n %}{% trans "Page not found" %}', {'LANGUAGE_CODE': 'de'}, "Seite nicht gefunden"),
+            # translation of singular form
+            'i18n07': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}plural{% endblocktrans %}', {'number': 1}, "singular"),
+            # translation of plural form
+            'i18n08': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}plural{% endblocktrans %}', {'number': 2}, "plural"),
+            # simple non-translation (only marking) of a string to german
+            'i18n09': ('{% load i18n %}{% trans "Page not found" noop %}', {'LANGUAGE_CODE': 'de'}, "Page not found"),
+            # translation of a variable with a translated filter
+            'i18n10': ('{{ bool|yesno:_("ja,nein") }}', {'bool': True}, 'ja'),
+            # translation of a variable with a non-translated filter
+            'i18n11': ('{{ bool|yesno:"ja,nein" }}', {'bool': True}, 'ja'),
+            # usage of the get_available_languages tag
+            'i18n12': ('{% load i18n %}{% get_available_languages as langs %}{% for lang in langs %}{% ifequal lang.0 "de" %}{{ lang.0 }}{% endifequal %}{% endfor %}', {}, 'de'),
+            # translation of a constant string
+            'i18n13': ('{{ _("Page not found") }}', {'LANGUAGE_CODE': 'de'}, 'Seite nicht gefunden'),
+            ### MULTILINE #############################################################
+            'multiline01': ("""
+                            Hello,
+                            boys.
+                            How
+                            are
+                            you
+                            gentlemen.
+                            """,
+                            {},
+                            """
+                            Hello,
+                            boys.
+                            How
+                            are
+                            you
+                            gentlemen.
+                            """),
+            ### REGROUP TAG ###########################################################
+            'regroup01': ('{% regroup data by bar as grouped %}' + \
+                          '{% for group in grouped %}' + \
+                          '{{ group.grouper }}:' + \
+                          '{% for item in group.list %}' + \
+                          '{{ item.foo }}' + \
+                          '{% endfor %},' + \
+                          '{% endfor %}',
+                          {'data': [ {'foo':'c', 'bar':1},
+                                     {'foo':'d', 'bar':1},
+                                     {'foo':'a', 'bar':2},
+                                     {'foo':'b', 'bar':2},
+                                     {'foo':'x', 'bar':3}  ]},
+                          '1:cd,2:ab,3:x,'),
+            # Test for silent failure when target variable isn't found
+            'regroup02': ('{% regroup data by bar as grouped %}' + \
+                          '{% for group in grouped %}' + \
+                          '{{ group.grouper }}:' + \
+                          '{% for item in group.list %}' + \
+                          '{{ item.foo }}' + \
+                          '{% endfor %},' + \
+                          '{% endfor %}',
+                          {}, 'INVALID:INVALIDINVALIDINVALIDINVALIDINVALIDINVALIDINVALID,'),
+            ### TEMPLATETAG TAG #######################################################
+            'templatetag01': ('{% templatetag openblock %}', {}, '{%'),
+            'templatetag02': ('{% templatetag closeblock %}', {}, '%}'),
+            'templatetag03': ('{% templatetag openvariable %}', {}, '{{'),
+            'templatetag04': ('{% templatetag closevariable %}', {}, '}}'),
+            'templatetag05': ('{% templatetag %}', {}, template.TemplateSyntaxError),
+            'templatetag06': ('{% templatetag foo %}', {}, template.TemplateSyntaxError),
+            'templatetag07': ('{% templatetag openbrace %}', {}, '{'),
+            'templatetag08': ('{% templatetag closebrace %}', {}, '}'),
+            'templatetag09': ('{% templatetag openbrace %}{% templatetag openbrace %}', {}, '{{'),
+            'templatetag10': ('{% templatetag closebrace %}{% templatetag closebrace %}', {}, '}}'),
+            ### WIDTHRATIO TAG ########################################################
+            'widthratio01': ('{% widthratio a b 0 %}', {'a':50,'b':100}, '0'),
+            'widthratio02': ('{% widthratio a b 100 %}', {'a':0,'b':0}, ''),
+            'widthratio03': ('{% widthratio a b 100 %}', {'a':0,'b':100}, '0'),
+            'widthratio04': ('{% widthratio a b 100 %}', {'a':50,'b':100}, '50'),
+            'widthratio05': ('{% widthratio a b 100 %}', {'a':100,'b':100}, '100'),
+            # 62.5 should round to 63
+            'widthratio06': ('{% widthratio a b 100 %}', {'a':50,'b':80}, '63'),
+            # 71.4 should round to 71
+            'widthratio07': ('{% widthratio a b 100 %}', {'a':50,'b':70}, '71'),
+            # Raise exception if we don't have 3 args, last one an integer
+            'widthratio08': ('{% widthratio %}', {}, template.TemplateSyntaxError),
+            'widthratio09': ('{% widthratio a b %}', {'a':50,'b':100}, template.TemplateSyntaxError),
+            'widthratio10': ('{% widthratio a b 100.0 %}', {'a':50,'b':100}, template.TemplateSyntaxError),
+            ### NOW TAG ########################################################
+            # Simple case
+            'now01' : ('{% now "j n Y"%}', {}, str(datetime.now().day) + ' ' + str(datetime.now().month) + ' ' + str(datetime.now().year)),
+            # Check parsing of escaped and special characters
+            'now02' : ('{% now "j "n" Y"%}', {}, template.TemplateSyntaxError),
+        #    'now03' : ('{% now "j \"n\" Y"%}', {}, str(datetime.now().day) + '"' + str(datetime.now().month) + '"' + str(datetime.now().year)),
+        #    'now04' : ('{% now "j \nn\n Y"%}', {}, str(datetime.now().day) + '\n' + str(datetime.now().month) + '\n' + str(datetime.now().year))
+            ### TIMESINCE TAG ##################################################
+            # Default compare with datetime.now()
+            'timesince01' : ('{{ a|timesince }}', {'a':datetime.now() + timedelta(minutes=-1, seconds = -10)}, '1 minute'),
+            'timesince02' : ('{{ a|timesince }}', {'a':(datetime.now() - timedelta(days=1, minutes = 1))}, '1 day'),
+            'timesince03' : ('{{ a|timesince }}', {'a':(datetime.now() -
+                timedelta(hours=1, minutes=25, seconds = 10))}, '1 hour, 25 minutes'),
+            # Compare to a given parameter
+            'timesince04' : ('{{ a|timesince:b }}', {'a':NOW + timedelta(days=2), 'b':NOW + timedelta(days=1)}, '1 day'),
+            'timesince05' : ('{{ a|timesince:b }}', {'a':NOW + timedelta(days=2, minutes=1), 'b':NOW + timedelta(days=2)}, '1 minute'),
+            # Check that timezone is respected
+            'timesince06' : ('{{ a|timesince:b }}', {'a':NOW_tz + timedelta(hours=8), 'b':NOW_tz}, '8 hours'),
+            ### TIMEUNTIL TAG ##################################################
+            # Default compare with datetime.now()
+            'timeuntil01' : ('{{ a|timeuntil }}', {'a':datetime.now() + timedelta(minutes=2, seconds = 10)}, '2 minutes'),
+            'timeuntil02' : ('{{ a|timeuntil }}', {'a':(datetime.now() + timedelta(days=1, seconds = 10))}, '1 day'),
+            'timeuntil03' : ('{{ a|timeuntil }}', {'a':(datetime.now() + timedelta(hours=8, minutes=10, seconds = 10))}, '8 hours, 10 minutes'),
+            # Compare to a given parameter
+            'timeuntil04' : ('{{ a|timeuntil:b }}', {'a':NOW - timedelta(days=1), 'b':NOW - timedelta(days=2)}, '1 day'),
+            'timeuntil05' : ('{{ a|timeuntil:b }}', {'a':NOW - timedelta(days=2), 'b':NOW - timedelta(days=2, minutes=1)}, '1 minute'),
+        }
+        # Register our custom template loader.
+        def test_template_loader(template_name, template_dirs=None):
+            "A custom template loader that loads the unit-test templates."
+            try:
+                return (TEMPLATE_TESTS[template_name][0] , "test:%s" % template_name)
+            except KeyError:
+                raise template.TemplateDoesNotExist, template_name
+        old_template_loaders = loader.template_source_loaders
+        loader.template_source_loaders = [test_template_loader]
+        failures = []
+        tests = TEMPLATE_TESTS.items()
+        tests.sort()
+        # Turn TEMPLATE_DEBUG off, because tests assume that.
+        old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, False
+        # Set TEMPLATE_STRING_IF_INVALID to a known string
+        old_invalid, settings.TEMPLATE_STRING_IF_INVALID = settings.TEMPLATE_STRING_IF_INVALID, 'INVALID'
+        for name, vals in tests:
+            install()
+            if 'LANGUAGE_CODE' in vals[1]:
+                activate(vals[1]['LANGUAGE_CODE'])
+            else:
+                activate('en-us')
+            try:
+                output = loader.get_template(name).render(template.Context(vals[1]))
+            except Exception, e:
+                if e.__class__ != vals[2]:
+                    failures.append("Template test: %s -- FAILED. Got %s, exception: %s" % (name, e.__class__, e))
+                continue
+            if 'LANGUAGE_CODE' in vals[1]:
+                deactivate()
+            if output != vals[2]:
+                failures.append("Template test: %s -- FAILED. Expected %r, got %r" % (name, vals[2], output))
+        loader.template_source_loaders = old_template_loaders
+        deactivate()
+        settings.TEMPLATE_DEBUG = old_td
+        settings.TEMPLATE_STRING_IF_INVALID = old_invalid
+        self.assertEqual(failures,[])
+if __name__ == '__main__':
+    unittest.main()

tests/regressiontests/urlpatterns_reverse/tests.py

+"Unit tests for reverse URL lookup"
+from django.core.urlresolvers import reverse_helper, NoReverseMatch
+import re
+test_data = (
+    ('^places/(\d+)/$', 'places/3/', [3], {}),
+    ('^places/(\d+)/$', 'places/3/', ['3'], {}),
+    ('^places/(\d+)/$', NoReverseMatch, ['a'], {}),
+    ('^places/(\d+)/$', NoReverseMatch, [], {}),
+    ('^places/(?P<id>\d+)/$', 'places/3/', [], {'id': 3}),
+    ('^people/(?P<name>\w+)/$', 'people/adrian/', ['adrian'], {}),
+    ('^people/(?P<name>\w+)/$', 'people/adrian/', [], {'name': 'adrian'}),
+    ('^people/(?P<name>\w+)/$', NoReverseMatch, ['name with spaces'], {}),
+    ('^people/(?P<name>\w+)/$', NoReverseMatch, [], {'name': 'name with spaces'}),
+    ('^people/(?P<name>\w+)/$', NoReverseMatch, [], {}),
+    ('^hardcoded/$', 'hardcoded/', [], {}),
+    ('^hardcoded/$', 'hardcoded/', ['any arg'], {}),
+    ('^hardcoded/$', 'hardcoded/', [], {'kwarg': 'foo'}),
+    ('^people/(?P<state>\w\w)/(?P<name>\w+)/$', 'people/il/adrian/', [], {'state': 'il', 'name': 'adrian'}),
+    ('^people/(?P<state>\w\w)/(?P<name>\d)/$', NoReverseMatch, [], {'state': 'il', 'name': 'adrian'}),
+    ('^people/(?P<state>\w\w)/(?P<name>\w+)/$', NoReverseMatch, [], {'state': 'il'}),
+    ('^people/(?P<state>\w\w)/(?P<name>\w+)/$', NoReverseMatch, [], {'name': 'adrian'}),
+    ('^people/(?P<state>\w\w)/(\w+)/$', NoReverseMatch, ['il'], {'name': 'adrian'}),
+    ('^people/(?P<state>\w\w)/(\w+)/$', 'people/il/adrian/', ['adrian'], {'state': 'il'}),
+)
+def run_tests(verbosity=0):
+    for regex, expected, args, kwargs in test_data:
+        passed = True
+        try:
+            got = reverse_helper(re.compile(regex), *args, **kwargs)
+        except NoReverseMatch, e:
+            if expected != NoReverseMatch:
+                passed, got = False, str(e)
+        else:
+            if got != expected:
+                passed, got = False, got
+        if passed and verbosity:
+            print "Passed: %s" % regex
+        elif not passed:
+            print "REVERSE LOOKUP FAILED: %s" % regex
+            print "   Got: %s" % got
+            print "   Expected: %r" % expected
+if __name__ == "__main__":
+    run_tests(1)

tests/othertests/defaultfilters.py

-r"""
->>> floatformat(7.7)
-'7.7'
->>> floatformat(7.0)
-'7'
->>> floatformat(0.7)
-'0.7'
->>> floatformat(0.07)
-'0.1'
->>> floatformat(0.007)
-'0.0'
->>> floatformat(0.0)
-'0'
->>> addslashes('"double quotes" and \'single quotes\'')
-'\\"double quotes\\" and \\\'single quotes\\\''
->>> capfirst('hello world')
-'Hello world'
->>> fix_ampersands('Jack & Jill & Jeroboam')
-'Jack &amp; Jill &amp; Jeroboam'
->>> linenumbers('line 1\nline 2')
-'1. line 1\n2. line 2'
->>> linenumbers('\n'.join(['x'] * 10))
-'01. x\n02. x\n03. x\n04. x\n05. x\n06. x\n07. x\n08. x\n09. x\n10. x'
->>> lower('TEST')
-'test'
->>> lower(u'\xcb') # uppercase E umlaut
-u'\xeb'
->>> make_list('abc')
-['a', 'b', 'c']
->>> make_list(1234)
-['1', '2', '3', '4']
->>> slugify(' Jack & Jill like numbers 1,2,3 and 4 and silly characters ?%.$!/')
-'jack-jill-like-numbers-123-and-4-and-silly-characters'
->>> stringformat(1, '03d')
-'001'
->>> stringformat(1, 'z')
-''
->>> title('a nice title, isn\'t it?')
-"A Nice Title, Isn't It?"
->>> truncatewords('A sentence with a few words in it', 1)
-'A ...'
->>> truncatewords('A sentence with a few words in it', 5)
-'A sentence with a few ...'
->>> truncatewords('A sentence with a few words in it', 100)
-'A sentence with a few words in it'
->>> truncatewords('A sentence with a few words in it', 'not a number')
-'A sentence with a few words in it'
->>> upper('Mixed case input')
-'MIXED CASE INPUT'
->>> upper(u'\xeb') # lowercase e umlaut
-u'\xcb'
->>> urlencode('jack & jill')
-'jack%20%26%20jill'
->>> urlizetrunc('http://short.com/', 20)
-'<a href="http://short.com/" rel="nofollow">http://short.com/</a>'
->>> urlizetrunc('http://www.google.co.uk/search?hl=en&q=some+long+url&btnG=Search&meta=', 20)
-'<a href="http://www.google.co.uk/search?hl=en&q=some+long+url&btnG=Search&meta=" rel="nofollow">http://www.google.co...</a>'
->>> wordcount('')
->>> wordcount('oneword')
->>> wordcount('lots of words')
->>> wordwrap('this is a long paragraph of text that really needs to be wrapped I\'m afraid', 14)
-"this is a long\nparagraph of\ntext that\nreally needs\nto be wrapped\nI'm afraid"
->>> ljust('test', 10)
-'test      '
->>> ljust('test', 3)
-'test'
->>> rjust('test', 10)
-'      test'
->>> rjust('test', 3)
-'test'
->>> center('test', 6)
-' test '
->>> cut('a string to be mangled', 'a')
-' string to be mngled'
->>> cut('a string to be mangled', 'ng')
-'a stri to be maled'
->>> cut('a string to be mangled', 'strings')
-'a string to be mangled'
->>> escape('<some html & special characters > here')
-'&lt;some html &amp; special characters &gt; here'
->>> linebreaks('line 1')
-'<p>line 1</p>'
->>> linebreaks('line 1\nline 2')
-'<p>line 1<br />line 2</p>'
->>> removetags('some <b>html</b> with <script>alert("You smell")</script> disallowed <img /> tags', 'script img')
-'some <b>html</b> with alert("You smell") disallowed  tags'
->>> striptags('some <b>html</b> with <script>alert("You smell")</script> disallowed <img /> tags')
-'some html with alert("You smell") disallowed  tags'
->>> dictsort([{'age': 23, 'name': 'Barbara-Ann'},
-...           {'age': 63, 'name': 'Ra Ra Rasputin'},
-...           {'name': 'Jonny B Goode', 'age': 18}], 'age')
-[{'age': 18, 'name': 'Jonny B Goode'}, {'age': 23, 'name': 'Barbara-Ann'}, {'age': 63, 'name': 'Ra Ra Rasputin'}]
->>> dictsortreversed([{'age': 23, 'name': 'Barbara-Ann'},
-...           {'age': 63, 'name': 'Ra Ra Rasputin'},
-...           {'name': 'Jonny B Goode', 'age': 18}], 'age')
-[{'age': 63, 'name': 'Ra Ra Rasputin'}, {'age': 23, 'name': 'Barbara-Ann'}, {'age': 18, 'name': 'Jonny B Goode'}]
->>> first([0,1,2])
->>> first('')
-''
->>> first('test')
-'t'
->>> join([0,1,2], 'glue')
-'0glue1glue2'
->>> length('1234')
->>> length([1,2,3,4])
->>> length_is([], 0)
-True
->>> length_is([], 1)
-False
->>> length_is('a', 1)
-True
->>> length_is('a', 10)
-False
->>> slice_('abcdefg', '0')
-''
->>> slice_('abcdefg', '1')
-'a'
->>> slice_('abcdefg', '-1')
-'abcdef'
->>> slice_('abcdefg', '1:2')
-'b'
->>> slice_('abcdefg', '1:3')
-'bc'
->>> slice_('abcdefg', '0::2')
-'aceg'
->>> unordered_list(['item 1', []])
-'\t<li>item 1</li>'
->>> unordered_list(['item 1', [['item 1.1', []]]])
-'\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t</ul>\n\t</li>'
->>> unordered_list(['item 1', [['item 1.1', []], ['item 1.2', []]]])
-'\t<li>item 1\n\t<ul>\n\t\t<li>item 1.1</li>\n\t\t<li>item 1.2</li>\n\t</ul>\n\t</li>'
->>> add('1', '2')
->>> get_digit(123, 1)
->>> get_digit(123, 2)
->>> get_digit(123, 3)
->>> get_digit(123, 4)
->>> get_digit(123, 0)
->>> get_digit('xyz', 0)
-'xyz'
-# real testing of date() is in dateformat.py
->>> date(datetime.datetime(2005, 12, 29), "d F Y")
-'29 December 2005'
->>> date(datetime.datetime(2005, 12, 29), r'jS o\f F')
-'29th of December'
-# real testing of time() is done in dateformat.py
->>> time(datetime.time(13), "h")
-'01'
-# real testing is done in timesince.py, where we can provide our own 'now'
->>> timesince(datetime.datetime.now() - datetime.timedelta(1))
-'1 day'
->>> default("val", "default")
-'val'
->>> default(None, "default")
-'default'
->>> default('', "default")
-'default'
->>> default_if_none("val", "default")
-'val'
->>> default_if_none(None, "default")
-'default'
->>> default_if_none('', "default")
-''
->>> divisibleby(4, 2)
-True
->>> divisibleby(4, 3)
-False
->>> yesno(True)
-'yes'
->>> yesno(False)
-'no'
->>> yesno(None)
-'maybe'
->>> yesno(True, 'certainly,get out of town,perhaps')
-'certainly'
->>> yesno(False, 'certainly,get out of town,perhaps')
-'get out of town'
->>> yesno(None, 'certainly,get out of town,perhaps')
-'perhaps'
->>> yesno(None, 'certainly,get out of town')
-'get out of town'
->>> filesizeformat(1023)
-'1023 bytes'
->>> filesizeformat(1024)
-'1.0 KB'
->>> filesizeformat(10*1024)
-'10.0 KB'
->>> filesizeformat(1024*1024-1)
-'1024.0 KB'
->>> filesizeformat(1024*1024)
-'1.0 MB'
->>> filesizeformat(1024*1024*50)
-'50.0 MB'
->>> filesizeformat(1024*1024*1024-1)
-'1024.0 MB'
->>> filesizeformat(1024*1024*1024)
-'1.0 GB'
->>> pluralize(1)
-''
->>> pluralize(0)
-'s'
->>> pluralize(2)
-'s'
->>> pluralize([1])
-''
->>> pluralize([])
-'s'
->>> pluralize([1,2,3])
-'s'
->>> pluralize(1,'es')
-''
->>> pluralize(0,'es')
-'es'
->>> pluralize(2,'es')
-'es'
->>> pluralize(1,'y,ies')
-'y'
->>> pluralize(0,'y,ies')
-'ies'
->>> pluralize(2,'y,ies')
-'ies'
->>> pluralize(0,'y,ies,error')
-''
->>> phone2numeric('0800 flowers')
-'0800 3569377'
-"""
-from django.template.defaultfilters import *
-import datetime
-if __name__ == '__main__':
-    import doctest
-    doctest.testmod()

tests/othertests/templates.py

-from django.conf import settings
-if __name__ == '__main__':
-    # When running this file in isolation, we need to set up the configuration
-    # before importing 'template'.
-    settings.configure()
-from django import template
-from django.template import loader
-from django.utils.translation import activate, deactivate, install
-from django.utils.tzinfo import LocalTimezone
-from datetime import datetime, timedelta
-import traceback
-#################################
-# Custom template tag for tests #
-#################################
-register = template.Library()
-class EchoNode(template.Node):
-    def __init__(self, contents):
-        self.contents = contents
-    def render(self, context):
-        return " ".join(self.contents)
-def do_echo(parser, token):
-    return EchoNode(token.contents.split()[1:])
-register.tag("echo", do_echo)
-template.libraries['django.templatetags.testtags'] = register
-#####################################
-# Helper objects for template tests #
-#####################################
-class SomeException(Exception):
-    silent_variable_failure = True
-class SomeOtherException(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
-class OtherClass:
-    def method(self):
-        return "OtherClass.method"
-# NOW and NOW_tz are used by timesince tag tests.
-NOW = datetime.now()
-NOW_tz = datetime.now(LocalTimezone(datetime.now()))
-# SYNTAX --
-# 'template_name': ('template contents', 'context dict', 'expected string output' or Exception class)
-TEMPLATE_TESTS = {
-    ### BASIC SYNTAX ##########################################################
-    # Plain text should go through the template parser untouched
-    'basic-syntax01': ("something cool", {}, "something cool"),
-    # Variables should be replaced with their value in the current context
-    'basic-syntax02': ("{{ headline }}", {'headline':'Success'}, "Success"),
-    # More than one replacement variable is allowed in a template
-    'basic-syntax03': ("{{ first }} --- {{ second }}", {"first" : 1, "second" : 2}, "1 --- 2"),
-    # Fail silently when a variable is not found in the current context
-    'basic-syntax04': ("as{{ missing }}df", {}, "asINVALIDdf"),
-    # A variable may not contain more than one word
-    'basic-syntax06': ("{{ multi word variable }}", {}, template.TemplateSyntaxError),
-    # Raise TemplateSyntaxError for empty variable tags
-    'basic-syntax07': ("{{ }}",        {}, template.TemplateSyntaxError),
-    'basic-syntax08': ("{{        }}", {}, template.TemplateSyntaxError),
-    # Attribute syntax allows a template to call an object's attribute
-    'basic-syntax09': ("{{ var.method }}", {"var": SomeClass()}, "SomeClass.method"),
-    # Multiple levels of attribute access are allowed
-    'basic-syntax10': ("{{ var.otherclass.method }}", {"var": SomeClass()}, "OtherClass.method"),
-    # Fail silently when a variable's attribute isn't found
-    'basic-syntax11': ("{{ var.blech }}", {"var": SomeClass()}, "INVALID"),
-    # Raise TemplateSyntaxError when trying to access a variable beginning with an underscore
-    'basic-syntax12': ("{{ var.__dict__ }}", {"var": SomeClass()}, template.TemplateSyntaxError),
-    # Raise TemplateSyntaxError when trying to access a variable containing an illegal character
-    'basic-syntax13': ("{{ va>r }}", {}, template.TemplateSyntaxError),
-    'basic-syntax14': ("{{ (var.r) }}", {}, template.TemplateSyntaxError),
-    'basic-syntax15': ("{{ sp%am }}", {}, template.TemplateSyntaxError),
-    'basic-syntax16': ("{{ eggs! }}", {}, template.TemplateSyntaxError),
-    'basic-syntax17': ("{{ moo? }}", {}, template.TemplateSyntaxError),
-    # Attribute syntax allows a template to call a dictionary key's value
-    'basic-syntax18': ("{{ foo.bar }}", {"foo" : {"bar" : "baz"}}, "baz"),
-    # Fail silently when a variable's dictionary key isn't found
-    'basic-syntax19': ("{{ foo.spam }}", {"foo" : {"bar" : "baz"}}, "INVALID"),
-    # Fail silently when accessing a non-simple method
-    'basic-syntax20': ("{{ var.method2 }}", {"var": SomeClass()}, "INVALID"),
-    # Basic filter usage
-    'basic-syntax21': ("{{ var|upper }}", {"var": "Django is the greatest!"}, "DJANGO IS THE GREATEST!"),
-    # Chained filters
-    'basic-syntax22': ("{{ var|upper|lower }}", {"var": "Django is the greatest!"}, "django is the greatest!"),
-    # Raise TemplateSyntaxError for space between a variable and filter pipe
-    'basic-syntax23': ("{{ var |upper }}", {}, template.TemplateSyntaxError),
-    # Raise TemplateSyntaxError for space after a filter pipe
-    'basic-syntax24': ("{{ var| upper }}", {}, template.TemplateSyntaxError),
-    # Raise TemplateSyntaxError for a nonexistent filter
-    'basic-syntax25': ("{{ var|does_not_exist }}", {}, template.TemplateSyntaxError),
-    # Raise TemplateSyntaxError when trying to access a filter containing an illegal character
-    'basic-syntax26': ("{{ var|fil(ter) }}", {}, template.TemplateSyntaxError),
-    # Raise TemplateSyntaxError for invalid block tags
-    'basic-syntax27': ("{% nothing_to_see_here %}", {}, template.TemplateSyntaxError),
-    # Raise TemplateSyntaxError for empty block tags
-    'basic-syntax28': ("{% %}", {}, template.TemplateSyntaxError),
-    # Chained filters, with an argument to the first one
-    'basic-syntax29': ('{{ var|removetags:"b i"|upper|lower }}', {"var": "<b><i>Yes</i></b>"}, "yes"),
-    # Escaped string as argument
-    'basic-syntax30': (r'{{ var|default_if_none:" endquote\" hah" }}', {"var": None}, ' endquote" hah'),
-    # Variable as argument
-    'basic-syntax31': (r'{{ var|default_if_none:var2 }}', {"var": None, "var2": "happy"}, 'happy'),
-    # Default argument testing
-    'basic-syntax32': (r'{{ var|yesno:"yup,nup,mup" }} {{ var|yesno }}', {"var": True}, 'yup yes'),
-    # Fail silently for methods that raise an exception with a "silent_variable_failure" attribute
-    'basic-syntax33': (r'1{{ var.method3 }}2', {"var": SomeClass()}, "1INVALID2"),
-    # In methods that raise an exception without a "silent_variable_attribute" set to True,
-    # the exception propogates
-    'basic-syntax34': (r'1{{ var.method4 }}2', {"var": SomeClass()}, SomeOtherException),
-    # Escaped backslash in argument
-    'basic-syntax35': (r'{{ var|default_if_none:"foo\bar" }}', {"var": None}, r'foo\bar'),
-    # Escaped backslash using known escape char
-    'basic-syntax35': (r'{{ var|default_if_none:"foo\now" }}', {"var": None}, r'foo\now'),
-    ### COMMENT TAG ###########################################################
-    'comment-tag01': ("{% comment %}this is hidden{% endcomment %}hello", {}, "hello"),
-    'comment-tag02': ("{% comment %}this is hidden{% endcomment %}hello{% comment %}foo{% endcomment %}", {}, "hello"),
-    # Comment tag can contain invalid stuff.
-    'comment-tag03': ("foo{% comment %} {% if %} {% endcomment %}", {}, "foo"),
-    'comment-tag04': ("foo{% comment %} {% endblock %} {% endcomment %}", {}, "foo"),
-    'comment-tag05': ("foo{% comment %} {% somerandomtag %} {% endcomment %}", {}, "foo"),
-    ### CYCLE TAG #############################################################
-    'cycle01': ('{% cycle a %}', {}, template.TemplateSyntaxError),
-    'cycle02': ('{% cycle a,b,c as abc %}{% cycle abc %}', {}, 'ab'),
-    'cycle03': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}', {}, 'abc'),
-    'cycle04': ('{% cycle a,b,c as abc %}{% cycle abc %}{% cycle abc %}{% cycle abc %}', {}, 'abca'),
-    'cycle05': ('{% cycle %}', {}, template.TemplateSyntaxError),
-    'cycle06': ('{% cycle a %}', {}, template.TemplateSyntaxError),
-    'cycle07': ('{% cycle a,b,c as foo %}{% cycle bar %}', {}, template.TemplateSyntaxError),
-    ### EXCEPTIONS ############################################################
-    # Raise exception for invalid template name
-    'exception01': ("{% extends 'nonexistent' %}", {}, template.TemplateSyntaxError),
-    # Raise exception for invalid template name (in variable)
-    'exception02': ("{% extends nonexistent %}", {}, template.TemplateSyntaxError),
-    # Raise exception for extra {% extends %} tags
-    'exception03': ("{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% extends 'inheritance16' %}", {}, template.TemplateSyntaxError),
-    # Raise exception for custom tags used in child with {% load %} tag in parent, not in child
-    'exception04': ("{% extends 'inheritance17' %}{% block first %}{% echo 400 %}5678{% endblock %}", {}, template.TemplateSyntaxError),
-    ### FILTER TAG ############################################################
-    'filter01': ('{% filter upper %}{% endfilter %}', {}, ''),
-    'filter02': ('{% filter upper %}django{% endfilter %}', {}, 'DJANGO'),
-    'filter03': ('{% filter upper|lower %}django{% endfilter %}', {}, 'django'),
-    ### FIRSTOF TAG ###########################################################
-    'firstof01': ('{% firstof a b c %}', {'a':0,'b':0,'c':0}, ''),
-    'firstof02': ('{% firstof a b c %}', {'a':1,'b':0,'c':0}, '1'),
-    'firstof03': ('{% firstof a b c %}', {'a':0,'b':2,'c':0}, '2'),
-    'firstof04': ('{% firstof a b c %}', {'a':0,'b':0,'c':3}, '3'),
-    'firstof05': ('{% firstof a b c %}', {'a':1,'b':2,'c':3}, '1'),
-    'firstof06': ('{% firstof %}', {}, template.TemplateSyntaxError),
-    ### FOR TAG ###############################################################
-    'for-tag01': ("{% for val in values %}{{ val }}{% endfor %}", {"values": [1, 2, 3]}, "123"),
-    'for-tag02': ("{% for val in values reversed %}{{ val }}{% endfor %}", {"values": [1, 2, 3]}, "321"),
-    'for-tag-vars01': ("{% for val in values %}{{ forloop.counter }}{% endfor %}", {"values": [6, 6, 6]}, "123"),
-    'for-tag-vars02': ("{% for val in values %}{{ forloop.counter0 }}{% endfor %}", {"values": [6, 6, 6]}, "012"),
-    'for-tag-vars03': ("{% for val in values %}{{ forloop.revcounter }}{% endfor %}", {"values": [6, 6, 6]}, "321"),
-    'for-tag-vars04': ("{% for val in values %}{{ forloop.revcounter0 }}{% endfor %}", {"values": [6, 6, 6]}, "210"),
-    ### IF TAG ################################################################
-    'if-tag01': ("{% if foo %}yes{% else %}no{% endif %}", {"foo": True}, "yes"),
-    'if-tag02': ("{% if foo %}yes{% else %}no{% endif %}", {"foo": False}, "no"),
-    'if-tag03': ("{% if foo %}yes{% else %}no{% endif %}", {}, "no"),
-    # AND
-    'if-tag-and01': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'yes'),
-    'if-tag-and02': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'no'),
-    'if-tag-and03': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'no'),
-    'if-tag-and04': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'no'),
-    'if-tag-and05': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': False}, 'no'),
-    'if-tag-and06': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'bar': False}, 'no'),
-    'if-tag-and07': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'foo': True}, 'no'),
-    'if-tag-and08': ("{% if foo and bar %}yes{% else %}no{% endif %}", {'bar': True}, 'no'),
-    # OR
-    'if-tag-or01': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'yes'),
-    'if-tag-or02': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'yes'),
-    'if-tag-or03': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'yes'),
-    'if-tag-or04': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'no'),
-    'if-tag-or05': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': False}, 'no'),
-    'if-tag-or06': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'bar': False}, 'no'),
-    'if-tag-or07': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'foo': True}, 'yes'),
-    'if-tag-or08': ("{% if foo or bar %}yes{% else %}no{% endif %}", {'bar': True}, 'yes'),
-    # TODO: multiple ORs
-    # NOT
-    'if-tag-not01': ("{% if not foo %}no{% else %}yes{% endif %}", {'foo': True}, 'yes'),
-    'if-tag-not02': ("{% if not %}yes{% else %}no{% endif %}", {'foo': True}, 'no'),
-    'if-tag-not03': ("{% if not %}yes{% else %}no{% endif %}", {'not': True}, 'yes'),
-    'if-tag-not04': ("{% if not not %}no{% else %}yes{% endif %}", {'not': True}, 'yes'),
-    'if-tag-not05': ("{% if not not %}no{% else %}yes{% endif %}", {}, 'no'),
-    'if-tag-not06': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {}, 'no'),
-    'if-tag-not07': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'no'),
-    'if-tag-not08': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'yes'),
-    'if-tag-not09': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'no'),
-    'if-tag-not10': ("{% if foo and not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'no'),
-    'if-tag-not11': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {}, 'no'),
-    'if-tag-not12': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'no'),
-    'if-tag-not13': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'no'),
-    'if-tag-not14': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'yes'),
-    'if-tag-not15': ("{% if not foo and bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'no'),
-    'if-tag-not16': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {}, 'yes'),
-    'if-tag-not17': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'yes'),
-    'if-tag-not18': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'yes'),
-    'if-tag-not19': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'no'),
-    'if-tag-not20': ("{% if foo or not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'yes'),
-    'if-tag-not21': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {}, 'yes'),
-    'if-tag-not22': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'yes'),
-    'if-tag-not23': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'no'),
-    'if-tag-not24': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'yes'),
-    'if-tag-not25': ("{% if not foo or bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'yes'),
-    'if-tag-not26': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {}, 'yes'),
-    'if-tag-not27': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'no'),
-    'if-tag-not28': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'no'),
-    'if-tag-not29': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'no'),
-    'if-tag-not30': ("{% if not foo and not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'yes'),
-    'if-tag-not31': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {}, 'yes'),
-    'if-tag-not32': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': True}, 'no'),
-    'if-tag-not33': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {'foo': True, 'bar': False}, 'yes'),
-    'if-tag-not34': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': True}, 'yes'),
-    'if-tag-not35': ("{% if not foo or not bar %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, 'yes'),
-    # AND and OR raises a TemplateSyntaxError
-    'if-tag-error01': ("{% if foo or bar and baz %}yes{% else %}no{% endif %}", {'foo': False, 'bar': False}, template.TemplateSyntaxError),
-    'if-tag-error02': ("{% if foo and %}yes{% else %}no{% endif %}", {'foo': True}, template.TemplateSyntaxError),
-    'if-tag-error03': ("{% if foo or %}yes{% else %}no{% endif %}", {'foo': True}, template.TemplateSyntaxError),
-    'if-tag-error04': ("{% if not foo and %}yes{% else %}no{% endif %}", {'foo': True}, template.TemplateSyntaxError),
-    'if-tag-error05': ("{% if not foo or %}yes{% else %}no{% endif %}", {'foo': True}, template.TemplateSyntaxError),
-    ### IFCHANGED TAG #########################################################
-    'ifchanged01': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', { 'num': (1,2,3) }, '123'),
-    'ifchanged02': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', { 'num': (1,1,3) }, '13'),
-    'ifchanged03': ('{% for n in num %}{% ifchanged %}{{ n }}{% endifchanged %}{% endfor %}', { 'num': (1,1,1) }, '1'),
-    ### IFEQUAL TAG ###########################################################
-    'ifequal01': ("{% ifequal a b %}yes{% endifequal %}", {"a": 1, "b": 2}, ""),
-    'ifequal02': ("{% ifequal a b %}yes{% endifequal %}", {"a": 1, "b": 1}, "yes"),
-    'ifequal03': ("{% ifequal a b %}yes{% else %}no{% endifequal %}", {"a": 1, "b": 2}, "no"),
-    'ifequal04': ("{% ifequal a b %}yes{% else %}no{% endifequal %}", {"a": 1, "b": 1}, "yes"),
-    'ifequal05': ("{% ifequal a 'test' %}yes{% else %}no{% endifequal %}", {"a": "test"}, "yes"),
-    'ifequal06': ("{% ifequal a 'test' %}yes{% else %}no{% endifequal %}", {"a": "no"}, "no"),
-    'ifequal07': ('{% ifequal a "test" %}yes{% else %}no{% endifequal %}', {"a": "test"}, "yes"),
-    'ifequal08': ('{% ifequal a "test" %}yes{% else %}no{% endifequal %}', {"a": "no"}, "no"),
-    'ifequal09': ('{% ifequal a "test" %}yes{% else %}no{% endifequal %}', {}, "no"),
-    'ifequal10': ('{% ifequal a b %}yes{% else %}no{% endifequal %}', {}, "yes"),
-    # SMART SPLITTING
-    'ifequal-split01': ('{% ifequal a "test man" %}yes{% else %}no{% endifequal %}', {}, "no"),
-    'ifequal-split02': ('{% ifequal a "test man" %}yes{% else %}no{% endifequal %}', {'a': 'foo'}, "no"),
-    'ifequal-split03': ('{% ifequal a "test man" %}yes{% else %}no{% endifequal %}', {'a': 'test man'}, "yes"),
-    'ifequal-split04': ("{% ifequal a 'test man' %}yes{% else %}no{% endifequal %}", {'a': 'test man'}, "yes"),
-    'ifequal-split05': ("{% ifequal a 'i \"love\" you' %}yes{% else %}no{% endifequal %}", {'a': ''}, "no"),
-    'ifequal-split06': ("{% ifequal a 'i \"love\" you' %}yes{% else %}no{% endifequal %}", {'a': 'i "love" you'}, "yes"),
-    'ifequal-split07': ("{% ifequal a 'i \"love\" you' %}yes{% else %}no{% endifequal %}", {'a': 'i love you'}, "no"),
-    'ifequal-split08': (r"{% ifequal a 'I\'m happy' %}yes{% else %}no{% endifequal %}", {'a': "I'm happy"}, "yes"),
-    'ifequal-split09': (r"{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}", {'a': r"slash\man"}, "yes"),
-    'ifequal-split10': (r"{% ifequal a 'slash\man' %}yes{% else %}no{% endifequal %}", {'a': r"slashman"}, "no"),
-    ### IFNOTEQUAL TAG ########################################################
-    'ifnotequal01': ("{% ifnotequal a b %}yes{% endifnotequal %}", {"a": 1, "b": 2}, "yes"),
-    'ifnotequal02': ("{% ifnotequal a b %}yes{% endifnotequal %}", {"a": 1, "b": 1}, ""),
-    'ifnotequal03': ("{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}", {"a": 1, "b": 2}, "yes"),
-    'ifnotequal04': ("{% ifnotequal a b %}yes{% else %}no{% endifnotequal %}", {"a": 1, "b": 1}, "no"),
-    ### INCLUDE TAG ###########################################################
-    'include01': ('{% include "basic-syntax01" %}', {}, "something cool"),
-    'include02': ('{% include "basic-syntax02" %}', {'headline': 'Included'}, "Included"),
-    'include03': ('{% include template_name %}', {'template_name': 'basic-syntax02', 'headline': 'Included'}, "Included"),
-    'include04': ('a{% include "nonexistent" %}b', {}, "ab"),
-    ### INHERITANCE ###########################################################
-    # Standard template with no inheritance
-    'inheritance01': ("1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}", {}, '1_3_'),
-    # Standard two-level inheritance
-    'inheritance02': ("{% extends 'inheritance01' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}", {}, '1234'),
-    # Three-level with no redefinitions on third level
-    'inheritance03': ("{% extends 'inheritance02' %}", {}, '1234'),
-    # Two-level with no redefinitions on second level
-    'inheritance04': ("{% extends 'inheritance01' %}", {}, '1_3_'),
-    # Two-level with double quotes instead of single quotes
-    'inheritance05': ('{% extends "inheritance02" %}', {}, '1234'),
-    # Three-level with variable parent-template name
-    'inheritance06': ("{% extends foo %}", {'foo': 'inheritance02'}, '1234'),
-    # Two-level with one block defined, one block not defined
-    'inheritance07': ("{% extends 'inheritance01' %}{% block second %}5{% endblock %}", {}, '1_35'),
-    # Three-level with one block defined on this level, two blocks defined next level
-    'inheritance08': ("{% extends 'inheritance02' %}{% block second %}5{% endblock %}", {}, '1235'),
-    # Three-level with second and third levels blank
-    'inheritance09': ("{% extends 'inheritance04' %}", {}, '1_3_'),
-    # Three-level with space NOT in a block -- should be ignored
-    'inheritance10': ("{% extends 'inheritance04' %}      ", {}, '1_3_'),
-    # Three-level with both blocks defined on this level, but none on second level
-    'inheritance11': ("{% extends 'inheritance04' %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}", {}, '1234'),
-    # Three-level with this level providing one and second level providing the other
-    'inheritance12': ("{% extends 'inheritance07' %}{% block first %}2{% endblock %}", {}, '1235'),
-    # Three-level with this level overriding second level
-    'inheritance13': ("{% extends 'inheritance02' %}{% block first %}a{% endblock %}{% block second %}b{% endblock %}", {}, '1a3b'),
-    # A block defined only in a child template shouldn't be displayed
-    'inheritance14': ("{% extends 'inheritance01' %}{% block newblock %}NO DISPLAY{% endblock %}", {}, '1_3_'),
-    # A block within another block
-    'inheritance15': ("{% extends 'inheritance01' %}{% block first %}2{% block inner %}inner{% endblock %}{% endblock %}", {}, '12inner3_'),
-    # A block within another block (level 2)
-    'inheritance16': ("{% extends 'inheritance15' %}{% block inner %}out{% endblock %}", {}, '12out3_'),
-    # {% load %} tag (parent -- setup for exception04)
-    'inheritance17': ("{% load testtags %}{% block first %}1234{% endblock %}", {}, '1234'),
-    # {% load %} tag (standard usage, without inheritance)
-    'inheritance18': ("{% load testtags %}{% echo this that theother %}5678", {}, 'this that theother5678'),
-    # {% load %} tag (within a child template)
-    'inheritance19': ("{% extends 'inheritance01' %}{% block first %}{% load testtags %}{% echo 400 %}5678{% endblock %}", {}, '140056783_'),
-    # Two-level inheritance with {{ block.super }}
-    'inheritance20': ("{% extends 'inheritance01' %}{% block first %}{{ block.super }}a{% endblock %}", {}, '1_a3_'),
-    # Three-level inheritance with {{ block.super }} from parent
-    'inheritance21': ("{% extends 'inheritance02' %}{% block first %}{{ block.super }}a{% endblock %}", {}, '12a34'),
-    # Three-level inheritance with {{ block.super }} from grandparent
-    'inheritance22': ("{% extends 'inheritance04' %}{% block first %}{{ block.super }}a{% endblock %}", {}, '1_a3_'),
-    # Three-level inheritance with {{ block.super }} from parent and grandparent
-    'inheritance23': ("{% extends 'inheritance20' %}{% block first %}{{ block.super }}b{% endblock %}", {}, '1_ab3_'),
-    # Inheritance from local context without use of template loader
-    'inheritance24': ("{% extends context_template %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}", {'context_template': template.Template("1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}")}, '1234'),
-    # Inheritance from local context with variable parent template
-    'inheritance25': ("{% extends context_template.1 %}{% block first %}2{% endblock %}{% block second %}4{% endblock %}", {'context_template': [template.Template("Wrong"), template.Template("1{% block first %}_{% endblock %}3{% block second %}_{% endblock %}")]}, '1234'),
-    ### I18N ##################################################################
-    # {% spaceless %} tag
-    'spaceless01': ("{% spaceless %} <b>    <i> text </i>    </b> {% endspaceless %}", {}, "<b> <i> text </i> </b>"),
-    'spaceless02': ("{% spaceless %} <b> \n <i> text </i> \n </b> {% endspaceless %}", {}, "<b> <i> text </i> </b>"),
-    'spaceless03': ("{% spaceless %}<b><i>text</i></b>{% endspaceless %}", {}, "<b><i>text</i></b>"),
-    # simple translation of a string delimited by '
-    'i18n01': ("{% load i18n %}{% trans 'xxxyyyxxx' %}", {}, "xxxyyyxxx"),
-    # simple translation of a string delimited by "
-    'i18n02': ('{% load i18n %}{% trans "xxxyyyxxx" %}', {}, "xxxyyyxxx"),
-    # simple translation of a variable
-    'i18n03': ('{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}', {'anton': 'xxxyyyxxx'}, "xxxyyyxxx"),
-    # simple translation of a variable and filter
-    'i18n04': ('{% load i18n %}{% blocktrans with anton|lower as berta %}{{ berta }}{% endblocktrans %}', {'anton': 'XXXYYYXXX'}, "xxxyyyxxx"),
-    # simple translation of a string with interpolation
-    'i18n05': ('{% load i18n %}{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}', {'anton': 'yyy'}, "xxxyyyxxx"),
-    # simple translation of a string to german
-    'i18n06': ('{% load i18n %}{% trans "Page not found" %}', {'LANGUAGE_CODE': 'de'}, "Seite nicht gefunden"),
-    # translation of singular form
-    'i18n07': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}plural{% endblocktrans %}', {'number': 1}, "singular"),
-    # translation of plural form
-    'i18n08': ('{% load i18n %}{% blocktrans count number as counter %}singular{% plural %}plural{% endblocktrans %}', {'number': 2}, "plural"),
-    # simple non-translation (only marking) of a string to german
-    'i18n09': ('{% load i18n %}{% trans "Page not found" noop %}', {'LANGUAGE_CODE': 'de'}, "Page not found"),
-    # translation of a variable with a translated filter
-    'i18n10': ('{{ bool|yesno:_("ja,nein") }}', {'bool': True}, 'ja'),
-    # translation of a variable with a non-translated filter
-    'i18n11': ('{{ bool|yesno:"ja,nein" }}', {'bool': True}, 'ja'),
-    # usage of the get_available_languages tag
-    'i18n12': ('{% load i18n %}{% get_available_languages as langs %}{% for lang in langs %}{% ifequal lang.0 "de" %}{{ lang.0 }}{% endifequal %}{% endfor %}', {}, 'de'),
-    # translation of a constant string
-    'i18n13': ('{{ _("Page not found") }}', {'LANGUAGE_CODE': 'de'}, 'Seite nicht gefunden'),
-    ### MULTILINE #############################################################
-    'multiline01': ("""
-                    Hello,
-                    boys.
-                    How
-                    are
-                    you
-                    gentlemen.
-                    """,
-                    {},
-                    """
-                    Hello,
-                    boys.
-                    How
-                    are
-                    you
-                    gentlemen.
-                    """),
-    ### REGROUP TAG ###########################################################
-    'regroup01': ('{% regroup data by bar as grouped %}' + \
-                  '{% for group in grouped %}' + \
-                  '{{ group.grouper }}:' + \
-                  '{% for item in group.list %}' + \
-                  '{{ item.foo }}' + \
-                  '{% endfor %},' + \
-                  '{% endfor %}',
-                  {'data': [ {'foo':'c', 'bar':1},
-                             {'foo':'d', 'bar':1},
-                             {'foo':'a', 'bar':2},
-                             {'foo':'b', 'bar':2},
-                             {'foo':'x', 'bar':3}  ]},
-                  '1:cd,2:ab,3:x,'),
-    # Test for silent failure when target variable isn't found
-    'regroup02': ('{% regroup data by bar as grouped %}' + \
-                  '{% for group in grouped %}' + \
-                  '{{ group.grouper }}:' + \
-                  '{% for item in group.list %}' + \
-                  '{{ item.foo }}' + \
-                  '{% endfor %},' + \
-                  '{% endfor %}',
-                  {}, 'INVALID:INVALIDINVALIDINVALIDINVALIDINVALIDINVALIDINVALID,'),
-    ### TEMPLATETAG TAG #######################################################
-    'templatetag01': ('{% templatetag openblock %}', {}, '{%'),
-    'templatetag02': ('{% templatetag closeblock %}', {}, '%}'),
-    'templatetag03': ('{% templatetag openvariable %}', {}, '{{'),
-    'templatetag04': ('{% templatetag closevariable %}', {}, '}}'),
-    'templatetag05': ('{% templatetag %}', {}, template.TemplateSyntaxError),
-    'templatetag06': ('{% templatetag foo %}', {}, template.TemplateSyntaxError),
-    'templatetag07': ('{% templatetag openbrace %}', {}, '{'),
-    'templatetag08': ('{% templatetag closebrace %}', {}, '}'),
-    'templatetag09': ('{% templatetag openbrace %}{% templatetag openbrace %}', {}, '{{'),
-    'templatetag10': ('{% templatetag closebrace %}{% templatetag closebrace %}', {}, '}}'),
-    ### WIDTHRATIO TAG ########################################################
-    'widthratio01': ('{% widthratio a b 0 %}', {'a':50,'b':100}, '0'),
-    'widthratio02': ('{% widthratio a b 100 %}', {'a':0,'b':0}, ''),
-    'widthratio03': ('{% widthratio a b 100 %}', {'a':0,'b':100}, '0'),
-    'widthratio04': ('{% widthratio a b 100 %}', {'a':50,'b':100}, '50'),
-    'widthratio05': ('{% widthratio a b 100 %}', {'a':100,'b':100}, '100'),
-    # 62.5 should round to 63
-    'widthratio06': ('{% widthratio a b 100 %}', {'a':50,'b':80}, '63'),
-    # 71.4 should round to 71
-    'widthratio07': ('{% widthratio a b 100 %}', {'a':50,'b':70}, '71'),
-    # Raise exception if we don't have 3 args, last one an integer
-    'widthratio08': ('{% widthratio %}', {}, template.TemplateSyntaxError),
-    'widthratio09': ('{% widthratio a b %}', {'a':50,'b':100}, template.TemplateSyntaxError),
-    'widthratio10': ('{% widthratio a b 100.0 %}', {'a':50,'b':100}, template.TemplateSyntaxError),
-    ### NOW TAG ########################################################
-    # Simple case
-    'now01' : ('{% now "j n Y"%}', {}, str(datetime.now().day) + ' ' + str(datetime.now().month) + ' ' + str(datetime.now().year)),
-    # Check parsing of escaped and special characters
-    'now02' : ('{% now "j "n" Y"%}', {}, template.TemplateSyntaxError),
-#    'now03' : ('{% now "j \"n\" Y"%}', {}, str(datetime.now().day) + '"' + str(datetime.now().month) + '"' + str(datetime.now().year)),
-#    'now04' : ('{% now "j \nn\n Y"%}', {}, str(datetime.now().day) + '\n' + str(datetime.now().month) + '\n' + str(datetime.now().year))
-    ### TIMESINCE TAG ##################################################
-    # Default compare with datetime.now()
-    'timesince01' : ('{{ a|timesince }}', {'a':datetime.now() + timedelta(minutes=-1, seconds = -10)}, '1 minute'),
-    'timesince02' : ('{{ a|timesince }}', {'a':(datetime.now() - timedelta(days=1, minutes = 1))}, '1 day'),
-    'timesince03' : ('{{ a|timesince }}', {'a':(datetime.now() -
-        timedelta(hours=1, minutes=25, seconds = 10))}, '1 hour, 25 minutes'),
-    # Compare to a given parameter
-    'timesince04' : ('{{ a|timesince:b }}', {'a':NOW + timedelta(days=2), 'b':NOW + timedelta(days=1)}, '1 day'),
-    'timesince05' : ('{{ a|timesince:b }}', {'a':NOW + timedelta(days=2, minutes=1), 'b':NOW + timedelta(days=2)}, '1 minute'),
-    # Check that timezone is respected
-    'timesince06' : ('{{ a|timesince:b }}', {'a':NOW_tz + timedelta(hours=8), 'b':NOW_tz}, '8 hours'),
-    ### TIMEUNTIL TAG ##################################################
-    # Default compare with datetime.now()
-    'timeuntil01' : ('{{ a|timeuntil }}', {'a':datetime.now() + timedelta(minutes=2, seconds = 10)}, '2 minutes'),
-    'timeuntil02' : ('{{ a|timeuntil }}', {'a':(datetime.now() + timedelta(days=1, seconds = 10))}, '1 day'),
-    'timeuntil03' : ('{{ a|timeuntil }}', {'a':(datetime.now() + timedelta(hours=8, minutes=10, seconds = 10))}, '8 hours, 10 minutes'),
-    # Compare to a given parameter
-    'timeuntil04' : ('{{ a|timeuntil:b }}', {'a':NOW - timedelta(days=1), 'b':NOW - timedelta(days=2)}, '1 day'),
-    'timeuntil05' : ('{{ a|timeuntil:b }}', {'a':NOW - timedelta(days=2), 'b':NOW - timedelta(days=2, minutes=1)}, '1 minute'),
+}
-def test_template_loader(template_name, template_dirs=None):
-    "A custom template loader that loads the unit-test templates."
-    try:
-        return (TEMPLATE_TESTS[template_name][0] , "test:%s" % template_name)
-    except KeyError:
-        raise template.TemplateDoesNotExist, template_name
-def run_tests(verbosity=0, standalone=False):
-    # Register our custom template loader.
-    old_template_loaders = loader.template_source_loaders
-    loader.template_source_loaders = [test_template_loader]
-    failed_tests = []
-    tests = TEMPLATE_TESTS.items()
-    tests.sort()
-    # Turn TEMPLATE_DEBUG off, because tests assume that.
-    old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, False
-    # Set TEMPLATE_STRING_IF_INVALID to a known string
-    old_invalid, settings.TEMPLATE_STRING_IF_INVALID = settings.TEMPLATE_STRING_IF_INVALID, 'INVALID'
-    for name, vals in tests:
-        install()
-        if 'LANGUAGE_CODE' in vals[1]:
-            activate(vals[1]['LANGUAGE_CODE'])
-        else:
-            activate('en-us')
-        try:
-            output = loader.get_template(name).render(template.Context(vals[1]))
-        except Exception, e:
-            if e.__class__ == vals[2]:
-                if verbosity:
-                    print "Template test: %s -- Passed" % name
-            else:
-                if verbosity:
-                    traceback.print_exc()
-                    print "Template test: %s -- FAILED. Got %s, exception: %s" % (name, e.__class__, e)
-                failed_tests.append(name)
-            continue
-        if 'LANGUAGE_CODE' in vals[1]:
-            deactivate()
-        if output == vals[2]:
-            if verbosity:
-                print "Template test: %s -- Passed" % name
-        else:
-            if verbosity:
-                print "Template test: %s -- FAILED. Expected %r, got %r" % (name, vals[2], output)
-            failed_tests.append(name)
-    loader.template_source_loaders = old_template_loaders
-    deactivate()
-    settings.TEMPLATE_DEBUG = old_td
-    settings.TEMPLATE_STRING_IF_INVALID = old_invalid
-    if failed_tests and not standalone:
-        msg = "Template tests %s failed." % failed_tests
-        if not verbosity:
-            msg += "  Re-run tests with -v1 to see actual failures"
-        raise Exception, msg
-if __name__ == "__main__":
-    run_tests(1, True)

tests/othertests/urlpatterns_reverse.py

-"Unit tests for reverse URL lookup"
-from django.core.urlresolvers import reverse_helper, NoReverseMatch
-import re
-test_data = (
-    ('^places/(\d+)/$', 'places/3/', [3], {}),
-    ('^places/(\d+)/$', 'places/3/', ['3'], {}),
-    ('^places/(\d+)/$', NoReverseMatch, ['a'], {}),
-    ('^places/(\d+)/$', NoReverseMatch, [], {}),
-    ('^places/(?P<id>\d+)/$', 'places/3/', [], {'id': 3}),
-    ('^people/(?P<name>\w+)/$', 'people/adrian/', ['adrian'], {}),
-    ('^people/(?P<name>\w+)/$', 'people/adrian/', [], {'name': 'adrian'}),
-    ('^people/(?P<name>\w+)/$', NoReverseMatch, ['name with spaces'], {}),
-    ('^people/(?P<name>\w+)/$', NoReverseMatch, [], {'name': 'name with spaces'}),
-    ('^people/(?P<name>\w+)/$', NoReverseMatch, [], {}),
-    ('^hardcoded/$', 'hardcoded/', [], {}),
-    ('^hardcoded/$', 'hardcoded/', ['any arg'], {}),
-    ('^hardcoded/$', 'hardcoded/', [], {'kwarg': 'foo'}),
-    ('^people/(?P<state>\w\w)/(?P<name>\w+)/$', 'people/il/adrian/', [], {'state': 'il', 'name': 'adrian'}),
-    ('^people/(?P<state>\w\w)/(?P<name>\d)/$', NoReverseMatch, [], {'state': 'il', 'name': 'adrian'}),
-    ('^people/(?P<state>\w\w)/(?P<name>\w+)/$', NoReverseMatch, [], {'state': 'il'}),
-    ('^people/(?P<state>\w\w)/(?P<name>\w+)/$', NoReverseMatch, [], {'name': 'adrian'}),
-    ('^people/(?P<state>\w\w)/(\w+)/$', NoReverseMatch, ['il'], {'name': 'adrian'}),
-    ('^people/(?P<state>\w\w)/(\w+)/$', 'people/il/adrian/', ['adrian'], {'state': 'il'}),
+)
-def run_tests(verbosity=0):
-    for regex, expected, args, kwargs in test_data:
-        passed = True
-        try:
-            got = reverse_helper(re.compile(regex), *args, **kwargs)
-        except NoReverseMatch, e:
-            if expected != NoReverseMatch:
-                passed, got = False, str(e)
-        else:
-            if got != expected:
-                passed, got = False, got
-        if passed and verbosity:
-            print "Passed: %s" % regex
-        elif not passed:
-            print "REVERSE LOOKUP FAILED: %s" % regex
-            print "   Got: %s" % got
-            print "   Expected: %r" % expected
-if __name__ == "__main__":
-    run_tests(1)

tests/othertests/markup.py

-# Quick tests for the markup templatetags (django.contrib.markup)
-from django.template import Template, Context, add_to_builtins
-import re
-add_to_builtins('django.contrib.markup.templatetags.markup')
-# find out if markup modules are installed and tailor the test appropriately
-try:
-    import textile
-except ImportError:
-    textile = None
-try:
-    import markdown
-except ImportError:
-    markdown = None
-try:
-    import docutils
-except ImportError:
-    docutils = None
-# simple examples 'cause this isn't actually testing the markup, just
-# that the filters work as advertised
-### test textile
-textile_content = """Paragraph 1
-Paragraph 2 with "quotes" and @code@"""
-t = Template("{{ textile_content|textile }}")
-rendered = t.render(Context(locals())).strip()
-if textile:
-    assert rendered == """<p>Paragraph 1</p>
-<p>Paragraph 2 with &#8220;quotes&#8221; and <code>code</code></p>"""
-else:
-    assert rendered == textile_content
-### test markdown
-markdown_content = """Paragraph 1
-## An h2"""
-t = Template("{{ markdown_content|markdown }}")
-rendered = t.render(Context(locals())).strip()
-if markdown:
-    pattern = re.compile("""<p>Paragraph 1\s*</p>\s*<h2>\s*An h2</h2>""")
-    assert pattern.match(rendered)
-else:
-    assert rendered == markdown_content
-### test rest
-rest_content = """Paragraph 1
-Paragraph 2 with a link_
-.. _link: http://www.example.com/"""
-t = Template("{{ rest_content|restructuredtext }}")
-rendered = t.render(Context(locals())).strip()
-if docutils:
-    assert rendered =="""<p>Paragraph 1</p>
-<p>Paragraph 2 with a <a class="reference" href="http://www.example.com/">link</a></p>"""
-else:
-    assert rendered == rest_content

tests/othertests/cache.py

-# Unit tests for cache framework
-# Uses whatever cache backend is set in the test settings file.
-from django.core.cache import cache
-import time
-# functions/classes for complex data type tests
-def f():
-    return 42
-class C:
-    def m(n):
-        return 24
-# simple set/get
-cache.set("key", "value")
-assert cache.get("key") == "value"
-# get with non-existent keys
-assert cache.get("does not exist") is None
-assert cache.get("does not exist", "bang!") == "bang!"
-# get_many
-cache.set('a', 'a')
-cache.set('b', 'b')
-cache.set('c', 'c')
-cache.set('d', 'd')
-assert cache.get_many(['a', 'c', 'd']) == {'a' : 'a', 'c' : 'c', 'd' : 'd'}
-assert cache.get_many(['a', 'b', 'e']) == {'a' : 'a', 'b' : 'b'}
-# delete
-cache.set("key1", "spam")
-cache.set("key2", "eggs")
-assert cache.get("key1") == "spam"
-cache.delete("key1")
-assert cache.get("key1") is None
-assert cache.get("key2") == "eggs"
-# has_key
-cache.set("hello", "goodbye")
-assert cache.has_key("hello") == True
-assert cache.has_key("goodbye") == False
-# test data types
-stuff = {
-    'string'    : 'this is a string',
-    'int'       : 42,
-    'list'      : [1, 2, 3, 4],
-    'tuple'     : (1, 2, 3, 4),
-    'dict'      : {'A': 1, 'B' : 2},
-    'function'  : f,
-    'class'     : C,
+}
-for (key, value) in stuff.items():
-    cache.set(key, value)
-    assert cache.get(key) == value
-# expiration
-cache.set('expire', 'very quickly', 1)
-time.sleep(2)
-assert cache.get("expire") == None

tests/othertests/httpwrappers.py

-"""
-###################
-# Empty QueryDict #
-###################
->>> q = QueryDict('')
->>> q['foo']
-Traceback (most recent call last):
-...
-MultiValueDictKeyError: "Key 'foo' not found in <MultiValueDict: {}>"
->>> q['something'] = 'bar'
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.get('foo', 'default')
-'default'
->>> q.getlist('foo')
-[]
->>> q.setlist('foo', ['bar', 'baz'])
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.appendlist('foo', ['bar'])
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.has_key('foo')
-False
->>> q.items()
-[]
->>> q.lists()
-[]
->>> q.keys()
-[]
->>> q.values()
-[]
->>> len(q)
->>> q.update({'foo': 'bar'})
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.pop('foo')
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.popitem()
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.clear()
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.setdefault('foo', 'bar')
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.urlencode()
-''
-###################################
-# Mutable copy of empty QueryDict #
-###################################
->>> q = q.copy()
->>> q['foo']
-Traceback (most recent call last):
-...
-MultiValueDictKeyError: "Key 'foo' not found in <MultiValueDict: {}>"
->>> q['name'] = 'john'
->>> q['name']
-'john'
->>> q.get('foo', 'default')
-'default'
->>> q.get('name', 'default')
-'john'
->>> q.getlist('name')
-['john']
->>> q.getlist('foo')
-[]
->>> q.setlist('foo', ['bar', 'baz'])
->>> q.get('foo', 'default')
-'baz'
->>> q.getlist('foo')
-['bar', 'baz']
->>> q.appendlist('foo', 'another')
->>> q.getlist('foo')
-['bar', 'baz', 'another']
->>> q['foo']
-'another'
->>> q.has_key('foo')
-True
->>> q.items()
-[('foo', 'another'), ('name', 'john')]
->>> q.lists()
-[('foo', ['bar', 'baz', 'another']), ('name', ['john'])]
->>> q.keys()
-['foo', 'name']
->>> q.values()
-['another', 'john']
->>> len(q)
->>> q.update({'foo': 'hello'})
-# Displays last value
->>> q['foo']
-'hello'
->>> q.get('foo', 'not available')
-'hello'
->>> q.getlist('foo')
-['bar', 'baz', 'another', 'hello']
->>> q.pop('foo')
-['bar', 'baz', 'another', 'hello']
->>> q.get('foo', 'not there')
-'not there'
->>> q.setdefault('foo', 'bar')
-'bar'
->>> q['foo']
-'bar'
->>> q.getlist('foo')
-['bar']
->>> q.urlencode()
-'foo=bar&name=john'
->>> q.clear()
->>> len(q)
-#####################################
-# QueryDict with one key/value pair #
-#####################################
->>> q = QueryDict('foo=bar')
->>> q['foo']
-'bar'
->>> q['bar']
-Traceback (most recent call last):
-...
-MultiValueDictKeyError: "Key 'bar' not found in <MultiValueDict: {'foo': ['bar']}>"
->>> q['something'] = 'bar'
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.get('foo', 'default')
-'bar'
->>> q.get('bar', 'default')
-'default'
->>> q.getlist('foo')
-['bar']
->>> q.getlist('bar')
-[]
->>> q.setlist('foo', ['bar', 'baz'])
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.appendlist('foo', ['bar'])
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.has_key('foo')
-True
->>> q.has_key('bar')
-False
->>> q.items()
-[('foo', 'bar')]
->>> q.lists()
-[('foo', ['bar'])]
->>> q.keys()
-['foo']
->>> q.values()
-['bar']
->>> len(q)
->>> q.update({'foo': 'bar'})
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.pop('foo')
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.popitem()
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.clear()
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.setdefault('foo', 'bar')
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.urlencode()
-'foo=bar'
-#####################################################
-# QueryDict with two key/value pairs with same keys #
-#####################################################
->>> q = QueryDict('vote=yes&vote=no')
->>> q['vote']
-'no'
->>> q['something'] = 'bar'
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.get('vote', 'default')
-'no'
->>> q.get('foo', 'default')
-'default'
->>> q.getlist('vote')
-['yes', 'no']
->>> q.getlist('foo')
-[]
->>> q.setlist('foo', ['bar', 'baz'])
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.appendlist('foo', ['bar'])
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.has_key('vote')
-True
->>> q.has_key('foo')
-False
->>> q.items()
-[('vote', 'no')]
->>> q.lists()
-[('vote', ['yes', 'no'])]
->>> q.keys()
-['vote']
->>> q.values()
-['no']
->>> len(q)
->>> q.update({'foo': 'bar'})
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.pop('foo')
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.popitem()
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.clear()
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.setdefault('foo', 'bar')
-Traceback (most recent call last):
-...
-AttributeError: This QueryDict instance is immutable
->>> q.urlencode()
-'vote=yes&vote=no'
-"""
-from django.http import QueryDict
-if __name__ == "__main__":
-    import doctest
-    doctest.testmod()

tests/othertests/db_typecasts.py

-# Unit tests for typecast functions in django.db.backends.util
-from django.db.backends import util as typecasts
-import datetime
-TEST_CASES = {
-    'typecast_date': (
-        ('', None),
-        (None, None),
-        ('2005-08-11', datetime.date(2005, 8, 11)),
-        ('1990-01-01', datetime.date(1990, 1, 1)),
-    ),
-    'typecast_time': (
-        ('', None),
-        (None, None),
-        ('0:00:00', datetime.time(0, 0)),
-        ('0:30:00', datetime.time(0, 30)),
-        ('8:50:00', datetime.time(8, 50)),
-        ('08:50:00', datetime.time(8, 50)),
-        ('12:00:00', datetime.time(12, 00)),
-        ('12:30:00', datetime.time(12, 30)),
-        ('13:00:00', datetime.time(13, 00)),
-        ('23:59:00', datetime.time(23, 59)),
-        ('00:00:12', datetime.time(0, 0, 12)),
-        ('00:00:12.5', datetime.time(0, 0, 12, 500000)),
-        ('7:22:13.312', datetime.time(7, 22, 13, 312000)),
-    ),
-    'typecast_timestamp': (
-        ('', None),
-        (None, None),
-        ('2005-08-11 0:00:00', datetime.datetime(2005, 8, 11)),
-        ('2005-08-11 0:30:00', datetime.datetime(2005, 8, 11, 0, 30)),
-        ('2005-08-11 8:50:30', datetime.datetime(2005, 8, 11, 8, 50, 30)),
-        ('2005-08-11 8:50:30.123', datetime.datetime(2005, 8, 11, 8, 50, 30, 123000)),
-        ('2005-08-11 8:50:30.9', datetime.datetime(2005, 8, 11, 8, 50, 30, 900000)),
-        ('2005-08-11 8:50:30.312-05', datetime.datetime(2005, 8, 11, 8, 50, 30, 312000)),
-        ('2005-08-11 8:50:30.312+02', datetime.datetime(2005, 8, 11, 8, 50, 30, 312000)),
-    ),
-    'typecast_boolean': (
-        (None, None),
-        ('', False),
-        ('t', True),
-        ('f', False),
-        ('x', False),
-    ),
+}
-for k, v in TEST_CASES.items():
-    for inpt, expected in v:
-        got = getattr(typecasts, k)(inpt)
-        assert got == expected, "In %s: %r doesn't match %r. Got %r instead." % (k, inpt, expected, got)

tests/othertests/dateformat.py

-r"""
->>> format(my_birthday, '')
-''
->>> format(my_birthday, 'a')
-'p.m.'
->>> format(my_birthday, 'A')
-'PM'
->>> format(my_birthday, 'd')
-'08'
->>> format(my_birthday, 'j')
-'8'
->>> format(my_birthday, 'l')
-'Sunday'
->>> format(my_birthday, 'L')
-'False'
->>> format(my_birthday, 'm')
-'07'
->>> format(my_birthday, 'M')
-'Jul'
->>> format(my_birthday, 'n')
-'7'
->>> format(my_birthday, 'N')
-'July'
->>> format(my_birthday, 'O')
-'+0100'
->>> format(my_birthday, 'P')
-'10 p.m.'
->>> format(my_birthday, 'r')
-'Sun, 8 Jul 1979 22:00:00 +0100'
->>> format(my_birthday, 's')
-'00'
->>> format(my_birthday, 'S')
-'th'
->>> format(my_birthday, 't')
-'31'
->>> format(my_birthday, 'T')
-'CET'
->>> format(my_birthday, 'U')
-'300531600'
->>> format(my_birthday, 'w')
-'0'
->>> format(my_birthday, 'W')
-'27'
->>> format(my_birthday, 'y')
-'79'
->>> format(my_birthday, 'Y')
-'1979'
->>> format(my_birthday, 'z')
-'189'
->>> format(my_birthday, 'Z')
-'3600'
->>> format(summertime, 'I')
-'1'
->>> format(summertime, 'O')
-'+0200'
->>> format(wintertime, 'I')
-'0'
->>> format(wintertime, 'O')
-'+0100'
->>> format(my_birthday, r'Y z \C\E\T')
-'1979 189 CET'
->>> format(my_birthday, r'jS o\f F')
-'8th of July'
-"""
-from django.utils import dateformat, translation
-import datetime, os, time
-format = dateformat.format
-os.environ['TZ'] = 'Europe/Copenhagen'
-translation.activate('en-us')
-time.tzset()
-my_birthday = datetime.datetime(1979, 7, 8, 22, 00)
-summertime = datetime.datetime(2005, 10, 30, 1, 00)
-wintertime = datetime.datetime(2005, 10, 30, 4, 00)

tests/runtests.py

 #!/usr/bin/env python
+import os, re, sys, time, traceback
+import os, sys, traceback
+import unittest
-# doctest is included in the same package as this module, because this testing
-# framework uses features only available in the Python 2.4 version of doctest,
-# and Django aims to work with Python 2.3+.
-import doctest
 MODEL_TESTS_DIR_NAME = 'modeltests'
-OTHER_TESTS_DIR = "othertests"
 REGRESSION_TESTS_DIR_NAME = 'regressiontests'
-TEST_DATABASE_NAME = 'django_test_db'
-error_list = []
-def log_error(model_name, title, description):
-    error_list.append({
-        'title': "%r module: %s" % (model_name, title),
-        'description': description,
-    })
 MODEL_TEST_DIR = os.path.join(os.path.dirname(__file__), MODEL_TESTS_DIR_NAME)
 REGRESSION_TEST_DIR = os.path.join(os.path.dirname(__file__), REGRESSION_TESTS_DIR_NAME)
 …
     models = []
     for loc, dirpath in (MODEL_TESTS_DIR_NAME, MODEL_TEST_DIR), (REGRESSION_TESTS_DIR_NAME, REGRESSION_TEST_DIR):
         for f in os.listdir(dirpath):
             if f.startswith('__init__') or f.startswith('.') or f.startswith('sql'):
+            if f.startswith('__init__') or f.startswith('.') or f.startswith('sql') or f.startswith('invalid'):
                 continue
             models.append((loc, f))
     return models
+class DjangoDoctestRunner(doctest.DocTestRunner):
+    def __init__(self, verbosity_level, *args, **kwargs):
+        self.verbosity_level = verbosity_level
+        doctest.DocTestRunner.__init__(self, *args, **kwargs)
+        self._checker = DjangoDoctestOutputChecker()
+        self.optionflags = doctest.ELLIPSIS
+    def report_start(self, out, test, example):
+        if self.verbosity_level > 1:
+            out("  >>> %s\n" % example.source.strip())
+    def report_failure(self, out, test, example, got):
+        log_error(test.name, "API test failed",
+            "Code: %r\nLine: %s\nExpected: %r\nGot: %r" % (example.source.strip(), example.lineno, example.want, got))
+    def report_unexpected_exception(self, out, test, example, exc_info):
+        from django.db import transaction
+        tb = ''.join(traceback.format_exception(*exc_info)[1:])
+        log_error(test.name, "API test raised an exception",
+            "Code: %r\nLine: %s\nException: %s" % (example.source.strip(), example.lineno, tb))
+        # Rollback, in case of database errors. Otherwise they'd have
+        # side effects on other tests.
+        transaction.rollback_unless_managed()
+normalize_long_ints = lambda s: re.sub(r'(?<![\w])(\d+)L(?![\w])', '\\1', s)
+class DjangoDoctestOutputChecker(doctest.OutputChecker):
+    def check_output(self, want, got, optionflags):
+        ok = doctest.OutputChecker.check_output(self, want, got, optionflags)
+        # Doctest does an exact string comparison of output, which means long
+        # integers aren't equal to normal integers ("22L" vs. "22"). The
+        # following code normalizes long integers so that they equal normal
+        # integers.
+        if not ok:
+            return normalize_long_ints(want) == normalize_long_ints(got)
+        return ok
+class TestRunner:
+    def __init__(self, verbosity_level=0, which_tests=None):
+        self.verbosity_level = verbosity_level
+        self.which_tests = which_tests
+    def output(self, required_level, message):
+        if self.verbosity_level > required_level - 1:
+            print message
+    def run_tests(self):
+        from django.conf import settings
+        # An empty access of the settings to force the default options to be
+        # installed prior to assigning to them.
+        settings.INSTALLED_APPS
+        # Manually set INSTALLED_APPS to point to the test models.
+        settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS + ['.'.join(a) for a in get_test_models()]
+        # Manually set DEBUG and USE_I18N.
+        settings.DEBUG = False
+        settings.USE_I18N = True
+        from django.db import connection
+def get_invalid_models():
+    models = []
+    for loc, dirpath in (MODEL_TESTS_DIR_NAME, MODEL_TEST_DIR), (REGRESSION_TESTS_DIR_NAME, REGRESSION_TEST_DIR):
+        for f in os.listdir(dirpath):
+            if f.startswith('__init__') or f.startswith('.') or f.startswith('sql'):
+                continue
+            if f.startswith('invalid'):
+                models.append((loc, f))
+    return models
+class InvalidModelTestCase(unittest.TestCase):
+    def __init__(self, model_label):
+        unittest.TestCase.__init__(self)
+        self.model_label = model_label
+    def runTest(self):
         from django.core import management
-        import django.db.models
-        # Determine which models we're going to test.
-        test_models = get_test_models()
-        if 'othertests' in self.which_tests:
-            self.which_tests.remove('othertests')
-            run_othertests = True
-            if not self.which_tests:
-                test_models = []
-        else:
-            run_othertests = not self.which_tests
-        if self.which_tests:
-            # Only run the specified tests.
-            bad_models = [m for m in self.which_tests if (MODEL_TESTS_DIR_NAME, m) not in test_models and (REGRESSION_TESTS_DIR_NAME, m) not in test_models]
-            if bad_models:
-                sys.stderr.write("Models not found: %s\n" % bad_models)
-                sys.exit(1)
-            else:
-                all_tests = []
-                for test in self.which_tests:
-                    for loc in MODEL_TESTS_DIR_NAME, REGRESSION_TESTS_DIR_NAME:
-                        if (loc, test) in test_models:
-                            all_tests.append((loc, test))
-                test_models = all_tests
-        self.output(0, "Running tests with database %r" % settings.DATABASE_ENGINE)
-        # If we're using SQLite, it's more convenient to test against an
-        # in-memory database.
-        if settings.DATABASE_ENGINE == "sqlite3":
-            global TEST_DATABASE_NAME
-            TEST_DATABASE_NAME = ":memory:"
-        else:
-            # Create the test database and connect to it. We need to autocommit
-            # if the database supports it because PostgreSQL doesn't allow
-            # CREATE/DROP DATABASE statements within transactions.
-            cursor = connection.cursor()
-            self._set_autocommit(connection)
-            self.output(1, "Creating test database")
-            try:
-                cursor.execute("CREATE DATABASE %s" % TEST_DATABASE_NAME)
-            except Exception, e:
-                sys.stderr.write("Got an error creating the test database: %s\n" % e)
-                confirm = raw_input("It appears the test database, %s, already exists. Type 'yes' to delete it, or 'no' to cancel: " % TEST_DATABASE_NAME)
-                if confirm == 'yes':
-                    cursor.execute("DROP DATABASE %s" % TEST_DATABASE_NAME)
-                    cursor.execute("CREATE DATABASE %s" % TEST_DATABASE_NAME)
-                else:
-                    print "Tests cancelled."
-                    return
-        connection.close()
-        old_database_name = settings.DATABASE_NAME
-        settings.DATABASE_NAME = TEST_DATABASE_NAME
-        # Initialize the test database.
-        cursor = connection.cursor()
         from django.db.models.loading import load_app
+        # Install the core always installed apps
+        for app in ALWAYS_INSTALLED_APPS:
+            self.output(1, "Installing contrib app %s" % app)
+            mod = load_app(app)
+            management.install(mod)
+        from cStringIO import StringIO
+        # Run the tests for each test model.
+        self.output(1, "Running app tests")
+        for model_dir, model_name in test_models:
+            self.output(1, "%s model: Importing" % model_name)
+            try:
+                mod = load_app(model_dir + '.' + model_name)
+            except Exception, e:
+                log_error(model_name, "Error while importing", ''.join(traceback.format_exception(*sys.exc_info())[1:]))
+                continue
+        try:
+            module = load_app(self.model_label)
+        except Exception, e:
+            self.fail('Unable to load invalid model module')
+        s = StringIO()
+        count = management.get_validation_errors(s, module)
+        s.seek(0)
+        error_log = s.read()
+        actual = error_log.split('\n')
+        expected = module.model_errors.split('\n')
+            if not getattr(mod, 'error_log', None):
+                # Model is not marked as an invalid model
+                self.output(1, "%s.%s model: Installing" % (model_dir, model_name))
+                management.install(mod)
+        unexpected = [err for err in actual if err not in expected]
+        missing = [err for err in expected if err not in actual]
+                # Run the API tests.
+                p = doctest.DocTestParser()
+                test_namespace = dict([(m._meta.object_name, m) \
+                                        for m in django.db.models.get_models(mod)])
+                dtest = p.get_doctest(mod.API_TESTS, test_namespace, model_name, None, None)
+                # Manually set verbose=False, because "-v" command-line parameter
+                # has side effects on doctest TestRunner class.
+                runner = DjangoDoctestRunner(verbosity_level=verbosity_level, verbose=False)
+                self.output(1, "%s.%s model: Running tests" % (model_dir, model_name))
+                runner.run(dtest, clear_globs=True, out=sys.stdout.write)
+            else:
+                # Check that model known to be invalid is invalid for the right reasons.
+                self.output(1, "%s.%s model: Validating" % (model_dir, model_name))
+        self.assert_(not unexpected, "Unexpected Errors: " + '\n'.join(unexpected))
+        self.assert_(not missing, "Missing Errors: " + '\n'.join(missing))
+                from cStringIO import StringIO
+                s = StringIO()
+                count = management.get_validation_errors(s, mod)
+                s.seek(0)
+                error_log = s.read()
+                actual = error_log.split('\n')
+                expected = mod.error_log.split('\n')
+def django_tests(verbosity, tests_to_run):
+    from django.conf import settings
+    from django.db.models.loading import get_apps, load_app
+    old_installed_apps = settings.INSTALLED_APPS
+    # load all the ALWAYS_INSTALLED_APPS
+    settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS
+    get_apps()
+    test_models = []
+    # Load all the test model apps
+    for model_dir, model_name in get_test_models():
+        model_label = '.'.join([model_dir, model_name])
+        try:
+            # if the model was named on the command line, or
+            # no models were named (i.e., run all), import
+            # this model and add it to the list to test.
+            if not tests_to_run or model_name in tests_to_run:
+                if verbosity >= 1:
+                    print "Importing model %s" % model_name
+                mod = load_app(model_label)
+                settings.INSTALLED_APPS.append(model_label)
+                test_models.append(mod)
+        except Exception, e:
+            sys.stderr.write("Error while importing %s:" % model_name + ''.join(traceback.format_exception(*sys.exc_info())[1:]))
+            continue
+                unexpected = [err for err in actual if err not in expected]
+                missing = [err for err in expected if err not in actual]
+                if unexpected or missing:
+                    unexpected_log = '\n'.join(unexpected)
+                    missing_log = '\n'.join(missing)
+                    log_error(model_name,
+                        "Validator found %d validation errors, %d expected" % (count, len(expected) - 1),
+                        "Missing errors:\n%s\n\nUnexpected errors:\n%s" % (missing_log, unexpected_log))
+        if run_othertests:
+            # Run the non-model tests in the other tests dir
+            self.output(1, "Running other tests")
+            other_tests_dir = os.path.join(os.path.dirname(__file__), OTHER_TESTS_DIR)
+            test_modules = [f[:-3] for f in os.listdir(other_tests_dir) if f.endswith('.py') and not f.startswith('__init__')]
+            for module in test_modules:
+                self.output(1, "%s module: Importing" % module)
+                try:
+                    mod = __import__("othertests." + module, '', '', [''])
+                except Exception, e:
+                    log_error(module, "Error while importing", ''.join(traceback.format_exception(*sys.exc_info())[1:]))
+                    continue
+                if mod.__doc__:
+                    p = doctest.DocTestParser()
+                    dtest = p.get_doctest(mod.__doc__, mod.__dict__, module, None, None)
+                    runner = DjangoDoctestRunner(verbosity_level=verbosity_level, verbose=False)
+                    self.output(1, "%s module: running tests" % module)
+                    runner.run(dtest, clear_globs=True, out=sys.stdout.write)
+                if hasattr(mod, "run_tests") and callable(mod.run_tests):
+                    self.output(1, "%s module: running tests" % module)
+                    try:
+                        mod.run_tests(verbosity_level)
+                    except Exception, e:
+                        log_error(module, "Exception running tests", ''.join(traceback.format_exception(*sys.exc_info())[1:]))
+                        continue
+        # Unless we're using SQLite, remove the test database to clean up after
+        # ourselves. Connect to the previous database (not the test database)
+        # to do so, because it's not allowed to delete a database while being
+        # connected to it.
+        if settings.DATABASE_ENGINE != "sqlite3":
+            connection.close()
+            settings.DATABASE_NAME = old_database_name
+            cursor = connection.cursor()
+            self.output(1, "Deleting test database")
+            self._set_autocommit(connection)
+            time.sleep(1) # To avoid "database is being accessed by other users" errors.
+            cursor.execute("DROP DATABASE %s" % TEST_DATABASE_NAME)
+        # Display output.
+        if error_list:
+            for d in error_list:
+                print
+                print d['title']
+                print "=" * len(d['title'])
+                print d['description']
+            print "%s error%s:" % (len(error_list), len(error_list) != 1 and 's' or '')
+        else:
+            print "All tests passed."
+    def _set_autocommit(self, connection):
+        """
+        Make sure a connection is in autocommit mode.
+        """
+        if hasattr(connection.connection, "autocommit"):
+            connection.connection.autocommit(True)
+        elif hasattr(connection.connection, "set_isolation_level"):
+            connection.connection.set_isolation_level(0)
+    # Add tests for invalid models
+    extra_tests = []
+    for model_dir, model_name in get_invalid_models():
+        model_label = '.'.join([model_dir, model_name])
+        if not tests_to_run or model_name in tests_to_run:
+            extra_tests.append(InvalidModelTestCase(model_label))
+    # Run the test suite, including the extra validation tests.
+    from django.test.simple import run_tests
+    run_tests(test_models, verbosity, extra_tests=extra_tests)
+    # Restore the old INSTALLED_APPS setting
+    settings.INSTALLED_APPS = old_installed_apps
 if __name__ == "__main__":
     from optparse import OptionParser
     usage = "%prog [options] [model model model ...]"
     parser = OptionParser(usage=usage)
+    parser.add_option('-v', help='How verbose should the output be? Choices are 0, 1 and 2, where 2 is most verbose. Default is 0.',
+        type='choice', choices=['0', '1', '2'])
+    parser.add_option('-v','--verbosity', action='store', dest='verbosity', default='0',
+        type='choice', choices=['0', '1', '2'],
+        help='Verbosity level; 0=minimal output, 1=normal output, 2=all output')
     parser.add_option('--settings',
         help='Python path to settings module, e.g. "myproject.settings". If this isn\'t provided, the DJANGO_SETTINGS_MODULE environment variable will be used.')
     options, args = parser.parse_args()
-    verbosity_level = 0
-    if options.v:
-        verbosity_level = int(options.v)
     if options.settings:
         os.environ['DJANGO_SETTINGS_MODULE'] = options.settings
     t = TestRunner(verbosity_level, args)
     t.run_tests()
+    django_tests(int(options.verbosity), args)

Download in other formats:

Original Format

Issues

Context Navigation

Ticket #2333: revised-tests.patch

Download in other formats: