From ce859b2defe1fc90c7a16551291799fc37284add Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sun, 28 Apr 2024 18:06:13 +0200
Subject: Adding upstream version 3.1.2.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 tests/conftest.py                    |   49 ++
 tests/res/__init__.py                |    0
 tests/res/package.zip                |  Bin 0 -> 1036 bytes
 tests/res/templates/broken.html      |    3 +
 tests/res/templates/foo/test.html    |    1 +
 tests/res/templates/mojibake.txt     |    1 +
 tests/res/templates/syntaxerror.html |    4 +
 tests/res/templates/test.html        |    1 +
 tests/res/templates2/foo             |    2 +
 tests/test_api.py                    |  434 ++++++++++++++
 tests/test_async.py                  |  660 ++++++++++++++++++++++
 tests/test_async_filters.py          |  273 +++++++++
 tests/test_bytecode_cache.py         |   77 +++
 tests/test_compile.py                |   28 +
 tests/test_core_tags.py              |  595 ++++++++++++++++++++
 tests/test_debug.py                  |  117 ++++
 tests/test_ext.py                    |  726 ++++++++++++++++++++++++
 tests/test_filters.py                |  873 ++++++++++++++++++++++++++++
 tests/test_idtracking.py             |  290 ++++++++++
 tests/test_imports.py                |  205 +++++++
 tests/test_inheritance.py            |  405 +++++++++++++
 tests/test_lexnparse.py              | 1030 ++++++++++++++++++++++++++++++++++
 tests/test_loader.py                 |  412 ++++++++++++++
 tests/test_nativetypes.py            |  162 ++++++
 tests/test_nodes.py                  |    3 +
 tests/test_pickle.py                 |    6 +
 tests/test_regression.py             |  744 ++++++++++++++++++++++++
 tests/test_runtime.py                |   75 +++
 tests/test_security.py               |  173 ++++++
 tests/test_tests.py                  |  233 ++++++++
 tests/test_utils.py                  |  185 ++++++
 31 files changed, 7767 insertions(+)
 create mode 100644 tests/conftest.py
 create mode 100644 tests/res/__init__.py
 create mode 100644 tests/res/package.zip
 create mode 100644 tests/res/templates/broken.html
 create mode 100644 tests/res/templates/foo/test.html
 create mode 100644 tests/res/templates/mojibake.txt
 create mode 100644 tests/res/templates/syntaxerror.html
 create mode 100644 tests/res/templates/test.html
 create mode 100644 tests/res/templates2/foo
 create mode 100644 tests/test_api.py
 create mode 100644 tests/test_async.py
 create mode 100644 tests/test_async_filters.py
 create mode 100644 tests/test_bytecode_cache.py
 create mode 100644 tests/test_compile.py
 create mode 100644 tests/test_core_tags.py
 create mode 100644 tests/test_debug.py
 create mode 100644 tests/test_ext.py
 create mode 100644 tests/test_filters.py
 create mode 100644 tests/test_idtracking.py
 create mode 100644 tests/test_imports.py
 create mode 100644 tests/test_inheritance.py
 create mode 100644 tests/test_lexnparse.py
 create mode 100644 tests/test_loader.py
 create mode 100644 tests/test_nativetypes.py
 create mode 100644 tests/test_nodes.py
 create mode 100644 tests/test_pickle.py
 create mode 100644 tests/test_regression.py
 create mode 100644 tests/test_runtime.py
 create mode 100644 tests/test_security.py
 create mode 100644 tests/test_tests.py
 create mode 100644 tests/test_utils.py

(limited to 'tests')

diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000..e225ab9
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,49 @@
+from pathlib import Path
+
+import pytest
+
+from jinja2 import loaders
+from jinja2.environment import Environment
+
+
+@pytest.fixture
+def env():
+    """returns a new environment."""
+    return Environment()
+
+
+@pytest.fixture
+def dict_loader():
+    """returns DictLoader"""
+    return loaders.DictLoader({"justdict.html": "FOO"})
+
+
+@pytest.fixture
+def package_loader():
+    """returns PackageLoader initialized from templates"""
+    return loaders.PackageLoader("res", "templates")
+
+
+@pytest.fixture
+def filesystem_loader():
+    """returns FileSystemLoader initialized to res/templates directory"""
+    here = Path(__file__).parent.resolve()
+    return loaders.FileSystemLoader(here / "res" / "templates")
+
+
+@pytest.fixture
+def function_loader():
+    """returns a FunctionLoader"""
+    return loaders.FunctionLoader({"justfunction.html": "FOO"}.get)
+
+
+@pytest.fixture
+def choice_loader(dict_loader, package_loader):
+    """returns a ChoiceLoader"""
+    return loaders.ChoiceLoader([dict_loader, package_loader])
+
+
+@pytest.fixture
+def prefix_loader(filesystem_loader, dict_loader):
+    """returns a PrefixLoader"""
+    return loaders.PrefixLoader({"a": filesystem_loader, "b": dict_loader})
diff --git a/tests/res/__init__.py b/tests/res/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/res/package.zip b/tests/res/package.zip
new file mode 100644
index 0000000..d4c9ce9
Binary files /dev/null and b/tests/res/package.zip differ
diff --git a/tests/res/templates/broken.html b/tests/res/templates/broken.html
new file mode 100644
index 0000000..77669fa
--- /dev/null
+++ b/tests/res/templates/broken.html
@@ -0,0 +1,3 @@
+Before
+{{ fail() }}
+After
diff --git a/tests/res/templates/foo/test.html b/tests/res/templates/foo/test.html
new file mode 100644
index 0000000..b7d6715
--- /dev/null
+++ b/tests/res/templates/foo/test.html
@@ -0,0 +1 @@
+FOO
diff --git a/tests/res/templates/mojibake.txt b/tests/res/templates/mojibake.txt
new file mode 100644
index 0000000..4b94aa6
--- /dev/null
+++ b/tests/res/templates/mojibake.txt
@@ -0,0 +1 @@
+文字化け
diff --git a/tests/res/templates/syntaxerror.html b/tests/res/templates/syntaxerror.html
new file mode 100644
index 0000000..f21b817
--- /dev/null
+++ b/tests/res/templates/syntaxerror.html
@@ -0,0 +1,4 @@
+Foo
+{% for item in broken %}
+  ...
+{% endif %}
diff --git a/tests/res/templates/test.html b/tests/res/templates/test.html
new file mode 100644
index 0000000..ba578e4
--- /dev/null
+++ b/tests/res/templates/test.html
@@ -0,0 +1 @@
+BAR
diff --git a/tests/res/templates2/foo b/tests/res/templates2/foo
new file mode 100644
index 0000000..1c4ad3e
--- /dev/null
+++ b/tests/res/templates2/foo
@@ -0,0 +1,2 @@
+Looks like the start of templates/foo/test.html
+Tested by test_filesystem_loader_overlapping_names
diff --git a/tests/test_api.py b/tests/test_api.py
new file mode 100644
index 0000000..4db3b4a
--- /dev/null
+++ b/tests/test_api.py
@@ -0,0 +1,434 @@
+import shutil
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from jinja2 import ChainableUndefined
+from jinja2 import DebugUndefined
+from jinja2 import DictLoader
+from jinja2 import Environment
+from jinja2 import is_undefined
+from jinja2 import make_logging_undefined
+from jinja2 import meta
+from jinja2 import StrictUndefined
+from jinja2 import Template
+from jinja2 import TemplatesNotFound
+from jinja2 import Undefined
+from jinja2 import UndefinedError
+from jinja2.compiler import CodeGenerator
+from jinja2.runtime import Context
+from jinja2.utils import Cycler
+from jinja2.utils import pass_context
+from jinja2.utils import pass_environment
+from jinja2.utils import pass_eval_context
+
+
+class TestExtendedAPI:
+    def test_item_and_attribute(self, env):
+        from jinja2.sandbox import SandboxedEnvironment
+
+        for env in Environment(), SandboxedEnvironment():
+            tmpl = env.from_string("{{ foo.items()|list }}")
+            assert tmpl.render(foo={"items": 42}) == "[('items', 42)]"
+            tmpl = env.from_string('{{ foo|attr("items")()|list }}')
+            assert tmpl.render(foo={"items": 42}) == "[('items', 42)]"
+            tmpl = env.from_string('{{ foo["items"] }}')
+            assert tmpl.render(foo={"items": 42}) == "42"
+
+    def test_finalize(self):
+        e = Environment(finalize=lambda v: "" if v is None else v)
+        t = e.from_string("{% for item in seq %}|{{ item }}{% endfor %}")
+        assert t.render(seq=(None, 1, "foo")) == "||1|foo"
+
+    def test_finalize_constant_expression(self):
+        e = Environment(finalize=lambda v: "" if v is None else v)
+        t = e.from_string("<{{ none }}>")
+        assert t.render() == "<>"
+
+    def test_no_finalize_template_data(self):
+        e = Environment(finalize=lambda v: type(v).__name__)
+        t = e.from_string("<{{ value }}>")
+        # If template data was finalized, it would print "strintstr".
+        assert t.render(value=123) == "<int>"
+
+    def test_context_finalize(self):
+        @pass_context
+        def finalize(context, value):
+            return value * context["scale"]
+
+        e = Environment(finalize=finalize)
+        t = e.from_string("{{ value }}")
+        assert t.render(value=5, scale=3) == "15"
+
+    def test_eval_finalize(self):
+        @pass_eval_context
+        def finalize(eval_ctx, value):
+            return str(eval_ctx.autoescape) + value
+
+        e = Environment(finalize=finalize, autoescape=True)
+        t = e.from_string("{{ value }}")
+        assert t.render(value="<script>") == "True&lt;script&gt;"
+
+    def test_env_autoescape(self):
+        @pass_environment
+        def finalize(env, value):
+            return " ".join(
+                (env.variable_start_string, repr(value), env.variable_end_string)
+            )
+
+        e = Environment(finalize=finalize)
+        t = e.from_string("{{ value }}")
+        assert t.render(value="hello") == "{{ 'hello' }}"
+
+    def test_cycler(self, env):
+        items = 1, 2, 3
+        c = Cycler(*items)
+        for item in items + items:
+            assert c.current == item
+            assert next(c) == item
+        next(c)
+        assert c.current == 2
+        c.reset()
+        assert c.current == 1
+
+    def test_expressions(self, env):
+        expr = env.compile_expression("foo")
+        assert expr() is None
+        assert expr(foo=42) == 42
+        expr2 = env.compile_expression("foo", undefined_to_none=False)
+        assert is_undefined(expr2())
+
+        expr = env.compile_expression("42 + foo")
+        assert expr(foo=42) == 84
+
+    def test_template_passthrough(self, env):
+        t = Template("Content")
+        assert env.get_template(t) is t
+        assert env.select_template([t]) is t
+        assert env.get_or_select_template([t]) is t
+        assert env.get_or_select_template(t) is t
+
+    def test_get_template_undefined(self, env):
+        """Passing Undefined to get/select_template raises an
+        UndefinedError or shows the undefined message in the list.
+        """
+        env.loader = DictLoader({})
+        t = Undefined(name="no_name_1")
+
+        with pytest.raises(UndefinedError):
+            env.get_template(t)
+
+        with pytest.raises(UndefinedError):
+            env.get_or_select_template(t)
+
+        with pytest.raises(UndefinedError):
+            env.select_template(t)
+
+        with pytest.raises(TemplatesNotFound) as exc_info:
+            env.select_template([t, "no_name_2"])
+
+        exc_message = str(exc_info.value)
+        assert "'no_name_1' is undefined" in exc_message
+        assert "no_name_2" in exc_message
+
+    def test_autoescape_autoselect(self, env):
+        def select_autoescape(name):
+            if name is None or "." not in name:
+                return False
+            return name.endswith(".html")
+
+        env = Environment(
+            autoescape=select_autoescape,
+            loader=DictLoader({"test.txt": "{{ foo }}", "test.html": "{{ foo }}"}),
+        )
+        t = env.get_template("test.txt")
+        assert t.render(foo="<foo>") == "<foo>"
+        t = env.get_template("test.html")
+        assert t.render(foo="<foo>") == "&lt;foo&gt;"
+        t = env.from_string("{{ foo }}")
+        assert t.render(foo="<foo>") == "<foo>"
+
+    def test_sandbox_max_range(self, env):
+        from jinja2.sandbox import SandboxedEnvironment, MAX_RANGE
+
+        env = SandboxedEnvironment()
+        t = env.from_string("{% for item in range(total) %}{{ item }}{% endfor %}")
+
+        with pytest.raises(OverflowError):
+            t.render(total=MAX_RANGE + 1)
+
+
+class TestMeta:
+    def test_find_undeclared_variables(self, env):
+        ast = env.parse("{% set foo = 42 %}{{ bar + foo }}")
+        x = meta.find_undeclared_variables(ast)
+        assert x == {"bar"}
+
+        ast = env.parse(
+            "{% set foo = 42 %}{{ bar + foo }}"
+            "{% macro meh(x) %}{{ x }}{% endmacro %}"
+            "{% for item in seq %}{{ muh(item) + meh(seq) }}"
+            "{% endfor %}"
+        )
+        x = meta.find_undeclared_variables(ast)
+        assert x == {"bar", "seq", "muh"}
+
+        ast = env.parse("{% for x in range(5) %}{{ x }}{% endfor %}{{ foo }}")
+        x = meta.find_undeclared_variables(ast)
+        assert x == {"foo"}
+
+    def test_find_refererenced_templates(self, env):
+        ast = env.parse('{% extends "layout.html" %}{% include helper %}')
+        i = meta.find_referenced_templates(ast)
+        assert next(i) == "layout.html"
+        assert next(i) is None
+        assert list(i) == []
+
+        ast = env.parse(
+            '{% extends "layout.html" %}'
+            '{% from "test.html" import a, b as c %}'
+            '{% import "meh.html" as meh %}'
+            '{% include "muh.html" %}'
+        )
+        i = meta.find_referenced_templates(ast)
+        assert list(i) == ["layout.html", "test.html", "meh.html", "muh.html"]
+
+    def test_find_included_templates(self, env):
+        ast = env.parse('{% include ["foo.html", "bar.html"] %}')
+        i = meta.find_referenced_templates(ast)
+        assert list(i) == ["foo.html", "bar.html"]
+
+        ast = env.parse('{% include ("foo.html", "bar.html") %}')
+        i = meta.find_referenced_templates(ast)
+        assert list(i) == ["foo.html", "bar.html"]
+
+        ast = env.parse('{% include ["foo.html", "bar.html", foo] %}')
+        i = meta.find_referenced_templates(ast)
+        assert list(i) == ["foo.html", "bar.html", None]
+
+        ast = env.parse('{% include ("foo.html", "bar.html", foo) %}')
+        i = meta.find_referenced_templates(ast)
+        assert list(i) == ["foo.html", "bar.html", None]
+
+
+class TestStreaming:
+    def test_basic_streaming(self, env):
+        t = env.from_string(
+            "<ul>{% for item in seq %}<li>{{ loop.index }} - {{ item }}</li>"
+            "{%- endfor %}</ul>"
+        )
+        stream = t.stream(seq=list(range(3)))
+        assert next(stream) == "<ul>"
+        assert "".join(stream) == "<li>1 - 0</li><li>2 - 1</li><li>3 - 2</li></ul>"
+
+    def test_buffered_streaming(self, env):
+        tmpl = env.from_string(
+            "<ul>{% for item in seq %}<li>{{ loop.index }} - {{ item }}</li>"
+            "{%- endfor %}</ul>"
+        )
+        stream = tmpl.stream(seq=list(range(3)))
+        stream.enable_buffering(size=3)
+        assert next(stream) == "<ul><li>1"
+        assert next(stream) == " - 0</li>"
+
+    def test_streaming_behavior(self, env):
+        tmpl = env.from_string("")
+        stream = tmpl.stream()
+        assert not stream.buffered
+        stream.enable_buffering(20)
+        assert stream.buffered
+        stream.disable_buffering()
+        assert not stream.buffered
+
+    def test_dump_stream(self, env):
+        tmp = Path(tempfile.mkdtemp())
+        try:
+            tmpl = env.from_string("\u2713")
+            stream = tmpl.stream()
+            stream.dump(str(tmp / "dump.txt"), "utf-8")
+            assert (tmp / "dump.txt").read_bytes() == b"\xe2\x9c\x93"
+        finally:
+            shutil.rmtree(tmp)
+
+
+class TestUndefined:
+    def test_stopiteration_is_undefined(self):
+        def test():
+            raise StopIteration()
+
+        t = Template("A{{ test() }}B")
+        assert t.render(test=test) == "AB"
+        t = Template("A{{ test().missingattribute }}B")
+        pytest.raises(UndefinedError, t.render, test=test)
+
+    def test_undefined_and_special_attributes(self):
+        with pytest.raises(AttributeError):
+            Undefined("Foo").__dict__
+
+    def test_undefined_attribute_error(self):
+        # Django's LazyObject turns the __class__ attribute into a
+        # property that resolves the wrapped function. If that wrapped
+        # function raises an AttributeError, printing the repr of the
+        # object in the undefined message would cause a RecursionError.
+        class Error:
+            @property  # type: ignore
+            def __class__(self):
+                raise AttributeError()
+
+        u = Undefined(obj=Error(), name="hello")
+
+        with pytest.raises(UndefinedError):
+            getattr(u, "recursion", None)
+
+    def test_logging_undefined(self):
+        _messages = []
+
+        class DebugLogger:
+            def warning(self, msg, *args):
+                _messages.append("W:" + msg % args)
+
+            def error(self, msg, *args):
+                _messages.append("E:" + msg % args)
+
+        logging_undefined = make_logging_undefined(DebugLogger())
+        env = Environment(undefined=logging_undefined)
+        assert env.from_string("{{ missing }}").render() == ""
+        pytest.raises(UndefinedError, env.from_string("{{ missing.attribute }}").render)
+        assert env.from_string("{{ missing|list }}").render() == "[]"
+        assert env.from_string("{{ missing is not defined }}").render() == "True"
+        assert env.from_string("{{ foo.missing }}").render(foo=42) == ""
+        assert env.from_string("{{ not missing }}").render() == "True"
+        assert _messages == [
+            "W:Template variable warning: 'missing' is undefined",
+            "E:Template variable error: 'missing' is undefined",
+            "W:Template variable warning: 'missing' is undefined",
+            "W:Template variable warning: 'int object' has no attribute 'missing'",
+            "W:Template variable warning: 'missing' is undefined",
+        ]
+
+    def test_default_undefined(self):
+        env = Environment(undefined=Undefined)
+        assert env.from_string("{{ missing }}").render() == ""
+        pytest.raises(UndefinedError, env.from_string("{{ missing.attribute }}").render)
+        assert env.from_string("{{ missing|list }}").render() == "[]"
+        assert env.from_string("{{ missing is not defined }}").render() == "True"
+        assert env.from_string("{{ foo.missing }}").render(foo=42) == ""
+        assert env.from_string("{{ not missing }}").render() == "True"
+        pytest.raises(UndefinedError, env.from_string("{{ missing - 1}}").render)
+        assert env.from_string("{{ 'foo' in missing }}").render() == "False"
+        und1 = Undefined(name="x")
+        und2 = Undefined(name="y")
+        assert und1 == und2
+        assert und1 != 42
+        assert hash(und1) == hash(und2) == hash(Undefined())
+        with pytest.raises(AttributeError):
+            getattr(Undefined, "__slots__")  # noqa: B009
+
+    def test_chainable_undefined(self):
+        env = Environment(undefined=ChainableUndefined)
+        # The following tests are copied from test_default_undefined
+        assert env.from_string("{{ missing }}").render() == ""
+        assert env.from_string("{{ missing|list }}").render() == "[]"
+        assert env.from_string("{{ missing is not defined }}").render() == "True"
+        assert env.from_string("{{ foo.missing }}").render(foo=42) == ""
+        assert env.from_string("{{ not missing }}").render() == "True"
+        pytest.raises(UndefinedError, env.from_string("{{ missing - 1}}").render)
+        with pytest.raises(AttributeError):
+            getattr(ChainableUndefined, "__slots__")  # noqa: B009
+
+        # The following tests ensure subclass functionality works as expected
+        assert env.from_string('{{ missing.bar["baz"] }}').render() == ""
+        assert env.from_string('{{ foo.bar["baz"]._undefined_name }}').render() == "foo"
+        assert (
+            env.from_string('{{ foo.bar["baz"]._undefined_name }}').render(foo=42)
+            == "bar"
+        )
+        assert (
+            env.from_string('{{ foo.bar["baz"]._undefined_name }}').render(
+                foo={"bar": 42}
+            )
+            == "baz"
+        )
+
+    def test_debug_undefined(self):
+        env = Environment(undefined=DebugUndefined)
+        assert env.from_string("{{ missing }}").render() == "{{ missing }}"
+        pytest.raises(UndefinedError, env.from_string("{{ missing.attribute }}").render)
+        assert env.from_string("{{ missing|list }}").render() == "[]"
+        assert env.from_string("{{ missing is not defined }}").render() == "True"
+        assert (
+            env.from_string("{{ foo.missing }}").render(foo=42)
+            == "{{ no such element: int object['missing'] }}"
+        )
+        assert env.from_string("{{ not missing }}").render() == "True"
+        undefined_hint = "this is testing undefined hint of DebugUndefined"
+        assert (
+            str(DebugUndefined(hint=undefined_hint))
+            == f"{{{{ undefined value printed: {undefined_hint} }}}}"
+        )
+        with pytest.raises(AttributeError):
+            getattr(DebugUndefined, "__slots__")  # noqa: B009
+
+    def test_strict_undefined(self):
+        env = Environment(undefined=StrictUndefined)
+        pytest.raises(UndefinedError, env.from_string("{{ missing }}").render)
+        pytest.raises(UndefinedError, env.from_string("{{ missing.attribute }}").render)
+        pytest.raises(UndefinedError, env.from_string("{{ missing|list }}").render)
+        pytest.raises(UndefinedError, env.from_string("{{ 'foo' in missing }}").render)
+        assert env.from_string("{{ missing is not defined }}").render() == "True"
+        pytest.raises(
+            UndefinedError, env.from_string("{{ foo.missing }}").render, foo=42
+        )
+        pytest.raises(UndefinedError, env.from_string("{{ not missing }}").render)
+        assert (
+            env.from_string('{{ missing|default("default", true) }}').render()
+            == "default"
+        )
+        with pytest.raises(AttributeError):
+            getattr(StrictUndefined, "__slots__")  # noqa: B009
+        assert env.from_string('{{ "foo" if false }}').render() == ""
+
+    def test_indexing_gives_undefined(self):
+        t = Template("{{ var[42].foo }}")
+        pytest.raises(UndefinedError, t.render, var=0)
+
+    def test_none_gives_proper_error(self):
+        with pytest.raises(UndefinedError, match="'None' has no attribute 'split'"):
+            Environment().getattr(None, "split")()
+
+    def test_object_repr(self):
+        with pytest.raises(
+            UndefinedError, match="'int object' has no attribute 'upper'"
+        ):
+            Undefined(obj=42, name="upper")()
+
+
+class TestLowLevel:
+    def test_custom_code_generator(self):
+        class CustomCodeGenerator(CodeGenerator):
+            def visit_Const(self, node, frame=None):
+                # This method is pure nonsense, but works fine for testing...
+                if node.value == "foo":
+                    self.write(repr("bar"))
+                else:
+                    super().visit_Const(node, frame)
+
+        class CustomEnvironment(Environment):
+            code_generator_class = CustomCodeGenerator
+
+        env = CustomEnvironment()
+        tmpl = env.from_string('{% set foo = "foo" %}{{ foo }}')
+        assert tmpl.render() == "bar"
+
+    def test_custom_context(self):
+        class CustomContext(Context):
+            def resolve_or_missing(self, key):
+                return "resolve-" + key
+
+        class CustomEnvironment(Environment):
+            context_class = CustomContext
+
+        env = CustomEnvironment()
+        tmpl = env.from_string("{{ foo }}")
+        assert tmpl.render() == "resolve-foo"
diff --git a/tests/test_async.py b/tests/test_async.py
new file mode 100644
index 0000000..c9ba70c
--- /dev/null
+++ b/tests/test_async.py
@@ -0,0 +1,660 @@
+import asyncio
+
+import pytest
+
+from jinja2 import ChainableUndefined
+from jinja2 import DictLoader
+from jinja2 import Environment
+from jinja2 import Template
+from jinja2.async_utils import auto_aiter
+from jinja2.exceptions import TemplateNotFound
+from jinja2.exceptions import TemplatesNotFound
+from jinja2.exceptions import UndefinedError
+from jinja2.nativetypes import NativeEnvironment
+
+
+def test_basic_async():
+    t = Template(
+        "{% for item in [1, 2, 3] %}[{{ item }}]{% endfor %}", enable_async=True
+    )
+
+    async def func():
+        return await t.render_async()
+
+    rv = asyncio.run(func())
+    assert rv == "[1][2][3]"
+
+
+def test_await_on_calls():
+    t = Template("{{ async_func() + normal_func() }}", enable_async=True)
+
+    async def async_func():
+        return 42
+
+    def normal_func():
+        return 23
+
+    async def func():
+        return await t.render_async(async_func=async_func, normal_func=normal_func)
+
+    rv = asyncio.run(func())
+    assert rv == "65"
+
+
+def test_await_on_calls_normal_render():
+    t = Template("{{ async_func() + normal_func() }}", enable_async=True)
+
+    async def async_func():
+        return 42
+
+    def normal_func():
+        return 23
+
+    rv = t.render(async_func=async_func, normal_func=normal_func)
+    assert rv == "65"
+
+
+def test_await_and_macros():
+    t = Template(
+        "{% macro foo(x) %}[{{ x }}][{{ async_func() }}]{% endmacro %}{{ foo(42) }}",
+        enable_async=True,
+    )
+
+    async def async_func():
+        return 42
+
+    async def func():
+        return await t.render_async(async_func=async_func)
+
+    rv = asyncio.run(func())
+    assert rv == "[42][42]"
+
+
+def test_async_blocks():
+    t = Template(
+        "{% block foo %}<Test>{% endblock %}{{ self.foo() }}",
+        enable_async=True,
+        autoescape=True,
+    )
+
+    async def func():
+        return await t.render_async()
+
+    rv = asyncio.run(func())
+    assert rv == "<Test><Test>"
+
+
+def test_async_generate():
+    t = Template("{% for x in [1, 2, 3] %}{{ x }}{% endfor %}", enable_async=True)
+    rv = list(t.generate())
+    assert rv == ["1", "2", "3"]
+
+
+def test_async_iteration_in_templates():
+    t = Template("{% for x in rng %}{{ x }}{% endfor %}", enable_async=True)
+
+    async def async_iterator():
+        for item in [1, 2, 3]:
+            yield item
+
+    rv = list(t.generate(rng=async_iterator()))
+    assert rv == ["1", "2", "3"]
+
+
+def test_async_iteration_in_templates_extended():
+    t = Template(
+        "{% for x in rng %}{{ loop.index0 }}/{{ x }}{% endfor %}", enable_async=True
+    )
+    stream = t.generate(rng=auto_aiter(range(1, 4)))
+    assert next(stream) == "0"
+    assert "".join(stream) == "/11/22/3"
+
+
+@pytest.fixture
+def test_env_async():
+    env = Environment(
+        loader=DictLoader(
+            dict(
+                module="{% macro test() %}[{{ foo }}|{{ bar }}]{% endmacro %}",
+                header="[{{ foo }}|{{ 23 }}]",
+                o_printer="({{ o }})",
+            )
+        ),
+        enable_async=True,
+    )
+    env.globals["bar"] = 23
+    return env
+
+
+class TestAsyncImports:
+    def test_context_imports(self, test_env_async):
+        t = test_env_async.from_string('{% import "module" as m %}{{ m.test() }}')
+        assert t.render(foo=42) == "[|23]"
+        t = test_env_async.from_string(
+            '{% import "module" as m without context %}{{ m.test() }}'
+        )
+        assert t.render(foo=42) == "[|23]"
+        t = test_env_async.from_string(
+            '{% import "module" as m with context %}{{ m.test() }}'
+        )
+        assert t.render(foo=42) == "[42|23]"
+        t = test_env_async.from_string('{% from "module" import test %}{{ test() }}')
+        assert t.render(foo=42) == "[|23]"
+        t = test_env_async.from_string(
+            '{% from "module" import test without context %}{{ test() }}'
+        )
+        assert t.render(foo=42) == "[|23]"
+        t = test_env_async.from_string(
+            '{% from "module" import test with context %}{{ test() }}'
+        )
+        assert t.render(foo=42) == "[42|23]"
+
+    def test_trailing_comma(self, test_env_async):
+        test_env_async.from_string('{% from "foo" import bar, baz with context %}')
+        test_env_async.from_string('{% from "foo" import bar, baz, with context %}')
+        test_env_async.from_string('{% from "foo" import bar, with context %}')
+        test_env_async.from_string('{% from "foo" import bar, with, context %}')
+        test_env_async.from_string('{% from "foo" import bar, with with context %}')
+
+    def test_exports(self, test_env_async):
+        coro = test_env_async.from_string(
+            """
+            {% macro toplevel() %}...{% endmacro %}
+            {% macro __private() %}...{% endmacro %}
+            {% set variable = 42 %}
+            {% for item in [1] %}
+                {% macro notthere() %}{% endmacro %}
+            {% endfor %}
+            """
+        )._get_default_module_async()
+        m = asyncio.run(coro)
+        assert asyncio.run(m.toplevel()) == "..."
+        assert not hasattr(m, "__missing")
+        assert m.variable == 42
+        assert not hasattr(m, "notthere")
+
+    def test_import_with_globals(self, test_env_async):
+        t = test_env_async.from_string(
+            '{% import "module" as m %}{{ m.test() }}', globals={"foo": 42}
+        )
+        assert t.render() == "[42|23]"
+
+        t = test_env_async.from_string('{% import "module" as m %}{{ m.test() }}')
+        assert t.render() == "[|23]"
+
+    def test_import_with_globals_override(self, test_env_async):
+        t = test_env_async.from_string(
+            '{% set foo = 41 %}{% import "module" as m %}{{ m.test() }}',
+            globals={"foo": 42},
+        )
+        assert t.render() == "[42|23]"
+
+    def test_from_import_with_globals(self, test_env_async):
+        t = test_env_async.from_string(
+            '{% from "module" import test %}{{ test() }}',
+            globals={"foo": 42},
+        )
+        assert t.render() == "[42|23]"
+
+
+class TestAsyncIncludes:
+    def test_context_include(self, test_env_async):
+        t = test_env_async.from_string('{% include "header" %}')
+        assert t.render(foo=42) == "[42|23]"
+        t = test_env_async.from_string('{% include "header" with context %}')
+        assert t.render(foo=42) == "[42|23]"
+        t = test_env_async.from_string('{% include "header" without context %}')
+        assert t.render(foo=42) == "[|23]"
+
+    def test_choice_includes(self, test_env_async):
+        t = test_env_async.from_string('{% include ["missing", "header"] %}')
+        assert t.render(foo=42) == "[42|23]"
+
+        t = test_env_async.from_string(
+            '{% include ["missing", "missing2"] ignore missing %}'
+        )
+        assert t.render(foo=42) == ""
+
+        t = test_env_async.from_string('{% include ["missing", "missing2"] %}')
+        pytest.raises(TemplateNotFound, t.render)
+        with pytest.raises(TemplatesNotFound) as e:
+            t.render()
+
+        assert e.value.templates == ["missing", "missing2"]
+        assert e.value.name == "missing2"
+
+        def test_includes(t, **ctx):
+            ctx["foo"] = 42
+            assert t.render(ctx) == "[42|23]"
+
+        t = test_env_async.from_string('{% include ["missing", "header"] %}')
+        test_includes(t)
+        t = test_env_async.from_string("{% include x %}")
+        test_includes(t, x=["missing", "header"])
+        t = test_env_async.from_string('{% include [x, "header"] %}')
+        test_includes(t, x="missing")
+        t = test_env_async.from_string("{% include x %}")
+        test_includes(t, x="header")
+        t = test_env_async.from_string("{% include x %}")
+        test_includes(t, x="header")
+        t = test_env_async.from_string("{% include [x] %}")
+        test_includes(t, x="header")
+
+    def test_include_ignoring_missing(self, test_env_async):
+        t = test_env_async.from_string('{% include "missing" %}')
+        pytest.raises(TemplateNotFound, t.render)
+        for extra in "", "with context", "without context":
+            t = test_env_async.from_string(
+                '{% include "missing" ignore missing ' + extra + " %}"
+            )
+            assert t.render() == ""
+
+    def test_context_include_with_overrides(self, test_env_async):
+        env = Environment(
+            loader=DictLoader(
+                dict(
+                    main="{% for item in [1, 2, 3] %}{% include 'item' %}{% endfor %}",
+                    item="{{ item }}",
+                )
+            )
+        )
+        assert env.get_template("main").render() == "123"
+
+    def test_unoptimized_scopes(self, test_env_async):
+        t = test_env_async.from_string(
+            """
+            {% macro outer(o) %}
+            {% macro inner() %}
+            {% include "o_printer" %}
+            {% endmacro %}
+            {{ inner() }}
+            {% endmacro %}
+            {{ outer("FOO") }}
+        """
+        )
+        assert t.render().strip() == "(FOO)"
+
+    def test_unoptimized_scopes_autoescape(self):
+        env = Environment(
+            loader=DictLoader({"o_printer": "({{ o }})"}),
+            autoescape=True,
+            enable_async=True,
+        )
+        t = env.from_string(
+            """
+            {% macro outer(o) %}
+            {% macro inner() %}
+            {% include "o_printer" %}
+            {% endmacro %}
+            {{ inner() }}
+            {% endmacro %}
+            {{ outer("FOO") }}
+        """
+        )
+        assert t.render().strip() == "(FOO)"
+
+
+class TestAsyncForLoop:
+    def test_simple(self, test_env_async):
+        tmpl = test_env_async.from_string("{% for item in seq %}{{ item }}{% endfor %}")
+        assert tmpl.render(seq=list(range(10))) == "0123456789"
+
+    def test_else(self, test_env_async):
+        tmpl = test_env_async.from_string(
+            "{% for item in seq %}XXX{% else %}...{% endfor %}"
+        )
+        assert tmpl.render() == "..."
+
+    def test_empty_blocks(self, test_env_async):
+        tmpl = test_env_async.from_string(
+            "<{% for item in seq %}{% else %}{% endfor %}>"
+        )
+        assert tmpl.render() == "<>"
+
+    @pytest.mark.parametrize(
+        "transform", [lambda x: x, iter, reversed, lambda x: (i for i in x), auto_aiter]
+    )
+    def test_context_vars(self, test_env_async, transform):
+        t = test_env_async.from_string(
+            "{% for item in seq %}{{ loop.index }}|{{ loop.index0 }}"
+            "|{{ loop.revindex }}|{{ loop.revindex0 }}|{{ loop.first }}"
+            "|{{ loop.last }}|{{ loop.length }}\n{% endfor %}"
+        )
+        out = t.render(seq=transform([42, 24]))
+        assert out == "1|0|2|1|True|False|2\n2|1|1|0|False|True|2\n"
+
+    def test_cycling(self, test_env_async):
+        tmpl = test_env_async.from_string(
+            """{% for item in seq %}{{
+            loop.cycle('<1>', '<2>') }}{% endfor %}{%
+            for item in seq %}{{ loop.cycle(*through) }}{% endfor %}"""
+        )
+        output = tmpl.render(seq=list(range(4)), through=("<1>", "<2>"))
+        assert output == "<1><2>" * 4
+
+    def test_lookaround(self, test_env_async):
+        tmpl = test_env_async.from_string(
+            """{% for item in seq -%}
+            {{ loop.previtem|default('x') }}-{{ item }}-{{
+            loop.nextitem|default('x') }}|
+        {%- endfor %}"""
+        )
+        output = tmpl.render(seq=list(range(4)))
+        assert output == "x-0-1|0-1-2|1-2-3|2-3-x|"
+
+    def test_changed(self, test_env_async):
+        tmpl = test_env_async.from_string(
+            """{% for item in seq -%}
+            {{ loop.changed(item) }},
+        {%- endfor %}"""
+        )
+        output = tmpl.render(seq=[None, None, 1, 2, 2, 3, 4, 4, 4])
+        assert output == "True,False,True,True,False,True,True,False,False,"
+
+    def test_scope(self, test_env_async):
+        tmpl = test_env_async.from_string("{% for item in seq %}{% endfor %}{{ item }}")
+        output = tmpl.render(seq=list(range(10)))
+        assert not output
+
+    def test_varlen(self, test_env_async):
+        def inner():
+            yield from range(5)
+
+        tmpl = test_env_async.from_string(
+            "{% for item in iter %}{{ item }}{% endfor %}"
+        )
+        output = tmpl.render(iter=inner())
+        assert output == "01234"
+
+    def test_noniter(self, test_env_async):
+        tmpl = test_env_async.from_string("{% for item in none %}...{% endfor %}")
+        pytest.raises(TypeError, tmpl.render)
+
+    def test_recursive(self, test_env_async):
+        tmpl = test_env_async.from_string(
+            """{% for item in seq recursive -%}
+            [{{ item.a }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}]
+        {%- endfor %}"""
+        )
+        assert (
+            tmpl.render(
+                seq=[
+                    dict(a=1, b=[dict(a=1), dict(a=2)]),
+                    dict(a=2, b=[dict(a=1), dict(a=2)]),
+                    dict(a=3, b=[dict(a="a")]),
+                ]
+            )
+            == "[1<[1][2]>][2<[1][2]>][3<[a]>]"
+        )
+
+    def test_recursive_lookaround(self, test_env_async):
+        tmpl = test_env_async.from_string(
+            """{% for item in seq recursive -%}
+            [{{ loop.previtem.a if loop.previtem is defined else 'x' }}.{{
+            item.a }}.{{ loop.nextitem.a if loop.nextitem is defined else 'x'
+            }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}]
+        {%- endfor %}"""
+        )
+        assert (
+            tmpl.render(
+                seq=[
+                    dict(a=1, b=[dict(a=1), dict(a=2)]),
+                    dict(a=2, b=[dict(a=1), dict(a=2)]),
+                    dict(a=3, b=[dict(a="a")]),
+                ]
+            )
+            == "[x.1.2<[x.1.2][1.2.x]>][1.2.3<[x.1.2][1.2.x]>][2.3.x<[x.a.x]>]"
+        )
+
+    def test_recursive_depth0(self, test_env_async):
+        tmpl = test_env_async.from_string(
+            "{% for item in seq recursive %}[{{ loop.depth0 }}:{{ item.a }}"
+            "{% if item.b %}<{{ loop(item.b) }}>{% endif %}]{% endfor %}"
+        )
+        assert (
+            tmpl.render(
+                seq=[
+                    dict(a=1, b=[dict(a=1), dict(a=2)]),
+                    dict(a=2, b=[dict(a=1), dict(a=2)]),
+                    dict(a=3, b=[dict(a="a")]),
+                ]
+            )
+            == "[0:1<[1:1][1:2]>][0:2<[1:1][1:2]>][0:3<[1:a]>]"
+        )
+
+    def test_recursive_depth(self, test_env_async):
+        tmpl = test_env_async.from_string(
+            "{% for item in seq recursive %}[{{ loop.depth }}:{{ item.a }}"
+            "{% if item.b %}<{{ loop(item.b) }}>{% endif %}]{% endfor %}"
+        )
+        assert (
+            tmpl.render(
+                seq=[
+                    dict(a=1, b=[dict(a=1), dict(a=2)]),
+                    dict(a=2, b=[dict(a=1), dict(a=2)]),
+                    dict(a=3, b=[dict(a="a")]),
+                ]
+            )
+            == "[1:1<[2:1][2:2]>][1:2<[2:1][2:2]>][1:3<[2:a]>]"
+        )
+
+    def test_looploop(self, test_env_async):
+        tmpl = test_env_async.from_string(
+            """{% for row in table %}
+            {%- set rowloop = loop -%}
+            {% for cell in row -%}
+                [{{ rowloop.index }}|{{ loop.index }}]
+            {%- endfor %}
+        {%- endfor %}"""
+        )
+        assert tmpl.render(table=["ab", "cd"]) == "[1|1][1|2][2|1][2|2]"
+
+    def test_reversed_bug(self, test_env_async):
+        tmpl = test_env_async.from_string(
+            "{% for i in items %}{{ i }}"
+            "{% if not loop.last %}"
+            ",{% endif %}{% endfor %}"
+        )
+        assert tmpl.render(items=reversed([3, 2, 1])) == "1,2,3"
+
+    def test_loop_errors(self, test_env_async):
+        tmpl = test_env_async.from_string(
+            """{% for item in [1] if loop.index
+                                      == 0 %}...{% endfor %}"""
+        )
+        pytest.raises(UndefinedError, tmpl.render)
+        tmpl = test_env_async.from_string(
+            """{% for item in [] %}...{% else
+            %}{{ loop }}{% endfor %}"""
+        )
+        assert tmpl.render() == ""
+
+    def test_loop_filter(self, test_env_async):
+        tmpl = test_env_async.from_string(
+            "{% for item in range(10) if item is even %}[{{ item }}]{% endfor %}"
+        )
+        assert tmpl.render() == "[0][2][4][6][8]"
+        tmpl = test_env_async.from_string(
+            """
+            {%- for item in range(10) if item is even %}[{{
+                loop.index }}:{{ item }}]{% endfor %}"""
+        )
+        assert tmpl.render() == "[1:0][2:2][3:4][4:6][5:8]"
+
+    def test_scoped_special_var(self, test_env_async):
+        t = test_env_async.from_string(
+            "{% for s in seq %}[{{ loop.first }}{% for c in s %}"
+            "|{{ loop.first }}{% endfor %}]{% endfor %}"
+        )
+        assert t.render(seq=("ab", "cd")) == "[True|True|False][False|True|False]"
+
+    def test_scoped_loop_var(self, test_env_async):
+        t = test_env_async.from_string(
+            "{% for x in seq %}{{ loop.first }}"
+            "{% for y in seq %}{% endfor %}{% endfor %}"
+        )
+        assert t.render(seq="ab") == "TrueFalse"
+        t = test_env_async.from_string(
+            "{% for x in seq %}{% for y in seq %}"
+            "{{ loop.first }}{% endfor %}{% endfor %}"
+        )
+        assert t.render(seq="ab") == "TrueFalseTrueFalse"
+
+    def test_recursive_empty_loop_iter(self, test_env_async):
+        t = test_env_async.from_string(
+            """
+        {%- for item in foo recursive -%}{%- endfor -%}
+        """
+        )
+        assert t.render(dict(foo=[])) == ""
+
+    def test_call_in_loop(self, test_env_async):
+        t = test_env_async.from_string(
+            """
+        {%- macro do_something() -%}
+            [{{ caller() }}]
+        {%- endmacro %}
+
+        {%- for i in [1, 2, 3] %}
+            {%- call do_something() -%}
+                {{ i }}
+            {%- endcall %}
+        {%- endfor -%}
+        """
+        )
+        assert t.render() == "[1][2][3]"
+
+    def test_scoping_bug(self, test_env_async):
+        t = test_env_async.from_string(
+            """
+        {%- for item in foo %}...{{ item }}...{% endfor %}
+        {%- macro item(a) %}...{{ a }}...{% endmacro %}
+        {{- item(2) -}}
+        """
+        )
+        assert t.render(foo=(1,)) == "...1......2..."
+
+    def test_unpacking(self, test_env_async):
+        tmpl = test_env_async.from_string(
+            "{% for a, b, c in [[1, 2, 3]] %}{{ a }}|{{ b }}|{{ c }}{% endfor %}"
+        )
+        assert tmpl.render() == "1|2|3"
+
+    def test_recursive_loop_filter(self, test_env_async):
+        t = test_env_async.from_string(
+            """
+        <?xml version="1.0" encoding="UTF-8"?>
+        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+          {%- for page in [site.root] if page.url != this recursive %}
+          <url><loc>{{ page.url }}</loc></url>
+          {{- loop(page.children) }}
+          {%- endfor %}
+        </urlset>
+        """
+        )
+        sm = t.render(
+            this="/foo",
+            site={"root": {"url": "/", "children": [{"url": "/foo"}, {"url": "/bar"}]}},
+        )
+        lines = [x.strip() for x in sm.splitlines() if x.strip()]
+        assert lines == [
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+            "<url><loc>/</loc></url>",
+            "<url><loc>/bar</loc></url>",
+            "</urlset>",
+        ]
+
+    def test_nonrecursive_loop_filter(self, test_env_async):
+        t = test_env_async.from_string(
+            """
+        <?xml version="1.0" encoding="UTF-8"?>
+        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+          {%- for page in items if page.url != this %}
+          <url><loc>{{ page.url }}</loc></url>
+          {%- endfor %}
+        </urlset>
+        """
+        )
+        sm = t.render(
+            this="/foo", items=[{"url": "/"}, {"url": "/foo"}, {"url": "/bar"}]
+        )
+        lines = [x.strip() for x in sm.splitlines() if x.strip()]
+        assert lines == [
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+            "<url><loc>/</loc></url>",
+            "<url><loc>/bar</loc></url>",
+            "</urlset>",
+        ]
+
+    def test_bare_async(self, test_env_async):
+        t = test_env_async.from_string('{% extends "header" %}')
+        assert t.render(foo=42) == "[42|23]"
+
+    def test_awaitable_property_slicing(self, test_env_async):
+        t = test_env_async.from_string("{% for x in a.b[:1] %}{{ x }}{% endfor %}")
+        assert t.render(a=dict(b=[1, 2, 3])) == "1"
+
+
+def test_namespace_awaitable(test_env_async):
+    async def _test():
+        t = test_env_async.from_string(
+            '{% set ns = namespace(foo="Bar") %}{{ ns.foo }}'
+        )
+        actual = await t.render_async()
+        assert actual == "Bar"
+
+    asyncio.run(_test())
+
+
+def test_chainable_undefined_aiter():
+    async def _test():
+        t = Template(
+            "{% for x in a['b']['c'] %}{{ x }}{% endfor %}",
+            enable_async=True,
+            undefined=ChainableUndefined,
+        )
+        rv = await t.render_async(a={})
+        assert rv == ""
+
+    asyncio.run(_test())
+
+
+@pytest.fixture
+def async_native_env():
+    return NativeEnvironment(enable_async=True)
+
+
+def test_native_async(async_native_env):
+    async def _test():
+        t = async_native_env.from_string("{{ x }}")
+        rv = await t.render_async(x=23)
+        assert rv == 23
+
+    asyncio.run(_test())
+
+
+def test_native_list_async(async_native_env):
+    async def _test():
+        t = async_native_env.from_string("{{ x }}")
+        rv = await t.render_async(x=list(range(3)))
+        assert rv == [0, 1, 2]
+
+    asyncio.run(_test())
+
+
+def test_getitem_after_filter():
+    env = Environment(enable_async=True)
+    env.filters["add_each"] = lambda v, x: [i + x for i in v]
+    t = env.from_string("{{ (a|add_each(2))[1:] }}")
+    out = t.render(a=range(3))
+    assert out == "[3, 4]"
+
+
+def test_getitem_after_call():
+    env = Environment(enable_async=True)
+    env.globals["add_each"] = lambda v, x: [i + x for i in v]
+    t = env.from_string("{{ add_each(a, 2)[1:] }}")
+    out = t.render(a=range(3))
+    assert out == "[3, 4]"
diff --git a/tests/test_async_filters.py b/tests/test_async_filters.py
new file mode 100644
index 0000000..f5b2627
--- /dev/null
+++ b/tests/test_async_filters.py
@@ -0,0 +1,273 @@
+from collections import namedtuple
+
+import pytest
+from markupsafe import Markup
+
+from jinja2 import Environment
+from jinja2.async_utils import auto_aiter
+
+
+async def make_aiter(iter):
+    for item in iter:
+        yield item
+
+
+def mark_dualiter(parameter, factory):
+    def decorator(f):
+        return pytest.mark.parametrize(
+            parameter, [lambda: factory(), lambda: make_aiter(factory())]
+        )(f)
+
+    return decorator
+
+
+@pytest.fixture
+def env_async():
+    return Environment(enable_async=True)
+
+
+@mark_dualiter("foo", lambda: range(10))
+def test_first(env_async, foo):
+    tmpl = env_async.from_string("{{ foo()|first }}")
+    out = tmpl.render(foo=foo)
+    assert out == "0"
+
+
+@mark_dualiter(
+    "items",
+    lambda: [
+        {"foo": 1, "bar": 2},
+        {"foo": 2, "bar": 3},
+        {"foo": 1, "bar": 1},
+        {"foo": 3, "bar": 4},
+    ],
+)
+def test_groupby(env_async, items):
+    tmpl = env_async.from_string(
+        """
+    {%- for grouper, list in items()|groupby('foo') -%}
+        {{ grouper }}{% for x in list %}: {{ x.foo }}, {{ x.bar }}{% endfor %}|
+    {%- endfor %}"""
+    )
+    assert tmpl.render(items=items).split("|") == [
+        "1: 1, 2: 1, 1",
+        "2: 2, 3",
+        "3: 3, 4",
+        "",
+    ]
+
+
+@pytest.mark.parametrize(
+    ("case_sensitive", "expect"),
+    [
+        (False, "a: 1, 3\nb: 2\n"),
+        (True, "A: 3\na: 1\nb: 2\n"),
+    ],
+)
+def test_groupby_case(env_async, case_sensitive, expect):
+    tmpl = env_async.from_string(
+        "{% for k, vs in data|groupby('k', case_sensitive=cs) %}"
+        "{{ k }}: {{ vs|join(', ', attribute='v') }}\n"
+        "{% endfor %}"
+    )
+    out = tmpl.render(
+        data=[{"k": "a", "v": 1}, {"k": "b", "v": 2}, {"k": "A", "v": 3}],
+        cs=case_sensitive,
+    )
+    assert out == expect
+
+
+@mark_dualiter("items", lambda: [("a", 1), ("a", 2), ("b", 1)])
+def test_groupby_tuple_index(env_async, items):
+    tmpl = env_async.from_string(
+        """
+    {%- for grouper, list in items()|groupby(0) -%}
+        {{ grouper }}{% for x in list %}:{{ x.1 }}{% endfor %}|
+    {%- endfor %}"""
+    )
+    assert tmpl.render(items=items) == "a:1:2|b:1|"
+
+
+def make_articles():
+    Date = namedtuple("Date", "day,month,year")
+    Article = namedtuple("Article", "title,date")
+    return [
+        Article("aha", Date(1, 1, 1970)),
+        Article("interesting", Date(2, 1, 1970)),
+        Article("really?", Date(3, 1, 1970)),
+        Article("totally not", Date(1, 1, 1971)),
+    ]
+
+
+@mark_dualiter("articles", make_articles)
+def test_groupby_multidot(env_async, articles):
+    tmpl = env_async.from_string(
+        """
+    {%- for year, list in articles()|groupby('date.year') -%}
+        {{ year }}{% for x in list %}[{{ x.title }}]{% endfor %}|
+    {%- endfor %}"""
+    )
+    assert tmpl.render(articles=articles).split("|") == [
+        "1970[aha][interesting][really?]",
+        "1971[totally not]",
+        "",
+    ]
+
+
+@mark_dualiter("int_items", lambda: [1, 2, 3])
+def test_join_env_int(env_async, int_items):
+    tmpl = env_async.from_string('{{ items()|join("|") }}')
+    out = tmpl.render(items=int_items)
+    assert out == "1|2|3"
+
+
+@mark_dualiter("string_items", lambda: ["<foo>", Markup("<span>foo</span>")])
+def test_join_string_list(string_items):
+    env2 = Environment(autoescape=True, enable_async=True)
+    tmpl = env2.from_string('{{ ["<foo>", "<span>foo</span>"|safe]|join }}')
+    assert tmpl.render(items=string_items) == "&lt;foo&gt;<span>foo</span>"
+
+
+def make_users():
+    User = namedtuple("User", "username")
+    return map(User, ["foo", "bar"])
+
+
+@mark_dualiter("users", make_users)
+def test_join_attribute(env_async, users):
+    tmpl = env_async.from_string("""{{ users()|join(', ', 'username') }}""")
+    assert tmpl.render(users=users) == "foo, bar"
+
+
+@mark_dualiter("items", lambda: [1, 2, 3, 4, 5])
+def test_simple_reject(env_async, items):
+    tmpl = env_async.from_string('{{ items()|reject("odd")|join("|") }}')
+    assert tmpl.render(items=items) == "2|4"
+
+
+@mark_dualiter("items", lambda: [None, False, 0, 1, 2, 3, 4, 5])
+def test_bool_reject(env_async, items):
+    tmpl = env_async.from_string('{{ items()|reject|join("|") }}')
+    assert tmpl.render(items=items) == "None|False|0"
+
+
+@mark_dualiter("items", lambda: [1, 2, 3, 4, 5])
+def test_simple_select(env_async, items):
+    tmpl = env_async.from_string('{{ items()|select("odd")|join("|") }}')
+    assert tmpl.render(items=items) == "1|3|5"
+
+
+@mark_dualiter("items", lambda: [None, False, 0, 1, 2, 3, 4, 5])
+def test_bool_select(env_async, items):
+    tmpl = env_async.from_string('{{ items()|select|join("|") }}')
+    assert tmpl.render(items=items) == "1|2|3|4|5"
+
+
+def make_users():  # type: ignore
+    User = namedtuple("User", "name,is_active")
+    return [
+        User("john", True),
+        User("jane", True),
+        User("mike", False),
+    ]
+
+
+@mark_dualiter("users", make_users)
+def test_simple_select_attr(env_async, users):
+    tmpl = env_async.from_string(
+        '{{ users()|selectattr("is_active")|map(attribute="name")|join("|") }}'
+    )
+    assert tmpl.render(users=users) == "john|jane"
+
+
+@mark_dualiter("items", lambda: list("123"))
+def test_simple_map(env_async, items):
+    tmpl = env_async.from_string('{{ items()|map("int")|sum }}')
+    assert tmpl.render(items=items) == "6"
+
+
+def test_map_sum(env_async):  # async map + async filter
+    tmpl = env_async.from_string('{{ [[1,2], [3], [4,5,6]]|map("sum")|list }}')
+    assert tmpl.render() == "[3, 3, 15]"
+
+
+@mark_dualiter("users", make_users)
+def test_attribute_map(env_async, users):
+    tmpl = env_async.from_string('{{ users()|map(attribute="name")|join("|") }}')
+    assert tmpl.render(users=users) == "john|jane|mike"
+
+
+def test_empty_map(env_async):
+    tmpl = env_async.from_string('{{ none|map("upper")|list }}')
+    assert tmpl.render() == "[]"
+
+
+@mark_dualiter("items", lambda: [1, 2, 3, 4, 5, 6])
+def test_sum(env_async, items):
+    tmpl = env_async.from_string("""{{ items()|sum }}""")
+    assert tmpl.render(items=items) == "21"
+
+
+@mark_dualiter("items", lambda: [{"value": 23}, {"value": 1}, {"value": 18}])
+def test_sum_attributes(env_async, items):
+    tmpl = env_async.from_string("""{{ items()|sum('value') }}""")
+    assert tmpl.render(items=items)
+
+
+def test_sum_attributes_nested(env_async):
+    tmpl = env_async.from_string("""{{ values|sum('real.value') }}""")
+    assert (
+        tmpl.render(
+            values=[
+                {"real": {"value": 23}},
+                {"real": {"value": 1}},
+                {"real": {"value": 18}},
+            ]
+        )
+        == "42"
+    )
+
+
+def test_sum_attributes_tuple(env_async):
+    tmpl = env_async.from_string("""{{ values.items()|sum('1') }}""")
+    assert tmpl.render(values={"foo": 23, "bar": 1, "baz": 18}) == "42"
+
+
+@mark_dualiter("items", lambda: range(10))
+def test_slice(env_async, items):
+    tmpl = env_async.from_string(
+        "{{ items()|slice(3)|list }}|{{ items()|slice(3, 'X')|list }}"
+    )
+    out = tmpl.render(items=items)
+    assert out == (
+        "[[0, 1, 2, 3], [4, 5, 6], [7, 8, 9]]|"
+        "[[0, 1, 2, 3], [4, 5, 6, 'X'], [7, 8, 9, 'X']]"
+    )
+
+
+def test_custom_async_filter(env_async):
+    async def customfilter(val):
+        return str(val)
+
+    env_async.filters["customfilter"] = customfilter
+    tmpl = env_async.from_string("{{ 'static'|customfilter }} {{ arg|customfilter }}")
+    out = tmpl.render(arg="dynamic")
+    assert out == "static dynamic"
+
+
+@mark_dualiter("items", lambda: range(10))
+def test_custom_async_iteratable_filter(env_async, items):
+    async def customfilter(iterable):
+        items = []
+        async for item in auto_aiter(iterable):
+            items.append(str(item))
+            if len(items) == 3:
+                break
+        return ",".join(items)
+
+    env_async.filters["customfilter"] = customfilter
+    tmpl = env_async.from_string(
+        "{{ items()|customfilter }} .. {{ [3, 4, 5, 6]|customfilter }}"
+    )
+    out = tmpl.render(items=items)
+    assert out == "0,1,2 .. 3,4,5"
diff --git a/tests/test_bytecode_cache.py b/tests/test_bytecode_cache.py
new file mode 100644
index 0000000..5b9eb0f
--- /dev/null
+++ b/tests/test_bytecode_cache.py
@@ -0,0 +1,77 @@
+import pytest
+
+from jinja2 import Environment
+from jinja2.bccache import Bucket
+from jinja2.bccache import FileSystemBytecodeCache
+from jinja2.bccache import MemcachedBytecodeCache
+from jinja2.exceptions import TemplateNotFound
+
+
+@pytest.fixture
+def env(package_loader, tmp_path):
+    bytecode_cache = FileSystemBytecodeCache(str(tmp_path))
+    return Environment(loader=package_loader, bytecode_cache=bytecode_cache)
+
+
+class TestByteCodeCache:
+    def test_simple(self, env):
+        tmpl = env.get_template("test.html")
+        assert tmpl.render().strip() == "BAR"
+        pytest.raises(TemplateNotFound, env.get_template, "missing.html")
+
+
+class MockMemcached:
+    class Error(Exception):
+        pass
+
+    key = None
+    value = None
+    timeout = None
+
+    def get(self, key):
+        return self.value
+
+    def set(self, key, value, timeout=None):
+        self.key = key
+        self.value = value
+        self.timeout = timeout
+
+    def get_side_effect(self, key):
+        raise self.Error()
+
+    def set_side_effect(self, *args):
+        raise self.Error()
+
+
+class TestMemcachedBytecodeCache:
+    def test_dump_load(self):
+        memcached = MockMemcached()
+        m = MemcachedBytecodeCache(memcached)
+
+        b = Bucket(None, "key", "")
+        b.code = "code"
+        m.dump_bytecode(b)
+        assert memcached.key == "jinja2/bytecode/key"
+
+        b = Bucket(None, "key", "")
+        m.load_bytecode(b)
+        assert b.code == "code"
+
+    def test_exception(self):
+        memcached = MockMemcached()
+        memcached.get = memcached.get_side_effect
+        memcached.set = memcached.set_side_effect
+        m = MemcachedBytecodeCache(memcached)
+        b = Bucket(None, "key", "")
+        b.code = "code"
+
+        m.dump_bytecode(b)
+        m.load_bytecode(b)
+
+        m.ignore_memcache_errors = False
+
+        with pytest.raises(MockMemcached.Error):
+            m.dump_bytecode(b)
+
+        with pytest.raises(MockMemcached.Error):
+            m.load_bytecode(b)
diff --git a/tests/test_compile.py b/tests/test_compile.py
new file mode 100644
index 0000000..42a773f
--- /dev/null
+++ b/tests/test_compile.py
@@ -0,0 +1,28 @@
+import os
+import re
+
+from jinja2.environment import Environment
+from jinja2.loaders import DictLoader
+
+
+def test_filters_deterministic(tmp_path):
+    src = "".join(f"{{{{ {i}|filter{i} }}}}" for i in range(10))
+    env = Environment(loader=DictLoader({"foo": src}))
+    env.filters.update(dict.fromkeys((f"filter{i}" for i in range(10)), lambda: None))
+    env.compile_templates(tmp_path, zip=None)
+    name = os.listdir(tmp_path)[0]
+    content = (tmp_path / name).read_text("utf8")
+    expect = [f"filters['filter{i}']" for i in range(10)]
+    found = re.findall(r"filters\['filter\d']", content)
+    assert found == expect
+
+
+def test_import_as_with_context_deterministic(tmp_path):
+    src = "\n".join(f'{{% import "bar" as bar{i} with context %}}' for i in range(10))
+    env = Environment(loader=DictLoader({"foo": src}))
+    env.compile_templates(tmp_path, zip=None)
+    name = os.listdir(tmp_path)[0]
+    content = (tmp_path / name).read_text("utf8")
+    expect = [f"'bar{i}': " for i in range(10)]
+    found = re.findall(r"'bar\d': ", content)[:10]
+    assert found == expect
diff --git a/tests/test_core_tags.py b/tests/test_core_tags.py
new file mode 100644
index 0000000..4bb95e0
--- /dev/null
+++ b/tests/test_core_tags.py
@@ -0,0 +1,595 @@
+import pytest
+
+from jinja2 import DictLoader
+from jinja2 import Environment
+from jinja2 import TemplateRuntimeError
+from jinja2 import TemplateSyntaxError
+from jinja2 import UndefinedError
+
+
+@pytest.fixture
+def env_trim():
+    return Environment(trim_blocks=True)
+
+
+class TestForLoop:
+    def test_simple(self, env):
+        tmpl = env.from_string("{% for item in seq %}{{ item }}{% endfor %}")
+        assert tmpl.render(seq=list(range(10))) == "0123456789"
+
+    def test_else(self, env):
+        tmpl = env.from_string("{% for item in seq %}XXX{% else %}...{% endfor %}")
+        assert tmpl.render() == "..."
+
+    def test_else_scoping_item(self, env):
+        tmpl = env.from_string("{% for item in [] %}{% else %}{{ item }}{% endfor %}")
+        assert tmpl.render(item=42) == "42"
+
+    def test_empty_blocks(self, env):
+        tmpl = env.from_string("<{% for item in seq %}{% else %}{% endfor %}>")
+        assert tmpl.render() == "<>"
+
+    def test_context_vars(self, env):
+        slist = [42, 24]
+        for seq in [slist, iter(slist), reversed(slist), (_ for _ in slist)]:
+            tmpl = env.from_string(
+                """{% for item in seq -%}
+            {{ loop.index }}|{{ loop.index0 }}|{{ loop.revindex }}|{{
+                loop.revindex0 }}|{{ loop.first }}|{{ loop.last }}|{{
+               loop.length }}###{% endfor %}"""
+            )
+            one, two, _ = tmpl.render(seq=seq).split("###")
+            (
+                one_index,
+                one_index0,
+                one_revindex,
+                one_revindex0,
+                one_first,
+                one_last,
+                one_length,
+            ) = one.split("|")
+            (
+                two_index,
+                two_index0,
+                two_revindex,
+                two_revindex0,
+                two_first,
+                two_last,
+                two_length,
+            ) = two.split("|")
+
+            assert int(one_index) == 1 and int(two_index) == 2
+            assert int(one_index0) == 0 and int(two_index0) == 1
+            assert int(one_revindex) == 2 and int(two_revindex) == 1
+            assert int(one_revindex0) == 1 and int(two_revindex0) == 0
+            assert one_first == "True" and two_first == "False"
+            assert one_last == "False" and two_last == "True"
+            assert one_length == two_length == "2"
+
+    def test_cycling(self, env):
+        tmpl = env.from_string(
+            """{% for item in seq %}{{
+            loop.cycle('<1>', '<2>') }}{% endfor %}{%
+            for item in seq %}{{ loop.cycle(*through) }}{% endfor %}"""
+        )
+        output = tmpl.render(seq=list(range(4)), through=("<1>", "<2>"))
+        assert output == "<1><2>" * 4
+
+    def test_lookaround(self, env):
+        tmpl = env.from_string(
+            """{% for item in seq -%}
+            {{ loop.previtem|default('x') }}-{{ item }}-{{
+            loop.nextitem|default('x') }}|
+        {%- endfor %}"""
+        )
+        output = tmpl.render(seq=list(range(4)))
+        assert output == "x-0-1|0-1-2|1-2-3|2-3-x|"
+
+    def test_changed(self, env):
+        tmpl = env.from_string(
+            """{% for item in seq -%}
+            {{ loop.changed(item) }},
+        {%- endfor %}"""
+        )
+        output = tmpl.render(seq=[None, None, 1, 2, 2, 3, 4, 4, 4])
+        assert output == "True,False,True,True,False,True,True,False,False,"
+
+    def test_scope(self, env):
+        tmpl = env.from_string("{% for item in seq %}{% endfor %}{{ item }}")
+        output = tmpl.render(seq=list(range(10)))
+        assert not output
+
+    def test_varlen(self, env):
+        tmpl = env.from_string("{% for item in iter %}{{ item }}{% endfor %}")
+        output = tmpl.render(iter=range(5))
+        assert output == "01234"
+
+    def test_noniter(self, env):
+        tmpl = env.from_string("{% for item in none %}...{% endfor %}")
+        pytest.raises(TypeError, tmpl.render)
+
+    def test_recursive(self, env):
+        tmpl = env.from_string(
+            """{% for item in seq recursive -%}
+            [{{ item.a }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}]
+        {%- endfor %}"""
+        )
+        assert (
+            tmpl.render(
+                seq=[
+                    dict(a=1, b=[dict(a=1), dict(a=2)]),
+                    dict(a=2, b=[dict(a=1), dict(a=2)]),
+                    dict(a=3, b=[dict(a="a")]),
+                ]
+            )
+            == "[1<[1][2]>][2<[1][2]>][3<[a]>]"
+        )
+
+    def test_recursive_lookaround(self, env):
+        tmpl = env.from_string(
+            """{% for item in seq recursive -%}
+            [{{ loop.previtem.a if loop.previtem is defined else 'x' }}.{{
+            item.a }}.{{ loop.nextitem.a if loop.nextitem is defined else 'x'
+            }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}]
+        {%- endfor %}"""
+        )
+        assert (
+            tmpl.render(
+                seq=[
+                    dict(a=1, b=[dict(a=1), dict(a=2)]),
+                    dict(a=2, b=[dict(a=1), dict(a=2)]),
+                    dict(a=3, b=[dict(a="a")]),
+                ]
+            )
+            == "[x.1.2<[x.1.2][1.2.x]>][1.2.3<[x.1.2][1.2.x]>][2.3.x<[x.a.x]>]"
+        )
+
+    def test_recursive_depth0(self, env):
+        tmpl = env.from_string(
+            """{% for item in seq recursive -%}
+        [{{ loop.depth0 }}:{{ item.a }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}]
+        {%- endfor %}"""
+        )
+        assert (
+            tmpl.render(
+                seq=[
+                    dict(a=1, b=[dict(a=1), dict(a=2)]),
+                    dict(a=2, b=[dict(a=1), dict(a=2)]),
+                    dict(a=3, b=[dict(a="a")]),
+                ]
+            )
+            == "[0:1<[1:1][1:2]>][0:2<[1:1][1:2]>][0:3<[1:a]>]"
+        )
+
+    def test_recursive_depth(self, env):
+        tmpl = env.from_string(
+            """{% for item in seq recursive -%}
+        [{{ loop.depth }}:{{ item.a }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}]
+        {%- endfor %}"""
+        )
+        assert (
+            tmpl.render(
+                seq=[
+                    dict(a=1, b=[dict(a=1), dict(a=2)]),
+                    dict(a=2, b=[dict(a=1), dict(a=2)]),
+                    dict(a=3, b=[dict(a="a")]),
+                ]
+            )
+            == "[1:1<[2:1][2:2]>][1:2<[2:1][2:2]>][1:3<[2:a]>]"
+        )
+
+    def test_looploop(self, env):
+        tmpl = env.from_string(
+            """{% for row in table %}
+            {%- set rowloop = loop -%}
+            {% for cell in row -%}
+                [{{ rowloop.index }}|{{ loop.index }}]
+            {%- endfor %}
+        {%- endfor %}"""
+        )
+        assert tmpl.render(table=["ab", "cd"]) == "[1|1][1|2][2|1][2|2]"
+
+    def test_reversed_bug(self, env):
+        tmpl = env.from_string(
+            "{% for i in items %}{{ i }}"
+            "{% if not loop.last %}"
+            ",{% endif %}{% endfor %}"
+        )
+        assert tmpl.render(items=reversed([3, 2, 1])) == "1,2,3"
+
+    def test_loop_errors(self, env):
+        tmpl = env.from_string(
+            """{% for item in [1] if loop.index
+                                      == 0 %}...{% endfor %}"""
+        )
+        pytest.raises(UndefinedError, tmpl.render)
+        tmpl = env.from_string(
+            """{% for item in [] %}...{% else
+            %}{{ loop }}{% endfor %}"""
+        )
+        assert tmpl.render() == ""
+
+    def test_loop_filter(self, env):
+        tmpl = env.from_string(
+            "{% for item in range(10) if item is even %}[{{ item }}]{% endfor %}"
+        )
+        assert tmpl.render() == "[0][2][4][6][8]"
+        tmpl = env.from_string(
+            """
+            {%- for item in range(10) if item is even %}[{{
+                loop.index }}:{{ item }}]{% endfor %}"""
+        )
+        assert tmpl.render() == "[1:0][2:2][3:4][4:6][5:8]"
+
+    def test_loop_unassignable(self, env):
+        pytest.raises(
+            TemplateSyntaxError, env.from_string, "{% for loop in seq %}...{% endfor %}"
+        )
+
+    def test_scoped_special_var(self, env):
+        t = env.from_string(
+            "{% for s in seq %}[{{ loop.first }}{% for c in s %}"
+            "|{{ loop.first }}{% endfor %}]{% endfor %}"
+        )
+        assert t.render(seq=("ab", "cd")) == "[True|True|False][False|True|False]"
+
+    def test_scoped_loop_var(self, env):
+        t = env.from_string(
+            "{% for x in seq %}{{ loop.first }}"
+            "{% for y in seq %}{% endfor %}{% endfor %}"
+        )
+        assert t.render(seq="ab") == "TrueFalse"
+        t = env.from_string(
+            "{% for x in seq %}{% for y in seq %}"
+            "{{ loop.first }}{% endfor %}{% endfor %}"
+        )
+        assert t.render(seq="ab") == "TrueFalseTrueFalse"
+
+    def test_recursive_empty_loop_iter(self, env):
+        t = env.from_string(
+            """
+        {%- for item in foo recursive -%}{%- endfor -%}
+        """
+        )
+        assert t.render(dict(foo=[])) == ""
+
+    def test_call_in_loop(self, env):
+        t = env.from_string(
+            """
+        {%- macro do_something() -%}
+            [{{ caller() }}]
+        {%- endmacro %}
+
+        {%- for i in [1, 2, 3] %}
+            {%- call do_something() -%}
+                {{ i }}
+            {%- endcall %}
+        {%- endfor -%}
+        """
+        )
+        assert t.render() == "[1][2][3]"
+
+    def test_scoping_bug(self, env):
+        t = env.from_string(
+            """
+        {%- for item in foo %}...{{ item }}...{% endfor %}
+        {%- macro item(a) %}...{{ a }}...{% endmacro %}
+        {{- item(2) -}}
+        """
+        )
+        assert t.render(foo=(1,)) == "...1......2..."
+
+    def test_unpacking(self, env):
+        tmpl = env.from_string(
+            "{% for a, b, c in [[1, 2, 3]] %}{{ a }}|{{ b }}|{{ c }}{% endfor %}"
+        )
+        assert tmpl.render() == "1|2|3"
+
+    def test_intended_scoping_with_set(self, env):
+        tmpl = env.from_string(
+            "{% for item in seq %}{{ x }}{% set x = item %}{{ x }}{% endfor %}"
+        )
+        assert tmpl.render(x=0, seq=[1, 2, 3]) == "010203"
+
+        tmpl = env.from_string(
+            "{% set x = 9 %}{% for item in seq %}{{ x }}"
+            "{% set x = item %}{{ x }}{% endfor %}"
+        )
+        assert tmpl.render(x=0, seq=[1, 2, 3]) == "919293"
+
+
+class TestIfCondition:
+    def test_simple(self, env):
+        tmpl = env.from_string("""{% if true %}...{% endif %}""")
+        assert tmpl.render() == "..."
+
+    def test_elif(self, env):
+        tmpl = env.from_string(
+            """{% if false %}XXX{% elif true
+            %}...{% else %}XXX{% endif %}"""
+        )
+        assert tmpl.render() == "..."
+
+    def test_elif_deep(self, env):
+        elifs = "\n".join(f"{{% elif a == {i} %}}{i}" for i in range(1, 1000))
+        tmpl = env.from_string(f"{{% if a == 0 %}}0{elifs}{{% else %}}x{{% endif %}}")
+        for x in (0, 10, 999):
+            assert tmpl.render(a=x).strip() == str(x)
+        assert tmpl.render(a=1000).strip() == "x"
+
+    def test_else(self, env):
+        tmpl = env.from_string("{% if false %}XXX{% else %}...{% endif %}")
+        assert tmpl.render() == "..."
+
+    def test_empty(self, env):
+        tmpl = env.from_string("[{% if true %}{% else %}{% endif %}]")
+        assert tmpl.render() == "[]"
+
+    def test_complete(self, env):
+        tmpl = env.from_string(
+            "{% if a %}A{% elif b %}B{% elif c == d %}C{% else %}D{% endif %}"
+        )
+        assert tmpl.render(a=0, b=False, c=42, d=42.0) == "C"
+
+    def test_no_scope(self, env):
+        tmpl = env.from_string("{% if a %}{% set foo = 1 %}{% endif %}{{ foo }}")
+        assert tmpl.render(a=True) == "1"
+        tmpl = env.from_string("{% if true %}{% set foo = 1 %}{% endif %}{{ foo }}")
+        assert tmpl.render() == "1"
+
+
+class TestMacros:
+    def test_simple(self, env_trim):
+        tmpl = env_trim.from_string(
+            """\
+{% macro say_hello(name) %}Hello {{ name }}!{% endmacro %}
+{{ say_hello('Peter') }}"""
+        )
+        assert tmpl.render() == "Hello Peter!"
+
+    def test_scoping(self, env_trim):
+        tmpl = env_trim.from_string(
+            """\
+{% macro level1(data1) %}
+{% macro level2(data2) %}{{ data1 }}|{{ data2 }}{% endmacro %}
+{{ level2('bar') }}{% endmacro %}
+{{ level1('foo') }}"""
+        )
+        assert tmpl.render() == "foo|bar"
+
+    def test_arguments(self, env_trim):
+        tmpl = env_trim.from_string(
+            """\
+{% macro m(a, b, c='c', d='d') %}{{ a }}|{{ b }}|{{ c }}|{{ d }}{% endmacro %}
+{{ m() }}|{{ m('a') }}|{{ m('a', 'b') }}|{{ m(1, 2, 3) }}"""
+        )
+        assert tmpl.render() == "||c|d|a||c|d|a|b|c|d|1|2|3|d"
+
+    def test_arguments_defaults_nonsense(self, env_trim):
+        pytest.raises(
+            TemplateSyntaxError,
+            env_trim.from_string,
+            """\
+{% macro m(a, b=1, c) %}a={{ a }}, b={{ b }}, c={{ c }}{% endmacro %}""",
+        )
+
+    def test_caller_defaults_nonsense(self, env_trim):
+        pytest.raises(
+            TemplateSyntaxError,
+            env_trim.from_string,
+            """\
+{% macro a() %}{{ caller() }}{% endmacro %}
+{% call(x, y=1, z) a() %}{% endcall %}""",
+        )
+
+    def test_varargs(self, env_trim):
+        tmpl = env_trim.from_string(
+            """\
+{% macro test() %}{{ varargs|join('|') }}{% endmacro %}\
+{{ test(1, 2, 3) }}"""
+        )
+        assert tmpl.render() == "1|2|3"
+
+    def test_simple_call(self, env_trim):
+        tmpl = env_trim.from_string(
+            """\
+{% macro test() %}[[{{ caller() }}]]{% endmacro %}\
+{% call test() %}data{% endcall %}"""
+        )
+        assert tmpl.render() == "[[data]]"
+
+    def test_complex_call(self, env_trim):
+        tmpl = env_trim.from_string(
+            """\
+{% macro test() %}[[{{ caller('data') }}]]{% endmacro %}\
+{% call(data) test() %}{{ data }}{% endcall %}"""
+        )
+        assert tmpl.render() == "[[data]]"
+
+    def test_caller_undefined(self, env_trim):
+        tmpl = env_trim.from_string(
+            """\
+{% set caller = 42 %}\
+{% macro test() %}{{ caller is not defined }}{% endmacro %}\
+{{ test() }}"""
+        )
+        assert tmpl.render() == "True"
+
+    def test_include(self, env_trim):
+        env_trim = Environment(
+            loader=DictLoader(
+                {"include": "{% macro test(foo) %}[{{ foo }}]{% endmacro %}"}
+            )
+        )
+        tmpl = env_trim.from_string('{% from "include" import test %}{{ test("foo") }}')
+        assert tmpl.render() == "[foo]"
+
+    def test_macro_api(self, env_trim):
+        tmpl = env_trim.from_string(
+            "{% macro foo(a, b) %}{% endmacro %}"
+            "{% macro bar() %}{{ varargs }}{{ kwargs }}{% endmacro %}"
+            "{% macro baz() %}{{ caller() }}{% endmacro %}"
+        )
+        assert tmpl.module.foo.arguments == ("a", "b")
+        assert tmpl.module.foo.name == "foo"
+        assert not tmpl.module.foo.caller
+        assert not tmpl.module.foo.catch_kwargs
+        assert not tmpl.module.foo.catch_varargs
+        assert tmpl.module.bar.arguments == ()
+        assert not tmpl.module.bar.caller
+        assert tmpl.module.bar.catch_kwargs
+        assert tmpl.module.bar.catch_varargs
+        assert tmpl.module.baz.caller
+
+    def test_callself(self, env_trim):
+        tmpl = env_trim.from_string(
+            "{% macro foo(x) %}{{ x }}{% if x > 1 %}|"
+            "{{ foo(x - 1) }}{% endif %}{% endmacro %}"
+            "{{ foo(5) }}"
+        )
+        assert tmpl.render() == "5|4|3|2|1"
+
+    def test_macro_defaults_self_ref(self, env):
+        tmpl = env.from_string(
+            """
+            {%- set x = 42 %}
+            {%- macro m(a, b=x, x=23) %}{{ a }}|{{ b }}|{{ x }}{% endmacro -%}
+        """
+        )
+        assert tmpl.module.m(1) == "1||23"
+        assert tmpl.module.m(1, 2) == "1|2|23"
+        assert tmpl.module.m(1, 2, 3) == "1|2|3"
+        assert tmpl.module.m(1, x=7) == "1|7|7"
+
+
+class TestSet:
+    def test_normal(self, env_trim):
+        tmpl = env_trim.from_string("{% set foo = 1 %}{{ foo }}")
+        assert tmpl.render() == "1"
+        assert tmpl.module.foo == 1
+
+    def test_block(self, env_trim):
+        tmpl = env_trim.from_string("{% set foo %}42{% endset %}{{ foo }}")
+        assert tmpl.render() == "42"
+        assert tmpl.module.foo == "42"
+
+    def test_block_escaping(self):
+        env = Environment(autoescape=True)
+        tmpl = env.from_string(
+            "{% set foo %}<em>{{ test }}</em>{% endset %}foo: {{ foo }}"
+        )
+        assert tmpl.render(test="<unsafe>") == "foo: <em>&lt;unsafe&gt;</em>"
+
+    def test_set_invalid(self, env_trim):
+        pytest.raises(
+            TemplateSyntaxError, env_trim.from_string, "{% set foo['bar'] = 1 %}"
+        )
+        tmpl = env_trim.from_string("{% set foo.bar = 1 %}")
+        exc_info = pytest.raises(TemplateRuntimeError, tmpl.render, foo={})
+        assert "non-namespace object" in exc_info.value.message
+
+    def test_namespace_redefined(self, env_trim):
+        tmpl = env_trim.from_string("{% set ns = namespace() %}{% set ns.bar = 'hi' %}")
+        exc_info = pytest.raises(TemplateRuntimeError, tmpl.render, namespace=dict)
+        assert "non-namespace object" in exc_info.value.message
+
+    def test_namespace(self, env_trim):
+        tmpl = env_trim.from_string(
+            "{% set ns = namespace() %}{% set ns.bar = '42' %}{{ ns.bar }}"
+        )
+        assert tmpl.render() == "42"
+
+    def test_namespace_block(self, env_trim):
+        tmpl = env_trim.from_string(
+            "{% set ns = namespace() %}{% set ns.bar %}42{% endset %}{{ ns.bar }}"
+        )
+        assert tmpl.render() == "42"
+
+    def test_init_namespace(self, env_trim):
+        tmpl = env_trim.from_string(
+            "{% set ns = namespace(d, self=37) %}"
+            "{% set ns.b = 42 %}"
+            "{{ ns.a }}|{{ ns.self }}|{{ ns.b }}"
+        )
+        assert tmpl.render(d={"a": 13}) == "13|37|42"
+
+    def test_namespace_loop(self, env_trim):
+        tmpl = env_trim.from_string(
+            "{% set ns = namespace(found=false) %}"
+            "{% for x in range(4) %}"
+            "{% if x == v %}"
+            "{% set ns.found = true %}"
+            "{% endif %}"
+            "{% endfor %}"
+            "{{ ns.found }}"
+        )
+        assert tmpl.render(v=3) == "True"
+        assert tmpl.render(v=4) == "False"
+
+    def test_namespace_macro(self, env_trim):
+        tmpl = env_trim.from_string(
+            "{% set ns = namespace() %}"
+            "{% set ns.a = 13 %}"
+            "{% macro magic(x) %}"
+            "{% set x.b = 37 %}"
+            "{% endmacro %}"
+            "{{ magic(ns) }}"
+            "{{ ns.a }}|{{ ns.b }}"
+        )
+        assert tmpl.render() == "13|37"
+
+    def test_block_escaping_filtered(self):
+        env = Environment(autoescape=True)
+        tmpl = env.from_string(
+            "{% set foo | trim %}<em>{{ test }}</em>    {% endset %}foo: {{ foo }}"
+        )
+        assert tmpl.render(test="<unsafe>") == "foo: <em>&lt;unsafe&gt;</em>"
+
+    def test_block_filtered(self, env_trim):
+        tmpl = env_trim.from_string(
+            "{% set foo | trim | length | string %} 42    {% endset %}{{ foo }}"
+        )
+        assert tmpl.render() == "2"
+        assert tmpl.module.foo == "2"
+
+    def test_block_filtered_set(self, env_trim):
+        def _myfilter(val, arg):
+            assert arg == " xxx "
+            return val
+
+        env_trim.filters["myfilter"] = _myfilter
+        tmpl = env_trim.from_string(
+            '{% set a = " xxx " %}'
+            "{% set foo | myfilter(a) | trim | length | string %}"
+            ' {% set b = " yy " %} 42 {{ a }}{{ b }}   '
+            "{% endset %}"
+            "{{ foo }}"
+        )
+        assert tmpl.render() == "11"
+        assert tmpl.module.foo == "11"
+
+
+class TestWith:
+    def test_with(self, env):
+        tmpl = env.from_string(
+            """\
+        {% with a=42, b=23 -%}
+            {{ a }} = {{ b }}
+        {% endwith -%}
+            {{ a }} = {{ b }}\
+        """
+        )
+        assert [x.strip() for x in tmpl.render(a=1, b=2).splitlines()] == [
+            "42 = 23",
+            "1 = 2",
+        ]
+
+    def test_with_argument_scoping(self, env):
+        tmpl = env.from_string(
+            """\
+        {%- with a=1, b=2, c=b, d=e, e=5 -%}
+            {{ a }}|{{ b }}|{{ c }}|{{ d }}|{{ e }}
+        {%- endwith -%}
+        """
+        )
+        assert tmpl.render(b=3, e=4) == "1|2|3|4|5"
diff --git a/tests/test_debug.py b/tests/test_debug.py
new file mode 100644
index 0000000..bc11f40
--- /dev/null
+++ b/tests/test_debug.py
@@ -0,0 +1,117 @@
+import pickle
+import re
+from traceback import format_exception
+
+import pytest
+
+from jinja2 import ChoiceLoader
+from jinja2 import DictLoader
+from jinja2 import Environment
+from jinja2 import TemplateSyntaxError
+
+
+@pytest.fixture
+def fs_env(filesystem_loader):
+    """returns a new environment."""
+    return Environment(loader=filesystem_loader)
+
+
+class TestDebug:
+    def assert_traceback_matches(self, callback, expected_tb):
+        with pytest.raises(Exception) as exc_info:
+            callback()
+
+        tb = format_exception(exc_info.type, exc_info.value, exc_info.tb)
+        m = re.search(expected_tb.strip(), "".join(tb))
+        assert (
+            m is not None
+        ), f"Traceback did not match:\n\n{''.join(tb)}\nexpected:\n{expected_tb}"
+
+    def test_runtime_error(self, fs_env):
+        def test():
+            tmpl.render(fail=lambda: 1 / 0)
+
+        tmpl = fs_env.get_template("broken.html")
+        self.assert_traceback_matches(
+            test,
+            r"""
+  File ".*?broken.html", line 2, in (top-level template code|<module>)
+    \{\{ fail\(\) \}\}(
+    \^{12})?
+  File ".*debug?.pyc?", line \d+, in <lambda>
+    tmpl\.render\(fail=lambda: 1 / 0\)(
+                             ~~\^~~)?
+ZeroDivisionError: (int(eger)? )?division (or modulo )?by zero
+""",
+        )
+
+    def test_syntax_error(self, fs_env):
+        # The trailing .*? is for PyPy 2 and 3, which don't seem to
+        # clear the exception's original traceback, leaving the syntax
+        # error in the middle of other compiler frames.
+        self.assert_traceback_matches(
+            lambda: fs_env.get_template("syntaxerror.html"),
+            """(?sm)
+  File ".*?syntaxerror.html", line 4, in (template|<module>)
+    \\{% endif %\\}.*?
+(jinja2\\.exceptions\\.)?TemplateSyntaxError: Encountered unknown tag 'endif'. Jinja \
+was looking for the following tags: 'endfor' or 'else'. The innermost block that needs \
+to be closed is 'for'.
+    """,
+        )
+
+    def test_regular_syntax_error(self, fs_env):
+        def test():
+            raise TemplateSyntaxError("wtf", 42)
+
+        self.assert_traceback_matches(
+            test,
+            r"""
+  File ".*debug.pyc?", line \d+, in test
+    raise TemplateSyntaxError\("wtf", 42\)(
+    \^{36})?
+(jinja2\.exceptions\.)?TemplateSyntaxError: wtf
+  line 42""",
+        )
+
+    def test_pickleable_syntax_error(self, fs_env):
+        original = TemplateSyntaxError("bad template", 42, "test", "test.txt")
+        unpickled = pickle.loads(pickle.dumps(original))
+        assert str(original) == str(unpickled)
+        assert original.name == unpickled.name
+
+    def test_include_syntax_error_source(self, filesystem_loader):
+        e = Environment(
+            loader=ChoiceLoader(
+                [
+                    filesystem_loader,
+                    DictLoader({"inc": "a\n{% include 'syntaxerror.html' %}\nb"}),
+                ]
+            )
+        )
+        t = e.get_template("inc")
+
+        with pytest.raises(TemplateSyntaxError) as exc_info:
+            t.render()
+
+        assert exc_info.value.source is not None
+
+    def test_local_extraction(self):
+        from jinja2.debug import get_template_locals
+        from jinja2.runtime import missing
+
+        locals = get_template_locals(
+            {
+                "l_0_foo": 42,
+                "l_1_foo": 23,
+                "l_2_foo": 13,
+                "l_0_bar": 99,
+                "l_1_bar": missing,
+                "l_0_baz": missing,
+            }
+        )
+        assert locals == {"foo": 13, "bar": 99}
+
+    def test_get_corresponding_lineno_traceback(self, fs_env):
+        tmpl = fs_env.get_template("test.html")
+        assert tmpl.get_corresponding_lineno(1) == 1
diff --git a/tests/test_ext.py b/tests/test_ext.py
new file mode 100644
index 0000000..2e842e0
--- /dev/null
+++ b/tests/test_ext.py
@@ -0,0 +1,726 @@
+import re
+from io import BytesIO
+
+import pytest
+
+from jinja2 import DictLoader
+from jinja2 import Environment
+from jinja2 import nodes
+from jinja2 import pass_context
+from jinja2.exceptions import TemplateAssertionError
+from jinja2.ext import Extension
+from jinja2.lexer import count_newlines
+from jinja2.lexer import Token
+
+importable_object = 23
+
+_gettext_re = re.compile(r"_\((.*?)\)", re.DOTALL)
+
+
+i18n_templates = {
+    "default.html": '<title>{{ page_title|default(_("missing")) }}</title>'
+    "{% block body %}{% endblock %}",
+    "child.html": '{% extends "default.html" %}{% block body %}'
+    "{% trans %}watch out{% endtrans %}{% endblock %}",
+    "plural.html": "{% trans user_count %}One user online{% pluralize %}"
+    "{{ user_count }} users online{% endtrans %}",
+    "plural2.html": "{% trans user_count=get_user_count() %}{{ user_count }}s"
+    "{% pluralize %}{{ user_count }}p{% endtrans %}",
+    "stringformat.html": '{{ _("User: %(num)s")|format(num=user_count) }}',
+}
+
+newstyle_i18n_templates = {
+    "default.html": '<title>{{ page_title|default(_("missing")) }}</title>'
+    "{% block body %}{% endblock %}",
+    "child.html": '{% extends "default.html" %}{% block body %}'
+    "{% trans %}watch out{% endtrans %}{% endblock %}",
+    "plural.html": "{% trans user_count %}One user online{% pluralize %}"
+    "{{ user_count }} users online{% endtrans %}",
+    "stringformat.html": '{{ _("User: %(num)s", num=user_count) }}',
+    "ngettext.html": '{{ ngettext("%(num)s apple", "%(num)s apples", apples) }}',
+    "ngettext_long.html": "{% trans num=apples %}{{ num }} apple{% pluralize %}"
+    "{{ num }} apples{% endtrans %}",
+    "pgettext.html": '{{ pgettext("fruit", "Apple") }}',
+    "npgettext.html": '{{ npgettext("fruit", "%(num)s apple", "%(num)s apples",'
+    " apples) }}",
+    "pgettext_block": "{% trans 'fruit' num=apples %}Apple{% endtrans %}",
+    "npgettext_block": "{% trans 'fruit' num=apples %}{{ num }} apple"
+    "{% pluralize %}{{ num }} apples{% endtrans %}",
+    "transvars1.html": "{% trans %}User: {{ num }}{% endtrans %}",
+    "transvars2.html": "{% trans num=count %}User: {{ num }}{% endtrans %}",
+    "transvars3.html": "{% trans count=num %}User: {{ count }}{% endtrans %}",
+    "novars.html": "{% trans %}%(hello)s{% endtrans %}",
+    "vars.html": "{% trans %}{{ foo }}%(foo)s{% endtrans %}",
+    "explicitvars.html": '{% trans foo="42" %}%(foo)s{% endtrans %}',
+}
+
+
+languages = {
+    "de": {
+        "missing": "fehlend",
+        "watch out": "pass auf",
+        "One user online": "Ein Benutzer online",
+        "%(user_count)s users online": "%(user_count)s Benutzer online",
+        "User: %(num)s": "Benutzer: %(num)s",
+        "User: %(count)s": "Benutzer: %(count)s",
+        "Apple": {None: "Apfel", "fruit": "Apple"},
+        "%(num)s apple": {None: "%(num)s Apfel", "fruit": "%(num)s Apple"},
+        "%(num)s apples": {None: "%(num)s Äpfel", "fruit": "%(num)s Apples"},
+    }
+}
+
+
+def _get_with_context(value, ctx=None):
+    if isinstance(value, dict):
+        return value.get(ctx, value)
+
+    return value
+
+
+@pass_context
+def gettext(context, string):
+    language = context.get("LANGUAGE", "en")
+    value = languages.get(language, {}).get(string, string)
+    return _get_with_context(value)
+
+
+@pass_context
+def ngettext(context, s, p, n):
+    language = context.get("LANGUAGE", "en")
+
+    if n != 1:
+        value = languages.get(language, {}).get(p, p)
+        return _get_with_context(value)
+
+    value = languages.get(language, {}).get(s, s)
+    return _get_with_context(value)
+
+
+@pass_context
+def pgettext(context, c, s):
+    language = context.get("LANGUAGE", "en")
+    value = languages.get(language, {}).get(s, s)
+    return _get_with_context(value, c)
+
+
+@pass_context
+def npgettext(context, c, s, p, n):
+    language = context.get("LANGUAGE", "en")
+
+    if n != 1:
+        value = languages.get(language, {}).get(p, p)
+        return _get_with_context(value, c)
+
+    value = languages.get(language, {}).get(s, s)
+    return _get_with_context(value, c)
+
+
+i18n_env = Environment(
+    loader=DictLoader(i18n_templates), extensions=["jinja2.ext.i18n"]
+)
+i18n_env.globals.update(
+    {
+        "_": gettext,
+        "gettext": gettext,
+        "ngettext": ngettext,
+        "pgettext": pgettext,
+        "npgettext": npgettext,
+    }
+)
+i18n_env_trimmed = Environment(extensions=["jinja2.ext.i18n"])
+
+i18n_env_trimmed.policies["ext.i18n.trimmed"] = True
+i18n_env_trimmed.globals.update(
+    {
+        "_": gettext,
+        "gettext": gettext,
+        "ngettext": ngettext,
+        "pgettext": pgettext,
+        "npgettext": npgettext,
+    }
+)
+
+newstyle_i18n_env = Environment(
+    loader=DictLoader(newstyle_i18n_templates), extensions=["jinja2.ext.i18n"]
+)
+newstyle_i18n_env.install_gettext_callables(  # type: ignore
+    gettext, ngettext, newstyle=True, pgettext=pgettext, npgettext=npgettext
+)
+
+
+class ExampleExtension(Extension):
+    tags = {"test"}
+    ext_attr = 42
+    context_reference_node_cls = nodes.ContextReference
+
+    def parse(self, parser):
+        return nodes.Output(
+            [
+                self.call_method(
+                    "_dump",
+                    [
+                        nodes.EnvironmentAttribute("sandboxed"),
+                        self.attr("ext_attr"),
+                        nodes.ImportedName(__name__ + ".importable_object"),
+                        self.context_reference_node_cls(),
+                    ],
+                )
+            ]
+        ).set_lineno(next(parser.stream).lineno)
+
+    def _dump(self, sandboxed, ext_attr, imported_object, context):
+        return (
+            f"{sandboxed}|{ext_attr}|{imported_object}|{context.blocks}"
+            f"|{context.get('test_var')}"
+        )
+
+
+class DerivedExampleExtension(ExampleExtension):
+    context_reference_node_cls = nodes.DerivedContextReference  # type: ignore
+
+
+class PreprocessorExtension(Extension):
+    def preprocess(self, source, name, filename=None):
+        return source.replace("[[TEST]]", "({{ foo }})")
+
+
+class StreamFilterExtension(Extension):
+    def filter_stream(self, stream):
+        for token in stream:
+            if token.type == "data":
+                yield from self.interpolate(token)
+            else:
+                yield token
+
+    def interpolate(self, token):
+        pos = 0
+        end = len(token.value)
+        lineno = token.lineno
+        while True:
+            match = _gettext_re.search(token.value, pos)
+            if match is None:
+                break
+            value = token.value[pos : match.start()]
+            if value:
+                yield Token(lineno, "data", value)
+            lineno += count_newlines(token.value)
+            yield Token(lineno, "variable_begin", None)
+            yield Token(lineno, "name", "gettext")
+            yield Token(lineno, "lparen", None)
+            yield Token(lineno, "string", match.group(1))
+            yield Token(lineno, "rparen", None)
+            yield Token(lineno, "variable_end", None)
+            pos = match.end()
+        if pos < end:
+            yield Token(lineno, "data", token.value[pos:])
+
+
+class TestExtensions:
+    def test_extend_late(self):
+        env = Environment()
+        t = env.from_string('{% autoescape true %}{{ "<test>" }}{% endautoescape %}')
+        assert t.render() == "&lt;test&gt;"
+
+    def test_loop_controls(self):
+        env = Environment(extensions=["jinja2.ext.loopcontrols"])
+
+        tmpl = env.from_string(
+            """
+            {%- for item in [1, 2, 3, 4] %}
+                {%- if item % 2 == 0 %}{% continue %}{% endif -%}
+                {{ item }}
+            {%- endfor %}"""
+        )
+        assert tmpl.render() == "13"
+
+        tmpl = env.from_string(
+            """
+            {%- for item in [1, 2, 3, 4] %}
+                {%- if item > 2 %}{% break %}{% endif -%}
+                {{ item }}
+            {%- endfor %}"""
+        )
+        assert tmpl.render() == "12"
+
+    def test_do(self):
+        env = Environment(extensions=["jinja2.ext.do"])
+        tmpl = env.from_string(
+            """
+            {%- set items = [] %}
+            {%- for char in "foo" %}
+                {%- do items.append(loop.index0 ~ char) %}
+            {%- endfor %}{{ items|join(', ') }}"""
+        )
+        assert tmpl.render() == "0f, 1o, 2o"
+
+    def test_extension_nodes(self):
+        env = Environment(extensions=[ExampleExtension])
+        tmpl = env.from_string("{% test %}")
+        assert tmpl.render() == "False|42|23|{}|None"
+
+    def test_contextreference_node_passes_context(self):
+        env = Environment(extensions=[ExampleExtension])
+        tmpl = env.from_string('{% set test_var="test_content" %}{% test %}')
+        assert tmpl.render() == "False|42|23|{}|test_content"
+
+    def test_contextreference_node_can_pass_locals(self):
+        env = Environment(extensions=[DerivedExampleExtension])
+        tmpl = env.from_string(
+            '{% for test_var in ["test_content"] %}{% test %}{% endfor %}'
+        )
+        assert tmpl.render() == "False|42|23|{}|test_content"
+
+    def test_identifier(self):
+        assert ExampleExtension.identifier == __name__ + ".ExampleExtension"
+
+    def test_rebinding(self):
+        original = Environment(extensions=[ExampleExtension])
+        overlay = original.overlay()
+        for env in original, overlay:
+            for ext in env.extensions.values():
+                assert ext.environment is env
+
+    def test_preprocessor_extension(self):
+        env = Environment(extensions=[PreprocessorExtension])
+        tmpl = env.from_string("{[[TEST]]}")
+        assert tmpl.render(foo=42) == "{(42)}"
+
+    def test_streamfilter_extension(self):
+        env = Environment(extensions=[StreamFilterExtension])
+        env.globals["gettext"] = lambda x: x.upper()
+        tmpl = env.from_string("Foo _(bar) Baz")
+        out = tmpl.render()
+        assert out == "Foo BAR Baz"
+
+    def test_extension_ordering(self):
+        class T1(Extension):
+            priority = 1
+
+        class T2(Extension):
+            priority = 2
+
+        env = Environment(extensions=[T1, T2])
+        ext = list(env.iter_extensions())
+        assert ext[0].__class__ is T1
+        assert ext[1].__class__ is T2
+
+    def test_debug(self):
+        env = Environment(extensions=["jinja2.ext.debug"])
+        t = env.from_string("Hello\n{% debug %}\nGoodbye")
+        out = t.render()
+
+        for value in ("context", "cycler", "filters", "abs", "tests", "!="):
+            assert f"'{value}'" in out
+
+
+class TestInternationalization:
+    def test_trans(self):
+        tmpl = i18n_env.get_template("child.html")
+        assert tmpl.render(LANGUAGE="de") == "<title>fehlend</title>pass auf"
+
+    def test_trans_plural(self):
+        tmpl = i18n_env.get_template("plural.html")
+        assert tmpl.render(LANGUAGE="de", user_count=1) == "Ein Benutzer online"
+        assert tmpl.render(LANGUAGE="de", user_count=2) == "2 Benutzer online"
+
+    def test_trans_plural_with_functions(self):
+        tmpl = i18n_env.get_template("plural2.html")
+
+        def get_user_count():
+            get_user_count.called += 1
+            return 1
+
+        get_user_count.called = 0
+        assert tmpl.render(LANGUAGE="de", get_user_count=get_user_count) == "1s"
+        assert get_user_count.called == 1
+
+    def test_complex_plural(self):
+        tmpl = i18n_env.from_string(
+            "{% trans foo=42, count=2 %}{{ count }} item{% "
+            "pluralize count %}{{ count }} items{% endtrans %}"
+        )
+        assert tmpl.render() == "2 items"
+        pytest.raises(
+            TemplateAssertionError,
+            i18n_env.from_string,
+            "{% trans foo %}...{% pluralize bar %}...{% endtrans %}",
+        )
+
+    def test_trans_stringformatting(self):
+        tmpl = i18n_env.get_template("stringformat.html")
+        assert tmpl.render(LANGUAGE="de", user_count=5) == "Benutzer: 5"
+
+    def test_trimmed(self):
+        tmpl = i18n_env.from_string(
+            "{%- trans trimmed %}  hello\n  world  {% endtrans -%}"
+        )
+        assert tmpl.render() == "hello world"
+
+    def test_trimmed_policy(self):
+        s = "{%- trans %}  hello\n  world  {% endtrans -%}"
+        tmpl = i18n_env.from_string(s)
+        trimmed_tmpl = i18n_env_trimmed.from_string(s)
+        assert tmpl.render() == "  hello\n  world  "
+        assert trimmed_tmpl.render() == "hello world"
+
+    def test_trimmed_policy_override(self):
+        tmpl = i18n_env_trimmed.from_string(
+            "{%- trans notrimmed %}  hello\n  world  {% endtrans -%}"
+        )
+        assert tmpl.render() == "  hello\n  world  "
+
+    def test_trimmed_vars(self):
+        tmpl = i18n_env.from_string(
+            '{%- trans trimmed x="world" %}  hello\n  {{ x }} {% endtrans -%}'
+        )
+        assert tmpl.render() == "hello world"
+
+    def test_trimmed_varname_trimmed(self):
+        # unlikely variable name, but when used as a variable
+        # it should not enable trimming
+        tmpl = i18n_env.from_string(
+            "{%- trans trimmed = 'world' %}  hello\n  {{ trimmed }}  {% endtrans -%}"
+        )
+        assert tmpl.render() == "  hello\n  world  "
+
+    def test_extract(self):
+        from jinja2.ext import babel_extract
+
+        source = BytesIO(
+            b"""
+            {{ gettext('Hello World') }}
+            {% trans %}Hello World{% endtrans %}
+            {% trans %}{{ users }} user{% pluralize %}{{ users }} users{% endtrans %}
+            """
+        )
+        assert list(babel_extract(source, ("gettext", "ngettext", "_"), [], {})) == [
+            (2, "gettext", "Hello World", []),
+            (3, "gettext", "Hello World", []),
+            (4, "ngettext", ("%(users)s user", "%(users)s users", None), []),
+        ]
+
+    def test_extract_trimmed(self):
+        from jinja2.ext import babel_extract
+
+        source = BytesIO(
+            b"""
+            {{ gettext(' Hello  \n  World') }}
+            {% trans trimmed %} Hello  \n  World{% endtrans %}
+            {% trans trimmed %}{{ users }} \n user
+            {%- pluralize %}{{ users }} \n users{% endtrans %}
+            """
+        )
+        assert list(babel_extract(source, ("gettext", "ngettext", "_"), [], {})) == [
+            (2, "gettext", " Hello  \n  World", []),
+            (4, "gettext", "Hello World", []),
+            (6, "ngettext", ("%(users)s user", "%(users)s users", None), []),
+        ]
+
+    def test_extract_trimmed_option(self):
+        from jinja2.ext import babel_extract
+
+        source = BytesIO(
+            b"""
+            {{ gettext(' Hello  \n  World') }}
+            {% trans %} Hello  \n  World{% endtrans %}
+            {% trans %}{{ users }} \n user
+            {%- pluralize %}{{ users }} \n users{% endtrans %}
+            """
+        )
+        opts = {"trimmed": "true"}
+        assert list(babel_extract(source, ("gettext", "ngettext", "_"), [], opts)) == [
+            (2, "gettext", " Hello  \n  World", []),
+            (4, "gettext", "Hello World", []),
+            (6, "ngettext", ("%(users)s user", "%(users)s users", None), []),
+        ]
+
+    def test_comment_extract(self):
+        from jinja2.ext import babel_extract
+
+        source = BytesIO(
+            b"""
+            {# trans first #}
+            {{ gettext('Hello World') }}
+            {% trans %}Hello World{% endtrans %}{# trans second #}
+            {#: third #}
+            {% trans %}{{ users }} user{% pluralize %}{{ users }} users{% endtrans %}
+            """
+        )
+        assert list(
+            babel_extract(source, ("gettext", "ngettext", "_"), ["trans", ":"], {})
+        ) == [
+            (3, "gettext", "Hello World", ["first"]),
+            (4, "gettext", "Hello World", ["second"]),
+            (6, "ngettext", ("%(users)s user", "%(users)s users", None), ["third"]),
+        ]
+
+    def test_extract_context(self):
+        from jinja2.ext import babel_extract
+
+        source = BytesIO(
+            b"""
+             {{ pgettext("babel", "Hello World") }}
+             {{ npgettext("babel", "%(users)s user", "%(users)s users", users) }}
+             """
+        )
+        assert list(babel_extract(source, ("pgettext", "npgettext", "_"), [], {})) == [
+            (2, "pgettext", ("babel", "Hello World"), []),
+            (3, "npgettext", ("babel", "%(users)s user", "%(users)s users", None), []),
+        ]
+
+
+class TestScope:
+    def test_basic_scope_behavior(self):
+        # This is what the old with statement compiled down to
+        class ScopeExt(Extension):
+            tags = {"scope"}
+
+            def parse(self, parser):
+                node = nodes.Scope(lineno=next(parser.stream).lineno)
+                assignments = []
+                while parser.stream.current.type != "block_end":
+                    lineno = parser.stream.current.lineno
+                    if assignments:
+                        parser.stream.expect("comma")
+                    target = parser.parse_assign_target()
+                    parser.stream.expect("assign")
+                    expr = parser.parse_expression()
+                    assignments.append(nodes.Assign(target, expr, lineno=lineno))
+                node.body = assignments + list(
+                    parser.parse_statements(("name:endscope",), drop_needle=True)
+                )
+                return node
+
+        env = Environment(extensions=[ScopeExt])
+        tmpl = env.from_string(
+            """\
+        {%- scope a=1, b=2, c=b, d=e, e=5 -%}
+            {{ a }}|{{ b }}|{{ c }}|{{ d }}|{{ e }}
+        {%- endscope -%}
+        """
+        )
+        assert tmpl.render(b=3, e=4) == "1|2|2|4|5"
+
+
+class TestNewstyleInternationalization:
+    def test_trans(self):
+        tmpl = newstyle_i18n_env.get_template("child.html")
+        assert tmpl.render(LANGUAGE="de") == "<title>fehlend</title>pass auf"
+
+    def test_trans_plural(self):
+        tmpl = newstyle_i18n_env.get_template("plural.html")
+        assert tmpl.render(LANGUAGE="de", user_count=1) == "Ein Benutzer online"
+        assert tmpl.render(LANGUAGE="de", user_count=2) == "2 Benutzer online"
+
+    def test_complex_plural(self):
+        tmpl = newstyle_i18n_env.from_string(
+            "{% trans foo=42, count=2 %}{{ count }} item{% "
+            "pluralize count %}{{ count }} items{% endtrans %}"
+        )
+        assert tmpl.render() == "2 items"
+        pytest.raises(
+            TemplateAssertionError,
+            i18n_env.from_string,
+            "{% trans foo %}...{% pluralize bar %}...{% endtrans %}",
+        )
+
+    def test_trans_stringformatting(self):
+        tmpl = newstyle_i18n_env.get_template("stringformat.html")
+        assert tmpl.render(LANGUAGE="de", user_count=5) == "Benutzer: 5"
+
+    def test_newstyle_plural(self):
+        tmpl = newstyle_i18n_env.get_template("ngettext.html")
+        assert tmpl.render(LANGUAGE="de", apples=1) == "1 Apfel"
+        assert tmpl.render(LANGUAGE="de", apples=5) == "5 Äpfel"
+
+    def test_autoescape_support(self):
+        env = Environment(extensions=["jinja2.ext.i18n"])
+        env.install_gettext_callables(
+            lambda x: "<strong>Wert: %(name)s</strong>",
+            lambda s, p, n: s,
+            newstyle=True,
+        )
+        t = env.from_string(
+            '{% autoescape ae %}{{ gettext("foo", name='
+            '"<test>") }}{% endautoescape %}'
+        )
+        assert t.render(ae=True) == "<strong>Wert: &lt;test&gt;</strong>"
+        assert t.render(ae=False) == "<strong>Wert: <test></strong>"
+
+    def test_autoescape_macros(self):
+        env = Environment(autoescape=False)
+        template = (
+            "{% macro m() %}<html>{% endmacro %}"
+            "{% autoescape true %}{{ m() }}{% endautoescape %}"
+        )
+        assert env.from_string(template).render() == "<html>"
+
+    def test_num_used_twice(self):
+        tmpl = newstyle_i18n_env.get_template("ngettext_long.html")
+        assert tmpl.render(apples=5, LANGUAGE="de") == "5 Äpfel"
+
+    def test_num_called_num(self):
+        source = newstyle_i18n_env.compile(
+            """
+            {% trans num=3 %}{{ num }} apple{% pluralize
+            %}{{ num }} apples{% endtrans %}
+        """,
+            raw=True,
+        )
+        # quite hacky, but the only way to properly test that.  The idea is
+        # that the generated code does not pass num twice (although that
+        # would work) for better performance.  This only works on the
+        # newstyle gettext of course
+        assert (
+            re.search(r"u?'%\(num\)s apple', u?'%\(num\)s apples', 3", source)
+            is not None
+        )
+
+    def test_trans_vars(self):
+        t1 = newstyle_i18n_env.get_template("transvars1.html")
+        t2 = newstyle_i18n_env.get_template("transvars2.html")
+        t3 = newstyle_i18n_env.get_template("transvars3.html")
+        assert t1.render(num=1, LANGUAGE="de") == "Benutzer: 1"
+        assert t2.render(count=23, LANGUAGE="de") == "Benutzer: 23"
+        assert t3.render(num=42, LANGUAGE="de") == "Benutzer: 42"
+
+    def test_novars_vars_escaping(self):
+        t = newstyle_i18n_env.get_template("novars.html")
+        assert t.render() == "%(hello)s"
+        t = newstyle_i18n_env.get_template("vars.html")
+        assert t.render(foo="42") == "42%(foo)s"
+        t = newstyle_i18n_env.get_template("explicitvars.html")
+        assert t.render() == "%(foo)s"
+
+    def test_context(self):
+        tmpl = newstyle_i18n_env.get_template("pgettext.html")
+        assert tmpl.render(LANGUAGE="de") == "Apple"
+
+    def test_context_plural(self):
+        tmpl = newstyle_i18n_env.get_template("npgettext.html")
+        assert tmpl.render(LANGUAGE="de", apples=1) == "1 Apple"
+        assert tmpl.render(LANGUAGE="de", apples=5) == "5 Apples"
+
+    def test_context_block(self):
+        tmpl = newstyle_i18n_env.get_template("pgettext_block")
+        assert tmpl.render(LANGUAGE="de") == "Apple"
+
+    def test_context_plural_block(self):
+        tmpl = newstyle_i18n_env.get_template("npgettext_block")
+        assert tmpl.render(LANGUAGE="de", apples=1) == "1 Apple"
+        assert tmpl.render(LANGUAGE="de", apples=5) == "5 Apples"
+
+
+class TestAutoEscape:
+    def test_scoped_setting(self):
+        env = Environment(autoescape=True)
+        tmpl = env.from_string(
+            """
+            {{ "<HelloWorld>" }}
+            {% autoescape false %}
+                {{ "<HelloWorld>" }}
+            {% endautoescape %}
+            {{ "<HelloWorld>" }}
+        """
+        )
+        assert tmpl.render().split() == [
+            "&lt;HelloWorld&gt;",
+            "<HelloWorld>",
+            "&lt;HelloWorld&gt;",
+        ]
+
+        env = Environment(autoescape=False)
+        tmpl = env.from_string(
+            """
+            {{ "<HelloWorld>" }}
+            {% autoescape true %}
+                {{ "<HelloWorld>" }}
+            {% endautoescape %}
+            {{ "<HelloWorld>" }}
+        """
+        )
+        assert tmpl.render().split() == [
+            "<HelloWorld>",
+            "&lt;HelloWorld&gt;",
+            "<HelloWorld>",
+        ]
+
+    def test_nonvolatile(self):
+        env = Environment(autoescape=True)
+        tmpl = env.from_string('{{ {"foo": "<test>"}|xmlattr|escape }}')
+        assert tmpl.render() == ' foo="&lt;test&gt;"'
+        tmpl = env.from_string(
+            '{% autoescape false %}{{ {"foo": "<test>"}'
+            "|xmlattr|escape }}{% endautoescape %}"
+        )
+        assert tmpl.render() == " foo=&#34;&amp;lt;test&amp;gt;&#34;"
+
+    def test_volatile(self):
+        env = Environment(autoescape=True)
+        tmpl = env.from_string(
+            '{% autoescape foo %}{{ {"foo": "<test>"}'
+            "|xmlattr|escape }}{% endautoescape %}"
+        )
+        assert tmpl.render(foo=False) == " foo=&#34;&amp;lt;test&amp;gt;&#34;"
+        assert tmpl.render(foo=True) == ' foo="&lt;test&gt;"'
+
+    def test_scoping(self):
+        env = Environment()
+        tmpl = env.from_string(
+            '{% autoescape true %}{% set x = "<x>" %}{{ x }}'
+            '{% endautoescape %}{{ x }}{{ "<y>" }}'
+        )
+        assert tmpl.render(x=1) == "&lt;x&gt;1<y>"
+
+    def test_volatile_scoping(self):
+        env = Environment()
+        tmplsource = """
+        {% autoescape val %}
+            {% macro foo(x) %}
+                [{{ x }}]
+            {% endmacro %}
+            {{ foo().__class__.__name__ }}
+        {% endautoescape %}
+        {{ '<testing>' }}
+        """
+        tmpl = env.from_string(tmplsource)
+        assert tmpl.render(val=True).split()[0] == "Markup"
+        assert tmpl.render(val=False).split()[0] == "str"
+
+        # looking at the source we should see <testing> there in raw
+        # (and then escaped as well)
+        env = Environment()
+        pysource = env.compile(tmplsource, raw=True)
+        assert "<testing>\\n" in pysource
+
+        env = Environment(autoescape=True)
+        pysource = env.compile(tmplsource, raw=True)
+        assert "&lt;testing&gt;\\n" in pysource
+
+    def test_overlay_scopes(self):
+        class MagicScopeExtension(Extension):
+            tags = {"overlay"}
+
+            def parse(self, parser):
+                node = nodes.OverlayScope(lineno=next(parser.stream).lineno)
+                node.body = list(
+                    parser.parse_statements(("name:endoverlay",), drop_needle=True)
+                )
+                node.context = self.call_method("get_scope")
+                return node
+
+            def get_scope(self):
+                return {"x": [1, 2, 3]}
+
+        env = Environment(extensions=[MagicScopeExtension])
+
+        tmpl = env.from_string(
+            """
+            {{- x }}|{% set z = 99 %}
+            {%- overlay %}
+                {{- y }}|{{ z }}|{% for item in x %}[{{ item }}]{% endfor %}
+            {%- endoverlay %}|
+            {{- x -}}
+        """
+        )
+        assert tmpl.render(x=42, y=23) == "42|23|99|[1][2][3]|42"
diff --git a/tests/test_filters.py b/tests/test_filters.py
new file mode 100644
index 0000000..73f0f0b
--- /dev/null
+++ b/tests/test_filters.py
@@ -0,0 +1,873 @@
+import random
+from collections import namedtuple
+
+import pytest
+from markupsafe import Markup
+
+from jinja2 import Environment
+from jinja2 import StrictUndefined
+from jinja2 import TemplateRuntimeError
+from jinja2 import UndefinedError
+from jinja2.exceptions import TemplateAssertionError
+
+
+class Magic:
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return str(self.value)
+
+
+class Magic2:
+    def __init__(self, value1, value2):
+        self.value1 = value1
+        self.value2 = value2
+
+    def __str__(self):
+        return f"({self.value1},{self.value2})"
+
+
+class TestFilter:
+    def test_filter_calling(self, env):
+        rv = env.call_filter("sum", [1, 2, 3])
+        assert rv == 6
+
+    def test_capitalize(self, env):
+        tmpl = env.from_string('{{ "foo bar"|capitalize }}')
+        assert tmpl.render() == "Foo bar"
+
+    def test_center(self, env):
+        tmpl = env.from_string('{{ "foo"|center(9) }}')
+        assert tmpl.render() == "   foo   "
+
+    def test_default(self, env):
+        tmpl = env.from_string(
+            "{{ missing|default('no') }}|{{ false|default('no') }}|"
+            "{{ false|default('no', true) }}|{{ given|default('no') }}"
+        )
+        assert tmpl.render(given="yes") == "no|False|no|yes"
+
+    @pytest.mark.parametrize(
+        "args,expect",
+        (
+            ("", "[('aa', 0), ('AB', 3), ('b', 1), ('c', 2)]"),
+            ("true", "[('AB', 3), ('aa', 0), ('b', 1), ('c', 2)]"),
+            ('by="value"', "[('aa', 0), ('b', 1), ('c', 2), ('AB', 3)]"),
+            ("reverse=true", "[('c', 2), ('b', 1), ('AB', 3), ('aa', 0)]"),
+        ),
+    )
+    def test_dictsort(self, env, args, expect):
+        t = env.from_string(f"{{{{ foo|dictsort({args}) }}}}")
+        out = t.render(foo={"aa": 0, "b": 1, "c": 2, "AB": 3})
+        assert out == expect
+
+    def test_batch(self, env):
+        tmpl = env.from_string("{{ foo|batch(3)|list }}|{{ foo|batch(3, 'X')|list }}")
+        out = tmpl.render(foo=list(range(10)))
+        assert out == (
+            "[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]|"
+            "[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 'X', 'X']]"
+        )
+
+    def test_slice(self, env):
+        tmpl = env.from_string("{{ foo|slice(3)|list }}|{{ foo|slice(3, 'X')|list }}")
+        out = tmpl.render(foo=list(range(10)))
+        assert out == (
+            "[[0, 1, 2, 3], [4, 5, 6], [7, 8, 9]]|"
+            "[[0, 1, 2, 3], [4, 5, 6, 'X'], [7, 8, 9, 'X']]"
+        )
+
+    def test_escape(self, env):
+        tmpl = env.from_string("""{{ '<">&'|escape }}""")
+        out = tmpl.render()
+        assert out == "&lt;&#34;&gt;&amp;"
+
+    @pytest.mark.parametrize(
+        ("chars", "expect"), [(None, "..stays.."), (".", "  ..stays"), (" .", "stays")]
+    )
+    def test_trim(self, env, chars, expect):
+        tmpl = env.from_string("{{ foo|trim(chars) }}")
+        out = tmpl.render(foo="  ..stays..", chars=chars)
+        assert out == expect
+
+    def test_striptags(self, env):
+        tmpl = env.from_string("""{{ foo|striptags }}""")
+        out = tmpl.render(
+            foo='  <p>just a small   \n <a href="#">'
+            "example</a> link</p>\n<p>to a webpage</p> "
+            "<!-- <p>and some commented stuff</p> -->"
+        )
+        assert out == "just a small example link to a webpage"
+
+    def test_filesizeformat(self, env):
+        tmpl = env.from_string(
+            "{{ 100|filesizeformat }}|"
+            "{{ 1000|filesizeformat }}|"
+            "{{ 1000000|filesizeformat }}|"
+            "{{ 1000000000|filesizeformat }}|"
+            "{{ 1000000000000|filesizeformat }}|"
+            "{{ 100|filesizeformat(true) }}|"
+            "{{ 1000|filesizeformat(true) }}|"
+            "{{ 1000000|filesizeformat(true) }}|"
+            "{{ 1000000000|filesizeformat(true) }}|"
+            "{{ 1000000000000|filesizeformat(true) }}"
+        )
+        out = tmpl.render()
+        assert out == (
+            "100 Bytes|1.0 kB|1.0 MB|1.0 GB|1.0 TB|100 Bytes|"
+            "1000 Bytes|976.6 KiB|953.7 MiB|931.3 GiB"
+        )
+
+    def test_filesizeformat_issue59(self, env):
+        tmpl = env.from_string(
+            "{{ 300|filesizeformat }}|"
+            "{{ 3000|filesizeformat }}|"
+            "{{ 3000000|filesizeformat }}|"
+            "{{ 3000000000|filesizeformat }}|"
+            "{{ 3000000000000|filesizeformat }}|"
+            "{{ 300|filesizeformat(true) }}|"
+            "{{ 3000|filesizeformat(true) }}|"
+            "{{ 3000000|filesizeformat(true) }}"
+        )
+        out = tmpl.render()
+        assert out == (
+            "300 Bytes|3.0 kB|3.0 MB|3.0 GB|3.0 TB|300 Bytes|2.9 KiB|2.9 MiB"
+        )
+
+    def test_first(self, env):
+        tmpl = env.from_string("{{ foo|first }}")
+        out = tmpl.render(foo=list(range(10)))
+        assert out == "0"
+
+    @pytest.mark.parametrize(
+        ("value", "expect"), (("42", "42.0"), ("abc", "0.0"), ("32.32", "32.32"))
+    )
+    def test_float(self, env, value, expect):
+        t = env.from_string("{{ value|float }}")
+        assert t.render(value=value) == expect
+
+    def test_float_default(self, env):
+        t = env.from_string("{{ value|float(default=1.0) }}")
+        assert t.render(value="abc") == "1.0"
+
+    def test_format(self, env):
+        tmpl = env.from_string("{{ '%s|%s'|format('a', 'b') }}")
+        out = tmpl.render()
+        assert out == "a|b"
+
+    @staticmethod
+    def _test_indent_multiline_template(env, markup=False):
+        text = "\n".join(["", "foo bar", '"baz"', ""])
+        if markup:
+            text = Markup(text)
+        t = env.from_string("{{ foo|indent(2, false, false) }}")
+        assert t.render(foo=text) == '\n  foo bar\n  "baz"\n'
+        t = env.from_string("{{ foo|indent(2, false, true) }}")
+        assert t.render(foo=text) == '\n  foo bar\n  "baz"\n  '
+        t = env.from_string("{{ foo|indent(2, true, false) }}")
+        assert t.render(foo=text) == '  \n  foo bar\n  "baz"\n'
+        t = env.from_string("{{ foo|indent(2, true, true) }}")
+        assert t.render(foo=text) == '  \n  foo bar\n  "baz"\n  '
+
+    def test_indent(self, env):
+        self._test_indent_multiline_template(env)
+        t = env.from_string('{{ "jinja"|indent }}')
+        assert t.render() == "jinja"
+        t = env.from_string('{{ "jinja"|indent(first=true) }}')
+        assert t.render() == "    jinja"
+        t = env.from_string('{{ "jinja"|indent(blank=true) }}')
+        assert t.render() == "jinja"
+
+    def test_indent_markup_input(self, env):
+        """
+        Tests cases where the filter input is a Markup type
+        """
+        self._test_indent_multiline_template(env, markup=True)
+
+    def test_indent_width_string(self, env):
+        t = env.from_string("{{ 'jinja\nflask'|indent(width='>>> ', first=True) }}")
+        assert t.render() == ">>> jinja\n>>> flask"
+
+    @pytest.mark.parametrize(
+        ("value", "expect"),
+        (
+            ("42", "42"),
+            ("abc", "0"),
+            ("32.32", "32"),
+            ("12345678901234567890", "12345678901234567890"),
+        ),
+    )
+    def test_int(self, env, value, expect):
+        t = env.from_string("{{ value|int }}")
+        assert t.render(value=value) == expect
+
+    @pytest.mark.parametrize(
+        ("value", "base", "expect"),
+        (("0x4d32", 16, "19762"), ("011", 8, "9"), ("0x33Z", 16, "0")),
+    )
+    def test_int_base(self, env, value, base, expect):
+        t = env.from_string("{{ value|int(base=base) }}")
+        assert t.render(value=value, base=base) == expect
+
+    def test_int_default(self, env):
+        t = env.from_string("{{ value|int(default=1) }}")
+        assert t.render(value="abc") == "1"
+
+    def test_int_special_method(self, env):
+        class IntIsh:
+            def __int__(self):
+                return 42
+
+        t = env.from_string("{{ value|int }}")
+        assert t.render(value=IntIsh()) == "42"
+
+    def test_join(self, env):
+        tmpl = env.from_string('{{ [1, 2, 3]|join("|") }}')
+        out = tmpl.render()
+        assert out == "1|2|3"
+
+        env2 = Environment(autoescape=True)
+        tmpl = env2.from_string('{{ ["<foo>", "<span>foo</span>"|safe]|join }}')
+        assert tmpl.render() == "&lt;foo&gt;<span>foo</span>"
+
+    def test_join_attribute(self, env):
+        User = namedtuple("User", "username")
+        tmpl = env.from_string("""{{ users|join(', ', 'username') }}""")
+        assert tmpl.render(users=map(User, ["foo", "bar"])) == "foo, bar"
+
+    def test_last(self, env):
+        tmpl = env.from_string("""{{ foo|last }}""")
+        out = tmpl.render(foo=list(range(10)))
+        assert out == "9"
+
+    def test_length(self, env):
+        tmpl = env.from_string("""{{ "hello world"|length }}""")
+        out = tmpl.render()
+        assert out == "11"
+
+    def test_lower(self, env):
+        tmpl = env.from_string("""{{ "FOO"|lower }}""")
+        out = tmpl.render()
+        assert out == "foo"
+
+    def test_items(self, env):
+        d = {i: c for i, c in enumerate("abc")}
+        tmpl = env.from_string("""{{ d|items|list }}""")
+        out = tmpl.render(d=d)
+        assert out == "[(0, 'a'), (1, 'b'), (2, 'c')]"
+
+    def test_items_undefined(self, env):
+        tmpl = env.from_string("""{{ d|items|list }}""")
+        out = tmpl.render()
+        assert out == "[]"
+
+    def test_pprint(self, env):
+        from pprint import pformat
+
+        tmpl = env.from_string("""{{ data|pprint }}""")
+        data = list(range(1000))
+        assert tmpl.render(data=data) == pformat(data)
+
+    def test_random(self, env, request):
+        # restore the random state when the test ends
+        state = random.getstate()
+        request.addfinalizer(lambda: random.setstate(state))
+        # generate the random values from a known seed
+        random.seed("jinja")
+        expected = [random.choice("1234567890") for _ in range(10)]
+
+        # check that the random sequence is generated again by a template
+        # ensures that filter result is not constant folded
+        random.seed("jinja")
+        t = env.from_string('{{ "1234567890"|random }}')
+
+        for value in expected:
+            assert t.render() == value
+
+    def test_reverse(self, env):
+        tmpl = env.from_string(
+            "{{ 'foobar'|reverse|join }}|{{ [1, 2, 3]|reverse|list }}"
+        )
+        assert tmpl.render() == "raboof|[3, 2, 1]"
+
+    def test_string(self, env):
+        x = [1, 2, 3, 4, 5]
+        tmpl = env.from_string("""{{ obj|string }}""")
+        assert tmpl.render(obj=x) == str(x)
+
+    def test_title(self, env):
+        tmpl = env.from_string("""{{ "foo bar"|title }}""")
+        assert tmpl.render() == "Foo Bar"
+        tmpl = env.from_string("""{{ "foo's bar"|title }}""")
+        assert tmpl.render() == "Foo's Bar"
+        tmpl = env.from_string("""{{ "foo   bar"|title }}""")
+        assert tmpl.render() == "Foo   Bar"
+        tmpl = env.from_string("""{{ "f bar f"|title }}""")
+        assert tmpl.render() == "F Bar F"
+        tmpl = env.from_string("""{{ "foo-bar"|title }}""")
+        assert tmpl.render() == "Foo-Bar"
+        tmpl = env.from_string("""{{ "foo\tbar"|title }}""")
+        assert tmpl.render() == "Foo\tBar"
+        tmpl = env.from_string("""{{ "FOO\tBAR"|title }}""")
+        assert tmpl.render() == "Foo\tBar"
+        tmpl = env.from_string("""{{ "foo (bar)"|title }}""")
+        assert tmpl.render() == "Foo (Bar)"
+        tmpl = env.from_string("""{{ "foo {bar}"|title }}""")
+        assert tmpl.render() == "Foo {Bar}"
+        tmpl = env.from_string("""{{ "foo [bar]"|title }}""")
+        assert tmpl.render() == "Foo [Bar]"
+        tmpl = env.from_string("""{{ "foo <bar>"|title }}""")
+        assert tmpl.render() == "Foo <Bar>"
+
+        class Foo:
+            def __str__(self):
+                return "foo-bar"
+
+        tmpl = env.from_string("""{{ data|title }}""")
+        out = tmpl.render(data=Foo())
+        assert out == "Foo-Bar"
+
+    def test_truncate(self, env):
+        tmpl = env.from_string(
+            '{{ data|truncate(15, true, ">>>") }}|'
+            '{{ data|truncate(15, false, ">>>") }}|'
+            "{{ smalldata|truncate(15) }}"
+        )
+        out = tmpl.render(data="foobar baz bar" * 1000, smalldata="foobar baz bar")
+        assert out == "foobar baz b>>>|foobar baz>>>|foobar baz bar"
+
+    def test_truncate_very_short(self, env):
+        tmpl = env.from_string(
+            '{{ "foo bar baz"|truncate(9) }}|{{ "foo bar baz"|truncate(9, true) }}'
+        )
+        out = tmpl.render()
+        assert out == "foo bar baz|foo bar baz"
+
+    def test_truncate_end_length(self, env):
+        tmpl = env.from_string('{{ "Joel is a slug"|truncate(7, true) }}')
+        out = tmpl.render()
+        assert out == "Joel..."
+
+    def test_upper(self, env):
+        tmpl = env.from_string('{{ "foo"|upper }}')
+        assert tmpl.render() == "FOO"
+
+    def test_urlize(self, env):
+        tmpl = env.from_string('{{ "foo example.org bar"|urlize }}')
+        assert tmpl.render() == (
+            'foo <a href="https://example.org" rel="noopener">' "example.org</a> bar"
+        )
+        tmpl = env.from_string('{{ "foo http://www.example.com/ bar"|urlize }}')
+        assert tmpl.render() == (
+            'foo <a href="http://www.example.com/" rel="noopener">'
+            "http://www.example.com/</a> bar"
+        )
+        tmpl = env.from_string('{{ "foo mailto:email@example.com bar"|urlize }}')
+        assert tmpl.render() == (
+            'foo <a href="mailto:email@example.com">email@example.com</a> bar'
+        )
+        tmpl = env.from_string('{{ "foo email@example.com bar"|urlize }}')
+        assert tmpl.render() == (
+            'foo <a href="mailto:email@example.com">email@example.com</a> bar'
+        )
+
+    def test_urlize_rel_policy(self):
+        env = Environment()
+        env.policies["urlize.rel"] = None
+        tmpl = env.from_string('{{ "foo http://www.example.com/ bar"|urlize }}')
+        assert tmpl.render() == (
+            'foo <a href="http://www.example.com/">http://www.example.com/</a> bar'
+        )
+
+    def test_urlize_target_parameter(self, env):
+        tmpl = env.from_string(
+            '{{ "foo http://www.example.com/ bar"|urlize(target="_blank") }}'
+        )
+        assert (
+            tmpl.render()
+            == 'foo <a href="http://www.example.com/" rel="noopener" target="_blank">'
+            "http://www.example.com/</a> bar"
+        )
+
+    def test_urlize_extra_schemes_parameter(self, env):
+        tmpl = env.from_string(
+            '{{ "foo tel:+1-514-555-1234 ftp://localhost bar"|'
+            'urlize(extra_schemes=["tel:", "ftp:"]) }}'
+        )
+        assert tmpl.render() == (
+            'foo <a href="tel:+1-514-555-1234" rel="noopener">'
+            'tel:+1-514-555-1234</a> <a href="ftp://localhost" rel="noopener">'
+            "ftp://localhost</a> bar"
+        )
+
+    def test_wordcount(self, env):
+        tmpl = env.from_string('{{ "foo bar baz"|wordcount }}')
+        assert tmpl.render() == "3"
+
+        strict_env = Environment(undefined=StrictUndefined)
+        t = strict_env.from_string("{{ s|wordcount }}")
+        with pytest.raises(UndefinedError):
+            t.render()
+
+    def test_block(self, env):
+        tmpl = env.from_string("{% filter lower|escape %}<HEHE>{% endfilter %}")
+        assert tmpl.render() == "&lt;hehe&gt;"
+
+    def test_chaining(self, env):
+        tmpl = env.from_string("""{{ ['<foo>', '<bar>']|first|upper|escape }}""")
+        assert tmpl.render() == "&lt;FOO&gt;"
+
+    def test_sum(self, env):
+        tmpl = env.from_string("""{{ [1, 2, 3, 4, 5, 6]|sum }}""")
+        assert tmpl.render() == "21"
+
+    def test_sum_attributes(self, env):
+        tmpl = env.from_string("""{{ values|sum('value') }}""")
+        assert tmpl.render(values=[{"value": 23}, {"value": 1}, {"value": 18}]) == "42"
+
+    def test_sum_attributes_nested(self, env):
+        tmpl = env.from_string("""{{ values|sum('real.value') }}""")
+        assert (
+            tmpl.render(
+                values=[
+                    {"real": {"value": 23}},
+                    {"real": {"value": 1}},
+                    {"real": {"value": 18}},
+                ]
+            )
+            == "42"
+        )
+
+    def test_sum_attributes_tuple(self, env):
+        tmpl = env.from_string("""{{ values.items()|sum('1') }}""")
+        assert tmpl.render(values={"foo": 23, "bar": 1, "baz": 18}) == "42"
+
+    def test_abs(self, env):
+        tmpl = env.from_string("""{{ -1|abs }}|{{ 1|abs }}""")
+        assert tmpl.render() == "1|1", tmpl.render()
+
+    def test_round_positive(self, env):
+        tmpl = env.from_string(
+            "{{ 2.7|round }}|{{ 2.1|round }}|"
+            "{{ 2.1234|round(3, 'floor') }}|"
+            "{{ 2.1|round(0, 'ceil') }}"
+        )
+        assert tmpl.render() == "3.0|2.0|2.123|3.0", tmpl.render()
+
+    def test_round_negative(self, env):
+        tmpl = env.from_string(
+            "{{ 21.3|round(-1)}}|"
+            "{{ 21.3|round(-1, 'ceil')}}|"
+            "{{ 21.3|round(-1, 'floor')}}"
+        )
+        assert tmpl.render() == "20.0|30.0|20.0", tmpl.render()
+
+    def test_xmlattr(self, env):
+        tmpl = env.from_string(
+            "{{ {'foo': 42, 'bar': 23, 'fish': none, "
+            "'spam': missing, 'blub:blub': '<?>'}|xmlattr }}"
+        )
+        out = tmpl.render().split()
+        assert len(out) == 3
+        assert 'foo="42"' in out
+        assert 'bar="23"' in out
+        assert 'blub:blub="&lt;?&gt;"' in out
+
+    def test_sort1(self, env):
+        tmpl = env.from_string("{{ [2, 3, 1]|sort }}|{{ [2, 3, 1]|sort(true) }}")
+        assert tmpl.render() == "[1, 2, 3]|[3, 2, 1]"
+
+    def test_sort2(self, env):
+        tmpl = env.from_string('{{ "".join(["c", "A", "b", "D"]|sort) }}')
+        assert tmpl.render() == "AbcD"
+
+    def test_sort3(self, env):
+        tmpl = env.from_string("""{{ ['foo', 'Bar', 'blah']|sort }}""")
+        assert tmpl.render() == "['Bar', 'blah', 'foo']"
+
+    def test_sort4(self, env):
+        tmpl = env.from_string("""{{ items|sort(attribute='value')|join }}""")
+        assert tmpl.render(items=map(Magic, [3, 2, 4, 1])) == "1234"
+
+    def test_sort5(self, env):
+        tmpl = env.from_string("""{{ items|sort(attribute='value.0')|join }}""")
+        assert tmpl.render(items=map(Magic, [[3], [2], [4], [1]])) == "[1][2][3][4]"
+
+    def test_sort6(self, env):
+        tmpl = env.from_string("""{{ items|sort(attribute='value1,value2')|join }}""")
+        assert (
+            tmpl.render(
+                items=map(
+                    lambda x: Magic2(x[0], x[1]), [(3, 1), (2, 2), (2, 1), (2, 5)]
+                )
+            )
+            == "(2,1)(2,2)(2,5)(3,1)"
+        )
+
+    def test_sort7(self, env):
+        tmpl = env.from_string("""{{ items|sort(attribute='value2,value1')|join }}""")
+        assert (
+            tmpl.render(
+                items=map(
+                    lambda x: Magic2(x[0], x[1]), [(3, 1), (2, 2), (2, 1), (2, 5)]
+                )
+            )
+            == "(2,1)(3,1)(2,2)(2,5)"
+        )
+
+    def test_sort8(self, env):
+        tmpl = env.from_string(
+            """{{ items|sort(attribute='value1.0,value2.0')|join }}"""
+        )
+        assert (
+            tmpl.render(
+                items=map(
+                    lambda x: Magic2(x[0], x[1]),
+                    [([3], [1]), ([2], [2]), ([2], [1]), ([2], [5])],
+                )
+            )
+            == "([2],[1])([2],[2])([2],[5])([3],[1])"
+        )
+
+    def test_unique(self, env):
+        t = env.from_string('{{ "".join(["b", "A", "a", "b"]|unique) }}')
+        assert t.render() == "bA"
+
+    def test_unique_case_sensitive(self, env):
+        t = env.from_string('{{ "".join(["b", "A", "a", "b"]|unique(true)) }}')
+        assert t.render() == "bAa"
+
+    def test_unique_attribute(self, env):
+        t = env.from_string("{{ items|unique(attribute='value')|join }}")
+        assert t.render(items=map(Magic, [3, 2, 4, 1, 2])) == "3241"
+
+    @pytest.mark.parametrize(
+        "source,expect",
+        (
+            ('{{ ["a", "B"]|min }}', "a"),
+            ('{{ ["a", "B"]|min(case_sensitive=true) }}', "B"),
+            ("{{ []|min }}", ""),
+            ('{{ ["a", "B"]|max }}', "B"),
+            ('{{ ["a", "B"]|max(case_sensitive=true) }}', "a"),
+            ("{{ []|max }}", ""),
+        ),
+    )
+    def test_min_max(self, env, source, expect):
+        t = env.from_string(source)
+        assert t.render() == expect
+
+    @pytest.mark.parametrize(("name", "expect"), [("min", "1"), ("max", "9")])
+    def test_min_max_attribute(self, env, name, expect):
+        t = env.from_string("{{ items|" + name + '(attribute="value") }}')
+        assert t.render(items=map(Magic, [5, 1, 9])) == expect
+
+    def test_groupby(self, env):
+        tmpl = env.from_string(
+            """
+        {%- for grouper, list in [{'foo': 1, 'bar': 2},
+                                  {'foo': 2, 'bar': 3},
+                                  {'foo': 1, 'bar': 1},
+                                  {'foo': 3, 'bar': 4}]|groupby('foo') -%}
+            {{ grouper }}{% for x in list %}: {{ x.foo }}, {{ x.bar }}{% endfor %}|
+        {%- endfor %}"""
+        )
+        assert tmpl.render().split("|") == ["1: 1, 2: 1, 1", "2: 2, 3", "3: 3, 4", ""]
+
+    def test_groupby_tuple_index(self, env):
+        tmpl = env.from_string(
+            """
+        {%- for grouper, list in [('a', 1), ('a', 2), ('b', 1)]|groupby(0) -%}
+            {{ grouper }}{% for x in list %}:{{ x.1 }}{% endfor %}|
+        {%- endfor %}"""
+        )
+        assert tmpl.render() == "a:1:2|b:1|"
+
+    def test_groupby_multidot(self, env):
+        Date = namedtuple("Date", "day,month,year")
+        Article = namedtuple("Article", "title,date")
+        articles = [
+            Article("aha", Date(1, 1, 1970)),
+            Article("interesting", Date(2, 1, 1970)),
+            Article("really?", Date(3, 1, 1970)),
+            Article("totally not", Date(1, 1, 1971)),
+        ]
+        tmpl = env.from_string(
+            """
+        {%- for year, list in articles|groupby('date.year') -%}
+            {{ year }}{% for x in list %}[{{ x.title }}]{% endfor %}|
+        {%- endfor %}"""
+        )
+        assert tmpl.render(articles=articles).split("|") == [
+            "1970[aha][interesting][really?]",
+            "1971[totally not]",
+            "",
+        ]
+
+    def test_groupby_default(self, env):
+        tmpl = env.from_string(
+            "{% for city, items in users|groupby('city', default='NY') %}"
+            "{{ city }}: {{ items|map(attribute='name')|join(', ') }}\n"
+            "{% endfor %}"
+        )
+        out = tmpl.render(
+            users=[
+                {"name": "emma", "city": "NY"},
+                {"name": "smith", "city": "WA"},
+                {"name": "john"},
+            ]
+        )
+        assert out == "NY: emma, john\nWA: smith\n"
+
+    @pytest.mark.parametrize(
+        ("case_sensitive", "expect"),
+        [
+            (False, "a: 1, 3\nb: 2\n"),
+            (True, "A: 3\na: 1\nb: 2\n"),
+        ],
+    )
+    def test_groupby_case(self, env, case_sensitive, expect):
+        tmpl = env.from_string(
+            "{% for k, vs in data|groupby('k', case_sensitive=cs) %}"
+            "{{ k }}: {{ vs|join(', ', attribute='v') }}\n"
+            "{% endfor %}"
+        )
+        out = tmpl.render(
+            data=[{"k": "a", "v": 1}, {"k": "b", "v": 2}, {"k": "A", "v": 3}],
+            cs=case_sensitive,
+        )
+        assert out == expect
+
+    def test_filtertag(self, env):
+        tmpl = env.from_string(
+            "{% filter upper|replace('FOO', 'foo') %}foobar{% endfilter %}"
+        )
+        assert tmpl.render() == "fooBAR"
+
+    def test_replace(self, env):
+        env = Environment()
+        tmpl = env.from_string('{{ string|replace("o", 42) }}')
+        assert tmpl.render(string="<foo>") == "<f4242>"
+        env = Environment(autoescape=True)
+        tmpl = env.from_string('{{ string|replace("o", 42) }}')
+        assert tmpl.render(string="<foo>") == "&lt;f4242&gt;"
+        tmpl = env.from_string('{{ string|replace("<", 42) }}')
+        assert tmpl.render(string="<foo>") == "42foo&gt;"
+        tmpl = env.from_string('{{ string|replace("o", ">x<") }}')
+        assert tmpl.render(string=Markup("foo")) == "f&gt;x&lt;&gt;x&lt;"
+
+    def test_forceescape(self, env):
+        tmpl = env.from_string("{{ x|forceescape }}")
+        assert tmpl.render(x=Markup("<div />")) == "&lt;div /&gt;"
+
+    def test_safe(self, env):
+        env = Environment(autoescape=True)
+        tmpl = env.from_string('{{ "<div>foo</div>"|safe }}')
+        assert tmpl.render() == "<div>foo</div>"
+        tmpl = env.from_string('{{ "<div>foo</div>" }}')
+        assert tmpl.render() == "&lt;div&gt;foo&lt;/div&gt;"
+
+    @pytest.mark.parametrize(
+        ("value", "expect"),
+        [
+            ("Hello, world!", "Hello%2C%20world%21"),
+            ("Hello, world\u203d", "Hello%2C%20world%E2%80%BD"),
+            ({"f": 1}, "f=1"),
+            ([("f", 1), ("z", 2)], "f=1&amp;z=2"),
+            ({"\u203d": 1}, "%E2%80%BD=1"),
+            ({0: 1}, "0=1"),
+            ([("a b/c", "a b/c")], "a+b%2Fc=a+b%2Fc"),
+            ("a b/c", "a%20b/c"),
+        ],
+    )
+    def test_urlencode(self, value, expect):
+        e = Environment(autoescape=True)
+        t = e.from_string("{{ value|urlencode }}")
+        assert t.render(value=value) == expect
+
+    def test_simple_map(self, env):
+        env = Environment()
+        tmpl = env.from_string('{{ ["1", "2", "3"]|map("int")|sum }}')
+        assert tmpl.render() == "6"
+
+    def test_map_sum(self, env):
+        tmpl = env.from_string('{{ [[1,2], [3], [4,5,6]]|map("sum")|list }}')
+        assert tmpl.render() == "[3, 3, 15]"
+
+    def test_attribute_map(self, env):
+        User = namedtuple("User", "name")
+        env = Environment()
+        users = [
+            User("john"),
+            User("jane"),
+            User("mike"),
+        ]
+        tmpl = env.from_string('{{ users|map(attribute="name")|join("|") }}')
+        assert tmpl.render(users=users) == "john|jane|mike"
+
+    def test_empty_map(self, env):
+        env = Environment()
+        tmpl = env.from_string('{{ none|map("upper")|list }}')
+        assert tmpl.render() == "[]"
+
+    def test_map_default(self, env):
+        Fullname = namedtuple("Fullname", "firstname,lastname")
+        Firstname = namedtuple("Firstname", "firstname")
+        env = Environment()
+        tmpl = env.from_string(
+            '{{ users|map(attribute="lastname", default="smith")|join(", ") }}'
+        )
+        test_list = env.from_string(
+            '{{ users|map(attribute="lastname", default=["smith","x"])|join(", ") }}'
+        )
+        test_str = env.from_string(
+            '{{ users|map(attribute="lastname", default="")|join(", ") }}'
+        )
+        users = [
+            Fullname("john", "lennon"),
+            Fullname("jane", "edwards"),
+            Fullname("jon", None),
+            Firstname("mike"),
+        ]
+        assert tmpl.render(users=users) == "lennon, edwards, None, smith"
+        assert test_list.render(users=users) == "lennon, edwards, None, ['smith', 'x']"
+        assert test_str.render(users=users) == "lennon, edwards, None, "
+
+    def test_simple_select(self, env):
+        env = Environment()
+        tmpl = env.from_string('{{ [1, 2, 3, 4, 5]|select("odd")|join("|") }}')
+        assert tmpl.render() == "1|3|5"
+
+    def test_bool_select(self, env):
+        env = Environment()
+        tmpl = env.from_string('{{ [none, false, 0, 1, 2, 3, 4, 5]|select|join("|") }}')
+        assert tmpl.render() == "1|2|3|4|5"
+
+    def test_simple_reject(self, env):
+        env = Environment()
+        tmpl = env.from_string('{{ [1, 2, 3, 4, 5]|reject("odd")|join("|") }}')
+        assert tmpl.render() == "2|4"
+
+    def test_bool_reject(self, env):
+        env = Environment()
+        tmpl = env.from_string('{{ [none, false, 0, 1, 2, 3, 4, 5]|reject|join("|") }}')
+        assert tmpl.render() == "None|False|0"
+
+    def test_simple_select_attr(self, env):
+        User = namedtuple("User", "name,is_active")
+        env = Environment()
+        users = [
+            User("john", True),
+            User("jane", True),
+            User("mike", False),
+        ]
+        tmpl = env.from_string(
+            '{{ users|selectattr("is_active")|map(attribute="name")|join("|") }}'
+        )
+        assert tmpl.render(users=users) == "john|jane"
+
+    def test_simple_reject_attr(self, env):
+        User = namedtuple("User", "name,is_active")
+        env = Environment()
+        users = [
+            User("john", True),
+            User("jane", True),
+            User("mike", False),
+        ]
+        tmpl = env.from_string(
+            '{{ users|rejectattr("is_active")|map(attribute="name")|join("|") }}'
+        )
+        assert tmpl.render(users=users) == "mike"
+
+    def test_func_select_attr(self, env):
+        User = namedtuple("User", "id,name")
+        env = Environment()
+        users = [
+            User(1, "john"),
+            User(2, "jane"),
+            User(3, "mike"),
+        ]
+        tmpl = env.from_string(
+            '{{ users|selectattr("id", "odd")|map(attribute="name")|join("|") }}'
+        )
+        assert tmpl.render(users=users) == "john|mike"
+
+    def test_func_reject_attr(self, env):
+        User = namedtuple("User", "id,name")
+        env = Environment()
+        users = [
+            User(1, "john"),
+            User(2, "jane"),
+            User(3, "mike"),
+        ]
+        tmpl = env.from_string(
+            '{{ users|rejectattr("id", "odd")|map(attribute="name")|join("|") }}'
+        )
+        assert tmpl.render(users=users) == "jane"
+
+    def test_json_dump(self):
+        env = Environment(autoescape=True)
+        t = env.from_string("{{ x|tojson }}")
+        assert t.render(x={"foo": "bar"}) == '{"foo": "bar"}'
+        assert t.render(x="\"ba&r'") == r'"\"ba\u0026r\u0027"'
+        assert t.render(x="<bar>") == r'"\u003cbar\u003e"'
+
+        def my_dumps(value, **options):
+            assert options == {"foo": "bar"}
+            return "42"
+
+        env.policies["json.dumps_function"] = my_dumps
+        env.policies["json.dumps_kwargs"] = {"foo": "bar"}
+        assert t.render(x=23) == "42"
+
+    def test_wordwrap(self, env):
+        env.newline_sequence = "\n"
+        t = env.from_string("{{ s|wordwrap(20) }}")
+        result = t.render(s="Hello!\nThis is Jinja saying something.")
+        assert result == "Hello!\nThis is Jinja saying\nsomething."
+
+    def test_filter_undefined(self, env):
+        with pytest.raises(TemplateAssertionError, match="No filter named 'f'"):
+            env.from_string("{{ var|f }}")
+
+    def test_filter_undefined_in_if(self, env):
+        t = env.from_string("{%- if x is defined -%}{{ x|f }}{%- else -%}x{% endif %}")
+        assert t.render() == "x"
+        with pytest.raises(TemplateRuntimeError, match="No filter named 'f'"):
+            t.render(x=42)
+
+    def test_filter_undefined_in_elif(self, env):
+        t = env.from_string(
+            "{%- if x is defined -%}{{ x }}{%- elif y is defined -%}"
+            "{{ y|f }}{%- else -%}foo{%- endif -%}"
+        )
+        assert t.render() == "foo"
+        with pytest.raises(TemplateRuntimeError, match="No filter named 'f'"):
+            t.render(y=42)
+
+    def test_filter_undefined_in_else(self, env):
+        t = env.from_string(
+            "{%- if x is not defined -%}foo{%- else -%}{{ x|f }}{%- endif -%}"
+        )
+        assert t.render() == "foo"
+        with pytest.raises(TemplateRuntimeError, match="No filter named 'f'"):
+            t.render(x=42)
+
+    def test_filter_undefined_in_nested_if(self, env):
+        t = env.from_string(
+            "{%- if x is not defined -%}foo{%- else -%}{%- if y "
+            "is defined -%}{{ y|f }}{%- endif -%}{{ x }}{%- endif -%}"
+        )
+        assert t.render() == "foo"
+        assert t.render(x=42) == "42"
+        with pytest.raises(TemplateRuntimeError, match="No filter named 'f'"):
+            t.render(x=24, y=42)
+
+    def test_filter_undefined_in_condexpr(self, env):
+        t1 = env.from_string("{{ x|f if x is defined else 'foo' }}")
+        t2 = env.from_string("{{ 'foo' if x is not defined else x|f }}")
+        assert t1.render() == t2.render() == "foo"
+
+        with pytest.raises(TemplateRuntimeError, match="No filter named 'f'"):
+            t1.render(x=42)
+            t2.render(x=42)
diff --git a/tests/test_idtracking.py b/tests/test_idtracking.py
new file mode 100644
index 0000000..4e1d2c3
--- /dev/null
+++ b/tests/test_idtracking.py
@@ -0,0 +1,290 @@
+from jinja2 import nodes
+from jinja2.idtracking import symbols_for_node
+
+
+def test_basics():
+    for_loop = nodes.For(
+        nodes.Name("foo", "store"),
+        nodes.Name("seq", "load"),
+        [nodes.Output([nodes.Name("foo", "load")])],
+        [],
+        None,
+        False,
+    )
+    tmpl = nodes.Template(
+        [nodes.Assign(nodes.Name("foo", "store"), nodes.Name("bar", "load")), for_loop]
+    )
+
+    sym = symbols_for_node(tmpl)
+    assert sym.refs == {
+        "foo": "l_0_foo",
+        "bar": "l_0_bar",
+        "seq": "l_0_seq",
+    }
+    assert sym.loads == {
+        "l_0_foo": ("undefined", None),
+        "l_0_bar": ("resolve", "bar"),
+        "l_0_seq": ("resolve", "seq"),
+    }
+
+    sym = symbols_for_node(for_loop, sym)
+    assert sym.refs == {
+        "foo": "l_1_foo",
+    }
+    assert sym.loads == {
+        "l_1_foo": ("param", None),
+    }
+
+
+def test_complex():
+    title_block = nodes.Block(
+        "title", [nodes.Output([nodes.TemplateData("Page Title")])], False, False
+    )
+
+    render_title_macro = nodes.Macro(
+        "render_title",
+        [nodes.Name("title", "param")],
+        [],
+        [
+            nodes.Output(
+                [
+                    nodes.TemplateData('\n  <div class="title">\n    <h1>'),
+                    nodes.Name("title", "load"),
+                    nodes.TemplateData("</h1>\n    <p>"),
+                    nodes.Name("subtitle", "load"),
+                    nodes.TemplateData("</p>\n    "),
+                ]
+            ),
+            nodes.Assign(
+                nodes.Name("subtitle", "store"), nodes.Const("something else")
+            ),
+            nodes.Output(
+                [
+                    nodes.TemplateData("\n    <p>"),
+                    nodes.Name("subtitle", "load"),
+                    nodes.TemplateData("</p>\n  </div>\n"),
+                    nodes.If(
+                        nodes.Name("something", "load"),
+                        [
+                            nodes.Assign(
+                                nodes.Name("title_upper", "store"),
+                                nodes.Filter(
+                                    nodes.Name("title", "load"),
+                                    "upper",
+                                    [],
+                                    [],
+                                    None,
+                                    None,
+                                ),
+                            ),
+                            nodes.Output(
+                                [
+                                    nodes.Name("title_upper", "load"),
+                                    nodes.Call(
+                                        nodes.Name("render_title", "load"),
+                                        [nodes.Const("Aha")],
+                                        [],
+                                        None,
+                                        None,
+                                    ),
+                                ]
+                            ),
+                        ],
+                        [],
+                        [],
+                    ),
+                ]
+            ),
+        ],
+    )
+
+    for_loop = nodes.For(
+        nodes.Name("item", "store"),
+        nodes.Name("seq", "load"),
+        [
+            nodes.Output(
+                [
+                    nodes.TemplateData("\n    <li>"),
+                    nodes.Name("item", "load"),
+                    nodes.TemplateData("</li>\n    <span>"),
+                ]
+            ),
+            nodes.Include(nodes.Const("helper.html"), True, False),
+            nodes.Output([nodes.TemplateData("</span>\n  ")]),
+        ],
+        [],
+        None,
+        False,
+    )
+
+    body_block = nodes.Block(
+        "body",
+        [
+            nodes.Output(
+                [
+                    nodes.TemplateData("\n  "),
+                    nodes.Call(
+                        nodes.Name("render_title", "load"),
+                        [nodes.Name("item", "load")],
+                        [],
+                        None,
+                        None,
+                    ),
+                    nodes.TemplateData("\n  <ul>\n  "),
+                ]
+            ),
+            for_loop,
+            nodes.Output([nodes.TemplateData("\n  </ul>\n")]),
+        ],
+        False,
+        False,
+    )
+
+    tmpl = nodes.Template(
+        [
+            nodes.Extends(nodes.Const("layout.html")),
+            title_block,
+            render_title_macro,
+            body_block,
+        ]
+    )
+
+    tmpl_sym = symbols_for_node(tmpl)
+    assert tmpl_sym.refs == {
+        "render_title": "l_0_render_title",
+    }
+    assert tmpl_sym.loads == {
+        "l_0_render_title": ("undefined", None),
+    }
+    assert tmpl_sym.stores == {"render_title"}
+    assert tmpl_sym.dump_stores() == {
+        "render_title": "l_0_render_title",
+    }
+
+    macro_sym = symbols_for_node(render_title_macro, tmpl_sym)
+    assert macro_sym.refs == {
+        "subtitle": "l_1_subtitle",
+        "something": "l_1_something",
+        "title": "l_1_title",
+        "title_upper": "l_1_title_upper",
+    }
+    assert macro_sym.loads == {
+        "l_1_subtitle": ("resolve", "subtitle"),
+        "l_1_something": ("resolve", "something"),
+        "l_1_title": ("param", None),
+        "l_1_title_upper": ("resolve", "title_upper"),
+    }
+    assert macro_sym.stores == {"title", "title_upper", "subtitle"}
+    assert macro_sym.find_ref("render_title") == "l_0_render_title"
+    assert macro_sym.dump_stores() == {
+        "title": "l_1_title",
+        "title_upper": "l_1_title_upper",
+        "subtitle": "l_1_subtitle",
+        "render_title": "l_0_render_title",
+    }
+
+    body_sym = symbols_for_node(body_block)
+    assert body_sym.refs == {
+        "item": "l_0_item",
+        "seq": "l_0_seq",
+        "render_title": "l_0_render_title",
+    }
+    assert body_sym.loads == {
+        "l_0_item": ("resolve", "item"),
+        "l_0_seq": ("resolve", "seq"),
+        "l_0_render_title": ("resolve", "render_title"),
+    }
+    assert body_sym.stores == set()
+
+    for_sym = symbols_for_node(for_loop, body_sym)
+    assert for_sym.refs == {
+        "item": "l_1_item",
+    }
+    assert for_sym.loads == {
+        "l_1_item": ("param", None),
+    }
+    assert for_sym.stores == {"item"}
+    assert for_sym.dump_stores() == {
+        "item": "l_1_item",
+    }
+
+
+def test_if_branching_stores():
+    tmpl = nodes.Template(
+        [
+            nodes.If(
+                nodes.Name("expression", "load"),
+                [nodes.Assign(nodes.Name("variable", "store"), nodes.Const(42))],
+                [],
+                [],
+            )
+        ]
+    )
+
+    sym = symbols_for_node(tmpl)
+    assert sym.refs == {"variable": "l_0_variable", "expression": "l_0_expression"}
+    assert sym.stores == {"variable"}
+    assert sym.loads == {
+        "l_0_variable": ("resolve", "variable"),
+        "l_0_expression": ("resolve", "expression"),
+    }
+    assert sym.dump_stores() == {
+        "variable": "l_0_variable",
+    }
+
+
+def test_if_branching_stores_undefined():
+    tmpl = nodes.Template(
+        [
+            nodes.Assign(nodes.Name("variable", "store"), nodes.Const(23)),
+            nodes.If(
+                nodes.Name("expression", "load"),
+                [nodes.Assign(nodes.Name("variable", "store"), nodes.Const(42))],
+                [],
+                [],
+            ),
+        ]
+    )
+
+    sym = symbols_for_node(tmpl)
+    assert sym.refs == {"variable": "l_0_variable", "expression": "l_0_expression"}
+    assert sym.stores == {"variable"}
+    assert sym.loads == {
+        "l_0_variable": ("undefined", None),
+        "l_0_expression": ("resolve", "expression"),
+    }
+    assert sym.dump_stores() == {
+        "variable": "l_0_variable",
+    }
+
+
+def test_if_branching_multi_scope():
+    for_loop = nodes.For(
+        nodes.Name("item", "store"),
+        nodes.Name("seq", "load"),
+        [
+            nodes.If(
+                nodes.Name("expression", "load"),
+                [nodes.Assign(nodes.Name("x", "store"), nodes.Const(42))],
+                [],
+                [],
+            ),
+            nodes.Include(nodes.Const("helper.html"), True, False),
+        ],
+        [],
+        None,
+        False,
+    )
+
+    tmpl = nodes.Template(
+        [nodes.Assign(nodes.Name("x", "store"), nodes.Const(23)), for_loop]
+    )
+
+    tmpl_sym = symbols_for_node(tmpl)
+    for_sym = symbols_for_node(for_loop, tmpl_sym)
+    assert for_sym.stores == {"item", "x"}
+    assert for_sym.loads == {
+        "l_1_x": ("alias", "l_0_x"),
+        "l_1_item": ("param", None),
+        "l_1_expression": ("resolve", "expression"),
+    }
diff --git a/tests/test_imports.py b/tests/test_imports.py
new file mode 100644
index 0000000..b59fb49
--- /dev/null
+++ b/tests/test_imports.py
@@ -0,0 +1,205 @@
+import pytest
+
+from jinja2.environment import Environment
+from jinja2.exceptions import TemplateNotFound
+from jinja2.exceptions import TemplatesNotFound
+from jinja2.exceptions import TemplateSyntaxError
+from jinja2.exceptions import UndefinedError
+from jinja2.loaders import DictLoader
+
+
+@pytest.fixture
+def test_env():
+    env = Environment(
+        loader=DictLoader(
+            dict(
+                module="{% macro test() %}[{{ foo }}|{{ bar }}]{% endmacro %}",
+                header="[{{ foo }}|{{ 23 }}]",
+                o_printer="({{ o }})",
+            )
+        )
+    )
+    env.globals["bar"] = 23
+    return env
+
+
+class TestImports:
+    def test_context_imports(self, test_env):
+        t = test_env.from_string('{% import "module" as m %}{{ m.test() }}')
+        assert t.render(foo=42) == "[|23]"
+        t = test_env.from_string(
+            '{% import "module" as m without context %}{{ m.test() }}'
+        )
+        assert t.render(foo=42) == "[|23]"
+        t = test_env.from_string(
+            '{% import "module" as m with context %}{{ m.test() }}'
+        )
+        assert t.render(foo=42) == "[42|23]"
+        t = test_env.from_string('{% from "module" import test %}{{ test() }}')
+        assert t.render(foo=42) == "[|23]"
+        t = test_env.from_string(
+            '{% from "module" import test without context %}{{ test() }}'
+        )
+        assert t.render(foo=42) == "[|23]"
+        t = test_env.from_string(
+            '{% from "module" import test with context %}{{ test() }}'
+        )
+        assert t.render(foo=42) == "[42|23]"
+
+    def test_import_needs_name(self, test_env):
+        test_env.from_string('{% from "foo" import bar %}')
+        test_env.from_string('{% from "foo" import bar, baz %}')
+
+        with pytest.raises(TemplateSyntaxError):
+            test_env.from_string('{% from "foo" import %}')
+
+    def test_no_trailing_comma(self, test_env):
+        with pytest.raises(TemplateSyntaxError):
+            test_env.from_string('{% from "foo" import bar, %}')
+
+        with pytest.raises(TemplateSyntaxError):
+            test_env.from_string('{% from "foo" import bar,, %}')
+
+        with pytest.raises(TemplateSyntaxError):
+            test_env.from_string('{% from "foo" import, %}')
+
+    def test_trailing_comma_with_context(self, test_env):
+        test_env.from_string('{% from "foo" import bar, baz with context %}')
+        test_env.from_string('{% from "foo" import bar, baz, with context %}')
+        test_env.from_string('{% from "foo" import bar, with context %}')
+        test_env.from_string('{% from "foo" import bar, with, context %}')
+        test_env.from_string('{% from "foo" import bar, with with context %}')
+
+        with pytest.raises(TemplateSyntaxError):
+            test_env.from_string('{% from "foo" import bar,, with context %}')
+
+        with pytest.raises(TemplateSyntaxError):
+            test_env.from_string('{% from "foo" import bar with context, %}')
+
+    def test_exports(self, test_env):
+        m = test_env.from_string(
+            """
+            {% macro toplevel() %}...{% endmacro %}
+            {% macro __private() %}...{% endmacro %}
+            {% set variable = 42 %}
+            {% for item in [1] %}
+                {% macro notthere() %}{% endmacro %}
+            {% endfor %}
+        """
+        ).module
+        assert m.toplevel() == "..."
+        assert not hasattr(m, "__missing")
+        assert m.variable == 42
+        assert not hasattr(m, "notthere")
+
+    def test_not_exported(self, test_env):
+        t = test_env.from_string("{% from 'module' import nothing %}{{ nothing() }}")
+
+        with pytest.raises(UndefinedError, match="does not export the requested name"):
+            t.render()
+
+    def test_import_with_globals(self, test_env):
+        t = test_env.from_string(
+            '{% import "module" as m %}{{ m.test() }}', globals={"foo": 42}
+        )
+        assert t.render() == "[42|23]"
+
+        t = test_env.from_string('{% import "module" as m %}{{ m.test() }}')
+        assert t.render() == "[|23]"
+
+    def test_import_with_globals_override(self, test_env):
+        t = test_env.from_string(
+            '{% set foo = 41 %}{% import "module" as m %}{{ m.test() }}',
+            globals={"foo": 42},
+        )
+        assert t.render() == "[42|23]"
+
+    def test_from_import_with_globals(self, test_env):
+        t = test_env.from_string(
+            '{% from "module" import test %}{{ test() }}',
+            globals={"foo": 42},
+        )
+        assert t.render() == "[42|23]"
+
+
+class TestIncludes:
+    def test_context_include(self, test_env):
+        t = test_env.from_string('{% include "header" %}')
+        assert t.render(foo=42) == "[42|23]"
+        t = test_env.from_string('{% include "header" with context %}')
+        assert t.render(foo=42) == "[42|23]"
+        t = test_env.from_string('{% include "header" without context %}')
+        assert t.render(foo=42) == "[|23]"
+
+    def test_choice_includes(self, test_env):
+        t = test_env.from_string('{% include ["missing", "header"] %}')
+        assert t.render(foo=42) == "[42|23]"
+
+        t = test_env.from_string('{% include ["missing", "missing2"] ignore missing %}')
+        assert t.render(foo=42) == ""
+
+        t = test_env.from_string('{% include ["missing", "missing2"] %}')
+        pytest.raises(TemplateNotFound, t.render)
+        with pytest.raises(TemplatesNotFound) as e:
+            t.render()
+
+        assert e.value.templates == ["missing", "missing2"]
+        assert e.value.name == "missing2"
+
+        def test_includes(t, **ctx):
+            ctx["foo"] = 42
+            assert t.render(ctx) == "[42|23]"
+
+        t = test_env.from_string('{% include ["missing", "header"] %}')
+        test_includes(t)
+        t = test_env.from_string("{% include x %}")
+        test_includes(t, x=["missing", "header"])
+        t = test_env.from_string('{% include [x, "header"] %}')
+        test_includes(t, x="missing")
+        t = test_env.from_string("{% include x %}")
+        test_includes(t, x="header")
+        t = test_env.from_string("{% include [x] %}")
+        test_includes(t, x="header")
+
+    def test_include_ignoring_missing(self, test_env):
+        t = test_env.from_string('{% include "missing" %}')
+        pytest.raises(TemplateNotFound, t.render)
+        for extra in "", "with context", "without context":
+            t = test_env.from_string(
+                '{% include "missing" ignore missing ' + extra + " %}"
+            )
+            assert t.render() == ""
+
+    def test_context_include_with_overrides(self, test_env):
+        env = Environment(
+            loader=DictLoader(
+                dict(
+                    main="{% for item in [1, 2, 3] %}{% include 'item' %}{% endfor %}",
+                    item="{{ item }}",
+                )
+            )
+        )
+        assert env.get_template("main").render() == "123"
+
+    def test_unoptimized_scopes(self, test_env):
+        t = test_env.from_string(
+            """
+            {% macro outer(o) %}
+            {% macro inner() %}
+            {% include "o_printer" %}
+            {% endmacro %}
+            {{ inner() }}
+            {% endmacro %}
+            {{ outer("FOO") }}
+        """
+        )
+        assert t.render().strip() == "(FOO)"
+
+    def test_import_from_with_context(self):
+        env = Environment(
+            loader=DictLoader({"a": "{% macro x() %}{{ foobar }}{% endmacro %}"})
+        )
+        t = env.from_string(
+            "{% set foobar = 42 %}{% from 'a' import x with context %}{{ x() }}"
+        )
+        assert t.render() == "42"
diff --git a/tests/test_inheritance.py b/tests/test_inheritance.py
new file mode 100644
index 0000000..0c20d4d
--- /dev/null
+++ b/tests/test_inheritance.py
@@ -0,0 +1,405 @@
+import pytest
+
+from jinja2 import DictLoader
+from jinja2 import Environment
+from jinja2 import TemplateRuntimeError
+from jinja2 import TemplateSyntaxError
+
+LAYOUTTEMPLATE = """\
+|{% block block1 %}block 1 from layout{% endblock %}
+|{% block block2 %}block 2 from layout{% endblock %}
+|{% block block3 %}
+{% block block4 %}nested block 4 from layout{% endblock %}
+{% endblock %}|"""
+
+LEVEL1TEMPLATE = """\
+{% extends "layout" %}
+{% block block1 %}block 1 from level1{% endblock %}"""
+
+LEVEL2TEMPLATE = """\
+{% extends "level1" %}
+{% block block2 %}{% block block5 %}nested block 5 from level2{%
+endblock %}{% endblock %}"""
+
+LEVEL3TEMPLATE = """\
+{% extends "level2" %}
+{% block block5 %}block 5 from level3{% endblock %}
+{% block block4 %}block 4 from level3{% endblock %}
+"""
+
+LEVEL4TEMPLATE = """\
+{% extends "level3" %}
+{% block block3 %}block 3 from level4{% endblock %}
+"""
+
+WORKINGTEMPLATE = """\
+{% extends "layout" %}
+{% block block1 %}
+  {% if false %}
+    {% block block2 %}
+      this should work
+    {% endblock %}
+  {% endif %}
+{% endblock %}
+"""
+
+DOUBLEEXTENDS = """\
+{% extends "layout" %}
+{% extends "layout" %}
+{% block block1 %}
+  {% if false %}
+    {% block block2 %}
+      this should work
+    {% endblock %}
+  {% endif %}
+{% endblock %}
+"""
+
+
+@pytest.fixture
+def env():
+    return Environment(
+        loader=DictLoader(
+            {
+                "layout": LAYOUTTEMPLATE,
+                "level1": LEVEL1TEMPLATE,
+                "level2": LEVEL2TEMPLATE,
+                "level3": LEVEL3TEMPLATE,
+                "level4": LEVEL4TEMPLATE,
+                "working": WORKINGTEMPLATE,
+                "doublee": DOUBLEEXTENDS,
+            }
+        ),
+        trim_blocks=True,
+    )
+
+
+class TestInheritance:
+    def test_layout(self, env):
+        tmpl = env.get_template("layout")
+        assert tmpl.render() == (
+            "|block 1 from layout|block 2 from layout|nested block 4 from layout|"
+        )
+
+    def test_level1(self, env):
+        tmpl = env.get_template("level1")
+        assert tmpl.render() == (
+            "|block 1 from level1|block 2 from layout|nested block 4 from layout|"
+        )
+
+    def test_level2(self, env):
+        tmpl = env.get_template("level2")
+        assert tmpl.render() == (
+            "|block 1 from level1|nested block 5 from "
+            "level2|nested block 4 from layout|"
+        )
+
+    def test_level3(self, env):
+        tmpl = env.get_template("level3")
+        assert tmpl.render() == (
+            "|block 1 from level1|block 5 from level3|block 4 from level3|"
+        )
+
+    def test_level4(self, env):
+        tmpl = env.get_template("level4")
+        assert tmpl.render() == (
+            "|block 1 from level1|block 5 from level3|block 3 from level4|"
+        )
+
+    def test_super(self, env):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "a": "{% block intro %}INTRO{% endblock %}|"
+                    "BEFORE|{% block data %}INNER{% endblock %}|AFTER",
+                    "b": '{% extends "a" %}{% block data %}({{ '
+                    "super() }}){% endblock %}",
+                    "c": '{% extends "b" %}{% block intro %}--{{ '
+                    "super() }}--{% endblock %}\n{% block data "
+                    "%}[{{ super() }}]{% endblock %}",
+                }
+            )
+        )
+        tmpl = env.get_template("c")
+        assert tmpl.render() == "--INTRO--|BEFORE|[(INNER)]|AFTER"
+
+    def test_working(self, env):
+        env.get_template("working")
+
+    def test_reuse_blocks(self, env):
+        tmpl = env.from_string(
+            "{{ self.foo() }}|{% block foo %}42{% endblock %}|{{ self.foo() }}"
+        )
+        assert tmpl.render() == "42|42|42"
+
+    def test_preserve_blocks(self, env):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "a": "{% if false %}{% block x %}A{% endblock %}"
+                    "{% endif %}{{ self.x() }}",
+                    "b": '{% extends "a" %}{% block x %}B{{ super() }}{% endblock %}',
+                }
+            )
+        )
+        tmpl = env.get_template("b")
+        assert tmpl.render() == "BA"
+
+    def test_dynamic_inheritance(self, env):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "default1": "DEFAULT1{% block x %}{% endblock %}",
+                    "default2": "DEFAULT2{% block x %}{% endblock %}",
+                    "child": "{% extends default %}{% block x %}CHILD{% endblock %}",
+                }
+            )
+        )
+        tmpl = env.get_template("child")
+        for m in range(1, 3):
+            assert tmpl.render(default=f"default{m}") == f"DEFAULT{m}CHILD"
+
+    def test_multi_inheritance(self, env):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "default1": "DEFAULT1{% block x %}{% endblock %}",
+                    "default2": "DEFAULT2{% block x %}{% endblock %}",
+                    "child": (
+                        "{% if default %}{% extends default %}{% else %}"
+                        "{% extends 'default1' %}{% endif %}"
+                        "{% block x %}CHILD{% endblock %}"
+                    ),
+                }
+            )
+        )
+        tmpl = env.get_template("child")
+        assert tmpl.render(default="default2") == "DEFAULT2CHILD"
+        assert tmpl.render(default="default1") == "DEFAULT1CHILD"
+        assert tmpl.render() == "DEFAULT1CHILD"
+
+    def test_scoped_block(self, env):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "default.html": "{% for item in seq %}[{% block item scoped %}"
+                    "{% endblock %}]{% endfor %}"
+                }
+            )
+        )
+        t = env.from_string(
+            "{% extends 'default.html' %}{% block item %}{{ item }}{% endblock %}"
+        )
+        assert t.render(seq=list(range(5))) == "[0][1][2][3][4]"
+
+    def test_super_in_scoped_block(self, env):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "default.html": "{% for item in seq %}[{% block item scoped %}"
+                    "{{ item }}{% endblock %}]{% endfor %}"
+                }
+            )
+        )
+        t = env.from_string(
+            '{% extends "default.html" %}{% block item %}'
+            "{{ super() }}|{{ item * 2 }}{% endblock %}"
+        )
+        assert t.render(seq=list(range(5))) == "[0|0][1|2][2|4][3|6][4|8]"
+
+    def test_scoped_block_after_inheritance(self, env):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "layout.html": """
+            {% block useless %}{% endblock %}
+            """,
+                    "index.html": """
+            {%- extends 'layout.html' %}
+            {% from 'helpers.html' import foo with context %}
+            {% block useless %}
+                {% for x in [1, 2, 3] %}
+                    {% block testing scoped %}
+                        {{ foo(x) }}
+                    {% endblock %}
+                {% endfor %}
+            {% endblock %}
+            """,
+                    "helpers.html": """
+            {% macro foo(x) %}{{ the_foo + x }}{% endmacro %}
+            """,
+                }
+            )
+        )
+        rv = env.get_template("index.html").render(the_foo=42).split()
+        assert rv == ["43", "44", "45"]
+
+    def test_level1_required(self, env):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "default": "{% block x required %}{# comment #}\n {% endblock %}",
+                    "level1": "{% extends 'default' %}{% block x %}[1]{% endblock %}",
+                }
+            )
+        )
+        rv = env.get_template("level1").render()
+        assert rv == "[1]"
+
+    def test_level2_required(self, env):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "default": "{% block x required %}{% endblock %}",
+                    "level1": "{% extends 'default' %}{% block x %}[1]{% endblock %}",
+                    "level2": "{% extends 'default' %}{% block x %}[2]{% endblock %}",
+                }
+            )
+        )
+        rv1 = env.get_template("level1").render()
+        rv2 = env.get_template("level2").render()
+
+        assert rv1 == "[1]"
+        assert rv2 == "[2]"
+
+    def test_level3_required(self, env):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "default": "{% block x required %}{% endblock %}",
+                    "level1": "{% extends 'default' %}",
+                    "level2": "{% extends 'level1' %}{% block x %}[2]{% endblock %}",
+                    "level3": "{% extends 'level2' %}",
+                }
+            )
+        )
+        t1 = env.get_template("level1")
+        t2 = env.get_template("level2")
+        t3 = env.get_template("level3")
+
+        with pytest.raises(TemplateRuntimeError, match="Required block 'x' not found"):
+            assert t1.render()
+
+        assert t2.render() == "[2]"
+        assert t3.render() == "[2]"
+
+    def test_invalid_required(self, env):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "default": "{% block x required %}data {# #}{% endblock %}",
+                    "default1": "{% block x required %}{% block y %}"
+                    "{% endblock %}  {% endblock %}",
+                    "default2": "{% block x required %}{% if true %}"
+                    "{% endif %}  {% endblock %}",
+                    "level1": "{% if default %}{% extends default %}"
+                    "{% else %}{% extends 'default' %}{% endif %}"
+                    "{%- block x %}CHILD{% endblock %}",
+                }
+            )
+        )
+        t = env.get_template("level1")
+
+        with pytest.raises(
+            TemplateSyntaxError,
+            match="Required blocks can only contain comments or whitespace",
+        ):
+            assert t.render(default="default")
+            assert t.render(default="default2")
+            assert t.render(default="default3")
+
+    def test_required_with_scope(self, env):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "default1": "{% for item in seq %}[{% block item scoped required %}"
+                    "{% endblock %}]{% endfor %}",
+                    "child1": "{% extends 'default1' %}{% block item %}"
+                    "{{ item }}{% endblock %}",
+                    "default2": "{% for item in seq %}[{% block item required scoped %}"
+                    "{% endblock %}]{% endfor %}",
+                    "child2": "{% extends 'default2' %}{% block item %}"
+                    "{{ item }}{% endblock %}",
+                }
+            )
+        )
+        t1 = env.get_template("child1")
+        t2 = env.get_template("child2")
+
+        assert t1.render(seq=list(range(3))) == "[0][1][2]"
+
+        # scoped must come before required
+        with pytest.raises(TemplateSyntaxError):
+            t2.render(seq=list(range(3)))
+
+    def test_duplicate_required_or_scoped(self, env):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "default1": "{% for item in seq %}[{% block item "
+                    "scoped scoped %}}{{% endblock %}}]{{% endfor %}}",
+                    "default2": "{% for item in seq %}[{% block item "
+                    "required required %}}{{% endblock %}}]{{% endfor %}}",
+                    "child": "{% if default %}{% extends default %}{% else %}"
+                    "{% extends 'default1' %}{% endif %}{%- block x %}"
+                    "CHILD{% endblock %}",
+                }
+            )
+        )
+        tmpl = env.get_template("child")
+        with pytest.raises(TemplateSyntaxError):
+            tmpl.render(default="default1", seq=list(range(3)))
+            tmpl.render(default="default2", seq=list(range(3)))
+
+
+class TestBugFix:
+    def test_fixed_macro_scoping_bug(self, env):
+        assert (
+            Environment(
+                loader=DictLoader(
+                    {
+                        "test.html": """\
+        {% extends 'details.html' %}
+
+        {% macro my_macro() %}
+        my_macro
+        {% endmacro %}
+
+        {% block inner_box %}
+            {{ my_macro() }}
+        {% endblock %}
+            """,
+                        "details.html": """\
+        {% extends 'standard.html' %}
+
+        {% macro my_macro() %}
+        my_macro
+        {% endmacro %}
+
+        {% block content %}
+            {% block outer_box %}
+                outer_box
+                {% block inner_box %}
+                    inner_box
+                {% endblock %}
+            {% endblock %}
+        {% endblock %}
+        """,
+                        "standard.html": """
+        {% block content %}&nbsp;{% endblock %}
+        """,
+                    }
+                )
+            )
+            .get_template("test.html")
+            .render()
+            .split()
+            == ["outer_box", "my_macro"]
+        )
+
+    def test_double_extends(self, env):
+        """Ensures that a template with more than 1 {% extends ... %} usage
+        raises a ``TemplateError``.
+        """
+        with pytest.raises(TemplateRuntimeError, match="extended multiple times"):
+            env.get_template("doublee").render()
diff --git a/tests/test_lexnparse.py b/tests/test_lexnparse.py
new file mode 100644
index 0000000..c02adad
--- /dev/null
+++ b/tests/test_lexnparse.py
@@ -0,0 +1,1030 @@
+import pytest
+
+from jinja2 import Environment
+from jinja2 import nodes
+from jinja2 import Template
+from jinja2 import TemplateSyntaxError
+from jinja2 import UndefinedError
+from jinja2.lexer import Token
+from jinja2.lexer import TOKEN_BLOCK_BEGIN
+from jinja2.lexer import TOKEN_BLOCK_END
+from jinja2.lexer import TOKEN_EOF
+from jinja2.lexer import TokenStream
+
+
+class TestTokenStream:
+    test_tokens = [
+        Token(1, TOKEN_BLOCK_BEGIN, ""),
+        Token(2, TOKEN_BLOCK_END, ""),
+    ]
+
+    def test_simple(self, env):
+        ts = TokenStream(self.test_tokens, "foo", "bar")
+        assert ts.current.type is TOKEN_BLOCK_BEGIN
+        assert bool(ts)
+        assert not bool(ts.eos)
+        next(ts)
+        assert ts.current.type is TOKEN_BLOCK_END
+        assert bool(ts)
+        assert not bool(ts.eos)
+        next(ts)
+        assert ts.current.type is TOKEN_EOF
+        assert not bool(ts)
+        assert bool(ts.eos)
+
+    def test_iter(self, env):
+        token_types = [t.type for t in TokenStream(self.test_tokens, "foo", "bar")]
+        assert token_types == [
+            "block_begin",
+            "block_end",
+        ]
+
+
+class TestLexer:
+    def test_raw1(self, env):
+        tmpl = env.from_string(
+            "{% raw %}foo{% endraw %}|"
+            "{%raw%}{{ bar }}|{% baz %}{%       endraw    %}"
+        )
+        assert tmpl.render() == "foo|{{ bar }}|{% baz %}"
+
+    def test_raw2(self, env):
+        tmpl = env.from_string("1  {%- raw -%}   2   {%- endraw -%}   3")
+        assert tmpl.render() == "123"
+
+    def test_raw3(self, env):
+        # The second newline after baz exists because it is AFTER the
+        # {% raw %} and is ignored.
+        env = Environment(lstrip_blocks=True, trim_blocks=True)
+        tmpl = env.from_string("bar\n{% raw %}\n  {{baz}}2 spaces\n{% endraw %}\nfoo")
+        assert tmpl.render(baz="test") == "bar\n\n  {{baz}}2 spaces\nfoo"
+
+    def test_raw4(self, env):
+        # The trailing dash of the {% raw -%} cleans both the spaces and
+        # newlines up to the first character of data.
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
+        tmpl = env.from_string(
+            "bar\n{%- raw -%}\n\n  \n  2 spaces\n space{%- endraw -%}\nfoo"
+        )
+        assert tmpl.render() == "bar2 spaces\n spacefoo"
+
+    def test_balancing(self, env):
+        env = Environment("{%", "%}", "${", "}")
+        tmpl = env.from_string(
+            """{% for item in seq
+            %}${{'foo': item}|upper}{% endfor %}"""
+        )
+        assert tmpl.render(seq=list(range(3))) == "{'FOO': 0}{'FOO': 1}{'FOO': 2}"
+
+    def test_comments(self, env):
+        env = Environment("<!--", "-->", "{", "}")
+        tmpl = env.from_string(
+            """\
+<ul>
+<!--- for item in seq -->
+  <li>{item}</li>
+<!--- endfor -->
+</ul>"""
+        )
+        assert tmpl.render(seq=list(range(3))) == (
+            "<ul>\n  <li>0</li>\n  <li>1</li>\n  <li>2</li>\n</ul>"
+        )
+
+    def test_string_escapes(self, env):
+        for char in "\0", "\u2668", "\xe4", "\t", "\r", "\n":
+            tmpl = env.from_string(f"{{{{ {char!r} }}}}")
+            assert tmpl.render() == char
+        assert env.from_string('{{ "\N{HOT SPRINGS}" }}').render() == "\u2668"
+
+    def test_bytefallback(self, env):
+        from pprint import pformat
+
+        tmpl = env.from_string("""{{ 'foo'|pprint }}|{{ 'bär'|pprint }}""")
+        assert tmpl.render() == pformat("foo") + "|" + pformat("bär")
+
+    def test_operators(self, env):
+        from jinja2.lexer import operators
+
+        for test, expect in operators.items():
+            if test in "([{}])":
+                continue
+            stream = env.lexer.tokenize(f"{{{{ {test} }}}}")
+            next(stream)
+            assert stream.current.type == expect
+
+    def test_normalizing(self, env):
+        for seq in "\r", "\r\n", "\n":
+            env = Environment(newline_sequence=seq)
+            tmpl = env.from_string("1\n2\r\n3\n4\n")
+            result = tmpl.render()
+            assert result.replace(seq, "X") == "1X2X3X4"
+
+    def test_trailing_newline(self, env):
+        for keep in [True, False]:
+            env = Environment(keep_trailing_newline=keep)
+            for template, expected in [
+                ("", {}),
+                ("no\nnewline", {}),
+                ("with\nnewline\n", {False: "with\nnewline"}),
+                ("with\nseveral\n\n\n", {False: "with\nseveral\n\n"}),
+            ]:
+                tmpl = env.from_string(template)
+                expect = expected.get(keep, template)
+                result = tmpl.render()
+                assert result == expect, (keep, template, result, expect)
+
+    @pytest.mark.parametrize(
+        ("name", "valid"),
+        [
+            ("foo", True),
+            ("föö", True),
+            ("き", True),
+            ("_", True),
+            ("1a", False),  # invalid ascii start
+            ("a-", False),  # invalid ascii continue
+            ("\U0001f40da", False),  # invalid unicode start
+            ("a🐍\U0001f40d", False),  # invalid unicode continue
+            # start characters not matched by \w
+            ("\u1885", True),
+            ("\u1886", True),
+            ("\u2118", True),
+            ("\u212e", True),
+            # continue character not matched by \w
+            ("\xb7", False),
+            ("a\xb7", True),
+        ],
+    )
+    def test_name(self, env, name, valid):
+        t = "{{ " + name + " }}"
+
+        if valid:
+            # valid for version being tested, shouldn't raise
+            env.from_string(t)
+        else:
+            pytest.raises(TemplateSyntaxError, env.from_string, t)
+
+    def test_lineno_with_strip(self, env):
+        tokens = env.lex(
+            """\
+<html>
+    <body>
+    {%- block content -%}
+        <hr>
+        {{ item }}
+    {% endblock %}
+    </body>
+</html>"""
+        )
+        for tok in tokens:
+            lineno, token_type, value = tok
+            if token_type == "name" and value == "item":
+                assert lineno == 5
+                break
+
+
+class TestParser:
+    def test_php_syntax(self, env):
+        env = Environment("<?", "?>", "<?=", "?>", "<!--", "-->")
+        tmpl = env.from_string(
+            """\
+<!-- I'm a comment, I'm not interesting -->\
+<? for item in seq -?>
+    <?= item ?>
+<?- endfor ?>"""
+        )
+        assert tmpl.render(seq=list(range(5))) == "01234"
+
+    def test_erb_syntax(self, env):
+        env = Environment("<%", "%>", "<%=", "%>", "<%#", "%>")
+        tmpl = env.from_string(
+            """\
+<%# I'm a comment, I'm not interesting %>\
+<% for item in seq -%>
+    <%= item %>
+<%- endfor %>"""
+        )
+        assert tmpl.render(seq=list(range(5))) == "01234"
+
+    def test_comment_syntax(self, env):
+        env = Environment("<!--", "-->", "${", "}", "<!--#", "-->")
+        tmpl = env.from_string(
+            """\
+<!--# I'm a comment, I'm not interesting -->\
+<!-- for item in seq --->
+    ${item}
+<!--- endfor -->"""
+        )
+        assert tmpl.render(seq=list(range(5))) == "01234"
+
+    def test_balancing(self, env):
+        tmpl = env.from_string("""{{{'foo':'bar'}.foo}}""")
+        assert tmpl.render() == "bar"
+
+    def test_start_comment(self, env):
+        tmpl = env.from_string(
+            """{# foo comment
+and bar comment #}
+{% macro blub() %}foo{% endmacro %}
+{{ blub() }}"""
+        )
+        assert tmpl.render().strip() == "foo"
+
+    def test_line_syntax(self, env):
+        env = Environment("<%", "%>", "${", "}", "<%#", "%>", "%")
+        tmpl = env.from_string(
+            """\
+<%# regular comment %>
+% for item in seq:
+    ${item}
+% endfor"""
+        )
+        assert [
+            int(x.strip()) for x in tmpl.render(seq=list(range(5))).split()
+        ] == list(range(5))
+
+        env = Environment("<%", "%>", "${", "}", "<%#", "%>", "%", "##")
+        tmpl = env.from_string(
+            """\
+<%# regular comment %>
+% for item in seq:
+    ${item} ## the rest of the stuff
+% endfor"""
+        )
+        assert [
+            int(x.strip()) for x in tmpl.render(seq=list(range(5))).split()
+        ] == list(range(5))
+
+    def test_line_syntax_priority(self, env):
+        # XXX: why is the whitespace there in front of the newline?
+        env = Environment("{%", "%}", "${", "}", "/*", "*/", "##", "#")
+        tmpl = env.from_string(
+            """\
+/* ignore me.
+   I'm a multiline comment */
+## for item in seq:
+* ${item}          # this is just extra stuff
+## endfor"""
+        )
+        assert tmpl.render(seq=[1, 2]).strip() == "* 1\n* 2"
+        env = Environment("{%", "%}", "${", "}", "/*", "*/", "#", "##")
+        tmpl = env.from_string(
+            """\
+/* ignore me.
+   I'm a multiline comment */
+# for item in seq:
+* ${item}          ## this is just extra stuff
+    ## extra stuff i just want to ignore
+# endfor"""
+        )
+        assert tmpl.render(seq=[1, 2]).strip() == "* 1\n\n* 2"
+
+    def test_error_messages(self, env):
+        def assert_error(code, expected):
+            with pytest.raises(TemplateSyntaxError, match=expected):
+                Template(code)
+
+        assert_error(
+            "{% for item in seq %}...{% endif %}",
+            "Encountered unknown tag 'endif'. Jinja was looking "
+            "for the following tags: 'endfor' or 'else'. The "
+            "innermost block that needs to be closed is 'for'.",
+        )
+        assert_error(
+            "{% if foo %}{% for item in seq %}...{% endfor %}{% endfor %}",
+            "Encountered unknown tag 'endfor'. Jinja was looking for "
+            "the following tags: 'elif' or 'else' or 'endif'. The "
+            "innermost block that needs to be closed is 'if'.",
+        )
+        assert_error(
+            "{% if foo %}",
+            "Unexpected end of template. Jinja was looking for the "
+            "following tags: 'elif' or 'else' or 'endif'. The "
+            "innermost block that needs to be closed is 'if'.",
+        )
+        assert_error(
+            "{% for item in seq %}",
+            "Unexpected end of template. Jinja was looking for the "
+            "following tags: 'endfor' or 'else'. The innermost block "
+            "that needs to be closed is 'for'.",
+        )
+        assert_error(
+            "{% block foo-bar-baz %}",
+            "Block names in Jinja have to be valid Python identifiers "
+            "and may not contain hyphens, use an underscore instead.",
+        )
+        assert_error("{% unknown_tag %}", "Encountered unknown tag 'unknown_tag'.")
+
+
+class TestSyntax:
+    def test_call(self, env):
+        env = Environment()
+        env.globals["foo"] = lambda a, b, c, e, g: a + b + c + e + g
+        tmpl = env.from_string("{{ foo('a', c='d', e='f', *['b'], **{'g': 'h'}) }}")
+        assert tmpl.render() == "abdfh"
+
+    def test_slicing(self, env):
+        tmpl = env.from_string("{{ [1, 2, 3][:] }}|{{ [1, 2, 3][::-1] }}")
+        assert tmpl.render() == "[1, 2, 3]|[3, 2, 1]"
+
+    def test_attr(self, env):
+        tmpl = env.from_string("{{ foo.bar }}|{{ foo['bar'] }}")
+        assert tmpl.render(foo={"bar": 42}) == "42|42"
+
+    def test_subscript(self, env):
+        tmpl = env.from_string("{{ foo[0] }}|{{ foo[-1] }}")
+        assert tmpl.render(foo=[0, 1, 2]) == "0|2"
+
+    def test_tuple(self, env):
+        tmpl = env.from_string("{{ () }}|{{ (1,) }}|{{ (1, 2) }}")
+        assert tmpl.render() == "()|(1,)|(1, 2)"
+
+    def test_math(self, env):
+        tmpl = env.from_string("{{ (1 + 1 * 2) - 3 / 2 }}|{{ 2**3 }}")
+        assert tmpl.render() == "1.5|8"
+
+    def test_div(self, env):
+        tmpl = env.from_string("{{ 3 // 2 }}|{{ 3 / 2 }}|{{ 3 % 2 }}")
+        assert tmpl.render() == "1|1.5|1"
+
+    def test_unary(self, env):
+        tmpl = env.from_string("{{ +3 }}|{{ -3 }}")
+        assert tmpl.render() == "3|-3"
+
+    def test_concat(self, env):
+        tmpl = env.from_string("{{ [1, 2] ~ 'foo' }}")
+        assert tmpl.render() == "[1, 2]foo"
+
+    @pytest.mark.parametrize(
+        ("a", "op", "b"),
+        [
+            (1, ">", 0),
+            (1, ">=", 1),
+            (2, "<", 3),
+            (3, "<=", 4),
+            (4, "==", 4),
+            (4, "!=", 5),
+        ],
+    )
+    def test_compare(self, env, a, op, b):
+        t = env.from_string(f"{{{{ {a} {op} {b} }}}}")
+        assert t.render() == "True"
+
+    def test_compare_parens(self, env):
+        t = env.from_string("{{ i * (j < 5) }}")
+        assert t.render(i=2, j=3) == "2"
+
+    @pytest.mark.parametrize(
+        ("src", "expect"),
+        [
+            ("{{ 4 < 2 < 3 }}", "False"),
+            ("{{ a < b < c }}", "False"),
+            ("{{ 4 > 2 > 3 }}", "False"),
+            ("{{ a > b > c }}", "False"),
+            ("{{ 4 > 2 < 3 }}", "True"),
+            ("{{ a > b < c }}", "True"),
+        ],
+    )
+    def test_compare_compound(self, env, src, expect):
+        t = env.from_string(src)
+        assert t.render(a=4, b=2, c=3) == expect
+
+    def test_inop(self, env):
+        tmpl = env.from_string("{{ 1 in [1, 2, 3] }}|{{ 1 not in [1, 2, 3] }}")
+        assert tmpl.render() == "True|False"
+
+    @pytest.mark.parametrize("value", ("[]", "{}", "()"))
+    def test_collection_literal(self, env, value):
+        t = env.from_string(f"{{{{ {value} }}}}")
+        assert t.render() == value
+
+    @pytest.mark.parametrize(
+        ("value", "expect"),
+        (
+            ("1", "1"),
+            ("123", "123"),
+            ("12_34_56", "123456"),
+            ("1.2", "1.2"),
+            ("34.56", "34.56"),
+            ("3_4.5_6", "34.56"),
+            ("1e0", "1.0"),
+            ("10e1", "100.0"),
+            ("2.5e100", "2.5e+100"),
+            ("2.5e+100", "2.5e+100"),
+            ("25.6e-10", "2.56e-09"),
+            ("1_2.3_4e5_6", "1.234e+57"),
+            ("0", "0"),
+            ("0_00", "0"),
+            ("0b1001_1111", "159"),
+            ("0o123", "83"),
+            ("0o1_23", "83"),
+            ("0x123abc", "1194684"),
+            ("0x12_3abc", "1194684"),
+        ),
+    )
+    def test_numeric_literal(self, env, value, expect):
+        t = env.from_string(f"{{{{ {value} }}}}")
+        assert t.render() == expect
+
+    def test_bool(self, env):
+        tmpl = env.from_string(
+            "{{ true and false }}|{{ false or true }}|{{ not false }}"
+        )
+        assert tmpl.render() == "False|True|True"
+
+    def test_grouping(self, env):
+        tmpl = env.from_string(
+            "{{ (true and false) or (false and true) and not false }}"
+        )
+        assert tmpl.render() == "False"
+
+    def test_django_attr(self, env):
+        tmpl = env.from_string("{{ [1, 2, 3].0 }}|{{ [[1]].0.0 }}")
+        assert tmpl.render() == "1|1"
+
+    def test_conditional_expression(self, env):
+        tmpl = env.from_string("""{{ 0 if true else 1 }}""")
+        assert tmpl.render() == "0"
+
+    def test_short_conditional_expression(self, env):
+        tmpl = env.from_string("<{{ 1 if false }}>")
+        assert tmpl.render() == "<>"
+
+        tmpl = env.from_string("<{{ (1 if false).bar }}>")
+        pytest.raises(UndefinedError, tmpl.render)
+
+    def test_filter_priority(self, env):
+        tmpl = env.from_string('{{ "foo"|upper + "bar"|upper }}')
+        assert tmpl.render() == "FOOBAR"
+
+    def test_function_calls(self, env):
+        tests = [
+            (True, "*foo, bar"),
+            (True, "*foo, *bar"),
+            (True, "**foo, *bar"),
+            (True, "**foo, bar"),
+            (True, "**foo, **bar"),
+            (True, "**foo, bar=42"),
+            (False, "foo, bar"),
+            (False, "foo, bar=42"),
+            (False, "foo, bar=23, *args"),
+            (False, "foo, *args, bar=23"),
+            (False, "a, b=c, *d, **e"),
+            (False, "*foo, bar=42"),
+            (False, "*foo, **bar"),
+            (False, "*foo, bar=42, **baz"),
+            (False, "foo, *args, bar=23, **baz"),
+        ]
+        for should_fail, sig in tests:
+            if should_fail:
+                with pytest.raises(TemplateSyntaxError):
+                    env.from_string(f"{{{{ foo({sig}) }}}}")
+            else:
+                env.from_string(f"foo({sig})")
+
+    def test_tuple_expr(self, env):
+        for tmpl in [
+            "{{ () }}",
+            "{{ (1, 2) }}",
+            "{{ (1, 2,) }}",
+            "{{ 1, }}",
+            "{{ 1, 2 }}",
+            "{% for foo, bar in seq %}...{% endfor %}",
+            "{% for x in foo, bar %}...{% endfor %}",
+            "{% for x in foo, %}...{% endfor %}",
+        ]:
+            assert env.from_string(tmpl)
+
+    def test_trailing_comma(self, env):
+        tmpl = env.from_string("{{ (1, 2,) }}|{{ [1, 2,] }}|{{ {1: 2,} }}")
+        assert tmpl.render().lower() == "(1, 2)|[1, 2]|{1: 2}"
+
+    def test_block_end_name(self, env):
+        env.from_string("{% block foo %}...{% endblock foo %}")
+        pytest.raises(
+            TemplateSyntaxError, env.from_string, "{% block x %}{% endblock y %}"
+        )
+
+    def test_constant_casing(self, env):
+        for const in True, False, None:
+            const = str(const)
+            tmpl = env.from_string(
+                f"{{{{ {const} }}}}|{{{{ {const.lower()} }}}}|{{{{ {const.upper()} }}}}"
+            )
+            assert tmpl.render() == f"{const}|{const}|"
+
+    def test_test_chaining(self, env):
+        pytest.raises(
+            TemplateSyntaxError, env.from_string, "{{ foo is string is sequence }}"
+        )
+        assert env.from_string("{{ 42 is string or 42 is number }}").render() == "True"
+
+    def test_string_concatenation(self, env):
+        tmpl = env.from_string('{{ "foo" "bar" "baz" }}')
+        assert tmpl.render() == "foobarbaz"
+
+    def test_notin(self, env):
+        bar = range(100)
+        tmpl = env.from_string("""{{ not 42 in bar }}""")
+        assert tmpl.render(bar=bar) == "False"
+
+    def test_operator_precedence(self, env):
+        tmpl = env.from_string("""{{ 2 * 3 + 4 % 2 + 1 - 2 }}""")
+        assert tmpl.render() == "5"
+
+    def test_implicit_subscribed_tuple(self, env):
+        class Foo:
+            def __getitem__(self, x):
+                return x
+
+        t = env.from_string("{{ foo[1, 2] }}")
+        assert t.render(foo=Foo()) == "(1, 2)"
+
+    def test_raw2(self, env):
+        tmpl = env.from_string("{% raw %}{{ FOO }} and {% BAR %}{% endraw %}")
+        assert tmpl.render() == "{{ FOO }} and {% BAR %}"
+
+    def test_const(self, env):
+        tmpl = env.from_string(
+            "{{ true }}|{{ false }}|{{ none }}|"
+            "{{ none is defined }}|{{ missing is defined }}"
+        )
+        assert tmpl.render() == "True|False|None|True|False"
+
+    def test_neg_filter_priority(self, env):
+        node = env.parse("{{ -1|foo }}")
+        assert isinstance(node.body[0].nodes[0], nodes.Filter)
+        assert isinstance(node.body[0].nodes[0].node, nodes.Neg)
+
+    def test_const_assign(self, env):
+        constass1 = """{% set true = 42 %}"""
+        constass2 = """{% for none in seq %}{% endfor %}"""
+        for tmpl in constass1, constass2:
+            pytest.raises(TemplateSyntaxError, env.from_string, tmpl)
+
+    def test_localset(self, env):
+        tmpl = env.from_string(
+            """{% set foo = 0 %}\
+{% for item in [1, 2] %}{% set foo = 1 %}{% endfor %}\
+{{ foo }}"""
+        )
+        assert tmpl.render() == "0"
+
+    def test_parse_unary(self, env):
+        tmpl = env.from_string('{{ -foo["bar"] }}')
+        assert tmpl.render(foo={"bar": 42}) == "-42"
+        tmpl = env.from_string('{{ -foo["bar"]|abs }}')
+        assert tmpl.render(foo={"bar": 42}) == "42"
+
+
+class TestLstripBlocks:
+    def test_lstrip(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
+        tmpl = env.from_string("""    {% if True %}\n    {% endif %}""")
+        assert tmpl.render() == "\n"
+
+    def test_lstrip_trim(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=True)
+        tmpl = env.from_string("""    {% if True %}\n    {% endif %}""")
+        assert tmpl.render() == ""
+
+    def test_no_lstrip(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
+        tmpl = env.from_string("""    {%+ if True %}\n    {%+ endif %}""")
+        assert tmpl.render() == "    \n    "
+
+    def test_lstrip_blocks_false_with_no_lstrip(self, env):
+        # Test that + is a NOP (but does not cause an error) if lstrip_blocks=False
+        env = Environment(lstrip_blocks=False, trim_blocks=False)
+        tmpl = env.from_string("""    {% if True %}\n    {% endif %}""")
+        assert tmpl.render() == "    \n    "
+        tmpl = env.from_string("""    {%+ if True %}\n    {%+ endif %}""")
+        assert tmpl.render() == "    \n    "
+
+    def test_lstrip_endline(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
+        tmpl = env.from_string("""    hello{% if True %}\n    goodbye{% endif %}""")
+        assert tmpl.render() == "    hello\n    goodbye"
+
+    def test_lstrip_inline(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
+        tmpl = env.from_string("""    {% if True %}hello    {% endif %}""")
+        assert tmpl.render() == "hello    "
+
+    def test_lstrip_nested(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
+        tmpl = env.from_string(
+            """    {% if True %}a {% if True %}b {% endif %}c {% endif %}"""
+        )
+        assert tmpl.render() == "a b c "
+
+    def test_lstrip_left_chars(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
+        tmpl = env.from_string(
+            """    abc {% if True %}
+        hello{% endif %}"""
+        )
+        assert tmpl.render() == "    abc \n        hello"
+
+    def test_lstrip_embeded_strings(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
+        tmpl = env.from_string("""    {% set x = " {% str %} " %}{{ x }}""")
+        assert tmpl.render() == " {% str %} "
+
+    def test_lstrip_preserve_leading_newlines(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
+        tmpl = env.from_string("""\n\n\n{% set hello = 1 %}""")
+        assert tmpl.render() == "\n\n\n"
+
+    def test_lstrip_comment(self, env):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
+        tmpl = env.from_string(
+            """    {# if True #}
+hello
+    {#endif#}"""
+        )
+        assert tmpl.render() == "\nhello\n"
+
+    def test_lstrip_angle_bracket_simple(self, env):
+        env = Environment(
+            "<%",
+            "%>",
+            "${",
+            "}",
+            "<%#",
+            "%>",
+            "%",
+            "##",
+            lstrip_blocks=True,
+            trim_blocks=True,
+        )
+        tmpl = env.from_string("""    <% if True %>hello    <% endif %>""")
+        assert tmpl.render() == "hello    "
+
+    def test_lstrip_angle_bracket_comment(self, env):
+        env = Environment(
+            "<%",
+            "%>",
+            "${",
+            "}",
+            "<%#",
+            "%>",
+            "%",
+            "##",
+            lstrip_blocks=True,
+            trim_blocks=True,
+        )
+        tmpl = env.from_string("""    <%# if True %>hello    <%# endif %>""")
+        assert tmpl.render() == "hello    "
+
+    def test_lstrip_angle_bracket(self, env):
+        env = Environment(
+            "<%",
+            "%>",
+            "${",
+            "}",
+            "<%#",
+            "%>",
+            "%",
+            "##",
+            lstrip_blocks=True,
+            trim_blocks=True,
+        )
+        tmpl = env.from_string(
+            """\
+    <%# regular comment %>
+    <% for item in seq %>
+${item} ## the rest of the stuff
+   <% endfor %>"""
+        )
+        assert tmpl.render(seq=range(5)) == "".join(f"{x}\n" for x in range(5))
+
+    def test_lstrip_angle_bracket_compact(self, env):
+        env = Environment(
+            "<%",
+            "%>",
+            "${",
+            "}",
+            "<%#",
+            "%>",
+            "%",
+            "##",
+            lstrip_blocks=True,
+            trim_blocks=True,
+        )
+        tmpl = env.from_string(
+            """\
+    <%#regular comment%>
+    <%for item in seq%>
+${item} ## the rest of the stuff
+   <%endfor%>"""
+        )
+        assert tmpl.render(seq=range(5)) == "".join(f"{x}\n" for x in range(5))
+
+    def test_lstrip_blocks_outside_with_new_line(self):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
+        tmpl = env.from_string(
+            "  {% if kvs %}(\n"
+            "   {% for k, v in kvs %}{{ k }}={{ v }} {% endfor %}\n"
+            "  ){% endif %}"
+        )
+        out = tmpl.render(kvs=[("a", 1), ("b", 2)])
+        assert out == "(\na=1 b=2 \n  )"
+
+    def test_lstrip_trim_blocks_outside_with_new_line(self):
+        env = Environment(lstrip_blocks=True, trim_blocks=True)
+        tmpl = env.from_string(
+            "  {% if kvs %}(\n"
+            "   {% for k, v in kvs %}{{ k }}={{ v }} {% endfor %}\n"
+            "  ){% endif %}"
+        )
+        out = tmpl.render(kvs=[("a", 1), ("b", 2)])
+        assert out == "(\na=1 b=2   )"
+
+    def test_lstrip_blocks_inside_with_new_line(self):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
+        tmpl = env.from_string(
+            "  ({% if kvs %}\n"
+            "   {% for k, v in kvs %}{{ k }}={{ v }} {% endfor %}\n"
+            "  {% endif %})"
+        )
+        out = tmpl.render(kvs=[("a", 1), ("b", 2)])
+        assert out == "  (\na=1 b=2 \n)"
+
+    def test_lstrip_trim_blocks_inside_with_new_line(self):
+        env = Environment(lstrip_blocks=True, trim_blocks=True)
+        tmpl = env.from_string(
+            "  ({% if kvs %}\n"
+            "   {% for k, v in kvs %}{{ k }}={{ v }} {% endfor %}\n"
+            "  {% endif %})"
+        )
+        out = tmpl.render(kvs=[("a", 1), ("b", 2)])
+        assert out == "  (a=1 b=2 )"
+
+    def test_lstrip_blocks_without_new_line(self):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
+        tmpl = env.from_string(
+            "  {% if kvs %}"
+            "   {% for k, v in kvs %}{{ k }}={{ v }} {% endfor %}"
+            "  {% endif %}"
+        )
+        out = tmpl.render(kvs=[("a", 1), ("b", 2)])
+        assert out == "   a=1 b=2   "
+
+    def test_lstrip_trim_blocks_without_new_line(self):
+        env = Environment(lstrip_blocks=True, trim_blocks=True)
+        tmpl = env.from_string(
+            "  {% if kvs %}"
+            "   {% for k, v in kvs %}{{ k }}={{ v }} {% endfor %}"
+            "  {% endif %}"
+        )
+        out = tmpl.render(kvs=[("a", 1), ("b", 2)])
+        assert out == "   a=1 b=2   "
+
+    def test_lstrip_blocks_consume_after_without_new_line(self):
+        env = Environment(lstrip_blocks=True, trim_blocks=False)
+        tmpl = env.from_string(
+            "  {% if kvs -%}"
+            "   {% for k, v in kvs %}{{ k }}={{ v }} {% endfor -%}"
+            "  {% endif -%}"
+        )
+        out = tmpl.render(kvs=[("a", 1), ("b", 2)])
+        assert out == "a=1 b=2 "
+
+    def test_lstrip_trim_blocks_consume_before_without_new_line(self):
+        env = Environment(lstrip_blocks=False, trim_blocks=False)
+        tmpl = env.from_string(
+            "  {%- if kvs %}"
+            "   {%- for k, v in kvs %}{{ k }}={{ v }} {% endfor -%}"
+            "  {%- endif %}"
+        )
+        out = tmpl.render(kvs=[("a", 1), ("b", 2)])
+        assert out == "a=1 b=2 "
+
+    def test_lstrip_trim_blocks_comment(self):
+        env = Environment(lstrip_blocks=True, trim_blocks=True)
+        tmpl = env.from_string(" {# 1 space #}\n  {# 2 spaces #}    {# 4 spaces #}")
+        out = tmpl.render()
+        assert out == " " * 4
+
+    def test_lstrip_trim_blocks_raw(self):
+        env = Environment(lstrip_blocks=True, trim_blocks=True)
+        tmpl = env.from_string("{{x}}\n{%- raw %} {% endraw -%}\n{{ y }}")
+        out = tmpl.render(x=1, y=2)
+        assert out == "1 2"
+
+    def test_php_syntax_with_manual(self, env):
+        env = Environment(
+            "<?", "?>", "<?=", "?>", "<!--", "-->", lstrip_blocks=True, trim_blocks=True
+        )
+        tmpl = env.from_string(
+            """\
+    <!-- I'm a comment, I'm not interesting -->
+    <? for item in seq -?>
+        <?= item ?>
+    <?- endfor ?>"""
+        )
+        assert tmpl.render(seq=range(5)) == "01234"
+
+    def test_php_syntax(self, env):
+        env = Environment(
+            "<?", "?>", "<?=", "?>", "<!--", "-->", lstrip_blocks=True, trim_blocks=True
+        )
+        tmpl = env.from_string(
+            """\
+    <!-- I'm a comment, I'm not interesting -->
+    <? for item in seq ?>
+        <?= item ?>
+    <? endfor ?>"""
+        )
+        assert tmpl.render(seq=range(5)) == "".join(f"        {x}\n" for x in range(5))
+
+    def test_php_syntax_compact(self, env):
+        env = Environment(
+            "<?", "?>", "<?=", "?>", "<!--", "-->", lstrip_blocks=True, trim_blocks=True
+        )
+        tmpl = env.from_string(
+            """\
+    <!-- I'm a comment, I'm not interesting -->
+    <?for item in seq?>
+        <?=item?>
+    <?endfor?>"""
+        )
+        assert tmpl.render(seq=range(5)) == "".join(f"        {x}\n" for x in range(5))
+
+    def test_erb_syntax(self, env):
+        env = Environment(
+            "<%", "%>", "<%=", "%>", "<%#", "%>", lstrip_blocks=True, trim_blocks=True
+        )
+        tmpl = env.from_string(
+            """\
+<%# I'm a comment, I'm not interesting %>
+    <% for item in seq %>
+    <%= item %>
+    <% endfor %>
+"""
+        )
+        assert tmpl.render(seq=range(5)) == "".join(f"    {x}\n" for x in range(5))
+
+    def test_erb_syntax_with_manual(self, env):
+        env = Environment(
+            "<%", "%>", "<%=", "%>", "<%#", "%>", lstrip_blocks=True, trim_blocks=True
+        )
+        tmpl = env.from_string(
+            """\
+<%# I'm a comment, I'm not interesting %>
+    <% for item in seq -%>
+        <%= item %>
+    <%- endfor %>"""
+        )
+        assert tmpl.render(seq=range(5)) == "01234"
+
+    def test_erb_syntax_no_lstrip(self, env):
+        env = Environment(
+            "<%", "%>", "<%=", "%>", "<%#", "%>", lstrip_blocks=True, trim_blocks=True
+        )
+        tmpl = env.from_string(
+            """\
+<%# I'm a comment, I'm not interesting %>
+    <%+ for item in seq -%>
+        <%= item %>
+    <%- endfor %>"""
+        )
+        assert tmpl.render(seq=range(5)) == "    01234"
+
+    def test_comment_syntax(self, env):
+        env = Environment(
+            "<!--",
+            "-->",
+            "${",
+            "}",
+            "<!--#",
+            "-->",
+            lstrip_blocks=True,
+            trim_blocks=True,
+        )
+        tmpl = env.from_string(
+            """\
+<!--# I'm a comment, I'm not interesting -->\
+<!-- for item in seq --->
+    ${item}
+<!--- endfor -->"""
+        )
+        assert tmpl.render(seq=range(5)) == "01234"
+
+
+class TestTrimBlocks:
+    def test_trim(self, env):
+        env = Environment(trim_blocks=True, lstrip_blocks=False)
+        tmpl = env.from_string("    {% if True %}\n    {% endif %}")
+        assert tmpl.render() == "        "
+
+    def test_no_trim(self, env):
+        env = Environment(trim_blocks=True, lstrip_blocks=False)
+        tmpl = env.from_string("    {% if True +%}\n    {% endif %}")
+        assert tmpl.render() == "    \n    "
+
+    def test_no_trim_outer(self, env):
+        env = Environment(trim_blocks=True, lstrip_blocks=False)
+        tmpl = env.from_string("{% if True %}X{% endif +%}\nmore things")
+        assert tmpl.render() == "X\nmore things"
+
+    def test_lstrip_no_trim(self, env):
+        env = Environment(trim_blocks=True, lstrip_blocks=True)
+        tmpl = env.from_string("    {% if True +%}\n    {% endif %}")
+        assert tmpl.render() == "\n"
+
+    def test_trim_blocks_false_with_no_trim(self, env):
+        # Test that + is a NOP (but does not cause an error) if trim_blocks=False
+        env = Environment(trim_blocks=False, lstrip_blocks=False)
+        tmpl = env.from_string("    {% if True %}\n    {% endif %}")
+        assert tmpl.render() == "    \n    "
+        tmpl = env.from_string("    {% if True +%}\n    {% endif %}")
+        assert tmpl.render() == "    \n    "
+
+        tmpl = env.from_string("    {# comment #}\n    ")
+        assert tmpl.render() == "    \n    "
+        tmpl = env.from_string("    {# comment +#}\n    ")
+        assert tmpl.render() == "    \n    "
+
+        tmpl = env.from_string("    {% raw %}{% endraw %}\n    ")
+        assert tmpl.render() == "    \n    "
+        tmpl = env.from_string("    {% raw %}{% endraw +%}\n    ")
+        assert tmpl.render() == "    \n    "
+
+    def test_trim_nested(self, env):
+        env = Environment(trim_blocks=True, lstrip_blocks=True)
+        tmpl = env.from_string(
+            "    {% if True %}\na {% if True %}\nb {% endif %}\nc {% endif %}"
+        )
+        assert tmpl.render() == "a b c "
+
+    def test_no_trim_nested(self, env):
+        env = Environment(trim_blocks=True, lstrip_blocks=True)
+        tmpl = env.from_string(
+            "    {% if True +%}\na {% if True +%}\nb {% endif +%}\nc {% endif %}"
+        )
+        assert tmpl.render() == "\na \nb \nc "
+
+    def test_comment_trim(self, env):
+        env = Environment(trim_blocks=True, lstrip_blocks=True)
+        tmpl = env.from_string("""    {# comment #}\n\n  """)
+        assert tmpl.render() == "\n  "
+
+    def test_comment_no_trim(self, env):
+        env = Environment(trim_blocks=True, lstrip_blocks=True)
+        tmpl = env.from_string("""    {# comment +#}\n\n  """)
+        assert tmpl.render() == "\n\n  "
+
+    def test_multiple_comment_trim_lstrip(self, env):
+        env = Environment(trim_blocks=True, lstrip_blocks=True)
+        tmpl = env.from_string(
+            "   {# comment #}\n\n{# comment2 #}\n   \n{# comment3 #}\n\n "
+        )
+        assert tmpl.render() == "\n   \n\n "
+
+    def test_multiple_comment_no_trim_lstrip(self, env):
+        env = Environment(trim_blocks=True, lstrip_blocks=True)
+        tmpl = env.from_string(
+            "   {# comment +#}\n\n{# comment2 +#}\n   \n{# comment3 +#}\n\n "
+        )
+        assert tmpl.render() == "\n\n\n   \n\n\n "
+
+    def test_raw_trim_lstrip(self, env):
+        env = Environment(trim_blocks=True, lstrip_blocks=True)
+        tmpl = env.from_string("{{x}}{% raw %}\n\n    {% endraw %}\n\n{{ y }}")
+        assert tmpl.render(x=1, y=2) == "1\n\n\n2"
+
+    def test_raw_no_trim_lstrip(self, env):
+        env = Environment(trim_blocks=False, lstrip_blocks=True)
+        tmpl = env.from_string("{{x}}{% raw %}\n\n      {% endraw +%}\n\n{{ y }}")
+        assert tmpl.render(x=1, y=2) == "1\n\n\n\n2"
+
+        # raw blocks do not process inner text, so start tag cannot ignore trim
+        with pytest.raises(TemplateSyntaxError):
+            tmpl = env.from_string("{{x}}{% raw +%}\n\n  {% endraw +%}\n\n{{ y }}")
+
+    def test_no_trim_angle_bracket(self, env):
+        env = Environment(
+            "<%", "%>", "${", "}", "<%#", "%>", lstrip_blocks=True, trim_blocks=True
+        )
+        tmpl = env.from_string("    <% if True +%>\n\n    <% endif %>")
+        assert tmpl.render() == "\n\n"
+
+        tmpl = env.from_string("    <%# comment +%>\n\n   ")
+        assert tmpl.render() == "\n\n   "
+
+    def test_no_trim_php_syntax(self, env):
+        env = Environment(
+            "<?",
+            "?>",
+            "<?=",
+            "?>",
+            "<!--",
+            "-->",
+            lstrip_blocks=False,
+            trim_blocks=True,
+        )
+        tmpl = env.from_string("    <? if True +?>\n\n    <? endif ?>")
+        assert tmpl.render() == "    \n\n    "
+        tmpl = env.from_string("    <!-- comment +-->\n\n    ")
+        assert tmpl.render() == "    \n\n    "
diff --git a/tests/test_loader.py b/tests/test_loader.py
new file mode 100644
index 0000000..04c921d
--- /dev/null
+++ b/tests/test_loader.py
@@ -0,0 +1,412 @@
+import importlib.abc
+import importlib.machinery
+import importlib.util
+import os
+import platform
+import shutil
+import sys
+import tempfile
+import time
+import weakref
+from pathlib import Path
+
+import pytest
+
+from jinja2 import Environment
+from jinja2 import loaders
+from jinja2 import PackageLoader
+from jinja2.exceptions import TemplateNotFound
+from jinja2.loaders import split_template_path
+
+
+class TestLoaders:
+    def test_dict_loader(self, dict_loader):
+        env = Environment(loader=dict_loader)
+        tmpl = env.get_template("justdict.html")
+        assert tmpl.render().strip() == "FOO"
+        pytest.raises(TemplateNotFound, env.get_template, "missing.html")
+
+    def test_package_loader(self, package_loader):
+        env = Environment(loader=package_loader)
+        tmpl = env.get_template("test.html")
+        assert tmpl.render().strip() == "BAR"
+        pytest.raises(TemplateNotFound, env.get_template, "missing.html")
+
+    def test_filesystem_loader_overlapping_names(self, filesystem_loader):
+        t2_dir = Path(filesystem_loader.searchpath[0]) / ".." / "templates2"
+        # Make "foo" show up before "foo/test.html".
+        filesystem_loader.searchpath.insert(0, t2_dir)
+        e = Environment(loader=filesystem_loader)
+        e.get_template("foo")
+        # This would raise NotADirectoryError if "t2/foo" wasn't skipped.
+        e.get_template("foo/test.html")
+
+    def test_choice_loader(self, choice_loader):
+        env = Environment(loader=choice_loader)
+        tmpl = env.get_template("justdict.html")
+        assert tmpl.render().strip() == "FOO"
+        tmpl = env.get_template("test.html")
+        assert tmpl.render().strip() == "BAR"
+        pytest.raises(TemplateNotFound, env.get_template, "missing.html")
+
+    def test_function_loader(self, function_loader):
+        env = Environment(loader=function_loader)
+        tmpl = env.get_template("justfunction.html")
+        assert tmpl.render().strip() == "FOO"
+        pytest.raises(TemplateNotFound, env.get_template, "missing.html")
+
+    def test_prefix_loader(self, prefix_loader):
+        env = Environment(loader=prefix_loader)
+        tmpl = env.get_template("a/test.html")
+        assert tmpl.render().strip() == "BAR"
+        tmpl = env.get_template("b/justdict.html")
+        assert tmpl.render().strip() == "FOO"
+        pytest.raises(TemplateNotFound, env.get_template, "missing")
+
+    def test_caching(self):
+        changed = False
+
+        class TestLoader(loaders.BaseLoader):
+            def get_source(self, environment, template):
+                return "foo", None, lambda: not changed
+
+        env = Environment(loader=TestLoader(), cache_size=-1)
+        tmpl = env.get_template("template")
+        assert tmpl is env.get_template("template")
+        changed = True
+        assert tmpl is not env.get_template("template")
+        changed = False
+
+    def test_no_cache(self):
+        mapping = {"foo": "one"}
+        env = Environment(loader=loaders.DictLoader(mapping), cache_size=0)
+        assert env.get_template("foo") is not env.get_template("foo")
+
+    def test_limited_size_cache(self):
+        mapping = {"one": "foo", "two": "bar", "three": "baz"}
+        loader = loaders.DictLoader(mapping)
+        env = Environment(loader=loader, cache_size=2)
+        t1 = env.get_template("one")
+        t2 = env.get_template("two")
+        assert t2 is env.get_template("two")
+        assert t1 is env.get_template("one")
+        env.get_template("three")
+        loader_ref = weakref.ref(loader)
+        assert (loader_ref, "one") in env.cache
+        assert (loader_ref, "two") not in env.cache
+        assert (loader_ref, "three") in env.cache
+
+    def test_cache_loader_change(self):
+        loader1 = loaders.DictLoader({"foo": "one"})
+        loader2 = loaders.DictLoader({"foo": "two"})
+        env = Environment(loader=loader1, cache_size=2)
+        assert env.get_template("foo").render() == "one"
+        env.loader = loader2
+        assert env.get_template("foo").render() == "two"
+
+    def test_dict_loader_cache_invalidates(self):
+        mapping = {"foo": "one"}
+        env = Environment(loader=loaders.DictLoader(mapping))
+        assert env.get_template("foo").render() == "one"
+        mapping["foo"] = "two"
+        assert env.get_template("foo").render() == "two"
+
+    def test_split_template_path(self):
+        assert split_template_path("foo/bar") == ["foo", "bar"]
+        assert split_template_path("./foo/bar") == ["foo", "bar"]
+        pytest.raises(TemplateNotFound, split_template_path, "../foo")
+
+
+class TestFileSystemLoader:
+    searchpath = (Path(__file__) / ".." / "res" / "templates").resolve()
+
+    @staticmethod
+    def _test_common(env):
+        tmpl = env.get_template("test.html")
+        assert tmpl.render().strip() == "BAR"
+        tmpl = env.get_template("foo/test.html")
+        assert tmpl.render().strip() == "FOO"
+        pytest.raises(TemplateNotFound, env.get_template, "missing.html")
+
+    def test_searchpath_as_str(self):
+        filesystem_loader = loaders.FileSystemLoader(str(self.searchpath))
+
+        env = Environment(loader=filesystem_loader)
+        self._test_common(env)
+
+    def test_searchpath_as_pathlib(self):
+        filesystem_loader = loaders.FileSystemLoader(self.searchpath)
+        env = Environment(loader=filesystem_loader)
+        self._test_common(env)
+
+    def test_searchpath_as_list_including_pathlib(self):
+        filesystem_loader = loaders.FileSystemLoader(
+            ["/tmp/templates", self.searchpath]
+        )
+        env = Environment(loader=filesystem_loader)
+        self._test_common(env)
+
+    def test_caches_template_based_on_mtime(self):
+        filesystem_loader = loaders.FileSystemLoader(self.searchpath)
+
+        env = Environment(loader=filesystem_loader)
+        tmpl1 = env.get_template("test.html")
+        tmpl2 = env.get_template("test.html")
+        assert tmpl1 is tmpl2
+
+        os.utime(self.searchpath / "test.html", (time.time(), time.time()))
+        tmpl3 = env.get_template("test.html")
+        assert tmpl1 is not tmpl3
+
+    @pytest.mark.parametrize(
+        ("encoding", "expect"),
+        [
+            ("utf-8", "文字化け"),
+            ("iso-8859-1", "æ\x96\x87\xe5\xad\x97\xe5\x8c\x96\xe3\x81\x91"),
+        ],
+    )
+    def test_uses_specified_encoding(self, encoding, expect):
+        loader = loaders.FileSystemLoader(self.searchpath, encoding=encoding)
+        e = Environment(loader=loader)
+        t = e.get_template("mojibake.txt")
+        assert t.render() == expect
+
+    def test_filename_normpath(self):
+        """Nested template names should only contain ``os.sep`` in the
+        loaded filename.
+        """
+        loader = loaders.FileSystemLoader(self.searchpath)
+        e = Environment(loader=loader)
+        t = e.get_template("foo/test.html")
+        assert t.filename == str(self.searchpath / "foo" / "test.html")
+
+
+class TestModuleLoader:
+    archive = None
+
+    def compile_down(self, prefix_loader, zip="deflated"):
+        log = []
+        self.reg_env = Environment(loader=prefix_loader)
+        if zip is not None:
+            fd, self.archive = tempfile.mkstemp(suffix=".zip")
+            os.close(fd)
+        else:
+            self.archive = tempfile.mkdtemp()
+        self.reg_env.compile_templates(self.archive, zip=zip, log_function=log.append)
+        self.mod_env = Environment(loader=loaders.ModuleLoader(self.archive))
+        return "".join(log)
+
+    def teardown(self):
+        if hasattr(self, "mod_env"):
+            if os.path.isfile(self.archive):
+                os.remove(self.archive)
+            else:
+                shutil.rmtree(self.archive)
+            self.archive = None
+
+    def test_log(self, prefix_loader):
+        log = self.compile_down(prefix_loader)
+        assert (
+            'Compiled "a/foo/test.html" as '
+            "tmpl_a790caf9d669e39ea4d280d597ec891c4ef0404a" in log
+        )
+        assert "Finished compiling templates" in log
+        assert (
+            'Could not compile "a/syntaxerror.html": '
+            "Encountered unknown tag 'endif'" in log
+        )
+
+    def _test_common(self):
+        tmpl1 = self.reg_env.get_template("a/test.html")
+        tmpl2 = self.mod_env.get_template("a/test.html")
+        assert tmpl1.render() == tmpl2.render()
+
+        tmpl1 = self.reg_env.get_template("b/justdict.html")
+        tmpl2 = self.mod_env.get_template("b/justdict.html")
+        assert tmpl1.render() == tmpl2.render()
+
+    def test_deflated_zip_compile(self, prefix_loader):
+        self.compile_down(prefix_loader, zip="deflated")
+        self._test_common()
+
+    def test_stored_zip_compile(self, prefix_loader):
+        self.compile_down(prefix_loader, zip="stored")
+        self._test_common()
+
+    def test_filesystem_compile(self, prefix_loader):
+        self.compile_down(prefix_loader, zip=None)
+        self._test_common()
+
+    def test_weak_references(self, prefix_loader):
+        self.compile_down(prefix_loader)
+        self.mod_env.get_template("a/test.html")
+        key = loaders.ModuleLoader.get_template_key("a/test.html")
+        name = self.mod_env.loader.module.__name__
+
+        assert hasattr(self.mod_env.loader.module, key)
+        assert name in sys.modules
+
+        # unset all, ensure the module is gone from sys.modules
+        self.mod_env = None
+
+        try:
+            import gc
+
+            gc.collect()
+        except BaseException:
+            pass
+
+        assert name not in sys.modules
+
+    def test_choice_loader(self, prefix_loader):
+        self.compile_down(prefix_loader)
+        self.mod_env.loader = loaders.ChoiceLoader(
+            [self.mod_env.loader, loaders.DictLoader({"DICT_SOURCE": "DICT_TEMPLATE"})]
+        )
+        tmpl1 = self.mod_env.get_template("a/test.html")
+        assert tmpl1.render() == "BAR"
+        tmpl2 = self.mod_env.get_template("DICT_SOURCE")
+        assert tmpl2.render() == "DICT_TEMPLATE"
+
+    def test_prefix_loader(self, prefix_loader):
+        self.compile_down(prefix_loader)
+        self.mod_env.loader = loaders.PrefixLoader(
+            {
+                "MOD": self.mod_env.loader,
+                "DICT": loaders.DictLoader({"test.html": "DICT_TEMPLATE"}),
+            }
+        )
+        tmpl1 = self.mod_env.get_template("MOD/a/test.html")
+        assert tmpl1.render() == "BAR"
+        tmpl2 = self.mod_env.get_template("DICT/test.html")
+        assert tmpl2.render() == "DICT_TEMPLATE"
+
+    def test_path_as_pathlib(self, prefix_loader):
+        self.compile_down(prefix_loader)
+
+        mod_path = self.mod_env.loader.module.__path__[0]
+        mod_loader = loaders.ModuleLoader(Path(mod_path))
+        self.mod_env = Environment(loader=mod_loader)
+
+        self._test_common()
+
+    def test_supports_pathlib_in_list_of_paths(self, prefix_loader):
+        self.compile_down(prefix_loader)
+
+        mod_path = self.mod_env.loader.module.__path__[0]
+        mod_loader = loaders.ModuleLoader([Path(mod_path), "/tmp/templates"])
+        self.mod_env = Environment(loader=mod_loader)
+
+        self._test_common()
+
+
+@pytest.fixture()
+def package_dir_loader(monkeypatch):
+    monkeypatch.syspath_prepend(Path(__file__).parent)
+    return PackageLoader("res")
+
+
+@pytest.mark.parametrize(
+    ("template", "expect"), [("foo/test.html", "FOO"), ("test.html", "BAR")]
+)
+def test_package_dir_source(package_dir_loader, template, expect):
+    source, name, up_to_date = package_dir_loader.get_source(None, template)
+    assert source.rstrip() == expect
+    assert name.endswith(os.path.join(*split_template_path(template)))
+    assert up_to_date()
+
+
+def test_package_dir_list(package_dir_loader):
+    templates = package_dir_loader.list_templates()
+    assert "foo/test.html" in templates
+    assert "test.html" in templates
+
+
+@pytest.fixture()
+def package_file_loader(monkeypatch):
+    monkeypatch.syspath_prepend(Path(__file__).parent / "res")
+    return PackageLoader("__init__")
+
+
+@pytest.mark.parametrize(
+    ("template", "expect"), [("foo/test.html", "FOO"), ("test.html", "BAR")]
+)
+def test_package_file_source(package_file_loader, template, expect):
+    source, name, up_to_date = package_file_loader.get_source(None, template)
+    assert source.rstrip() == expect
+    assert name.endswith(os.path.join(*split_template_path(template)))
+    assert up_to_date()
+
+
+def test_package_file_list(package_file_loader):
+    templates = package_file_loader.list_templates()
+    assert "foo/test.html" in templates
+    assert "test.html" in templates
+
+
+@pytest.fixture()
+def package_zip_loader(monkeypatch):
+    package_zip = (Path(__file__) / ".." / "res" / "package.zip").resolve()
+    monkeypatch.syspath_prepend(package_zip)
+    return PackageLoader("t_pack")
+
+
+@pytest.mark.parametrize(
+    ("template", "expect"), [("foo/test.html", "FOO"), ("test.html", "BAR")]
+)
+def test_package_zip_source(package_zip_loader, template, expect):
+    source, name, up_to_date = package_zip_loader.get_source(None, template)
+    assert source.rstrip() == expect
+    assert name.endswith(os.path.join(*split_template_path(template)))
+    assert up_to_date is None
+
+
+@pytest.mark.xfail(
+    platform.python_implementation() == "PyPy",
+    reason="PyPy's zipimporter doesn't have a '_files' attribute.",
+    raises=TypeError,
+)
+def test_package_zip_list(package_zip_loader):
+    assert package_zip_loader.list_templates() == ["foo/test.html", "test.html"]
+
+
+@pytest.mark.parametrize("package_path", ["", ".", "./"])
+def test_package_zip_omit_curdir(package_zip_loader, package_path):
+    """PackageLoader should not add or include "." or "./" in the root
+    path, it is invalid in zip paths.
+    """
+    loader = PackageLoader("t_pack", package_path)
+    assert loader.package_path == ""
+    source, _, _ = loader.get_source(None, "templates/foo/test.html")
+    assert source.rstrip() == "FOO"
+
+
+def test_pep_451_import_hook():
+    class ImportHook(importlib.abc.MetaPathFinder, importlib.abc.Loader):
+        def find_spec(self, name, path=None, target=None):
+            if name != "res":
+                return None
+
+            spec = importlib.machinery.PathFinder.find_spec(name)
+            return importlib.util.spec_from_file_location(
+                name,
+                spec.origin,
+                loader=self,
+                submodule_search_locations=spec.submodule_search_locations,
+            )
+
+        def create_module(self, spec):
+            return None  # default behaviour is fine
+
+        def exec_module(self, module):
+            return None  # we need this to satisfy the interface, it's wrong
+
+    # ensure we restore `sys.meta_path` after putting in our loader
+    before = sys.meta_path[:]
+
+    try:
+        sys.meta_path.insert(0, ImportHook())
+        package_loader = PackageLoader("res")
+        assert "test.html" in package_loader.list_templates()
+    finally:
+        sys.meta_path[:] = before
diff --git a/tests/test_nativetypes.py b/tests/test_nativetypes.py
new file mode 100644
index 0000000..8c85252
--- /dev/null
+++ b/tests/test_nativetypes.py
@@ -0,0 +1,162 @@
+import math
+
+import pytest
+
+from jinja2.exceptions import UndefinedError
+from jinja2.nativetypes import NativeEnvironment
+from jinja2.nativetypes import NativeTemplate
+from jinja2.runtime import Undefined
+
+
+@pytest.fixture
+def env():
+    return NativeEnvironment()
+
+
+def test_is_defined_native_return(env):
+    t = env.from_string("{{ missing is defined }}")
+    assert not t.render()
+
+
+def test_undefined_native_return(env):
+    t = env.from_string("{{ missing }}")
+    assert isinstance(t.render(), Undefined)
+
+
+def test_adding_undefined_native_return(env):
+    t = env.from_string("{{ 3 + missing }}")
+
+    with pytest.raises(UndefinedError):
+        t.render()
+
+
+def test_cast_int(env):
+    t = env.from_string("{{ value|int }}")
+    result = t.render(value="3")
+    assert isinstance(result, int)
+    assert result == 3
+
+
+def test_list_add(env):
+    t = env.from_string("{{ a + b }}")
+    result = t.render(a=["a", "b"], b=["c", "d"])
+    assert isinstance(result, list)
+    assert result == ["a", "b", "c", "d"]
+
+
+def test_multi_expression_add(env):
+    t = env.from_string("{{ a }} + {{ b }}")
+    result = t.render(a=["a", "b"], b=["c", "d"])
+    assert not isinstance(result, list)
+    assert result == "['a', 'b'] + ['c', 'd']"
+
+
+def test_loops(env):
+    t = env.from_string("{% for x in value %}{{ x }}{% endfor %}")
+    result = t.render(value=["a", "b", "c", "d"])
+    assert isinstance(result, str)
+    assert result == "abcd"
+
+
+def test_loops_with_ints(env):
+    t = env.from_string("{% for x in value %}{{ x }}{% endfor %}")
+    result = t.render(value=[1, 2, 3, 4])
+    assert isinstance(result, int)
+    assert result == 1234
+
+
+def test_loop_look_alike(env):
+    t = env.from_string("{% for x in value %}{{ x }}{% endfor %}")
+    result = t.render(value=[1])
+    assert isinstance(result, int)
+    assert result == 1
+
+
+@pytest.mark.parametrize(
+    ("source", "expect"),
+    (
+        ("{{ value }}", True),
+        ("{{ value }}", False),
+        ("{{ 1 == 1 }}", True),
+        ("{{ 2 + 2 == 5 }}", False),
+        ("{{ None is none }}", True),
+        ("{{ '' == None }}", False),
+    ),
+)
+def test_booleans(env, source, expect):
+    t = env.from_string(source)
+    result = t.render(value=expect)
+    assert isinstance(result, bool)
+    assert result is expect
+
+
+def test_variable_dunder(env):
+    t = env.from_string("{{ x.__class__ }}")
+    result = t.render(x=True)
+    assert isinstance(result, type)
+
+
+def test_constant_dunder(env):
+    t = env.from_string("{{ true.__class__ }}")
+    result = t.render()
+    assert isinstance(result, type)
+
+
+def test_constant_dunder_to_string(env):
+    t = env.from_string("{{ true.__class__|string }}")
+    result = t.render()
+    assert not isinstance(result, type)
+    assert result in {"<type 'bool'>", "<class 'bool'>"}
+
+
+def test_string_literal_var(env):
+    t = env.from_string("[{{ 'all' }}]")
+    result = t.render()
+    assert isinstance(result, str)
+    assert result == "[all]"
+
+
+def test_string_top_level(env):
+    t = env.from_string("'Jinja'")
+    result = t.render()
+    assert result == "Jinja"
+
+
+def test_tuple_of_variable_strings(env):
+    t = env.from_string("'{{ a }}', 'data', '{{ b }}', b'{{ c }}'")
+    result = t.render(a=1, b=2, c="bytes")
+    assert isinstance(result, tuple)
+    assert result == ("1", "data", "2", b"bytes")
+
+
+def test_concat_strings_with_quotes(env):
+    t = env.from_string("--host='{{ host }}' --user \"{{ user }}\"")
+    result = t.render(host="localhost", user="Jinja")
+    assert result == "--host='localhost' --user \"Jinja\""
+
+
+def test_no_intermediate_eval(env):
+    t = env.from_string("0.000{{ a }}")
+    result = t.render(a=7)
+    assert isinstance(result, float)
+    # If intermediate eval happened, 0.000 would render 0.0, then 7
+    # would be appended, resulting in 0.07.
+    assert math.isclose(result, 0.0007)
+
+
+def test_spontaneous_env():
+    t = NativeTemplate("{{ true }}")
+    assert isinstance(t.environment, NativeEnvironment)
+
+
+def test_leading_spaces(env):
+    t = env.from_string(" {{ True }}")
+    result = t.render()
+    assert result == " True"
+
+
+def test_macro(env):
+    t = env.from_string("{%- macro x() -%}{{- [1,2] -}}{%- endmacro -%}{{- x()[1] -}}")
+    result = t.render()
+    assert result == 2
+    assert isinstance(result, int)
diff --git a/tests/test_nodes.py b/tests/test_nodes.py
new file mode 100644
index 0000000..e910998
--- /dev/null
+++ b/tests/test_nodes.py
@@ -0,0 +1,3 @@
+def test_template_hash(env):
+    template = env.parse("hash test")
+    hash(template)
diff --git a/tests/test_pickle.py b/tests/test_pickle.py
new file mode 100644
index 0000000..b0f6bcf
--- /dev/null
+++ b/tests/test_pickle.py
@@ -0,0 +1,6 @@
+import pickle
+
+
+def test_environment(env):
+    env = pickle.loads(pickle.dumps(env))
+    assert env.from_string("x={{ x }}").render(x=42) == "x=42"
diff --git a/tests/test_regression.py b/tests/test_regression.py
new file mode 100644
index 0000000..46e492b
--- /dev/null
+++ b/tests/test_regression.py
@@ -0,0 +1,744 @@
+import pytest
+
+from jinja2 import DictLoader
+from jinja2 import Environment
+from jinja2 import PrefixLoader
+from jinja2 import Template
+from jinja2 import TemplateAssertionError
+from jinja2 import TemplateNotFound
+from jinja2 import TemplateSyntaxError
+from jinja2.utils import pass_context
+
+
+class TestCorner:
+    def test_assigned_scoping(self, env):
+        t = env.from_string(
+            """
+        {%- for item in (1, 2, 3, 4) -%}
+            [{{ item }}]
+        {%- endfor %}
+        {{- item -}}
+        """
+        )
+        assert t.render(item=42) == "[1][2][3][4]42"
+
+        t = env.from_string(
+            """
+        {%- for item in (1, 2, 3, 4) -%}
+            [{{ item }}]
+        {%- endfor %}
+        {%- set item = 42 %}
+        {{- item -}}
+        """
+        )
+        assert t.render() == "[1][2][3][4]42"
+
+        t = env.from_string(
+            """
+        {%- set item = 42 %}
+        {%- for item in (1, 2, 3, 4) -%}
+            [{{ item }}]
+        {%- endfor %}
+        {{- item -}}
+        """
+        )
+        assert t.render() == "[1][2][3][4]42"
+
+    def test_closure_scoping(self, env):
+        t = env.from_string(
+            """
+        {%- set wrapper = "<FOO>" %}
+        {%- for item in (1, 2, 3, 4) %}
+            {%- macro wrapper() %}[{{ item }}]{% endmacro %}
+            {{- wrapper() }}
+        {%- endfor %}
+        {{- wrapper -}}
+        """
+        )
+        assert t.render() == "[1][2][3][4]<FOO>"
+
+        t = env.from_string(
+            """
+        {%- for item in (1, 2, 3, 4) %}
+            {%- macro wrapper() %}[{{ item }}]{% endmacro %}
+            {{- wrapper() }}
+        {%- endfor %}
+        {%- set wrapper = "<FOO>" %}
+        {{- wrapper -}}
+        """
+        )
+        assert t.render() == "[1][2][3][4]<FOO>"
+
+        t = env.from_string(
+            """
+        {%- for item in (1, 2, 3, 4) %}
+            {%- macro wrapper() %}[{{ item }}]{% endmacro %}
+            {{- wrapper() }}
+        {%- endfor %}
+        {{- wrapper -}}
+        """
+        )
+        assert t.render(wrapper=23) == "[1][2][3][4]23"
+
+
+class TestBug:
+    def test_keyword_folding(self, env):
+        env = Environment()
+        env.filters["testing"] = lambda value, some: value + some
+        assert (
+            env.from_string("{{ 'test'|testing(some='stuff') }}").render()
+            == "teststuff"
+        )
+
+    def test_extends_output_bugs(self, env):
+        env = Environment(
+            loader=DictLoader({"parent.html": "(({% block title %}{% endblock %}))"})
+        )
+
+        t = env.from_string(
+            '{% if expr %}{% extends "parent.html" %}{% endif %}'
+            "[[{% block title %}title{% endblock %}]]"
+            "{% for item in [1, 2, 3] %}({{ item }}){% endfor %}"
+        )
+        assert t.render(expr=False) == "[[title]](1)(2)(3)"
+        assert t.render(expr=True) == "((title))"
+
+    def test_urlize_filter_escaping(self, env):
+        tmpl = env.from_string('{{ "http://www.example.org/<foo"|urlize }}')
+        assert (
+            tmpl.render() == '<a href="http://www.example.org/&lt;foo" rel="noopener">'
+            "http://www.example.org/&lt;foo</a>"
+        )
+
+    def test_urlize_filter_closing_punctuation(self, env):
+        tmpl = env.from_string(
+            '{{ "(see http://www.example.org/?page=subj_<desc.h>)"|urlize }}'
+        )
+        assert tmpl.render() == (
+            '(see <a href="http://www.example.org/?page=subj_&lt;desc.h&gt;" '
+            'rel="noopener">http://www.example.org/?page=subj_&lt;desc.h&gt;</a>)'
+        )
+
+    def test_loop_call_loop(self, env):
+        tmpl = env.from_string(
+            """
+
+        {% macro test() %}
+            {{ caller() }}
+        {% endmacro %}
+
+        {% for num1 in range(5) %}
+            {% call test() %}
+                {% for num2 in range(10) %}
+                    {{ loop.index }}
+                {% endfor %}
+            {% endcall %}
+        {% endfor %}
+
+        """
+        )
+
+        assert tmpl.render().split() == [str(x) for x in range(1, 11)] * 5
+
+    def test_weird_inline_comment(self, env):
+        env = Environment(line_statement_prefix="%")
+        pytest.raises(
+            TemplateSyntaxError,
+            env.from_string,
+            "% for item in seq {# missing #}\n...% endfor",
+        )
+
+    def test_old_macro_loop_scoping_bug(self, env):
+        tmpl = env.from_string(
+            "{% for i in (1, 2) %}{{ i }}{% endfor %}"
+            "{% macro i() %}3{% endmacro %}{{ i() }}"
+        )
+        assert tmpl.render() == "123"
+
+    def test_partial_conditional_assignments(self, env):
+        tmpl = env.from_string("{% if b %}{% set a = 42 %}{% endif %}{{ a }}")
+        assert tmpl.render(a=23) == "23"
+        assert tmpl.render(b=True) == "42"
+
+    def test_stacked_locals_scoping_bug(self, env):
+        env = Environment(line_statement_prefix="#")
+        t = env.from_string(
+            """\
+# for j in [1, 2]:
+#   set x = 1
+#   for i in [1, 2]:
+#     print x
+#     if i % 2 == 0:
+#       set x = x + 1
+#     endif
+#   endfor
+# endfor
+# if a
+#   print 'A'
+# elif b
+#   print 'B'
+# elif c == d
+#   print 'C'
+# else
+#   print 'D'
+# endif
+    """
+        )
+        assert t.render(a=0, b=False, c=42, d=42.0) == "1111C"
+
+    def test_stacked_locals_scoping_bug_twoframe(self, env):
+        t = Template(
+            """
+            {% set x = 1 %}
+            {% for item in foo %}
+                {% if item == 1 %}
+                    {% set x = 2 %}
+                {% endif %}
+            {% endfor %}
+            {{ x }}
+        """
+        )
+        rv = t.render(foo=[1]).strip()
+        assert rv == "1"
+
+    def test_call_with_args(self, env):
+        t = Template(
+            """{% macro dump_users(users) -%}
+        <ul>
+          {%- for user in users -%}
+            <li><p>{{ user.username|e }}</p>{{ caller(user) }}</li>
+          {%- endfor -%}
+          </ul>
+        {%- endmacro -%}
+
+        {% call(user) dump_users(list_of_user) -%}
+          <dl>
+            <dl>Realname</dl>
+            <dd>{{ user.realname|e }}</dd>
+            <dl>Description</dl>
+            <dd>{{ user.description }}</dd>
+          </dl>
+        {% endcall %}"""
+        )
+
+        assert [
+            x.strip()
+            for x in t.render(
+                list_of_user=[
+                    {
+                        "username": "apo",
+                        "realname": "something else",
+                        "description": "test",
+                    }
+                ]
+            ).splitlines()
+        ] == [
+            "<ul><li><p>apo</p><dl>",
+            "<dl>Realname</dl>",
+            "<dd>something else</dd>",
+            "<dl>Description</dl>",
+            "<dd>test</dd>",
+            "</dl>",
+            "</li></ul>",
+        ]
+
+    def test_empty_if_condition_fails(self, env):
+        pytest.raises(TemplateSyntaxError, Template, "{% if %}....{% endif %}")
+        pytest.raises(
+            TemplateSyntaxError, Template, "{% if foo %}...{% elif %}...{% endif %}"
+        )
+        pytest.raises(TemplateSyntaxError, Template, "{% for x in %}..{% endfor %}")
+
+    def test_recursive_loop_compile(self, env):
+        Template(
+            """
+            {% for p in foo recursive%}
+                {{p.bar}}
+                {% for f in p.fields recursive%}
+                    {{f.baz}}
+                    {{p.bar}}
+                    {% if f.rec %}
+                        {{ loop(f.sub) }}
+                    {% endif %}
+                {% endfor %}
+            {% endfor %}
+            """
+        )
+        Template(
+            """
+            {% for p in foo%}
+                {{p.bar}}
+                {% for f in p.fields recursive%}
+                    {{f.baz}}
+                    {{p.bar}}
+                    {% if f.rec %}
+                        {{ loop(f.sub) }}
+                    {% endif %}
+                {% endfor %}
+            {% endfor %}
+            """
+        )
+
+    def test_else_loop_bug(self, env):
+        t = Template(
+            """
+            {% for x in y %}
+                {{ loop.index0 }}
+            {% else %}
+                {% for i in range(3) %}{{ i }}{% endfor %}
+            {% endfor %}
+        """
+        )
+        assert t.render(y=[]).strip() == "012"
+
+    def test_correct_prefix_loader_name(self, env):
+        env = Environment(loader=PrefixLoader({"foo": DictLoader({})}))
+        with pytest.raises(TemplateNotFound) as e:
+            env.get_template("foo/bar.html")
+
+        assert e.value.name == "foo/bar.html"
+
+    def test_pass_context_callable_class(self, env):
+        class CallableClass:
+            @pass_context
+            def __call__(self, ctx):
+                return ctx.resolve("hello")
+
+        tpl = Template("""{{ callableclass() }}""")
+        output = tpl.render(callableclass=CallableClass(), hello="TEST")
+        expected = "TEST"
+
+        assert output == expected
+
+    def test_block_set_with_extends(self):
+        env = Environment(
+            loader=DictLoader({"main": "{% block body %}[{{ x }}]{% endblock %}"})
+        )
+        t = env.from_string('{% extends "main" %}{% set x %}42{% endset %}')
+        assert t.render() == "[42]"
+
+    def test_nested_for_else(self, env):
+        tmpl = env.from_string(
+            "{% for x in y %}{{ loop.index0 }}{% else %}"
+            "{% for i in range(3) %}{{ i }}{% endfor %}"
+            "{% endfor %}"
+        )
+        assert tmpl.render() == "012"
+
+    def test_macro_var_bug(self, env):
+        tmpl = env.from_string(
+            """
+        {% set i = 1 %}
+        {% macro test() %}
+            {% for i in range(0, 10) %}{{ i }}{% endfor %}
+        {% endmacro %}{{ test() }}
+        """
+        )
+        assert tmpl.render().strip() == "0123456789"
+
+    def test_macro_var_bug_advanced(self, env):
+        tmpl = env.from_string(
+            """
+        {% macro outer() %}
+            {% set i = 1 %}
+            {% macro test() %}
+                {% for i in range(0, 10) %}{{ i }}{% endfor %}
+            {% endmacro %}{{ test() }}
+        {% endmacro %}{{ outer() }}
+        """
+        )
+        assert tmpl.render().strip() == "0123456789"
+
+    def test_callable_defaults(self):
+        env = Environment()
+        env.globals["get_int"] = lambda: 42
+        t = env.from_string(
+            """
+        {% macro test(a, b, c=get_int()) -%}
+             {{ a + b + c }}
+        {%- endmacro %}
+        {{ test(1, 2) }}|{{ test(1, 2, 3) }}
+        """
+        )
+        assert t.render().strip() == "45|6"
+
+    def test_macro_escaping(self):
+        env = Environment(autoescape=lambda x: False)
+        template = "{% macro m() %}<html>{% endmacro %}"
+        template += "{% autoescape true %}{{ m() }}{% endautoescape %}"
+        assert env.from_string(template).render()
+
+    def test_macro_scoping(self, env):
+        tmpl = env.from_string(
+            """
+        {% set n=[1,2,3,4,5] %}
+        {% for n in [[1,2,3], [3,4,5], [5,6,7]] %}
+
+        {% macro x(l) %}
+          {{ l.pop() }}
+          {% if l %}{{ x(l) }}{% endif %}
+        {% endmacro %}
+
+        {{ x(n) }}
+
+        {% endfor %}
+        """
+        )
+        assert list(map(int, tmpl.render().split())) == [3, 2, 1, 5, 4, 3, 7, 6, 5]
+
+    def test_scopes_and_blocks(self):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "a.html": """
+                {%- set foo = 'bar' -%}
+                {% include 'x.html' -%}
+            """,
+                    "b.html": """
+                {%- set foo = 'bar' -%}
+                {% block test %}{% include 'x.html' %}{% endblock -%}
+                """,
+                    "c.html": """
+                {%- set foo = 'bar' -%}
+                {% block test %}{% set foo = foo
+                    %}{% include 'x.html' %}{% endblock -%}
+            """,
+                    "x.html": """{{ foo }}|{{ test }}""",
+                }
+            )
+        )
+
+        a = env.get_template("a.html")
+        b = env.get_template("b.html")
+        c = env.get_template("c.html")
+
+        assert a.render(test="x").strip() == "bar|x"
+        assert b.render(test="x").strip() == "bar|x"
+        assert c.render(test="x").strip() == "bar|x"
+
+    def test_scopes_and_include(self):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "include.html": "{{ var }}",
+                    "base.html": '{% include "include.html" %}',
+                    "child.html": '{% extends "base.html" %}{% set var = 42 %}',
+                }
+            )
+        )
+        t = env.get_template("child.html")
+        assert t.render() == "42"
+
+    def test_caller_scoping(self, env):
+        t = env.from_string(
+            """
+        {% macro detail(icon, value) -%}
+          {% if value -%}
+            <p><span class="fa fa-fw fa-{{ icon }}"></span>
+                {%- if caller is undefined -%}
+                    {{ value }}
+                {%- else -%}
+                    {{ caller(value, *varargs) }}
+                {%- endif -%}</p>
+          {%- endif %}
+        {%- endmacro %}
+
+
+        {% macro link_detail(icon, value, href) -%}
+          {% call(value, href) detail(icon, value, href) -%}
+            <a href="{{ href }}">{{ value }}</a>
+          {%- endcall %}
+        {%- endmacro %}
+        """
+        )
+
+        assert t.module.link_detail("circle", "Index", "/") == (
+            '<p><span class="fa fa-fw fa-circle"></span><a href="/">Index</a></p>'
+        )
+
+    def test_variable_reuse(self, env):
+        t = env.from_string("{% for x in x.y %}{{ x }}{% endfor %}")
+        assert t.render(x={"y": [0, 1, 2]}) == "012"
+
+        t = env.from_string("{% for x in x.y %}{{ loop.index0 }}|{{ x }}{% endfor %}")
+        assert t.render(x={"y": [0, 1, 2]}) == "0|01|12|2"
+
+        t = env.from_string("{% for x in x.y recursive %}{{ x }}{% endfor %}")
+        assert t.render(x={"y": [0, 1, 2]}) == "012"
+
+    def test_double_caller(self, env):
+        t = env.from_string(
+            "{% macro x(caller=none) %}[{% if caller %}"
+            "{{ caller() }}{% endif %}]{% endmacro %}"
+            "{{ x() }}{% call x() %}aha!{% endcall %}"
+        )
+        assert t.render() == "[][aha!]"
+
+    def test_double_caller_no_default(self, env):
+        with pytest.raises(TemplateAssertionError) as exc_info:
+            env.from_string(
+                "{% macro x(caller) %}[{% if caller %}"
+                "{{ caller() }}{% endif %}]{% endmacro %}"
+            )
+        assert exc_info.match(
+            r'"caller" argument must be omitted or ' r"be given a default"
+        )
+
+        t = env.from_string(
+            "{% macro x(caller=none) %}[{% if caller %}"
+            "{{ caller() }}{% endif %}]{% endmacro %}"
+        )
+        with pytest.raises(TypeError) as exc_info:
+            t.module.x(None, caller=lambda: 42)
+        assert exc_info.match(
+            r"\'x\' was invoked with two values for the " r"special caller argument"
+        )
+
+    def test_macro_blocks(self, env):
+        t = env.from_string(
+            "{% macro x() %}{% block foo %}x{% endblock %}{% endmacro %}{{ x() }}"
+        )
+        assert t.render() == "x"
+
+    def test_scoped_block(self, env):
+        t = env.from_string(
+            "{% set x = 1 %}{% with x = 2 %}{% block y scoped %}"
+            "{{ x }}{% endblock %}{% endwith %}"
+        )
+        assert t.render() == "2"
+
+    def test_recursive_loop_filter(self, env):
+        t = env.from_string(
+            """
+        <?xml version="1.0" encoding="UTF-8"?>
+        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+          {%- for page in [site.root] if page.url != this recursive %}
+          <url><loc>{{ page.url }}</loc></url>
+          {{- loop(page.children) }}
+          {%- endfor %}
+        </urlset>
+        """
+        )
+        sm = t.render(
+            this="/foo",
+            site={"root": {"url": "/", "children": [{"url": "/foo"}, {"url": "/bar"}]}},
+        )
+        lines = [x.strip() for x in sm.splitlines() if x.strip()]
+        assert lines == [
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+            "<url><loc>/</loc></url>",
+            "<url><loc>/bar</loc></url>",
+            "</urlset>",
+        ]
+
+    def test_empty_if(self, env):
+        t = env.from_string("{% if foo %}{% else %}42{% endif %}")
+        assert t.render(foo=False) == "42"
+
+    def test_subproperty_if(self, env):
+        t = env.from_string(
+            "{% if object1.subproperty1 is eq object2.subproperty2 %}42{% endif %}"
+        )
+        assert (
+            t.render(
+                object1={"subproperty1": "value"}, object2={"subproperty2": "value"}
+            )
+            == "42"
+        )
+
+    def test_set_and_include(self):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "inc": "bar",
+                    "main": '{% set foo = "foo" %}{{ foo }}{% include "inc" %}',
+                }
+            )
+        )
+        assert env.get_template("main").render() == "foobar"
+
+    def test_loop_include(self):
+        env = Environment(
+            loader=DictLoader(
+                {
+                    "inc": "{{ i }}",
+                    "main": '{% for i in [1, 2, 3] %}{% include "inc" %}{% endfor %}',
+                }
+            )
+        )
+        assert env.get_template("main").render() == "123"
+
+    def test_grouper_repr(self):
+        from jinja2.filters import _GroupTuple
+
+        t = _GroupTuple("foo", [1, 2])
+        assert t.grouper == "foo"
+        assert t.list == [1, 2]
+        assert repr(t) == "('foo', [1, 2])"
+        assert str(t) == "('foo', [1, 2])"
+
+    def test_custom_context(self, env):
+        from jinja2.runtime import Context
+
+        class MyContext(Context):
+            pass
+
+        class MyEnvironment(Environment):
+            context_class = MyContext
+
+        loader = DictLoader({"base": "{{ foobar }}", "test": '{% extends "base" %}'})
+        env = MyEnvironment(loader=loader)
+        assert env.get_template("test").render(foobar="test") == "test"
+
+    def test_recursive_loop_bug(self, env):
+        tmpl = env.from_string(
+            "{%- for value in values recursive %}1{% else %}0{% endfor -%}"
+        )
+        assert tmpl.render(values=[]) == "0"
+
+    def test_markup_and_chainable_undefined(self):
+        from markupsafe import Markup
+        from jinja2.runtime import ChainableUndefined
+
+        assert str(Markup(ChainableUndefined())) == ""
+
+    def test_scoped_block_loop_vars(self, env):
+        tmpl = env.from_string(
+            """\
+Start
+{% for i in ["foo", "bar"] -%}
+{% block body scoped -%}
+{{ loop.index }}) {{ i }}{% if loop.last %} last{% endif -%}
+{%- endblock %}
+{% endfor -%}
+End"""
+        )
+        assert tmpl.render() == "Start\n1) foo\n2) bar last\nEnd"
+
+    def test_pass_context_loop_vars(self, env):
+        @pass_context
+        def test(ctx):
+            return f"{ctx['i']}{ctx['j']}"
+
+        tmpl = env.from_string(
+            """\
+{% set i = 42 %}
+{%- for idx in range(2) -%}
+{{ i }}{{ j }}
+{% set i = idx -%}
+{%- set j = loop.index -%}
+{{ test() }}
+{{ i }}{{ j }}
+{% endfor -%}
+{{ i }}{{ j }}"""
+        )
+        tmpl.globals["test"] = test
+        assert tmpl.render() == "42\n01\n01\n42\n12\n12\n42"
+
+    def test_pass_context_scoped_loop_vars(self, env):
+        @pass_context
+        def test(ctx):
+            return f"{ctx['i']}"
+
+        tmpl = env.from_string(
+            """\
+{% set i = 42 %}
+{%- for idx in range(2) -%}
+{{ i }}
+{%- set i = loop.index0 -%}
+{% block body scoped %}
+{{ test() }}
+{% endblock -%}
+{% endfor -%}
+{{ i }}"""
+        )
+        tmpl.globals["test"] = test
+        assert tmpl.render() == "42\n0\n42\n1\n42"
+
+    def test_pass_context_in_blocks(self, env):
+        @pass_context
+        def test(ctx):
+            return f"{ctx['i']}"
+
+        tmpl = env.from_string(
+            """\
+{%- set i = 42 -%}
+{{ i }}
+{% block body -%}
+{% set i = 24 -%}
+{{ test() }}
+{% endblock -%}
+{{ i }}"""
+        )
+        tmpl.globals["test"] = test
+        assert tmpl.render() == "42\n24\n42"
+
+    def test_pass_context_block_and_loop(self, env):
+        @pass_context
+        def test(ctx):
+            return f"{ctx['i']}"
+
+        tmpl = env.from_string(
+            """\
+{%- set i = 42 -%}
+{% for idx in range(2) -%}
+{{ test() }}
+{%- set i = idx -%}
+{% block body scoped %}
+{{ test() }}
+{% set i = 24 -%}
+{{ test() }}
+{% endblock -%}
+{{ test() }}
+{% endfor -%}
+{{ test() }}"""
+        )
+        tmpl.globals["test"] = test
+
+        # values set within a block or loop should not
+        # show up outside of it
+        assert tmpl.render() == "42\n0\n24\n0\n42\n1\n24\n1\n42"
+
+    @pytest.mark.parametrize("op", ["extends", "include"])
+    def test_cached_extends(self, op):
+        env = Environment(
+            loader=DictLoader(
+                {"base": "{{ x }} {{ y }}", "main": f"{{% {op} 'base' %}}"}
+            )
+        )
+        env.globals["x"] = "x"
+        env.globals["y"] = "y"
+
+        # template globals overlay env globals
+        tmpl = env.get_template("main", globals={"x": "bar"})
+        assert tmpl.render() == "bar y"
+
+        # base was loaded indirectly, it just has env globals
+        tmpl = env.get_template("base")
+        assert tmpl.render() == "x y"
+
+        # set template globals for base, no longer uses env globals
+        tmpl = env.get_template("base", globals={"x": 42})
+        assert tmpl.render() == "42 y"
+
+        # templates are cached, they keep template globals set earlier
+        tmpl = env.get_template("main")
+        assert tmpl.render() == "bar y"
+
+        tmpl = env.get_template("base")
+        assert tmpl.render() == "42 y"
+
+    def test_nested_loop_scoping(self, env):
+        tmpl = env.from_string(
+            "{% set output %}{% for x in [1,2,3] %}hello{% endfor %}"
+            "{% endset %}{{ output }}"
+        )
+        assert tmpl.render() == "hellohellohello"
+
+
+@pytest.mark.parametrize("unicode_char", ["\N{FORM FEED}", "\x85"])
+def test_unicode_whitespace(env, unicode_char):
+    content = "Lorem ipsum\n" + unicode_char + "\nMore text"
+    tmpl = env.from_string(content)
+    assert tmpl.render() == content
diff --git a/tests/test_runtime.py b/tests/test_runtime.py
new file mode 100644
index 0000000..1978c64
--- /dev/null
+++ b/tests/test_runtime.py
@@ -0,0 +1,75 @@
+import itertools
+
+from jinja2 import Template
+from jinja2.runtime import LoopContext
+
+TEST_IDX_TEMPLATE_STR_1 = (
+    "[{% for i in lst|reverse %}(len={{ loop.length }},"
+    " revindex={{ loop.revindex }}, index={{ loop.index }}, val={{ i }}){% endfor %}]"
+)
+TEST_IDX0_TEMPLATE_STR_1 = (
+    "[{% for i in lst|reverse %}(len={{ loop.length }},"
+    " revindex0={{ loop.revindex0 }}, index0={{ loop.index0 }}, val={{ i }})"
+    "{% endfor %}]"
+)
+
+
+def test_loop_idx():
+    t = Template(TEST_IDX_TEMPLATE_STR_1)
+    lst = [10]
+    excepted_render = "[(len=1, revindex=1, index=1, val=10)]"
+    assert excepted_render == t.render(lst=lst)
+
+
+def test_loop_idx0():
+    t = Template(TEST_IDX0_TEMPLATE_STR_1)
+    lst = [10]
+    excepted_render = "[(len=1, revindex0=0, index0=0, val=10)]"
+    assert excepted_render == t.render(lst=lst)
+
+
+def test_loopcontext0():
+    in_lst = []
+    lc = LoopContext(reversed(in_lst), None)
+    assert lc.length == len(in_lst)
+
+
+def test_loopcontext1():
+    in_lst = [10]
+    lc = LoopContext(reversed(in_lst), None)
+    assert lc.length == len(in_lst)
+
+
+def test_loopcontext2():
+    in_lst = [10, 11]
+    lc = LoopContext(reversed(in_lst), None)
+    assert lc.length == len(in_lst)
+
+
+def test_iterator_not_advanced_early():
+    t = Template("{% for _, g in gs %}{{ loop.index }} {{ g|list }}\n{% endfor %}")
+    out = t.render(
+        gs=itertools.groupby([(1, "a"), (1, "b"), (2, "c"), (3, "d")], lambda x: x[0])
+    )
+    # groupby groups depend on the current position of the iterator. If
+    # it was advanced early, the lists would appear empty.
+    assert out == "1 [(1, 'a'), (1, 'b')]\n2 [(2, 'c')]\n3 [(3, 'd')]\n"
+
+
+def test_mock_not_pass_arg_marker():
+    """If a callable class has a ``__getattr__`` that returns True-like
+    values for arbitrary attrs, it should not be incorrectly identified
+    as a ``pass_context`` function.
+    """
+
+    class Calc:
+        def __getattr__(self, item):
+            return object()
+
+        def __call__(self, *args, **kwargs):
+            return len(args) + len(kwargs)
+
+    t = Template("{{ calc() }}")
+    out = t.render(calc=Calc())
+    # Would be "1" if context argument was passed.
+    assert out == "0"
diff --git a/tests/test_security.py b/tests/test_security.py
new file mode 100644
index 0000000..0e8dc5c
--- /dev/null
+++ b/tests/test_security.py
@@ -0,0 +1,173 @@
+import pytest
+from markupsafe import escape
+
+from jinja2 import Environment
+from jinja2.exceptions import SecurityError
+from jinja2.exceptions import TemplateRuntimeError
+from jinja2.exceptions import TemplateSyntaxError
+from jinja2.nodes import EvalContext
+from jinja2.sandbox import ImmutableSandboxedEnvironment
+from jinja2.sandbox import SandboxedEnvironment
+from jinja2.sandbox import unsafe
+
+
+class PrivateStuff:
+    def bar(self):
+        return 23
+
+    @unsafe
+    def foo(self):
+        return 42
+
+    def __repr__(self):
+        return "PrivateStuff"
+
+
+class PublicStuff:
+    def bar(self):
+        return 23
+
+    def _foo(self):
+        return 42
+
+    def __repr__(self):
+        return "PublicStuff"
+
+
+class TestSandbox:
+    def test_unsafe(self, env):
+        env = SandboxedEnvironment()
+        pytest.raises(
+            SecurityError, env.from_string("{{ foo.foo() }}").render, foo=PrivateStuff()
+        )
+        assert env.from_string("{{ foo.bar() }}").render(foo=PrivateStuff()) == "23"
+
+        pytest.raises(
+            SecurityError, env.from_string("{{ foo._foo() }}").render, foo=PublicStuff()
+        )
+        assert env.from_string("{{ foo.bar() }}").render(foo=PublicStuff()) == "23"
+        assert env.from_string("{{ foo.__class__ }}").render(foo=42) == ""
+        assert env.from_string("{{ foo.func_code }}").render(foo=lambda: None) == ""
+        # security error comes from __class__ already.
+        pytest.raises(
+            SecurityError,
+            env.from_string("{{ foo.__class__.__subclasses__() }}").render,
+            foo=42,
+        )
+
+    def test_immutable_environment(self, env):
+        env = ImmutableSandboxedEnvironment()
+        pytest.raises(SecurityError, env.from_string("{{ [].append(23) }}").render)
+        pytest.raises(SecurityError, env.from_string("{{ {1:2}.clear() }}").render)
+
+    def test_restricted(self, env):
+        env = SandboxedEnvironment()
+        pytest.raises(
+            TemplateSyntaxError,
+            env.from_string,
+            "{% for item.attribute in seq %}...{% endfor %}",
+        )
+        pytest.raises(
+            TemplateSyntaxError,
+            env.from_string,
+            "{% for foo, bar.baz in seq %}...{% endfor %}",
+        )
+
+    def test_template_data(self, env):
+        env = Environment(autoescape=True)
+        t = env.from_string(
+            "{% macro say_hello(name) %}"
+            "<p>Hello {{ name }}!</p>{% endmacro %}"
+            '{{ say_hello("<blink>foo</blink>") }}'
+        )
+        escaped_out = "<p>Hello &lt;blink&gt;foo&lt;/blink&gt;!</p>"
+        assert t.render() == escaped_out
+        assert str(t.module) == escaped_out
+        assert escape(t.module) == escaped_out
+        assert t.module.say_hello("<blink>foo</blink>") == escaped_out
+        assert (
+            escape(t.module.say_hello(EvalContext(env), "<blink>foo</blink>"))
+            == escaped_out
+        )
+        assert escape(t.module.say_hello("<blink>foo</blink>")) == escaped_out
+
+    def test_attr_filter(self, env):
+        env = SandboxedEnvironment()
+        tmpl = env.from_string('{{ cls|attr("__subclasses__")() }}')
+        pytest.raises(SecurityError, tmpl.render, cls=int)
+
+    def test_binary_operator_intercepting(self, env):
+        def disable_op(left, right):
+            raise TemplateRuntimeError("that operator so does not work")
+
+        for expr, ctx, rv in ("1 + 2", {}, "3"), ("a + 2", {"a": 2}, "4"):
+            env = SandboxedEnvironment()
+            env.binop_table["+"] = disable_op
+            t = env.from_string(f"{{{{ {expr} }}}}")
+            assert t.render(ctx) == rv
+            env.intercepted_binops = frozenset(["+"])
+            t = env.from_string(f"{{{{ {expr} }}}}")
+            with pytest.raises(TemplateRuntimeError):
+                t.render(ctx)
+
+    def test_unary_operator_intercepting(self, env):
+        def disable_op(arg):
+            raise TemplateRuntimeError("that operator so does not work")
+
+        for expr, ctx, rv in ("-1", {}, "-1"), ("-a", {"a": 2}, "-2"):
+            env = SandboxedEnvironment()
+            env.unop_table["-"] = disable_op
+            t = env.from_string(f"{{{{ {expr} }}}}")
+            assert t.render(ctx) == rv
+            env.intercepted_unops = frozenset(["-"])
+            t = env.from_string(f"{{{{ {expr} }}}}")
+            with pytest.raises(TemplateRuntimeError):
+                t.render(ctx)
+
+
+class TestStringFormat:
+    def test_basic_format_safety(self):
+        env = SandboxedEnvironment()
+        t = env.from_string('{{ "a{0.__class__}b".format(42) }}')
+        assert t.render() == "ab"
+
+    def test_basic_format_all_okay(self):
+        env = SandboxedEnvironment()
+        t = env.from_string('{{ "a{0.foo}b".format({"foo": 42}) }}')
+        assert t.render() == "a42b"
+
+    def test_safe_format_safety(self):
+        env = SandboxedEnvironment()
+        t = env.from_string('{{ ("a{0.__class__}b{1}"|safe).format(42, "<foo>") }}')
+        assert t.render() == "ab&lt;foo&gt;"
+
+    def test_safe_format_all_okay(self):
+        env = SandboxedEnvironment()
+        t = env.from_string('{{ ("a{0.foo}b{1}"|safe).format({"foo": 42}, "<foo>") }}')
+        assert t.render() == "a42b&lt;foo&gt;"
+
+    def test_empty_braces_format(self):
+        env = SandboxedEnvironment()
+        t1 = env.from_string('{{ ("a{}b{}").format("foo", "42")}}')
+        t2 = env.from_string('{{ ("a{}b{}"|safe).format(42, "<foo>") }}')
+        assert t1.render() == "afoob42"
+        assert t2.render() == "a42b&lt;foo&gt;"
+
+
+class TestStringFormatMap:
+    def test_basic_format_safety(self):
+        env = SandboxedEnvironment()
+        t = env.from_string('{{ "a{x.__class__}b".format_map({"x":42}) }}')
+        assert t.render() == "ab"
+
+    def test_basic_format_all_okay(self):
+        env = SandboxedEnvironment()
+        t = env.from_string('{{ "a{x.foo}b".format_map({"x":{"foo": 42}}) }}')
+        assert t.render() == "a42b"
+
+    def test_safe_format_all_okay(self):
+        env = SandboxedEnvironment()
+        t = env.from_string(
+            '{{ ("a{x.foo}b{y}"|safe).format_map({"x":{"foo": 42}, "y":"<foo>"}) }}'
+        )
+        assert t.render() == "a42b&lt;foo&gt;"
diff --git a/tests/test_tests.py b/tests/test_tests.py
new file mode 100644
index 0000000..75178d6
--- /dev/null
+++ b/tests/test_tests.py
@@ -0,0 +1,233 @@
+import pytest
+from markupsafe import Markup
+
+from jinja2 import Environment
+from jinja2 import TemplateAssertionError
+from jinja2 import TemplateRuntimeError
+
+
+class MyDict(dict):
+    pass
+
+
+class TestTestsCase:
+    def test_defined(self, env):
+        tmpl = env.from_string("{{ missing is defined }}|{{ true is defined }}")
+        assert tmpl.render() == "False|True"
+
+    def test_even(self, env):
+        tmpl = env.from_string("""{{ 1 is even }}|{{ 2 is even }}""")
+        assert tmpl.render() == "False|True"
+
+    def test_odd(self, env):
+        tmpl = env.from_string("""{{ 1 is odd }}|{{ 2 is odd }}""")
+        assert tmpl.render() == "True|False"
+
+    def test_lower(self, env):
+        tmpl = env.from_string("""{{ "foo" is lower }}|{{ "FOO" is lower }}""")
+        assert tmpl.render() == "True|False"
+
+    # Test type checks
+    @pytest.mark.parametrize(
+        "op,expect",
+        (
+            ("none is none", True),
+            ("false is none", False),
+            ("true is none", False),
+            ("42 is none", False),
+            ("none is true", False),
+            ("false is true", False),
+            ("true is true", True),
+            ("0 is true", False),
+            ("1 is true", False),
+            ("42 is true", False),
+            ("none is false", False),
+            ("false is false", True),
+            ("true is false", False),
+            ("0 is false", False),
+            ("1 is false", False),
+            ("42 is false", False),
+            ("none is boolean", False),
+            ("false is boolean", True),
+            ("true is boolean", True),
+            ("0 is boolean", False),
+            ("1 is boolean", False),
+            ("42 is boolean", False),
+            ("0.0 is boolean", False),
+            ("1.0 is boolean", False),
+            ("3.14159 is boolean", False),
+            ("none is integer", False),
+            ("false is integer", False),
+            ("true is integer", False),
+            ("42 is integer", True),
+            ("3.14159 is integer", False),
+            ("(10 ** 100) is integer", True),
+            ("none is float", False),
+            ("false is float", False),
+            ("true is float", False),
+            ("42 is float", False),
+            ("4.2 is float", True),
+            ("(10 ** 100) is float", False),
+            ("none is number", False),
+            ("false is number", True),
+            ("true is number", True),
+            ("42 is number", True),
+            ("3.14159 is number", True),
+            ("complex is number", True),
+            ("(10 ** 100) is number", True),
+            ("none is string", False),
+            ("false is string", False),
+            ("true is string", False),
+            ("42 is string", False),
+            ('"foo" is string', True),
+            ("none is sequence", False),
+            ("false is sequence", False),
+            ("42 is sequence", False),
+            ('"foo" is sequence', True),
+            ("[] is sequence", True),
+            ("[1, 2, 3] is sequence", True),
+            ("{} is sequence", True),
+            ("none is mapping", False),
+            ("false is mapping", False),
+            ("42 is mapping", False),
+            ('"foo" is mapping', False),
+            ("[] is mapping", False),
+            ("{} is mapping", True),
+            ("mydict is mapping", True),
+            ("none is iterable", False),
+            ("false is iterable", False),
+            ("42 is iterable", False),
+            ('"foo" is iterable', True),
+            ("[] is iterable", True),
+            ("{} is iterable", True),
+            ("range(5) is iterable", True),
+            ("none is callable", False),
+            ("false is callable", False),
+            ("42 is callable", False),
+            ('"foo" is callable', False),
+            ("[] is callable", False),
+            ("{} is callable", False),
+            ("range is callable", True),
+        ),
+    )
+    def test_types(self, env, op, expect):
+        t = env.from_string(f"{{{{ {op} }}}}")
+        assert t.render(mydict=MyDict(), complex=complex(1, 2)) == str(expect)
+
+    def test_upper(self, env):
+        tmpl = env.from_string('{{ "FOO" is upper }}|{{ "foo" is upper }}')
+        assert tmpl.render() == "True|False"
+
+    def test_equalto(self, env):
+        tmpl = env.from_string(
+            "{{ foo is eq 12 }}|"
+            "{{ foo is eq 0 }}|"
+            "{{ foo is eq (3 * 4) }}|"
+            '{{ bar is eq "baz" }}|'
+            '{{ bar is eq "zab" }}|'
+            '{{ bar is eq ("ba" + "z") }}|'
+            "{{ bar is eq bar }}|"
+            "{{ bar is eq foo }}"
+        )
+        assert (
+            tmpl.render(foo=12, bar="baz")
+            == "True|False|True|True|False|True|True|False"
+        )
+
+    @pytest.mark.parametrize(
+        "op,expect",
+        (
+            ("eq 2", True),
+            ("eq 3", False),
+            ("ne 3", True),
+            ("ne 2", False),
+            ("lt 3", True),
+            ("lt 2", False),
+            ("le 2", True),
+            ("le 1", False),
+            ("gt 1", True),
+            ("gt 2", False),
+            ("ge 2", True),
+            ("ge 3", False),
+        ),
+    )
+    def test_compare_aliases(self, env, op, expect):
+        t = env.from_string(f"{{{{ 2 is {op} }}}}")
+        assert t.render() == str(expect)
+
+    def test_sameas(self, env):
+        tmpl = env.from_string("{{ foo is sameas false }}|{{ 0 is sameas false }}")
+        assert tmpl.render(foo=False) == "True|False"
+
+    def test_no_paren_for_arg1(self, env):
+        tmpl = env.from_string("{{ foo is sameas none }}")
+        assert tmpl.render(foo=None) == "True"
+
+    def test_escaped(self, env):
+        env = Environment(autoescape=True)
+        tmpl = env.from_string("{{ x is escaped }}|{{ y is escaped }}")
+        assert tmpl.render(x="foo", y=Markup("foo")) == "False|True"
+
+    def test_greaterthan(self, env):
+        tmpl = env.from_string("{{ 1 is greaterthan 0 }}|{{ 0 is greaterthan 1 }}")
+        assert tmpl.render() == "True|False"
+
+    def test_lessthan(self, env):
+        tmpl = env.from_string("{{ 0 is lessthan 1 }}|{{ 1 is lessthan 0 }}")
+        assert tmpl.render() == "True|False"
+
+    def test_multiple_tests(self):
+        items = []
+
+        def matching(x, y):
+            items.append((x, y))
+            return False
+
+        env = Environment()
+        env.tests["matching"] = matching
+        tmpl = env.from_string(
+            "{{ 'us-west-1' is matching '(us-east-1|ap-northeast-1)'"
+            " or 'stage' is matching '(dev|stage)' }}"
+        )
+        assert tmpl.render() == "False"
+        assert items == [
+            ("us-west-1", "(us-east-1|ap-northeast-1)"),
+            ("stage", "(dev|stage)"),
+        ]
+
+    def test_in(self, env):
+        tmpl = env.from_string(
+            '{{ "o" is in "foo" }}|'
+            '{{ "foo" is in "foo" }}|'
+            '{{ "b" is in "foo" }}|'
+            "{{ 1 is in ((1, 2)) }}|"
+            "{{ 3 is in ((1, 2)) }}|"
+            "{{ 1 is in [1, 2] }}|"
+            "{{ 3 is in [1, 2] }}|"
+            '{{ "foo" is in {"foo": 1}}}|'
+            '{{ "baz" is in {"bar": 1}}}'
+        )
+        assert tmpl.render() == "True|True|False|True|False|True|False|True|False"
+
+
+def test_name_undefined(env):
+    with pytest.raises(TemplateAssertionError, match="No test named 'f'"):
+        env.from_string("{{ x is f }}")
+
+
+def test_name_undefined_in_if(env):
+    t = env.from_string("{% if x is defined %}{{ x is f }}{% endif %}")
+    assert t.render() == ""
+
+    with pytest.raises(TemplateRuntimeError, match="No test named 'f'"):
+        t.render(x=1)
+
+
+def test_is_filter(env):
+    assert env.call_test("filter", "title")
+    assert not env.call_test("filter", "bad-name")
+
+
+def test_is_test(env):
+    assert env.call_test("test", "number")
+    assert not env.call_test("test", "bad-name")
diff --git a/tests/test_utils.py b/tests/test_utils.py
new file mode 100644
index 0000000..7b58af1
--- /dev/null
+++ b/tests/test_utils.py
@@ -0,0 +1,185 @@
+import pickle
+import random
+from collections import deque
+from copy import copy as shallow_copy
+
+import pytest
+from markupsafe import Markup
+
+from jinja2.utils import consume
+from jinja2.utils import generate_lorem_ipsum
+from jinja2.utils import LRUCache
+from jinja2.utils import missing
+from jinja2.utils import object_type_repr
+from jinja2.utils import select_autoescape
+from jinja2.utils import urlize
+
+
+class TestLRUCache:
+    def test_simple(self):
+        d = LRUCache(3)
+        d["a"] = 1
+        d["b"] = 2
+        d["c"] = 3
+        d["a"]
+        d["d"] = 4
+        assert d.keys() == ["d", "a", "c"]
+
+    def test_values(self):
+        cache = LRUCache(3)
+        cache["b"] = 1
+        cache["a"] = 2
+        assert cache.values() == [2, 1]
+
+    def test_values_empty(self):
+        cache = LRUCache(2)
+        assert cache.values() == []
+
+    def test_pickleable(self):
+        cache = LRUCache(2)
+        cache["foo"] = 42
+        cache["bar"] = 23
+        cache["foo"]
+
+        for protocol in range(3):
+            copy = pickle.loads(pickle.dumps(cache, protocol))
+            assert copy.capacity == cache.capacity
+            assert copy._mapping == cache._mapping
+            assert copy._queue == cache._queue
+
+    @pytest.mark.parametrize("copy_func", [LRUCache.copy, shallow_copy])
+    def test_copy(self, copy_func):
+        cache = LRUCache(2)
+        cache["a"] = 1
+        cache["b"] = 2
+        copy = copy_func(cache)
+        assert copy._queue == cache._queue
+        copy["c"] = 3
+        assert copy._queue != cache._queue
+        assert copy.keys() == ["c", "b"]
+
+    def test_clear(self):
+        d = LRUCache(3)
+        d["a"] = 1
+        d["b"] = 2
+        d["c"] = 3
+        d.clear()
+        assert d.__getstate__() == {"capacity": 3, "_mapping": {}, "_queue": deque([])}
+
+    def test_repr(self):
+        d = LRUCache(3)
+        d["a"] = 1
+        d["b"] = 2
+        d["c"] = 3
+        # Sort the strings - mapping is unordered
+        assert sorted(repr(d)) == sorted("<LRUCache {'a': 1, 'b': 2, 'c': 3}>")
+
+    def test_items(self):
+        """Test various items, keys, values and iterators of LRUCache."""
+        d = LRUCache(3)
+        d["a"] = 1
+        d["b"] = 2
+        d["c"] = 3
+        assert d.items() == [("c", 3), ("b", 2), ("a", 1)]
+        assert d.keys() == ["c", "b", "a"]
+        assert d.values() == [3, 2, 1]
+        assert list(reversed(d)) == ["a", "b", "c"]
+
+        # Change the cache a little
+        d["b"]
+        d["a"] = 4
+        assert d.items() == [("a", 4), ("b", 2), ("c", 3)]
+        assert d.keys() == ["a", "b", "c"]
+        assert d.values() == [4, 2, 3]
+        assert list(reversed(d)) == ["c", "b", "a"]
+
+    def test_setdefault(self):
+        d = LRUCache(3)
+        assert len(d) == 0
+        assert d.setdefault("a") is None
+        assert d.setdefault("a", 1) is None
+        assert len(d) == 1
+        assert d.setdefault("b", 2) == 2
+        assert len(d) == 2
+
+
+class TestHelpers:
+    def test_object_type_repr(self):
+        class X:
+            pass
+
+        assert object_type_repr(42) == "int object"
+        assert object_type_repr([]) == "list object"
+        assert object_type_repr(X()) == "test_utils.X object"
+        assert object_type_repr(None) == "None"
+        assert object_type_repr(Ellipsis) == "Ellipsis"
+
+    def test_autoescape_select(self):
+        func = select_autoescape(
+            enabled_extensions=("html", ".htm"),
+            disabled_extensions=("txt",),
+            default_for_string="STRING",
+            default="NONE",
+        )
+
+        assert func(None) == "STRING"
+        assert func("unknown.foo") == "NONE"
+        assert func("foo.html")
+        assert func("foo.htm")
+        assert not func("foo.txt")
+        assert func("FOO.HTML")
+        assert not func("FOO.TXT")
+
+
+class TestEscapeUrlizeTarget:
+    def test_escape_urlize_target(self):
+        url = "http://example.org"
+        target = "<script>"
+        assert urlize(url, target=target) == (
+            '<a href="http://example.org"'
+            ' target="&lt;script&gt;">'
+            "http://example.org</a>"
+        )
+
+
+class TestLoremIpsum:
+    def test_lorem_ipsum_markup(self):
+        """Test that output of lorem_ipsum is Markup by default."""
+        assert isinstance(generate_lorem_ipsum(), Markup)
+
+    def test_lorem_ipsum_html(self):
+        """Test that output of lorem_ipsum is a string_type when not html."""
+        assert isinstance(generate_lorem_ipsum(html=False), str)
+
+    def test_lorem_ipsum_n(self):
+        """Test that the n (number of lines) works as expected."""
+        assert generate_lorem_ipsum(n=0, html=False) == ""
+        for n in range(1, 50):
+            assert generate_lorem_ipsum(n=n, html=False).count("\n") == (n - 1) * 2
+
+    def test_lorem_ipsum_min(self):
+        """Test that at least min words are in the output of each line"""
+        for _ in range(5):
+            m = random.randrange(20, 99)
+            for _ in range(10):
+                assert generate_lorem_ipsum(n=1, min=m, html=False).count(" ") >= m - 1
+
+    def test_lorem_ipsum_max(self):
+        """Test that at least max words are in the output of each line"""
+        for _ in range(5):
+            m = random.randrange(21, 100)
+            for _ in range(10):
+                assert generate_lorem_ipsum(n=1, max=m, html=False).count(" ") < m - 1
+
+
+def test_missing():
+    """Test the repr of missing."""
+    assert repr(missing) == "missing"
+
+
+def test_consume():
+    """Test that consume consumes an iterator."""
+    x = iter([1, 2, 3, 4, 5])
+    consume(x)
+    with pytest.raises(StopIteration):
+        next(x)
-- 
cgit v1.2.3