Store filter names as symbols internally

2026-09-15 00:40:40 -07:00 · 2022-08-05 15:22:19 -04:00
80 changed files with 1069 additions and 1639 deletions
@@ -1,10 +1,5 @@
 name: Liquid
 on: [push, pull_request]
-
-env:
-  BUNDLE_JOBS: 4
-  BUNDLE_RETRY: 3
-
 jobs:
  test:
    runs-on: ubuntu-latest
@@ -12,18 +7,22 @@ jobs:
      matrix:
        entry:
          - { ruby: 2.7, allowed-failure: false } # minimum supported
-          - { ruby: 3.2, allowed-failure: false } # latest
+          - { ruby: 3.1, allowed-failure: false } # latest
          - { ruby: ruby-head, allowed-failure: true }
-    name: Test Ruby ${{ matrix.entry.ruby }}
+    name: test (${{ matrix.entry.ruby }})
    steps:
      - uses: actions/checkout@v3
      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: ${{ matrix.entry.ruby }}
-          bundler-cache: true
+      - uses: actions/cache@v1
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-gems-${{ hashFiles('Gemfile') }}
+          restore-keys: ${{ runner.os }}-gems-
+      - run: bundle install --jobs=3 --retry=3 --path=vendor/bundle
      - run: bundle exec rake
        continue-on-error: ${{ matrix.entry.allowed-failure }}
-
  memory_profile:
    runs-on: ubuntu-latest
    steps:
@@ -31,5 +30,10 @@ jobs:
      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: 2.7
-          bundler-cache: true
+      - uses: actions/cache@v1
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-gems-${{ hashFiles('Gemfile') }}
+          restore-keys: ${{ runner.os }}-gems-
+      - run: bundle install --jobs=3 --retry=3 --path=vendor/bundle
      - run: bundle exec rake memory_profile:run
@@ -12,7 +12,6 @@ Performance:
 AllCops:
  TargetRubyVersion: 2.7
  NewCops: disable
-  SuggestExtensions: false
  Exclude:
    - 'vendor/bundle/**/*'

@@ -20,10 +19,6 @@ Naming/MethodName:
  Exclude:
    - 'example/server/liquid_servlet.rb'

-Style/ClassMethodsDefinitions:
-  Enabled: false
-
-# liquid filter calls were being mistaken to be calls on arrays
-Style/ConcatArrayLiterals:
-  Exclude:
-    - 'test/integration/standard_filter_test.rb'
+# Backport https://github.com/Shopify/ruby-style-guide/pull/258
+Layout/BeginEndAlignment:
+  Enabled: true
@@ -18,8 +18,7 @@ group :benchmark, :test do
 end

 group :test do
-  gem 'rubocop', '~> 1.44.0'
-  gem 'rubocop-shopify', '~> 2.12.0', require: false
+  gem 'rubocop-shopify', '~> 2.7.0', require: false
  gem 'rubocop-performance', require: false

  platform :mri, :truffleruby do
@@ -5,7 +5,7 @@

 * [Contributing guidelines](CONTRIBUTING.md)
 * [Version history](History.md)
-* [Liquid documentation from Shopify](https://shopify.dev/docs/docs/api/liquid)
+* [Liquid documentation from Shopify](https://shopify.dev/api/liquid)
 * [Liquid Wiki at GitHub](https://github.com/Shopify/liquid/wiki)
 * [Website](http://liquidmarkup.org/)

@@ -30,18 +30,14 @@ class Servlet < LiquidServlet
  private

  def products_list
-    [
-      { 'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
-      { 'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling' },
-      { 'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity' }
-    ]
+    [{ 'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
+     { 'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling' },
+     { 'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity' }]
  end

  def more_products_list
-    [
-      { 'name' => 'Arbor Catalyst', 'price' => 39900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' },
-      { 'name' => 'Arbor Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' }
-    ]
+    [{ 'name' => 'Arbor Catalyst', 'price' => 39900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' },
+     { 'name' => 'Arbor Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' }]
  end

  def description
@@ -41,7 +41,7 @@ module Liquid
  AnyStartingTag              = /#{TagStart}|#{VariableStart}/o
  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
-  VariableParser              = /\[(?>[^\[\]]+|\g<0>)*\]|#{VariableSegment}+\??/o
+  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o

  RAISE_EXCEPTION_LAMBDA = ->(_e) { raise }

@@ -36,17 +36,13 @@ module Liquid
    # @api private
    def self.raise_unknown_tag(tag, block_name, block_delimiter, parse_context)
      if tag == 'else'
-        raise SyntaxError, parse_context.locale.t(
-          "errors.syntax.unexpected_else",
-          block_name: block_name,
-        )
+        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_else",
+          block_name: block_name)
      elsif tag.start_with?('end')
-        raise SyntaxError, parse_context.locale.t(
-          "errors.syntax.invalid_delimiter",
+        raise SyntaxError, parse_context.locale.t("errors.syntax.invalid_delimiter",
          tag: tag,
          block_name: block_name,
-          block_delimiter: block_delimiter,
-        )
+          block_delimiter: block_delimiter)
      else
        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag", tag: tag)
      end
@@ -109,22 +109,14 @@ module Liquid
      end
    end

-    private def handle_invalid_tag_token(token, parse_context)
-      if token.end_with?('%}')
-        yield token, token
-      else
-        BlockBody.raise_missing_tag_terminator(token, parse_context)
-      end
-    end
-
-    private def parse_for_document(tokenizer, parse_context, &block)
+    private def parse_for_document(tokenizer, parse_context)
      while (token = tokenizer.shift)
        next if token.empty?
        case
        when token.start_with?(TAGSTART)
          whitespace_handler(token, parse_context)
          unless token =~ FullToken
-            return handle_invalid_tag_token(token, parse_context, &block)
+            BlockBody.raise_missing_tag_terminator(token, parse_context)
          end
          tag_name = Regexp.last_match(2)
          markup   = Regexp.last_match(4)
@@ -159,10 +159,8 @@ module Liquid
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        [
-          @node.left,
-          @node.right,
-          @node.child_condition,
-          @node.attachment
+          @node.left, @node.right,
+          @node.child_condition, @node.attachment
        ].compact
      end
    end
@@ -26,7 +26,7 @@ module Liquid
      @environments = [environments]
      @environments.flatten!

-      @static_environments = [static_environments].flatten(1).freeze
+      @static_environments = [static_environments].flat_map(&:freeze).freeze
      @scopes              = [(outer_scope || {})]
      @registers           = registers.is_a?(Registers) ? registers : Registers.new(registers)
      @errors              = []
@@ -144,7 +144,7 @@ module Liquid
      self.class.build(
        resource_limits: resource_limits,
        static_environments: static_environments,
-        registers: Registers.new(registers),
+        registers: Registers.new(registers)
      ).tap do |subcontext|
        subcontext.base_scope_depth   = base_scope_depth + 1
        subcontext.exception_renderer = exception_renderer
@@ -25,10 +25,6 @@ module Liquid
  class Drop
    attr_writer :context

-    def initialize
-      @context = nil
-    end
-
    # Catch all for the method
    def liquid_method_missing(method)
      return nil unless @context&.strict_variables
@@ -3,10 +3,7 @@
 module Liquid
  class Expression
    LITERALS = {
-      nil => nil,
-      'nil' => nil,
-      'null' => nil,
-      '' => nil,
+      nil => nil, 'nil' => nil, 'null' => nil, '' => nil,
      'true' => true,
      'false' => false,
      'blank' => '',
@@ -5,7 +5,7 @@ module Liquid
  # @liquid_type object
  # @liquid_name forloop
  # @liquid_summary
-  #   Information about a parent [`for` loop](/docs/api/liquid/tags/for).
+  #   Information about a parent [`for` loop](/api/liquid/tags#for).
  class ForloopDrop < Drop
    def initialize(name, length, parentloop)
      @name       = name
@@ -30,7 +30,10 @@ module Liquid
    # @liquid_return [forloop]
    attr_reader :parentloop

-    attr_reader :name
+    def name
+      Usage.increment('forloop_drop_name')
+      @name
+    end

    # @liquid_public_docs
    # @liquid_summary
@@ -18,7 +18,6 @@ module Liquid
    IDENTIFIER            = /[a-zA-Z_][\w-]*\??/
    SINGLE_STRING_LITERAL = /'[^\']*'/
    DOUBLE_STRING_LITERAL = /"[^\"]*"/
-    STRING_LITERAL        = Regexp.union(SINGLE_STRING_LITERAL, DOUBLE_STRING_LITERAL)
    NUMBER_LITERAL        = /-?\d+(\.\d+)?/
    DOTDOT                = /\.\./
    COMPARISON_OPERATOR   = /==|!=|<>|<=?|>=?|contains(?=\s)/
@@ -36,7 +35,9 @@ module Liquid
        break if @ss.eos?
        tok      = if (t = @ss.scan(COMPARISON_OPERATOR))
          [:comparison, t]
-        elsif (t = @ss.scan(STRING_LITERAL))
+        elsif (t = @ss.scan(SINGLE_STRING_LITERAL))
+          [:string, t]
+        elsif (t = @ss.scan(DOUBLE_STRING_LITERAL))
          [:string, t]
        elsif (t = @ss.scan(NUMBER_LITERAL))
          [:number, t]
@@ -16,8 +16,6 @@ module Liquid
      template = template_factory.for(template_name)

      partial = template.parse(source, parse_context)
-      partial.name ||= template_name
-
      cached_partials[template_name] = partial
    ensure
      parse_context.partial = false
@@ -8,17 +8,7 @@ module Liquid
      if start_obj.respond_to?(:evaluate) || end_obj.respond_to?(:evaluate)
        new(start_obj, end_obj)
      else
-        begin
-          start_obj.to_i..end_obj.to_i
-        rescue NoMethodError
-          invalid_expr = start_markup unless start_obj.respond_to?(:to_i)
-          invalid_expr ||= end_markup unless end_obj.respond_to?(:to_i)
-          if invalid_expr
-            raise Liquid::SyntaxError, "Invalid expression type '#{invalid_expr}' in range expression"
-          end
-
-          raise
-        end
+        start_obj.to_i..end_obj.to_i
      end
    end

@@ -6,14 +6,7 @@ require 'bigdecimal'

 module Liquid
  module StandardFilters
-    MAX_I32 = (1 << 31) - 1
-    private_constant :MAX_I32
-
-    MIN_I64 = -(1 << 63)
-    MAX_I64 = (1 << 63) - 1
-    I64_RANGE = MIN_I64..MAX_I64
-    private_constant :MIN_I64, :MAX_I64, :I64_RANGE
-
+    MAX_INT = (1 << 31) - 1
    HTML_ESCAPE = {
      '&' => '&amp;',
      '>' => '&gt;',
@@ -25,7 +18,7 @@ module Liquid
    STRIP_HTML_BLOCKS       = Regexp.union(
      %r{<script.*?</script>}m,
      /<!--.*?-->/m,
-      %r{<style.*?</style>}m,
+      %r{<style.*?</style>}m
    )
    STRIP_HTML_TAGS = /<.*?>/m

@@ -80,7 +73,7 @@ module Liquid
    # @liquid_type filter
    # @liquid_category string
    # @liquid_summary
-    #   Escapes special characters in HTML, such as `<>`, `'`, and `&`, and converts characters into escape sequences. The filter doesn't effect characters within the string that don’t have a corresponding escape sequence.".
+    #   Escapes a string.
    # @liquid_syntax string | escape
    # @liquid_return [string]
    def escape(input)
@@ -193,19 +186,10 @@ module Liquid
      offset = Utils.to_integer(offset)
      length = length ? Utils.to_integer(length) : 1

-      begin
-        if input.is_a?(Array)
-          input.slice(offset, length) || []
-        else
-          input.to_s.slice(offset, length) || ''
-        end
-      rescue RangeError
-        if I64_RANGE.cover?(length) && I64_RANGE.cover?(offset)
-          raise # unexpected error
-        end
-        offset = offset.clamp(I64_RANGE)
-        length = length.clamp(I64_RANGE)
-        retry
+      if input.is_a?(Array)
+        input.slice(offset, length) || []
+      else
+        input.to_s.slice(offset, length) || ''
      end
    end

@@ -255,9 +239,9 @@ module Liquid
      wordlist = begin
        input.split(" ", words + 1)
      rescue RangeError
-        # integer too big for String#split, but we can semantically assume no truncation is needed
-        return input if words + 1 > MAX_I32
-        raise # unexpected error
+        raise if words + 1 < MAX_INT
+        # e.g. integer #{words} too big to convert to `int'
+        raise Liquid::ArgumentError, "integer #{words} too big for truncatewords"
      end
      return input if wordlist.length <= words

@@ -615,7 +599,7 @@ module Liquid
    # @liquid_description
    #   > Note:
    #   > The `concat` filter won't filter out duplicates. If you want to remove duplicates, then you need to use the
-    #   > [`uniq` filter](/docs/api/liquid/filters/uniq).
+    #   > [`uniq` filter](/api/liquid/filters#uniq).
    # @liquid_syntax array | concat: array
    # @liquid_return [array[untyped]]
    def concat(input, array)
@@ -757,7 +741,7 @@ module Liquid
    # @liquid_type filter
    # @liquid_category math
    # @liquid_summary
-    #   Divides a number by a given number. The `divided_by` filter produces a result of the same type as the divisor. This means if you divide by an integer, the result will be an integer, and if you divide by a float, the result will be a float.
+    #   Divides a number by a given number.
    # @liquid_syntax number | divided_by: number
    # @liquid_return [number]
    def divided_by(input, operand)
@@ -857,9 +841,9 @@ module Liquid
    # @liquid_summary
    #   Sets a default value for any variable whose value is one of the following:
    #
-    #   - [`empty`](/docs/api/liquid/basics#empty)
-    #   - [`false`](/docs/api/liquid/basics#truthy-and-falsy)
-    #   - [`nil`](/docs/api/liquid/basics#nil)
+    #   - [`empty`](/api/liquid/basics#empty)
+    #   - [`false`](/api/liquid/basics#truthy-and-falsy)
+    #   - [`nil`](/api/liquid/basics#nil)
    # @liquid_syntax variable | default: variable
    # @liquid_return [untyped]
    # @liquid_optional_param allow_false [boolean] Whether to use false values instead of the default.
@@ -24,11 +24,11 @@ module Liquid

        include(filter)

-        filter_methods.merge(filter.public_instance_methods.map(&:to_s))
+        filter_methods.merge(filter.public_instance_methods)
      end

      def invokable?(method)
-        filter_methods.include?(method.to_s)
+        filter_methods.include?(method.to_sym)
      end

      def inherited(subclass)
@@ -36,6 +36,9 @@ module Liquid
        subclass.instance_variable_set(:@filter_methods, @filter_methods.dup)
      end

+      # Assuming the filter name is a string is deprecated, explicitly
+      # cast to_s or to_sym for compatibility with liquid 6, where it is
+      # planned to return as a symbol.
      def filter_method_names
        filter_methods.map(&:to_s).to_a
      end
@@ -48,6 +51,7 @@ module Liquid
    end

    def invoke(method, *args)
+      method = method.to_sym
      if self.class.invokable?(method)
        send(method, *args)
      elsif @context.strict_filters
@@ -5,7 +5,7 @@ module Liquid
  # @liquid_type object
  # @liquid_name tablerowloop
  # @liquid_summary
-  #   Information about a parent [`tablerow` loop](/docs/api/liquid/tags/tablerow).
+  #   Information about a parent [`tablerow` loop](/api/liquid/tags#tablerow).
  class TablerowloopDrop < Drop
    def initialize(length, cols)
      @length = length
@@ -14,18 +14,12 @@ module Liquid
      end

      def disable_tags(*tag_names)
-        tag_names += disabled_tags
-        define_singleton_method(:disabled_tags) { tag_names }
+        @disabled_tags ||= []
+        @disabled_tags.concat(tag_names)
        prepend(Disabler)
      end

      private :new
-
-      protected
-
-      def disabled_tags
-        []
-      end
    end

    def initialize(tag_name, markup, parse_context)
@@ -3,6 +3,14 @@
 module Liquid
  class Tag
    module Disabler
+      module ClassMethods
+        attr_reader :disabled_tags
+      end
+
+      def self.prepended(base)
+        base.extend(ClassMethods)
+      end
+
      def render_to_output_buffer(context, output)
        context.with_disabled_tags(self.class.disabled_tags) do
          super
@@ -8,7 +8,7 @@ module Liquid
  # @liquid_summary
  #   Creates a new variable.
  # @liquid_description
-  #   You can create variables of any [basic type](/docs/api/liquid/basics#types), [object](/docs/api/liquid/objects), or object property.
+  #   You can create variables of any [basic type](/api/liquid/basics#types), [object](/api/liquid/objects), or object property.
  # @liquid_syntax
  #   {% assign variable_name = value %}
  # @liquid_syntax_keyword variable_name The name of the variable being created.
@@ -15,7 +15,7 @@ module Liquid
  # @liquid_category iteration
  # @liquid_name break
  # @liquid_summary
-  #   Stops a [`for` loop](/docs/api/liquid/tags/for) from iterating.
+  #   Stops a [`for` loop](/api/liquid/tags#for) from iterating.
  # @liquid_syntax
  #   {% break %}
  class Break < Tag
@@ -77,7 +77,7 @@ module Liquid
        end

        result = Liquid::Utils.to_liquid_value(
-          block.evaluate(context),
+          block.evaluate(context)
        )

        if result
@@ -8,7 +8,7 @@ module Liquid
  # @liquid_summary
  #   Prevents an expression from being rendered or output.
  # @liquid_description
-  #   Any text inside `comment` tags won't be output, and any Liquid code will be parsed, but not executed.
+  #   Any text inside `comment` tags won't be output, and any Liquid code won't be rendered.
  # @liquid_syntax
  #   {% comment %}
  #     content
@@ -6,7 +6,7 @@ module Liquid
  # @liquid_category iteration
  # @liquid_name continue
  # @liquid_summary
-  #   Causes a [`for` loop](/docs/api/liquid/tags/for) to skip to the next iteration.
+  #   Causes a [`for` loop](/api/liquid/tags#for) to skip to the next iteration.
  # @liquid_syntax
  #   {% continue %}
  class Continue < Tag
@@ -6,7 +6,7 @@ module Liquid
  # @liquid_category iteration
  # @liquid_name cycle
  # @liquid_summary
-  #   Loops through a group of strings and outputs them one at a time for each iteration of a [`for` loop](/docs/api/liquid/tags/for).
+  #   Loops through a group of strings and outputs them one at a time for each iteration of a [`for` loop](/api/liquid/tags#for).
  # @liquid_description
  #   The `cycle` tag must be used inside a `for` loop.
  #
@@ -12,25 +12,22 @@ module Liquid
  #   or [section](/themes/architecture/sections) file that they're created in. However, the variable is shared across
  #   [snippets](/themes/architecture#snippets) included in the file.
  #
-  #   Similarly, variables that are created with `decrement` are independent from those created with [`assign`](/docs/api/liquid/tags/assign)
-  #   and [`capture`](/docs/api/liquid/tags/capture). However, `decrement` and [`increment`](/docs/api/liquid/tags/increment) share
+  #   Similarly, variables that are created with `decrement` are independent from those created with [`assign`](/api/liquid/tags#assign)
+  #   and [`capture`](/api/liquid/tags#capture). However, `decrement` and [`increment`](/api/liquid/tags#increment) share
  #   variables.
  # @liquid_syntax
  #   {% decrement variable_name %}
  # @liquid_syntax_keyword variable_name The name of the variable being decremented.
  class Decrement < Tag
-    attr_reader :variable_name
-
    def initialize(tag_name, markup, options)
      super
-      @variable_name = markup.strip
+      @variable = markup.strip
    end

    def render_to_output_buffer(context, output)
-      counter_environment = context.environments.first
-      value = counter_environment[@variable_name] || 0
+      value = context.environments.first[@variable] ||= 0
      value -= 1
-      counter_environment[@variable_name] = value
+      context.environments.first[@variable] = value
      output << value.to_s
      output
    end
@@ -9,10 +9,10 @@ module Liquid
  #   Outputs an expression.
  # @liquid_description
  #   Using the `echo` tag is the same as wrapping an expression in curly brackets (`{{` and `}}`). However, unlike the curly
-  #   bracket method, you can use the `echo` tag inside [`liquid` tags](/docs/api/liquid/tags/liquid).
+  #   bracket method, you can use the `echo` tag inside [`liquid` tags](/api/liquid/tags#liquid).
  #
  #   > Tip:
-  #   > You can use [filters](/docs/api/liquid/filters) on expressions inside `echo` tags.
+  #   > You can use [filters](/api/liquid/filters) on expressions inside `echo` tags.
  # @liquid_syntax
  #   {% liquid
  #     echo expression
@@ -9,10 +9,10 @@ module Liquid
  #   Renders an expression for every item in an array.
  # @liquid_description
  #   You can do a maximum of 50 iterations with a `for` loop. If you need to iterate over more than 50 items, then use the
-  #   [`paginate` tag](/docs/api/liquid/tags/paginate) to split the items over multiple pages.
+  #   [`paginate` tag](/api/liquid/tags#paginate) to split the items over multiple pages.
  #
  #   > Tip:
-  #   > Every `for` loop has an associated [`forloop` object](/docs/api/liquid/objects/forloop) with information about the loop.
+  #   > Every `for` loop has an associated [`forloop` object](/api/liquid/objects#forloop) with information about the loop.
  # @liquid_syntax
  #   {% for variable in array %}
  #     expression
@@ -98,12 +98,11 @@ module Liquid
      @name     = "#{@variable_name}-#{collection_name}"
      @reversed = p.id?('reversed')

-      while p.look(:comma) || p.look(:id)
-        p.consume?(:comma)
+      while p.look(:id) && p.look(:colon, 1)
        unless (attribute = p.id?('limit') || p.id?('offset'))
          raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute")
        end
-        p.consume(:colon)
+        p.consume
        set_attribute(attribute, p.expression)
      end
      p.consume(:end_of_string)
@@ -178,6 +177,7 @@ module Liquid
      case key
      when 'offset'
        @from = if expr == 'continue'
+          Usage.increment('for_offset_continue')
          :continue
        else
          parse_expression(expr)
@@ -53,7 +53,7 @@ module Liquid
    def render_to_output_buffer(context, output)
      @blocks.each do |block|
        result = Liquid::Utils.to_liquid_value(
-          block.evaluate(context),
+          block.evaluate(context)
        )

        if result
@@ -8,7 +8,7 @@ module Liquid
  # @liquid_summary
  #   Renders a [snippet](/themes/architecture#snippets).
  # @liquid_description
-  #   Inside the snippet, you can access and alter variables that are [created](/docs/api/liquid/tags/variable-tags) outside of the
+  #   Inside the snippet, you can access and alter variables that are [created](/api/liquid/tags#variable-tags) outside of the
  #   snippet.
  # @liquid_syntax
  #   {% include 'filename' %}
@@ -16,7 +16,7 @@ module Liquid
  # @liquid_deprecated
  #   Deprecated because the way that variables are handled reduces performance and makes code harder to both read and maintain.
  #
-  #   The `include` tag has been replaced by [`render`](/docs/api/liquid/tags/render).
+  #   The `include` tag has been replaced by [`render`](/api/liquid/tags#render).
  class Include < Tag
    prepend Tag::Disableable

@@ -52,12 +52,12 @@ module Liquid

    def render_to_output_buffer(context, output)
      template_name = context.evaluate(@template_name_expr)
-      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name.is_a?(String)
+      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name

      partial = PartialCache.load(
        template_name,
        context: context,
-        parse_context: parse_context,
+        parse_context: parse_context
      )

      context_variable_name = @alias_name || template_name.split('/').last
@@ -70,11 +70,9 @@ module Liquid

      old_template_name = context.template_name
      old_partial       = context.partial
-
      begin
-        context.template_name = partial.name
-        context.partial = true
-
+        context.template_name = template_name
+        context.partial       = true
        context.stack do
          @attributes.each do |key, value|
            context[key] = context.evaluate(value)
@@ -12,24 +12,21 @@ module Liquid
  #   or [section](/themes/architecture/sections) file that they're created in. However, the variable is shared across
  #   [snippets](/themes/architecture#snippets) included in the file.
  #
-  #   Similarly, variables that are created with `increment` are independent from those created with [`assign`](/docs/api/liquid/tags/assign)
-  #   and [`capture`](/docs/api/liquid/tags/capture). However, `increment` and [`decrement`](/docs/api/liquid/tags/decrement) share
+  #   Similarly, variables that are created with `increment` are independent from those created with [`assign`](/api/liquid/tags#assign)
+  #   and [`capture`](/api/liquid/tags#capture). However, `increment` and [`decrement`](/api/liquid/tags#decrement) share
  #   variables.
  # @liquid_syntax
  #   {% increment variable_name %}
  # @liquid_syntax_keyword variable_name The name of the variable being incremented.
  class Increment < Tag
-    attr_reader :variable_name
-
    def initialize(tag_name, markup, options)
      super
-      @variable_name = markup.strip
+      @variable = markup.strip
    end

    def render_to_output_buffer(context, output)
-      counter_environment = context.environments.first
-      value = counter_environment[@variable_name] || 0
-      counter_environment[@variable_name] = value + 1
+      value = context.environments.first[@variable] ||= 0
+      context.environments.first[@variable] = value + 1

      output << value.to_s
      output
@@ -1,6 +1,19 @@
 # frozen_string_literal: true

 module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category syntax
+  # @liquid_name inline_comment
+  # @liquid_summary
+  #   Prevents an expression from being rendered or output.
+  # @liquid_description
+  #   Any text inside an `inline_comment` tag won't be rendered or output.
+  #
+  #   You can create multi-line inline comments. However, each line must begin with a `#`.
+  # @liquid_syntax
+  #   {% # content %}
+  # @liquid_syntax_keyword content The content of the comment.
  class InlineComment < Tag
    def initialize(tag_name, markup, options)
      super
@@ -14,7 +14,7 @@ module Liquid
  # @liquid_syntax_keyword expression The expression to be output without being rendered.
  class Raw < Block
    Syntax = /\A\s*\z/
-    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}#{WhitespaceControl}?\s*(\w+)\s*(.*)?#{WhitespaceControl}?#{TagEnd}\z/om
+    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om

    def initialize(tag_name, markup, parse_context)
      super
@@ -8,19 +8,19 @@ module Liquid
  # @liquid_summary
  #   Renders a [snippet](/themes/architecture#snippets) or [app block](/themes/architecture/sections/section-schema#render-app-blocks).
  # @liquid_description
-  #   Inside snippets and app blocks, you can't directly access variables that are [created](/docs/api/liquid/tags/variable-tags) outside
-  #   of the snippet or app block. However, you can [specify variables as parameters](/docs/api/liquid/tags/render#render-passing-variables-to-a-snippet)
+  #   Inside snippets and app blocks, you can't directly access variables that are [created](/api/liquid/tags#variable-tags) outside
+  #   of the snippet or app block. However, you can [specify variables as parameters](/api/liquid/tags#render-passing-variables-to-snippets)
  #   to pass outside variables to snippets.
  #
  #   While you can't directly access created variables, you can access global objects, as well as any objects that are
  #   directly accessible outside the snippet or app block. For example, a snippet or app block inside the [product template](/themes/architecture/templates/product)
-  #   can access the [`product` object](/docs/api/liquid/objects/product), and a snippet or app block inside a [section](/themes/architecture/sections)
-  #   can access the [`section` object](/docs/api/liquid/objects/section).
+  #   can access the [`product` object](/api/liquid/objects#product), and a snippet or app block inside a [section](/themes/architecture/sections)
+  #   can access the [`section` object](/api/liquid/objects#section).
  #
  #   Outside a snippet or app block, you can't access variables created inside the snippet or app block.
  #
  #   > Note:
-  #   > When you render a snippet using the `render` tag, you can't use the [`include` tag](/docs/api/liquid/tags/include)
+  #   > When you render a snippet using the `render` tag, you can't use the [`include` tag](/api/liquid/tags#include)
  #   > inside the snippet.
  # @liquid_syntax
  #   {% render 'filename' %}
@@ -31,7 +31,7 @@ module Liquid

    disable_tags "include"

-    attr_reader :template_name_expr, :variable_name_expr, :attributes, :alias_name
+    attr_reader :template_name_expr, :variable_name_expr, :attributes

    def initialize(tag_name, markup, options)
      super
@@ -45,7 +45,7 @@ module Liquid
      @alias_name = Regexp.last_match(6)
      @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
      @template_name_expr = parse_expression(template_name)
-      @is_for_loop = (with_or_for == FOR)
+      @for = (with_or_for == FOR)

      @attributes = {}
      markup.scan(TagAttributes) do |key, value|
@@ -53,10 +53,6 @@ module Liquid
      end
    end

-    def for_loop?
-      @is_for_loop
-    end
-
    def render_to_output_buffer(context, output)
      render_tag(context, output)
    end
@@ -69,14 +65,14 @@ module Liquid
      partial = PartialCache.load(
        template_name,
        context: context,
-        parse_context: parse_context,
+        parse_context: parse_context
      )

      context_variable_name = @alias_name || template_name.split('/').last

      render_partial_func = ->(var, forloop) {
        inner_context               = context.new_isolated_subcontext
-        inner_context.template_name = partial.name
+        inner_context.template_name = template_name
        inner_context.partial       = true
        inner_context['forloop']    = forloop if forloop

@@ -89,7 +85,7 @@ module Liquid
      }

      variable = @variable_name_expr ? context.evaluate(@variable_name_expr) : nil
-      if @is_for_loop && variable.respond_to?(:each) && variable.respond_to?(:count)
+      if @for && variable.respond_to?(:each) && variable.respond_to?(:count)
        forloop = Liquid::ForloopDrop.new(template_name, variable.count, nil)
        variable.each { |var| render_partial_func.call(var, forloop) }
      else
@@ -11,7 +11,7 @@ module Liquid
  #   The `tablerow` tag must be wrapped in HTML `<table>` and `</table>` tags.
  #
  #   > Tip:
-  #   > Every `tablerow` loop has an associated [`tablerowloop` object](/docs/api/liquid/objects/tablerowloop) with information about the loop.
+  #   > Every `tablerow` loop has an associated [`tablerowloop` object](/api/liquid/objects#tablerowloop) with information about the loop.
  # @liquid_syntax
  #   {% tablerow variable in array %}
  #     expression
@@ -45,13 +45,13 @@ module Liquid
    def render_to_output_buffer(context, output)
      (collection = context.evaluate(@collection_name)) || (return '')

-      from = @attributes.key?('offset') ? to_integer(context.evaluate(@attributes['offset'])) : 0
-      to = @attributes.key?('limit') ? from + to_integer(context.evaluate(@attributes['limit'])) : nil
+      from = @attributes.key?('offset') ? context.evaluate(@attributes['offset']).to_i : 0
+      to   = @attributes.key?('limit')  ? from + context.evaluate(@attributes['limit']).to_i : nil

      collection = Utils.slice_collection(collection, from, to)
      length     = collection.length

-      cols = @attributes.key?('cols') ? to_integer(context.evaluate(@attributes['cols'])) : length
+      cols = context.evaluate(@attributes['cols']).to_i

      output << "<tr class=\"row1\">\n"
      context.stack do
@@ -82,14 +82,6 @@ module Liquid
        super + @node.attributes.values + [@node.collection_name]
      end
    end
-
-    private
-
-    def to_integer(value)
-      value.to_i
-    rescue NoMethodError
-      raise Liquid::ArgumentError, "invalid integer"
-    end
  end

  Template.register_tag('tablerow', TableRow)
@@ -11,7 +11,7 @@ module Liquid
  #   Renders an expression unless a specific condition is `true`.
  # @liquid_description
  #   > Tip:
-  #   > Similar to the [`if` tag](/docs/api/liquid/tags/if), you can use `elsif` to add more conditions to an `unless` tag.
+  #   > Similar to the [`if` tag](/api/liquid/tags#if), you can use `elsif` to add more conditions to an `unless` tag.
  # @liquid_syntax
  #   {% unless condition %}
  #     expression
@@ -23,7 +23,7 @@ module Liquid
      # First condition is interpreted backwards ( if not )
      first_block = @blocks.first
      result = Liquid::Utils.to_liquid_value(
-        first_block.evaluate(context),
+        first_block.evaluate(context)
      )

      unless result
@@ -33,7 +33,7 @@ module Liquid
      # After the first condition unless works just like if
      @blocks[1..-1].each do |block|
        result = Liquid::Utils.to_liquid_value(
-          block.evaluate(context),
+          block.evaluate(context)
        )

        if result
@@ -15,7 +15,7 @@ module Liquid
  #   template.render('user_name' => 'bob')
  #
  class Template
-    attr_accessor :root, :name
+    attr_accessor :root
    attr_reader :resource_limits, :warnings

    class TagRegistry
@@ -8,15 +8,11 @@ module Liquid
      @source         = source.to_s.to_str
      @line_number    = line_number || (line_numbers ? 1 : nil)
      @for_liquid_tag = for_liquid_tag
-      @offset         = 0
      @tokens         = tokenize
    end

    def shift
-      token = @tokens[@offset]
-      return nil unless token
-
-      @offset += 1
+      (token = @tokens.shift) || return

      if @line_number
        @line_number += @for_liquid_tag ? 1 : token.count("\n")
@@ -35,9 +31,7 @@ module Liquid
      tokens = @source.split(TemplateParser)

      # removes the rogue empty element at the beginning of the array
-      if tokens[0]&.empty?
-        @offset += 1
-      end
+      tokens.shift if tokens[0]&.empty?

      tokens
    end
@@ -18,7 +18,7 @@ module Liquid
    JustTagAttributes        = /\A#{TagAttributes}\z/o
    MarkupWithQuotedFragment = /(#{QuotedFragment})(.*)/om

-    attr_accessor :filters, :name, :line_number
+    attr_accessor :name, :line_number
    attr_reader :parse_context
    alias_method :options, :parse_context

@@ -52,7 +52,7 @@ module Liquid
        filters = Regexp.last_match(1).scan(FilterParser)
        filters.each do |f|
          next unless f =~ /\w+/
-          filtername = Regexp.last_match(0)
+          filtername = Regexp.last_match(0).to_sym
          filterargs = f.scan(FilterArgsRegex).flatten
          @filters << parse_filter_expressions(filtername, filterargs)
        end
@@ -67,13 +67,21 @@ module Liquid

      @name = parse_context.parse_expression(p.expression)
      while p.consume?(:pipe)
-        filtername = p.consume(:id)
+        filtername = p.consume(:id).to_sym
        filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
        @filters << parse_filter_expressions(filtername, filterargs)
      end
      p.consume(:end_of_string)
    end

+    # Assuming the filter name is a string is deprecated, explicitly
+    # cast to_s or to_sym for compatibility with liquid 6, where it is
+    # planned to return as a symbol.
+    def filters
+      # Remove to_s in liquid 6.0
+      @filters.map { |key, *args| [key.to_s, *args].freeze }.freeze
+    end
+
    def parse_filterargs(p)
      # first argument
      filterargs = [p.argument]
@@ -49,3 +49,8 @@ module Database
    end
  end
 end
+
+if __FILE__ == $PROGRAM_NAME
+  p(Database.tables['collections']['frontpage'].keys)
+  # p Database.tables['blog']['articles']
+end
@@ -45,8 +45,8 @@ class Paginate < Liquid::Block

      pagination['items']      = collection_size
      pagination['pages']      = page_count - 1
-      pagination['previous']   = link('&laquo; Previous', current_page - 1)  if 1 < current_page
-      pagination['next']       = link('Next &raquo;', current_page + 1)      if page_count > current_page + 1
+      pagination['previous']   = link('&laquo; Previous', current_page - 1)  unless 1 >= current_page
+      pagination['next']       = link('Next &raquo;', current_page + 1)      unless page_count <= current_page + 1
      pagination['parts']      = []

      hellip_break = false
@@ -6,51 +6,51 @@ class AssignTest < Minitest::Test
  include Liquid

  def test_assign_with_hyphen_in_variable_name
-    template_source = <<~END_TEMPLATE
-      {% assign this-thing = 'Print this-thing' -%}
-      {{ this-thing -}}
+    template_source = <<-END_TEMPLATE
+    {% assign this-thing = 'Print this-thing' %}
+    {{ this-thing }}
    END_TEMPLATE
-    assert_template_result("Print this-thing", template_source)
+    template        = Template.parse(template_source)
+    rendered        = template.render!
+    assert_equal("Print this-thing", rendered.strip)
  end

  def test_assigned_variable
-    assert_template_result(
-      '.foo.',
+    assert_template_result('.foo.',
      '{% assign foo = values %}.{{ foo[0] }}.',
-      { 'values' => %w(foo bar baz) },
-    )
+      'values' => %w(foo bar baz))

-    assert_template_result(
-      '.bar.',
+    assert_template_result('.bar.',
      '{% assign foo = values %}.{{ foo[1] }}.',
-      { 'values' => %w(foo bar baz) },
-    )
+      'values' => %w(foo bar baz))
  end

  def test_assign_with_filter
-    assert_template_result(
-      '.bar.',
+    assert_template_result('.bar.',
      '{% assign foo = values | split: "," %}.{{ foo[1] }}.',
-      { 'values' => "foo,bar,baz" },
-    )
+      'values' => "foo,bar,baz")
  end

  def test_assign_syntax_error
-    assert_match_syntax_error(/assign/, '{% assign foo not values %}.')
+    assert_match_syntax_error(/assign/,
+      '{% assign foo not values %}.',
+      'values' => "foo,bar,baz")
  end

  def test_assign_uses_error_mode
-    assert_match_syntax_error(
-      "Expected dotdot but found pipe in ",
-      "{% assign foo = ('X' | downcase) %}",
-      error_mode: :strict,
-    )
-    assert_template_result("", "{% assign foo = ('X' | downcase) %}", error_mode: :lax)
+    with_error_mode(:strict) do
+      assert_raises(SyntaxError) do
+        Template.parse("{% assign foo = ('X' | downcase) %}")
+      end
+    end
+    with_error_mode(:lax) do
+      assert(Template.parse("{% assign foo = ('X' | downcase) %}"))
+    end
  end

  def test_expression_with_whitespace_in_square_brackets
    source = "{% assign r = a[ 'b' ] %}{{ r }}"
-    assert_template_result('result', source, { 'a' => { 'b' => 'result' } })
+    assert_template_result('result', source, 'a' => { 'b' => 'result' })
  end

  def test_assign_score_exceeding_resource_limit
@@ -9,6 +9,12 @@ class FoobarTag < Liquid::Tag
  end
 end

+class BlankTestFileSystem
+  def read_template_file(template_path)
+    template_path
+  end
+end
+
 class BlankTest < Minitest::Test
  include Liquid
  N = 10
@@ -27,7 +33,7 @@ class BlankTest < Minitest::Test

  def test_new_tags_are_not_blank_by_default
    with_custom_tag('foobar', FoobarTag) do
-      assert_equal(" " * N, Liquid::Template.parse(wrap_in_for("{% foobar %}")).render!)
+      assert_template_result(" " * N, wrap_in_for("{% foobar %}"))
    end
  end

@@ -57,11 +63,9 @@ class BlankTest < Minitest::Test

  def test_nested_blocks_are_blank_but_only_if_all_children_are
    assert_template_result("", wrap(wrap(" ")))
-    assert_template_result(
-      "\n       but this is not " * (N + 1),
+    assert_template_result("\n       but this is not " * (N + 1),
      wrap('{% if true %} {% comment %} this is blank {% endcomment %} {% endif %}
-      {% if true %} but this is not {% endif %}'),
-    )
+      {% if true %} but this is not {% endif %}'))
  end

  def test_assigns_are_blank
@@ -91,21 +95,10 @@ class BlankTest < Minitest::Test
  end

  def test_include_is_blank
-    assert_template_result(
-      "foobar" * (N + 1),
-      wrap("{% include 'foobar' %}"),
-      partials: { 'foobar' => 'foobar' },
-    )
-    assert_template_result(
-      " foobar " * (N + 1),
-      wrap("{% include ' foobar ' %}"),
-      partials: { ' foobar ' => ' foobar ' },
-    )
-    assert_template_result(
-      "   " * (N + 1),
-      wrap(" {% include ' ' %} "),
-      partials: { ' ' => ' ' },
-    )
+    Liquid::Template.file_system = BlankTestFileSystem.new
+    assert_template_result("foobar" * (N + 1), wrap("{% include 'foobar' %}"))
+    assert_template_result(" foobar " * (N + 1), wrap("{% include ' foobar ' %}"))
+    assert_template_result("   " * (N + 1), wrap(" {% include ' ' %} "))
  end

  def test_case_is_blank
@@ -6,8 +6,10 @@ class BlockTest < Minitest::Test
  include Liquid

  def test_unexpected_end_tag
-    source = '{% if true %}{% endunless %}'
-    assert_match_syntax_error("Liquid syntax error (line 1): 'endunless' is not a valid delimiter for if tags. use endif", source)
+    exc = assert_raises(SyntaxError) do
+      Template.parse("{% if true %}{% endunless %}")
+    end
+    assert_equal(exc.message, "Liquid syntax error: 'endunless' is not a valid delimiter for if tags. use endif")
  end

  def test_with_custom_tag
@@ -10,38 +10,44 @@ class CaptureTest < Minitest::Test
  end

  def test_capture_with_hyphen_in_variable_name
-    template_source = <<~END_TEMPLATE
-      {% capture this-thing %}Print this-thing{% endcapture -%}
-      {{ this-thing -}}
+    template_source = <<-END_TEMPLATE
+    {% capture this-thing %}Print this-thing{% endcapture %}
+    {{ this-thing }}
    END_TEMPLATE
-    assert_template_result("Print this-thing", template_source)
+    template        = Template.parse(template_source)
+    rendered        = template.render!
+    assert_equal("Print this-thing", rendered.strip)
  end

  def test_capture_to_variable_from_outer_scope_if_existing
-    template_source = <<~END_TEMPLATE
-      {% assign var = '' -%}
-      {% if true -%}
-        {% capture var %}first-block-string{% endcapture -%}
-      {% endif -%}
-      {% if true -%}
-        {% capture var %}test-string{% endcapture -%}
-      {% endif -%}
-      {{var-}}
+    template_source = <<-END_TEMPLATE
+    {% assign var = '' %}
+    {% if true %}
+    {% capture var %}first-block-string{% endcapture %}
+    {% endif %}
+    {% if true %}
+    {% capture var %}test-string{% endcapture %}
+    {% endif %}
+    {{var}}
    END_TEMPLATE
-    assert_template_result("test-string", template_source)
+    template        = Template.parse(template_source)
+    rendered        = template.render!
+    assert_equal("test-string", rendered.gsub(/\s/, ''))
  end

  def test_assigning_from_capture
-    template_source = <<~END_TEMPLATE
-      {% assign first = '' -%}
-      {% assign second = '' -%}
-      {% for number in (1..3) -%}
-        {% capture first %}{{number}}{% endcapture -%}
-        {% assign second = first -%}
-      {% endfor -%}
-      {{ first }}-{{ second -}}
+    template_source = <<-END_TEMPLATE
+    {% assign first = '' %}
+    {% assign second = '' %}
+    {% for number in (1..3) %}
+    {% capture first %}{{number}}{% endcapture %}
+    {% assign second = first %}
+    {% endfor %}
+    {{ first }}-{{ second }}
    END_TEMPLATE
-    assert_template_result("3-3", template_source)
+    template        = Template.parse(template_source)
+    rendered        = template.render!
+    assert_equal("3-3", rendered.gsub(/\s/, ''))
  end

  def test_increment_assign_score_by_bytes_not_characters
@@ -102,7 +102,7 @@ class ContextTest < Minitest::Test
  end

  def test_variables_not_existing
-    assert_template_result("true", "{% if does_not_exist == nil %}true{% endif %}")
+    assert_nil(@context['does_not_exist'])
  end

  def test_scoping
@@ -121,27 +121,22 @@ class ContextTest < Minitest::Test
  end

  def test_length_query
-    assert_template_result(
-      "true",
-      "{% if numbers.size == 4 %}true{% endif %}",
-      { "numbers" => [1, 2, 3, 4] },
-    )
+    @context['numbers'] = [1, 2, 3, 4]

-    assert_template_result(
-      "true",
-      "{% if numbers.size == 4 %}true{% endif %}",
-      { "numbers" => { 1 => 1, 2 => 2, 3 => 3, 4 => 4 } },
-    )
+    assert_equal(4, @context['numbers.size'])

-    assert_template_result(
-      "true",
-      "{% if numbers.size == 1000 %}true{% endif %}",
-      { "numbers" => { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 'size' => 1000 } },
-    )
+    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4 }
+
+    assert_equal(4, @context['numbers.size'])
+
+    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 'size' => 1000 }
+
+    assert_equal(1000, @context['numbers.size'])
  end

  def test_hyphenated_variable
-    assert_template_result("godz", "{{ oh-my }}", { "oh-my" => 'godz' })
+    @context['oh-my'] = 'godz'
+    assert_equal('godz', @context['oh-my'])
  end

  def test_add_filter
@@ -193,24 +188,24 @@ class ContextTest < Minitest::Test
  end

  def test_hierachical_data
-    assigns = { 'hash' => { "name" => 'tobi' } }
-    assert_template_result("tobi", "{{ hash.name }}", assigns)
-    assert_template_result("tobi", '{{ hash["name"] }}', assigns)
+    @context['hash'] = { "name" => 'tobi' }
+    assert_equal('tobi', @context['hash.name'])
+    assert_equal('tobi', @context['hash["name"]'])
  end

  def test_keywords
-    assert_template_result("pass", "{% if true == expect %}pass{% endif %}", { "expect" => true })
-    assert_template_result("pass", "{% if false == expect %}pass{% endif %}", { "expect" => false })
+    assert_equal(true, @context['true'])
+    assert_equal(false, @context['false'])
  end

  def test_digits
-    assert_template_result("pass", "{% if 100 == expect %}pass{% endif %}", { "expect" => 100 })
-    assert_template_result("pass", "{% if 100.00 == expect %}pass{% endif %}", { "expect" => 100.00 })
+    assert_equal(100, @context['100'])
+    assert_equal(100.00, @context['100.00'])
  end

  def test_strings
-    assert_template_result("hello!", '{{ "hello!" }}')
-    assert_template_result("hello!", "{{ 'hello!' }}")
+    assert_equal("hello!", @context['"hello!"'])
+    assert_equal("hello!", @context["'hello!'"])
  end

  def test_merge
@@ -222,92 +217,99 @@ class ContextTest < Minitest::Test
  end

  def test_array_notation
-    assigns = { "test" => ["a", "b"] }
-    assert_template_result("a", "{{ test[0] }}", assigns)
-    assert_template_result("b", "{{ test[1] }}", assigns)
-    assert_template_result("pass", "{% if test[2] == nil %}pass{% endif %}", assigns)
+    @context['test'] = [1, 2, 3, 4, 5]
+
+    assert_equal(1, @context['test[0]'])
+    assert_equal(2, @context['test[1]'])
+    assert_equal(3, @context['test[2]'])
+    assert_equal(4, @context['test[3]'])
+    assert_equal(5, @context['test[4]'])
  end

  def test_recoursive_array_notation
-    assigns = { "test" => { 'test' => [1, 2, 3, 4, 5] } }
-    assert_template_result("1", "{{ test.test[0] }}", assigns)
+    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }

-    assigns = { "test" => [{ 'test' => 'worked' }] }
-    assert_template_result("worked", "{{ test[0].test }}", assigns)
+    assert_equal(1, @context['test.test[0]'])
+
+    @context['test'] = [{ 'test' => 'worked' }]
+
+    assert_equal('worked', @context['test[0].test'])
  end

  def test_hash_to_array_transition
-    assigns = {
-      'colors' => {
-        'Blue' => ['003366', '336699', '6699CC', '99CCFF'],
-        'Green' => ['003300', '336633', '669966', '99CC99'],
-        'Yellow' => ['CC9900', 'FFCC00', 'FFFF99', 'FFFFCC'],
-        'Red' => ['660000', '993333', 'CC6666', 'FF9999'],
-      },
+    @context['colors'] = {
+      'Blue' => ['003366', '336699', '6699CC', '99CCFF'],
+      'Green' => ['003300', '336633', '669966', '99CC99'],
+      'Yellow' => ['CC9900', 'FFCC00', 'FFFF99', 'FFFFCC'],
+      'Red' => ['660000', '993333', 'CC6666', 'FF9999'],
    }

-    assert_template_result("003366", "{{ colors.Blue[0] }}", assigns)
-    assert_template_result("FF9999", "{{ colors.Red[3] }}", assigns)
+    assert_equal('003366', @context['colors.Blue[0]'])
+    assert_equal('FF9999', @context['colors.Red[3]'])
  end

  def test_try_first
-    assigns = { 'test' => [1, 2, 3, 4, 5] }
-    assert_template_result("1", "{{ test.first }}", assigns)
-    assert_template_result("pass", "{% if test.last == 5 %}pass{% endif %}", assigns)
+    @context['test'] = [1, 2, 3, 4, 5]

-    assigns = { "test" => { "test" => [1, 2, 3, 4, 5] } }
-    assert_template_result("1", "{{ test.test.first }}", assigns)
-    assert_template_result("5", "{{ test.test.last }}", assigns)
+    assert_equal(1, @context['test.first'])
+    assert_equal(5, @context['test.last'])

-    assigns = { "test" => [1] }
-    assert_template_result("1", "{{ test.first }}", assigns)
-    assert_template_result("1", "{{ test.last }}", assigns)
+    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
+
+    assert_equal(1, @context['test.test.first'])
+    assert_equal(5, @context['test.test.last'])
+
+    @context['test'] = [1]
+    assert_equal(1, @context['test.first'])
+    assert_equal(1, @context['test.last'])
  end

  def test_access_hashes_with_hash_notation
-    assigns = { 'products' => { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] } }
-    assert_template_result("5", '{{ products["count"] }}', assigns)
-    assert_template_result("deepsnow", '{{ products["tags"][0] }}', assigns)
-    assert_template_result("deepsnow", '{{ products["tags"].first }}', assigns)
+    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
+    @context['product']  = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }

-    assigns = { 'product' => { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] } }
-    assert_template_result("draft151cm", '{{ product["variants"][0]["title"] }}', assigns)
-    assert_template_result("element151cm", '{{ product["variants"][1]["title"] }}', assigns)
-    assert_template_result("draft151cm", '{{ product["variants"].first["title"] }}', assigns)
-    assert_template_result("element151cm", '{{ product["variants"].last["title"] }}', assigns)
+    assert_equal(5, @context['products["count"]'])
+    assert_equal('deepsnow', @context['products["tags"][0]'])
+    assert_equal('deepsnow', @context['products["tags"].first'])
+    assert_equal('draft151cm', @context['product["variants"][0]["title"]'])
+    assert_equal('element151cm', @context['product["variants"][1]["title"]'])
+    assert_equal('draft151cm', @context['product["variants"][0]["title"]'])
+    assert_equal('element151cm', @context['product["variants"].last["title"]'])
  end

  def test_access_variable_with_hash_notation
-    assert_template_result('baz', '{{ ["foo"] }}', { "foo" => "baz" })
-    assert_template_result('baz', '{{ [bar] }}', { 'foo' => 'baz', 'bar' => 'foo' })
+    @context['foo'] = 'baz'
+    @context['bar'] = 'foo'
+
+    assert_equal('baz', @context['["foo"]'])
+    assert_equal('baz', @context['[bar]'])
  end

  def test_access_hashes_with_hash_access_variables
-    assigns = {
-      'var' => 'tags',
-      'nested' => { 'var' => 'tags' },
-      'products' => { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] },
-    }
+    @context['var']      = 'tags'
+    @context['nested']   = { 'var' => 'tags' }
+    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }

-    assert_template_result('deepsnow', '{{ products[var].first }}', assigns)
-    assert_template_result('freestyle', '{{ products[nested.var].last }}', assigns)
+    assert_equal('deepsnow', @context['products[var].first'])
+    assert_equal('freestyle', @context['products[nested.var].last'])
  end

  def test_hash_notation_only_for_hash_access
-    assigns = { "array" => [1, 2, 3, 4, 5] }
-    assert_template_result("1", "{{ array.first }}", assigns)
-    assert_template_result("pass", '{% if array["first"] == nil %}pass{% endif %}', assigns)
+    @context['array'] = [1, 2, 3, 4, 5]
+    @context['hash']  = { 'first' => 'Hello' }

-    assert_template_result("Hello", '{{ hash["first"] }}', { "hash" => { "first" => "Hello" } })
+    assert_equal(1, @context['array.first'])
+    assert_nil(@context['array["first"]'])
+    assert_equal('Hello', @context['hash["first"]'])
  end

  def test_first_can_appear_in_middle_of_callchain
-    assigns = { "product" => { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] } }
+    @context['product'] = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }

-    assert_template_result('draft151cm', '{{ product.variants[0].title }}', assigns)
-    assert_template_result('element151cm', '{{ product.variants[1].title }}', assigns)
-    assert_template_result('draft151cm', '{{ product.variants.first.title }}', assigns)
-    assert_template_result('element151cm', '{{ product.variants.last.title }}', assigns)
+    assert_equal('draft151cm', @context['product.variants[0].title'])
+    assert_equal('element151cm', @context['product.variants[1].title'])
+    assert_equal('draft151cm', @context['product.variants.first.title'])
+    assert_equal('element151cm', @context['product.variants.last.title'])
  end

  def test_cents
@@ -349,12 +351,10 @@ class ContextTest < Minitest::Test
  end

  def test_ranges
-    assert_template_result("1..5", '{{ (1..5) }}')
-    assert_template_result("pass", '{% if (1..5) == expect %}pass{% endif %}', { "expect" => (1..5) })
-
-    assigns = { "test" => '5' }
-    assert_template_result("1..5", "{{ (1..test) }}", assigns)
-    assert_template_result("5..5", "{{ (test..test) }}", assigns)
+    @context.merge("test" => '5')
+    assert_equal((1..5), @context['(1..5)'])
+    assert_equal((1..5), @context['(1..test)'])
+    assert_equal((5..5), @context['(test..test)'])
  end

  def test_cents_through_drop_nestedly
@@ -421,12 +421,10 @@ class ContextTest < Minitest::Test
  def test_nested_lambda_is_called_once
    @global = 0

-    @context['callcount'] = {
-      "lambda" => proc {
-                    @global += 1
-                    @global.to_s
-                  },
-    }
+    @context['callcount'] = { "lambda" => proc {
+                                            @global += 1
+                                            @global.to_s
+                                          } }

    assert_equal('1', @context['callcount.lambda'])
    assert_equal('1', @context['callcount.lambda'])
@@ -436,11 +434,10 @@ class ContextTest < Minitest::Test
  def test_lambda_in_array_is_called_once
    @global = 0

-    p = proc {
-      @global += 1
-      @global.to_s
-    }
-    @context['callcount'] = [1, 2, p, 4, 5]
+    @context['callcount'] = [1, 2, proc {
+                                     @global += 1
+                                     @global.to_s
+                                   }, 4, 5]

    assert_equal('1', @context['callcount[2]'])
    assert_equal('1', @context['callcount[2]'])
@@ -487,7 +484,7 @@ class ContextTest < Minitest::Test
  def test_static_environments_are_read_with_lower_priority_than_environments
    context = Context.build(
      static_environments: { 'shadowed' => 'static', 'unshadowed' => 'static' },
-      environments: { 'shadowed' => 'dynamic' },
+      environments: { 'shadowed' => 'dynamic' }
    )

    assert_equal('dynamic', context['shadowed'])
@@ -6,12 +6,16 @@ class DocumentTest < Minitest::Test
  include Liquid

  def test_unexpected_outer_tag
-    source = "{% else %}"
-    assert_match_syntax_error("Liquid syntax error (line 1): Unexpected outer 'else' tag", source)
+    exc = assert_raises(SyntaxError) do
+      Template.parse("{% else %}")
+    end
+    assert_equal(exc.message, "Liquid syntax error: Unexpected outer 'else' tag")
  end

  def test_unknown_tag
-    source = "{% foo %}"
-    assert_match_syntax_error("Liquid syntax error (line 1): Unknown tag 'foo'", source)
+    exc = assert_raises(SyntaxError) do
+      Template.parse("{% foo %}")
+    end
+    assert_equal(exc.message, "Liquid syntax error: Unknown tag 'foo'")
  end
 end
@@ -63,7 +63,9 @@ class ErrorHandlingTest < Minitest::Test
  end

  def test_missing_endtag_parse_time_error
-    assert_match_syntax_error(/: 'for' tag was never closed\z/, ' {% for a in b %} ... ')
+    assert_raises(Liquid::SyntaxError) do
+      Liquid::Template.parse(' {% for a in b %} ... ')
+    end
  end

  def test_unrecognized_operator
@@ -82,31 +84,37 @@ class ErrorHandlingTest < Minitest::Test
  end

  def test_with_line_numbers_adds_numbers_to_parser_errors
-    source = <<~LIQUID
-      foobar
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse('
+          foobar

-      {% "cat" | foobar %}
+          {% "cat" | foobar %}

-      bla
-    LIQUID
-    assert_match_syntax_error(/Liquid syntax error \(line 3\)/, source)
+          bla
+        ',
+        line_numbers: true)
+    end
+
+    assert_match(/Liquid syntax error \(line 4\)/, err.message)
  end

  def test_with_line_numbers_adds_numbers_to_parser_errors_with_whitespace_trim
-    source = <<~LIQUID
-      foobar
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse('
+          foobar

-      {%- "cat" | foobar -%}
+          {%- "cat" | foobar -%}

-      bla
-    LIQUID
+          bla
+        ',
+        line_numbers: true)
+    end

-    assert_match_syntax_error(/Liquid syntax error \(line 3\)/, source)
+    assert_match(/Liquid syntax error \(line 4\)/, err.message)
  end

  def test_parsing_warn_with_line_numbers_adds_numbers_to_lexer_errors
-    template = Liquid::Template.parse(
-      '
+    template = Liquid::Template.parse('
        foobar

        {% if 1 =! 2 %}ok{% endif %}
@@ -114,19 +122,15 @@ class ErrorHandlingTest < Minitest::Test
        bla
            ',
      error_mode: :warn,
-      line_numbers: true,
-    )
+      line_numbers: true)

-    assert_equal(
-      ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
-      template.warnings.map(&:message),
-    )
+    assert_equal(['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
+      template.warnings.map(&:message))
  end

  def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors
    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(
-        '
+      Liquid::Template.parse('
          foobar

          {% if 1 =! 2 %}ok{% endif %}
@@ -134,25 +138,27 @@ class ErrorHandlingTest < Minitest::Test
          bla
                ',
        error_mode: :strict,
-        line_numbers: true,
-      )
+        line_numbers: true)
    end

    assert_equal('Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message)
  end

  def test_syntax_errors_in_nested_blocks_have_correct_line_number
-    source = <<~LIQUID
-      foobar
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse('
+          foobar

-      {% if 1 != 2 %}
-        {% foo %}
-      {% endif %}
+          {% if 1 != 2 %}
+            {% foo %}
+          {% endif %}

-      bla
-    LIQUID
+          bla
+                ',
+        line_numbers: true)
+    end

-    assert_match_syntax_error("Liquid syntax error (line 4): Unknown tag 'foo'", source)
+    assert_equal("Liquid syntax error (line 5): Unknown tag 'foo'", err.message)
  end

  def test_strict_error_messages
@@ -4,46 +4,43 @@ require 'test_helper'

 class ExpressionTest < Minitest::Test
  def test_keyword_literals
-    assert_template_result("true", "{{ true }}")
-    assert_expression_result(true, "true")
+    assert_equal(true, parse_and_eval("true"))
+    assert_equal(true, parse_and_eval(" true "))
  end

  def test_string
-    assert_template_result("single quoted", "{{'single quoted'}}")
-    assert_template_result("double quoted", '{{"double quoted"}}')
-    assert_template_result("spaced", "{{ 'spaced' }}")
-    assert_template_result("spaced2", "{{ 'spaced2' }}")
+    assert_equal("single quoted", parse_and_eval("'single quoted'"))
+    assert_equal("double quoted", parse_and_eval('"double quoted"'))
+    assert_equal("spaced", parse_and_eval(" 'spaced' "))
+    assert_equal("spaced2", parse_and_eval(' "spaced2" '))
  end

  def test_int
-    assert_template_result("456", "{{ 456 }}")
-    assert_expression_result(123, "123")
-    assert_expression_result(12, "012")
+    assert_equal(123, parse_and_eval("123"))
+    assert_equal(456, parse_and_eval(" 456 "))
+    assert_equal(12, parse_and_eval("012"))
  end

  def test_float
-    assert_template_result("2.5", "{{ 2.5 }}")
-    assert_expression_result(1.5, "1.5")
+    assert_equal(1.5, parse_and_eval("1.5"))
+    assert_equal(2.5, parse_and_eval(" 2.5 "))
  end

  def test_range
-    assert_template_result("3..4", "{{ ( 3 .. 4 ) }}")
-    assert_expression_result(1..2, "(1..2)")
-
-    assert_match_syntax_error(
-      "Liquid syntax error (line 1): Invalid expression type 'false' in range expression",
-      "{{ (false..true) }}",
-    )
-    assert_match_syntax_error(
-      "Liquid syntax error (line 1): Invalid expression type '(1..2)' in range expression",
-      "{{ ((1..2)..3) }}",
-    )
+    assert_equal(1..2, parse_and_eval("(1..2)"))
+    assert_equal(3..4, parse_and_eval(" ( 3 .. 4 ) "))
  end

  private

-  def assert_expression_result(expect, markup, **assigns)
-    liquid = "{% if expect == #{markup} %}pass{% else %}got {{ #{markup} }}{% endif %}"
-    assert_template_result("pass", liquid, { "expect" => expect, **assigns })
+  def parse_and_eval(markup, **assigns)
+    if Liquid::Template.error_mode == :strict
+      p = Liquid::Parser.new(markup)
+      markup = p.expression
+      p.consume(:end_of_string)
+    end
+    expression = Liquid::Expression.parse(markup)
+    context = Liquid::Context.new(assigns)
+    context.evaluate(expression)
  end
 end
@@ -17,7 +17,7 @@ class FilterKwargTest < Minitest::Test
    with_global_filter(KwargFilter) do
      assert_equal(
        "data-src='src' data-widths='100, 200'",
-        Template.parse("{{ 'img' | html_tag: data-src: 'src', data-widths: '100, 200' }}").render(nil, nil),
+        Template.parse("{{ 'img' | html_tag: data-src: 'src', data-widths: '100, 200' }}").render(nil, nil)
      )
    end
  end
@@ -59,87 +59,84 @@ class FiltersTest < Minitest::Test
  end

  def test_size
-    assert_template_result("4", "{{var | size}}", { "var" => 'abcd' })
+    @context['var'] = 'abcd'
+    @context.add_filters(MoneyFilter)
+
+    assert_equal('4', Template.parse("{{var | size}}").render(@context))
  end

  def test_join
-    assert_template_result("1 2 3 4", "{{var | join}}", { "var" => [1, 2, 3, 4] })
+    @context['var'] = [1, 2, 3, 4]
+
+    assert_equal("1 2 3 4", Template.parse("{{var | join}}").render(@context))
  end

  def test_sort
-    assert_template_result("1 2 3 4", "{{numbers | sort | join}}", { "numbers" => [2, 1, 4, 3] })
-    assert_template_result(
-      "alphabetic as expected",
-      "{{words | sort | join}}",
-      { "words" => ['expected', 'as', 'alphabetic'] },
-    )
-    assert_template_result("3", "{{value | sort}}", { "value" => 3 })
-    assert_template_result('are flower', "{{arrays | sort | join}}", { 'arrays' => ['flower', 'are'] })
-    assert_template_result(
-      "Expected case sensitive",
-      "{{case_sensitive | sort | join}}",
-      { "case_sensitive" => ["sensitive", "Expected", "case"] },
-    )
+    @context['value']   = 3
+    @context['numbers'] = [2, 1, 4, 3]
+    @context['words']   = ['expected', 'as', 'alphabetic']
+    @context['arrays']  = ['flower', 'are']
+    @context['case_sensitive'] = ['sensitive', 'Expected', 'case']
+
+    assert_equal('1 2 3 4', Template.parse("{{numbers | sort | join}}").render(@context))
+    assert_equal('alphabetic as expected', Template.parse("{{words | sort | join}}").render(@context))
+    assert_equal('3', Template.parse("{{value | sort}}").render(@context))
+    assert_equal('are flower', Template.parse("{{arrays | sort | join}}").render(@context))
+    assert_equal('Expected case sensitive', Template.parse("{{case_sensitive | sort | join}}").render(@context))
  end

  def test_sort_natural
+    @context['words']   = ['case', 'Assert', 'Insensitive']
+    @context['hashes']  = [{ 'a' => 'A' }, { 'a' => 'b' }, { 'a' => 'C' }]
+    @context['objects'] = [TestObject.new('A'), TestObject.new('b'), TestObject.new('C')]
+
    # Test strings
-    assert_template_result(
-      "Assert case Insensitive",
-      "{{words | sort_natural | join}}",
-      { "words" => ["case", "Assert", "Insensitive"] },
-    )
+    assert_equal('Assert case Insensitive', Template.parse("{{words | sort_natural | join}}").render(@context))

    # Test hashes
-    assert_template_result(
-      "A b C",
-      "{{hashes | sort_natural: 'a' | map: 'a' | join}}",
-      { "hashes" => [{ "a" => "A" }, { "a" => "b" }, { "a" => "C" }] },
-    )
+    assert_equal('A b C', Template.parse("{{hashes | sort_natural: 'a' | map: 'a' | join}}").render(@context))

    # Test objects
-    @context['objects'] = [TestObject.new('A'), TestObject.new('b'), TestObject.new('C')]
    assert_equal('A b C', Template.parse("{{objects | sort_natural: 'a' | map: 'a' | join}}").render(@context))
  end

  def test_compact
+    @context['words']   = ['a', nil, 'b', nil, 'c']
+    @context['hashes']  = [{ 'a' => 'A' }, { 'a' => nil }, { 'a' => 'C' }]
+    @context['objects'] = [TestObject.new('A'), TestObject.new(nil), TestObject.new('C')]
+
    # Test strings
-    assert_template_result(
-      "a b c",
-      "{{words | compact | join}}",
-      { "words" => ['a', nil, 'b', nil, 'c'] },
-    )
+    assert_equal('a b c', Template.parse("{{words | compact | join}}").render(@context))

    # Test hashes
-    assert_template_result(
-      "A C",
-      "{{hashes | compact: 'a' | map: 'a' | join}}",
-      { "hashes" => [{ "a" => "A" }, { "a" => nil }, { "a" => "C" }] },
-    )
+    assert_equal('A C', Template.parse("{{hashes | compact: 'a' | map: 'a' | join}}").render(@context))

    # Test objects
-    @context['objects'] = [TestObject.new('A'), TestObject.new(nil), TestObject.new('C')]
    assert_equal('A C', Template.parse("{{objects | compact: 'a' | map: 'a' | join}}").render(@context))
  end

  def test_strip_html
-    assert_template_result("bla blub", "{{ var | strip_html }}", { "var" => "<b>bla blub</a>" })
+    @context['var'] = "<b>bla blub</a>"
+
+    assert_equal("bla blub", Template.parse("{{ var | strip_html }}").render(@context))
  end

  def test_strip_html_ignore_comments_with_html
-    assert_template_result(
-      "bla blub",
-      "{{ var | strip_html }}",
-      { "var" => "<!-- split and some <ul> tag --><b>bla blub</a>" },
-    )
+    @context['var'] = "<!-- split and some <ul> tag --><b>bla blub</a>"
+
+    assert_equal("bla blub", Template.parse("{{ var | strip_html }}").render(@context))
  end

  def test_capitalize
-    assert_template_result("Blub", "{{ var | capitalize }}", { "var" => "blub" })
+    @context['var'] = "blub"
+
+    assert_equal("Blub", Template.parse("{{ var | capitalize }}").render(@context))
  end

  def test_nonexistent_filter_is_ignored
-    assert_template_result("1000", "{{ var | xyzzy }}", { "var" => 1000 })
+    @context['var'] = 1000
+
+    assert_equal('1000', Template.parse("{{ var | xyzzy }}").render(@context))
  end

  def test_filter_with_keyword_arguments
@@ -33,25 +33,31 @@ class OutputTest < Minitest::Test

  def setup
    @assigns = {
+      'best_cars' => 'bmw',
      'car' => { 'bmw' => 'good', 'gm' => 'bad' },
    }
  end

  def test_variable
-    assert_template_result(" bmw ", " {{best_cars}} ", { "best_cars" => "bmw" })
+    text = %( {{best_cars}} )
+
+    expected = %( bmw )
+    assert_equal(expected, Template.parse(text).render!(@assigns))
  end

  def test_variable_traversing_with_two_brackets
-    source = "{{ site.data.menu[include.menu][include.locale] }}"
-    assert_template_result("it works!", source, {
+    text = %({{ site.data.menu[include.menu][include.locale] }})
+    assert_equal("it works!", Template.parse(text).render!(
      "site" => { "data" => { "menu" => { "foo" => { "bar" => "it works!" } } } },
-      "include" => { "menu" => "foo", "locale" => "bar" },
-    })
+      "include" => { "menu" => "foo", "locale" => "bar" }
+    ))
  end

  def test_variable_traversing
-    source = " {{car.bmw}} {{car.gm}} {{car.bmw}} "
-    assert_template_result(" good bad good ", source, @assigns)
+    text = %( {{car.bmw}} {{car.gm}} {{car.bmw}} )
+
+    expected = %( good bad good )
+    assert_equal(expected, Template.parse(text).render!(@assigns))
  end

  def test_variable_piping
@@ -104,11 +110,10 @@ class OutputTest < Minitest::Test
  end

  def test_multiple_pipings
-    assigns = { 'best_cars' => 'bmw' }
    text     = %( {{ best_cars | cite_funny | paragraph }} )
    expected = %( <p>LOL: bmw</p> )

-    assert_equal(expected, Template.parse(text).render!(assigns, filters: [FunnyFilter]))
+    assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
  end

  def test_link_to
@@ -129,6 +129,6 @@ class ParsingQuirksTest < Minitest::Test
  end

  def test_contains_in_id
-    assert_template_result(' YES ', '{% if containsallshipments == true %} YES {% endif %}', { 'containsallshipments' => true })
+    assert_template_result(' YES ', '{% if containsallshipments == true %} YES {% endif %}', 'containsallshipments' => true)
  end
 end # ParsingQuirksTest
@@ -109,10 +109,6 @@ class StandardFiltersTest < Minitest::Test
    assert_raises(Liquid::ArgumentError) do
      @filters.slice('foobar', 0, "")
    end
-    assert_equal("", @filters.slice("foobar", 0, -(1 << 64)))
-    assert_equal("foobar", @filters.slice("foobar", 0, 1 << 63))
-    assert_equal("", @filters.slice("foobar", 1 << 63, 6))
-    assert_equal("", @filters.slice("foobar", -(1 << 63), 6))
  end

  def test_slice_on_arrays
@@ -127,10 +123,6 @@ class StandardFiltersTest < Minitest::Test
    assert_equal(%w(r), @filters.slice(input, -1))
    assert_equal(%w(), @filters.slice(input, 100, 10))
    assert_equal(%w(), @filters.slice(input, -100, 10))
-    assert_equal([], @filters.slice(input, 0, -(1 << 64)))
-    assert_equal(input, @filters.slice(input, 0, 1 << 63))
-    assert_equal([], @filters.slice(input, 1 << 63, 6))
-    assert_equal([], @filters.slice(input, -(1 << 63), 6))
  end

  def test_truncate
@@ -140,8 +132,6 @@ class StandardFiltersTest < Minitest::Test
    assert_equal('1234567890', @filters.truncate('1234567890'))
    assert_equal("测试...", @filters.truncate("测试测试测试测试", 5))
    assert_equal('12341', @filters.truncate("1234567890", 5, 1))
-    assert_equal("foobar", @filters.truncate("foobar", 1 << 63))
-    assert_equal("...", @filters.truncate("foobar", -(1 << 63)))
  end

  def test_split
@@ -188,7 +178,7 @@ class StandardFiltersTest < Minitest::Test
  def test_base64_url_safe_encode
    assert_equal(
      'YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXogQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVogMTIzNDU2Nzg5MCAhQCMkJV4mKigpLT1fKy8_Ljo7W117fVx8',
-      @filters.base64_url_safe_encode('abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 !@#$%^&*()-=_+/?.:;[]{}\|'),
+      @filters.base64_url_safe_encode('abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 !@#$%^&*()-=_+/?.:;[]{}\|')
    )
    assert_equal('', @filters.base64_url_safe_encode(nil))
  end
@@ -196,7 +186,7 @@ class StandardFiltersTest < Minitest::Test
  def test_base64_url_safe_decode
    assert_equal(
      'abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 !@#$%^&*()-=_+/?.:;[]{}\|',
-      @filters.base64_url_safe_decode('YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXogQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVogMTIzNDU2Nzg5MCAhQCMkJV4mKigpLT1fKy8_Ljo7W117fVx8'),
+      @filters.base64_url_safe_decode('YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXogQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVogMTIzNDU2Nzg5MCAhQCMkJV4mKigpLT1fKy8_Ljo7W117fVx8')
    )
    exception = assert_raises(Liquid::ArgumentError) do
      @filters.base64_url_safe_decode("invalidbase64")
@@ -230,15 +220,17 @@ class StandardFiltersTest < Minitest::Test
    assert_equal('one two three', @filters.truncatewords('one two three'))
    assert_equal(
      'Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221;...',
-      @filters.truncatewords('Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221; x 16&#8221; x 10.5&#8221; high) with cover.', 15),
+      @filters.truncatewords('Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221; x 16&#8221; x 10.5&#8221; high) with cover.', 15)
    )
    assert_equal("测试测试测试测试", @filters.truncatewords('测试测试测试测试', 5))
    assert_equal('one two1', @filters.truncatewords("one two three", 2, 1))
    assert_equal('one two three...', @filters.truncatewords("one  two\tthree\nfour", 3))
    assert_equal('one two...', @filters.truncatewords("one two three four", 2))
    assert_equal('one...', @filters.truncatewords("one two three four", 0))
-    assert_equal('one two three four', @filters.truncatewords("one two three four", 1 << 31))
-    assert_equal('one...', @filters.truncatewords("one two three four", -(1 << 32)))
+    exception = assert_raises(Liquid::ArgumentError) do
+      @filters.truncatewords("one two three four", 1 << 31)
+    end
+    assert_equal("Liquid error: integer #{1 << 31} too big for truncatewords", exception.message)
  end

  def test_strip_html
@@ -433,11 +425,8 @@ class StandardFiltersTest < Minitest::Test

  def test_map
    assert_equal([1, 2, 3, 4], @filters.map([{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }], 'a'))
-    assert_template_result(
-      'abc',
-      "{{ ary | map:'foo' | map:'bar' }}",
-      { 'ary' => [{ 'foo' => { 'bar' => 'a' } }, { 'foo' => { 'bar' => 'b' } }, { 'foo' => { 'bar' => 'c' } }] },
-    )
+    assert_template_result('abc', "{{ ary | map:'foo' | map:'bar' }}",
+      'ary' => [{ 'foo' => { 'bar' => 'a' } }, { 'foo' => { 'bar' => 'b' } }, { 'foo' => { 'bar' => 'c' } }])
  end

  def test_map_doesnt_call_arbitrary_stuff
@@ -447,7 +436,7 @@ class StandardFiltersTest < Minitest::Test

  def test_map_calls_to_liquid
    t = TestThing.new
-    assert_template_result("woot: 1", '{{ foo | map: "whatever" }}', { "foo" => [t] })
+    assert_template_result("woot: 1", '{{ foo | map: "whatever" }}', "foo" => [t])
  end

  def test_map_calls_context=
@@ -461,17 +450,14 @@ class StandardFiltersTest < Minitest::Test
  end

  def test_map_on_hashes
-    assert_template_result(
-      "4217",
-      '{{ thing | map: "foo" | map: "bar" }}',
-      { "thing" => { "foo" => [{ "bar" => 42 }, { "bar" => 17 }] } },
-    )
+    assert_template_result("4217", '{{ thing | map: "foo" | map: "bar" }}',
+      "thing" => { "foo" => [{ "bar" => 42 }, { "bar" => 17 }] })
  end

  def test_legacy_map_on_hashes_with_dynamic_key
    template = "{% assign key = 'foo' %}{{ thing | map: key | map: 'bar' }}"
    hash     = { "foo" => { "bar" => 42 } }
-    assert_template_result("42", template, { "thing" => hash })
+    assert_template_result("42", template, "thing" => hash)
  end

  def test_sort_calls_to_liquid
@@ -483,8 +469,8 @@ class StandardFiltersTest < Minitest::Test
  def test_map_over_proc
    drop  = TestDrop.new(value: "testfoo")
    p     = proc { drop }
-    output = Liquid::Template.parse('{{ procs | map: "value" }}').render!({ "procs" => [p] })
-    assert_equal("testfoo", output)
+    templ = '{{ procs | map: "value" }}'
+    assert_template_result("testfoo", templ, "procs" => [p])
  end

  def test_map_over_drops_returning_procs
@@ -496,13 +482,12 @@ class StandardFiltersTest < Minitest::Test
        "proc" => -> { "bar" },
      },
    ]
-    output = Liquid::Template.parse('{{ drops | map: "proc" }}').render!({ "drops" => drops })
-    assert_equal("foobar", output)
+    templ = '{{ drops | map: "proc" }}'
+    assert_template_result("foobar", templ, "drops" => drops)
  end

  def test_map_works_on_enumerables
-    output = Liquid::Template.parse('{{ foo | map: "foo" }}').render!({ "foo" => TestEnumerable.new })
-    assert_equal("123", output)
+    assert_template_result("123", '{{ foo | map: "foo" }}', "foo" => TestEnumerable.new)
  end

  def test_map_returns_empty_on_2d_input_array
@@ -529,16 +514,16 @@ class StandardFiltersTest < Minitest::Test
  end

  def test_sort_works_on_enumerables
-    assert_template_result("213", '{{ foo | sort: "bar" | map: "foo" }}', { "foo" => TestEnumerable.new })
+    assert_template_result("213", '{{ foo | sort: "bar" | map: "foo" }}', "foo" => TestEnumerable.new)
  end

  def test_first_and_last_call_to_liquid
-    assert_template_result('foobar', '{{ foo | first }}', { 'foo' => [ThingWithToLiquid.new] })
-    assert_template_result('foobar', '{{ foo | last }}', { 'foo' => [ThingWithToLiquid.new] })
+    assert_template_result('foobar', '{{ foo | first }}', 'foo' => [ThingWithToLiquid.new])
+    assert_template_result('foobar', '{{ foo | last }}', 'foo' => [ThingWithToLiquid.new])
  end

  def test_truncate_calls_to_liquid
-    assert_template_result("wo...", '{{ foo | truncate: 5 }}', { "foo" => TestThing.new })
+    assert_template_result("wo...", '{{ foo | truncate: 5 }}', "foo" => TestThing.new)
  end

  def test_date
@@ -612,42 +597,42 @@ class StandardFiltersTest < Minitest::Test
  end

  def test_strip
-    assert_template_result('ab c', "{{ source | strip }}", { 'source' => " ab c  " })
-    assert_template_result('ab c', "{{ source | strip }}", { 'source' => " \tab c  \n \t" })
+    assert_template_result('ab c', "{{ source | strip }}", 'source' => " ab c  ")
+    assert_template_result('ab c', "{{ source | strip }}", 'source' => " \tab c  \n \t")
  end

  def test_lstrip
-    assert_template_result('ab c  ', "{{ source | lstrip }}", { 'source' => " ab c  " })
-    assert_template_result("ab c  \n \t", "{{ source | lstrip }}", { 'source' => " \tab c  \n \t" })
+    assert_template_result('ab c  ', "{{ source | lstrip }}", 'source' => " ab c  ")
+    assert_template_result("ab c  \n \t", "{{ source | lstrip }}", 'source' => " \tab c  \n \t")
  end

  def test_rstrip
-    assert_template_result(" ab c", "{{ source | rstrip }}", { 'source' => " ab c  " })
-    assert_template_result(" \tab c", "{{ source | rstrip }}", { 'source' => " \tab c  \n \t" })
+    assert_template_result(" ab c", "{{ source | rstrip }}", 'source' => " ab c  ")
+    assert_template_result(" \tab c", "{{ source | rstrip }}", 'source' => " \tab c  \n \t")
  end

  def test_strip_newlines
-    assert_template_result('abc', "{{ source | strip_newlines }}", { 'source' => "a\nb\nc" })
-    assert_template_result('abc', "{{ source | strip_newlines }}", { 'source' => "a\r\nb\nc" })
+    assert_template_result('abc', "{{ source | strip_newlines }}", 'source' => "a\nb\nc")
+    assert_template_result('abc', "{{ source | strip_newlines }}", 'source' => "a\r\nb\nc")
  end

  def test_newlines_to_br
-    assert_template_result("a<br />\nb<br />\nc", "{{ source | newline_to_br }}", { 'source' => "a\nb\nc" })
-    assert_template_result("a<br />\nb<br />\nc", "{{ source | newline_to_br }}", { 'source' => "a\r\nb\nc" })
+    assert_template_result("a<br />\nb<br />\nc", "{{ source | newline_to_br }}", 'source' => "a\nb\nc")
+    assert_template_result("a<br />\nb<br />\nc", "{{ source | newline_to_br }}", 'source' => "a\r\nb\nc")
  end

  def test_plus
    assert_template_result("2", "{{ 1 | plus:1 }}")
    assert_template_result("2.0", "{{ '1' | plus:'1.0' }}")

-    assert_template_result("5", "{{ price | plus:'2' }}", { 'price' => NumberLikeThing.new(3) })
+    assert_template_result("5", "{{ price | plus:'2' }}", 'price' => NumberLikeThing.new(3))
  end

  def test_minus
-    assert_template_result("4", "{{ input | minus:operand }}", { 'input' => 5, 'operand' => 1 })
+    assert_template_result("4", "{{ input | minus:operand }}", 'input' => 5, 'operand' => 1)
    assert_template_result("2.3", "{{ '4.3' | minus:'2' }}")

-    assert_template_result("5", "{{ price | minus:'2' }}", { 'price' => NumberLikeThing.new(7) })
+    assert_template_result("5", "{{ price | minus:'2' }}", 'price' => NumberLikeThing.new(7))
  end

  def test_abs
@@ -670,7 +655,7 @@ class StandardFiltersTest < Minitest::Test
    assert_template_result("7.25", "{{ 0.0725 | times:100 }}")
    assert_template_result("-7.25", '{{ "-0.0725" | times:100 }}')
    assert_template_result("7.25", '{{ "-0.0725" | times: -100 }}')
-    assert_template_result("4", "{{ price | times:2 }}", { 'price' => NumberLikeThing.new(2) })
+    assert_template_result("4", "{{ price | times:2 }}", 'price' => NumberLikeThing.new(2))
  end

  def test_divided_by
@@ -685,7 +670,7 @@ class StandardFiltersTest < Minitest::Test
      assert_template_result("4", "{{ 1 | modulo: 0 }}")
    end

-    assert_template_result("5", "{{ price | divided_by:2 }}", { 'price' => NumberLikeThing.new(10) })
+    assert_template_result("5", "{{ price | divided_by:2 }}", 'price' => NumberLikeThing.new(10))
  end

  def test_modulo
@@ -694,39 +679,39 @@ class StandardFiltersTest < Minitest::Test
      assert_template_result("4", "{{ 1 | modulo: 0 }}")
    end

-    assert_template_result("1", "{{ price | modulo:2 }}", { 'price' => NumberLikeThing.new(3) })
+    assert_template_result("1", "{{ price | modulo:2 }}", 'price' => NumberLikeThing.new(3))
  end

  def test_round
-    assert_template_result("5", "{{ input | round }}", { 'input' => 4.6 })
+    assert_template_result("5", "{{ input | round }}", 'input' => 4.6)
    assert_template_result("4", "{{ '4.3' | round }}")
-    assert_template_result("4.56", "{{ input | round: 2 }}", { 'input' => 4.5612 })
+    assert_template_result("4.56", "{{ input | round: 2 }}", 'input' => 4.5612)
    assert_raises(Liquid::FloatDomainError) do
      assert_template_result("4", "{{ 1.0 | divided_by: 0.0 | round }}")
    end

-    assert_template_result("5", "{{ price | round }}", { 'price' => NumberLikeThing.new(4.6) })
-    assert_template_result("4", "{{ price | round }}", { 'price' => NumberLikeThing.new(4.3) })
+    assert_template_result("5", "{{ price | round }}", 'price' => NumberLikeThing.new(4.6))
+    assert_template_result("4", "{{ price | round }}", 'price' => NumberLikeThing.new(4.3))
  end

  def test_ceil
-    assert_template_result("5", "{{ input | ceil }}", { 'input' => 4.6 })
+    assert_template_result("5", "{{ input | ceil }}", 'input' => 4.6)
    assert_template_result("5", "{{ '4.3' | ceil }}")
    assert_raises(Liquid::FloatDomainError) do
      assert_template_result("4", "{{ 1.0 | divided_by: 0.0 | ceil }}")
    end

-    assert_template_result("5", "{{ price | ceil }}", { 'price' => NumberLikeThing.new(4.6) })
+    assert_template_result("5", "{{ price | ceil }}", 'price' => NumberLikeThing.new(4.6))
  end

  def test_floor
-    assert_template_result("4", "{{ input | floor }}", { 'input' => 4.6 })
+    assert_template_result("4", "{{ input | floor }}", 'input' => 4.6)
    assert_template_result("4", "{{ '4.3' | floor }}")
    assert_raises(Liquid::FloatDomainError) do
      assert_template_result("4", "{{ 1.0 | divided_by: 0.0 | floor }}")
    end

-    assert_template_result("5", "{{ price | floor }}", { 'price' => NumberLikeThing.new(5.4) })
+    assert_template_result("5", "{{ price | floor }}", 'price' => NumberLikeThing.new(5.4))
  end

  def test_at_most
@@ -735,9 +720,9 @@ class StandardFiltersTest < Minitest::Test
    assert_template_result("5", "{{ 5 | at_most:6 }}")

    assert_template_result("4.5", "{{ 4.5 | at_most:5 }}")
-    assert_template_result("5", "{{ width | at_most:5 }}", { 'width' => NumberLikeThing.new(6) })
-    assert_template_result("4", "{{ width | at_most:5 }}", { 'width' => NumberLikeThing.new(4) })
-    assert_template_result("4", "{{ 5 | at_most: width }}", { 'width' => NumberLikeThing.new(4) })
+    assert_template_result("5", "{{ width | at_most:5 }}", 'width' => NumberLikeThing.new(6))
+    assert_template_result("4", "{{ width | at_most:5 }}", 'width' => NumberLikeThing.new(4))
+    assert_template_result("4", "{{ 5 | at_most: width }}", 'width' => NumberLikeThing.new(4))
  end

  def test_at_least
@@ -746,9 +731,9 @@ class StandardFiltersTest < Minitest::Test
    assert_template_result("6", "{{ 5 | at_least:6 }}")

    assert_template_result("5", "{{ 4.5 | at_least:5 }}")
-    assert_template_result("6", "{{ width | at_least:5 }}", { 'width' => NumberLikeThing.new(6) })
-    assert_template_result("5", "{{ width | at_least:5 }}", { 'width' => NumberLikeThing.new(4) })
-    assert_template_result("6", "{{ 5 | at_least: width }}", { 'width' => NumberLikeThing.new(6) })
+    assert_template_result("6", "{{ width | at_least:5 }}", 'width' => NumberLikeThing.new(6))
+    assert_template_result("5", "{{ width | at_least:5 }}", 'width' => NumberLikeThing.new(4))
+    assert_template_result("6", "{{ 5 | at_least: width }}", 'width' => NumberLikeThing.new(6))
  end

  def test_append
@@ -781,8 +766,8 @@ class StandardFiltersTest < Minitest::Test
    assert_equal("bar", @filters.default([], "bar"))
    assert_equal("bar", @filters.default({}, "bar"))
    assert_template_result('bar', "{{ false | default: 'bar' }}")
-    assert_template_result('bar', "{{ drop | default: 'bar' }}", { 'drop' => BooleanDrop.new(false) })
-    assert_template_result('Yay', "{{ drop | default: 'bar' }}", { 'drop' => BooleanDrop.new(true) })
+    assert_template_result('bar', "{{ drop | default: 'bar' }}", 'drop' => BooleanDrop.new(false))
+    assert_template_result('Yay', "{{ drop | default: 'bar' }}", 'drop' => BooleanDrop.new(true))
  end

  def test_default_handle_false
@@ -793,8 +778,8 @@ class StandardFiltersTest < Minitest::Test
    assert_equal("bar", @filters.default([], "bar", "allow_false" => true))
    assert_equal("bar", @filters.default({}, "bar", "allow_false" => true))
    assert_template_result('false', "{{ false | default: 'bar', allow_false: true }}")
-    assert_template_result('Nay', "{{ drop | default: 'bar', allow_false: true }}", { 'drop' => BooleanDrop.new(false) })
-    assert_template_result('Yay', "{{ drop | default: 'bar', allow_false: true }}", { 'drop' => BooleanDrop.new(true) })
+    assert_template_result('Nay', "{{ drop | default: 'bar', allow_false: true }}", 'drop' => BooleanDrop.new(false))
+    assert_template_result('Yay', "{{ drop | default: 'bar', allow_false: true }}", 'drop' => BooleanDrop.new(true))
  end

  def test_cannot_access_private_methods
@@ -9,8 +9,8 @@ class BreakTagTest < Minitest::Test
  # block
  def test_break_with_no_block
    assigns  = { 'i' => 1 }
-    markup   = 'before{% break %}after'
-    expected = 'before'
+    markup   = '{% break %}'
+    expected = ''

    assert_template_result(expected, markup, assigns)
  end
@@ -6,7 +6,7 @@ class EchoTest < Minitest::Test
  include Liquid

  def test_echo_outputs_its_input
-    assert_template_result('BAR', <<~LIQUID, { 'variable-name' => 'bar' })
+    assert_template_result('BAR', <<~LIQUID, 'variable-name' => 'bar')
      {%- echo variable-name | upcase -%}
    LIQUID
  end
@@ -12,10 +12,10 @@ class ForTagTest < Minitest::Test
  include Liquid

  def test_for
-    assert_template_result(' yo  yo  yo  yo ', '{%for item in array%} yo {%endfor%}', { 'array' => [1, 2, 3, 4] })
-    assert_template_result('yoyo', '{%for item in array%}yo{%endfor%}', { 'array' => [1, 2] })
-    assert_template_result(' yo ', '{%for item in array%} yo {%endfor%}', { 'array' => [1] })
-    assert_template_result('', '{%for item in array%}{%endfor%}', { 'array' => [1, 2] })
+    assert_template_result(' yo  yo  yo  yo ', '{%for item in array%} yo {%endfor%}', 'array' => [1, 2, 3, 4])
+    assert_template_result('yoyo', '{%for item in array%}yo{%endfor%}', 'array' => [1, 2])
+    assert_template_result(' yo ', '{%for item in array%} yo {%endfor%}', 'array' => [1])
+    assert_template_result('', '{%for item in array%}{%endfor%}', 'array' => [1, 2])
    expected = <<HERE

  yo
@@ -30,7 +30,7 @@ HERE
        yo
      {%endfor%}
    HERE
-    assert_template_result(expected, template, { 'array' => [1, 2, 3] })
+    assert_template_result(expected, template, 'array' => [1, 2, 3])
  end

  def test_for_reversed
@@ -45,39 +45,37 @@ HERE
      Template.parse('{% for i in (a..2) %}{% endfor %}').render!("a" => [1, 2])
    end

-    assert_template_result(' 0  1  2  3 ', '{% for item in (a..3) %} {{item}} {% endfor %}', { "a" => "invalid integer" })
+    assert_template_result(' 0  1  2  3 ', '{% for item in (a..3) %} {{item}} {% endfor %}', "a" => "invalid integer")
  end

  def test_for_with_variable_range
-    assert_template_result(' 1  2  3 ', '{%for item in (1..foobar) %} {{item}} {%endfor%}', { "foobar" => 3 })
+    assert_template_result(' 1  2  3 ', '{%for item in (1..foobar) %} {{item}} {%endfor%}', "foobar" => 3)
  end

  def test_for_with_hash_value_range
    foobar = { "value" => 3 }
-    assert_template_result(' 1  2  3 ', '{%for item in (1..foobar.value) %} {{item}} {%endfor%}', { "foobar" => foobar })
+    assert_template_result(' 1  2  3 ', '{%for item in (1..foobar.value) %} {{item}} {%endfor%}', "foobar" => foobar)
  end

  def test_for_with_drop_value_range
    foobar = ThingWithValue.new
-    assert_template_result(' 1  2  3 ', '{%for item in (1..foobar.value) %} {{item}} {%endfor%}', { "foobar" => foobar })
+    assert_template_result(' 1  2  3 ', '{%for item in (1..foobar.value) %} {{item}} {%endfor%}', "foobar" => foobar)
  end

  def test_for_with_variable
-    assert_template_result(' 1  2  3 ', '{%for item in array%} {{item}} {%endfor%}', { 'array' => [1, 2, 3] })
-    assert_template_result('123', '{%for item in array%}{{item}}{%endfor%}', { 'array' => [1, 2, 3] })
-    assert_template_result('123', '{% for item in array %}{{item}}{% endfor %}', { 'array' => [1, 2, 3] })
-    assert_template_result('abcd', '{%for item in array%}{{item}}{%endfor%}', { 'array' => ['a', 'b', 'c', 'd'] })
-    assert_template_result('a b c', '{%for item in array%}{{item}}{%endfor%}', { 'array' => ['a', ' ', 'b', ' ', 'c'] })
-    assert_template_result('abc', '{%for item in array%}{{item}}{%endfor%}', { 'array' => ['a', '', 'b', '', 'c'] })
+    assert_template_result(' 1  2  3 ', '{%for item in array%} {{item}} {%endfor%}', 'array' => [1, 2, 3])
+    assert_template_result('123', '{%for item in array%}{{item}}{%endfor%}', 'array' => [1, 2, 3])
+    assert_template_result('123', '{% for item in array %}{{item}}{% endfor %}', 'array' => [1, 2, 3])
+    assert_template_result('abcd', '{%for item in array%}{{item}}{%endfor%}', 'array' => ['a', 'b', 'c', 'd'])
+    assert_template_result('a b c', '{%for item in array%}{{item}}{%endfor%}', 'array' => ['a', ' ', 'b', ' ', 'c'])
+    assert_template_result('abc', '{%for item in array%}{{item}}{%endfor%}', 'array' => ['a', '', 'b', '', 'c'])
  end

  def test_for_helpers
    assigns = { 'array' => [1, 2, 3] }
-    assert_template_result(
-      ' 1/3  2/3  3/3 ',
+    assert_template_result(' 1/3  2/3  3/3 ',
      '{%for item in array%} {{forloop.index}}/{{forloop.length}} {%endfor%}',
-      assigns,
-    )
+      assigns)
    assert_template_result(' 1  2  3 ', '{%for item in array%} {{forloop.index}} {%endfor%}', assigns)
    assert_template_result(' 0  1  2 ', '{%for item in array%} {{forloop.index0}} {%endfor%}', assigns)
    assert_template_result(' 2  1  0 ', '{%for item in array%} {{forloop.rindex0}} {%endfor%}', assigns)
@@ -88,17 +86,15 @@ HERE

  def test_for_and_if
    assigns = { 'array' => [1, 2, 3] }
-    assert_template_result(
-      '+--',
+    assert_template_result('+--',
      '{%for item in array%}{% if forloop.first %}+{% else %}-{% endif %}{%endfor%}',
-      assigns,
-    )
+      assigns)
  end

  def test_for_else
-    assert_template_result('+++', '{%for item in array%}+{%else%}-{%endfor%}', { 'array' => [1, 2, 3] })
-    assert_template_result('-',   '{%for item in array%}+{%else%}-{%endfor%}', { 'array' => [] })
-    assert_template_result('-',   '{%for item in array%}+{%else%}-{%endfor%}', { 'array' => nil })
+    assert_template_result('+++', '{%for item in array%}+{%else%}-{%endfor%}', 'array' => [1, 2, 3])
+    assert_template_result('-',   '{%for item in array%}+{%else%}-{%endfor%}', 'array' => [])
+    assert_template_result('-',   '{%for item in array%}+{%else%}-{%endfor%}', 'array' => nil)
  end

  def test_limiting
@@ -107,7 +103,6 @@ HERE
    assert_template_result('1234', '{%for i in array limit:4 %}{{ i }}{%endfor%}', assigns)
    assert_template_result('3456', '{%for i in array limit:4 offset:2 %}{{ i }}{%endfor%}', assigns)
    assert_template_result('3456', '{%for i in array limit: 4 offset: 2 %}{{ i }}{%endfor%}', assigns)
-    assert_template_result('3456', '{%for i in array, limit: 4, offset: 2 %}{{ i }}{%endfor%}', assigns)
  end

  def test_limiting_with_invalid_limit
@@ -268,19 +263,6 @@ HERE
    assert_template_result(expected, markup, assigns)
  end

-  def test_for_with_break_after_nested_loop
-    source = <<~LIQUID.chomp
-      {% for i in (1..2) -%}
-        {% for j in (1..2) -%}
-          {{ i }}-{{ j }},
-        {%- endfor -%}
-        {% break -%}
-      {% endfor -%}
-      after
-    LIQUID
-    assert_template_result("1-1,1-2,after", source)
-  end
-
  def test_for_with_continue
    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5] } }

@@ -329,20 +311,15 @@ HERE
    # ruby 1.9.3 no longer supports .each on String though we mimic
    # the functionality for backwards compatibility

-    assert_template_result(
-      'test string',
+    assert_template_result('test string',
      '{%for val in string%}{{val}}{%endfor%}',
-      { 'string' => "test string" },
-    )
+      'string' => "test string")

-    assert_template_result(
-      'test string',
+    assert_template_result('test string',
      '{%for val in string limit:1%}{{val}}{%endfor%}',
-      { 'string' => "test string" },
-    )
+      'string' => "test string")

-    assert_template_result(
-      'val-string-1-1-0-1-0-true-true-test string',
+    assert_template_result('val-string-1-1-0-1-0-true-true-test string',
      '{%for val in string%}' \
      '{{forloop.name}}-' \
      '{{forloop.index}}-' \
@@ -353,28 +330,23 @@ HERE
      '{{forloop.first}}-' \
      '{{forloop.last}}-' \
      '{{val}}{%endfor%}',
-      { 'string' => "test string" },
-    )
+      'string' => "test string")
  end

  def test_for_parentloop_references_parent_loop
-    assert_template_result(
-      '1.1 1.2 1.3 2.1 2.2 2.3 ',
+    assert_template_result('1.1 1.2 1.3 2.1 2.2 2.3 ',
      '{% for inner in outer %}{% for k in inner %}' \
      '{{ forloop.parentloop.index }}.{{ forloop.index }} ' \
      '{% endfor %}{% endfor %}',
-      { 'outer' => [[1, 1, 1], [1, 1, 1]] },
-    )
+      'outer' => [[1, 1, 1], [1, 1, 1]])
  end

  def test_for_parentloop_nil_when_not_present
-    assert_template_result(
-      '.1 .2 ',
+    assert_template_result('.1 .2 ',
      '{% for inner in outer %}' \
      '{{ forloop.parentloop.index }}.{{ forloop.index }} ' \
      '{% endfor %}',
-      { 'outer' => [[1, 1, 1], [1, 1, 1]] },
-    )
+      'outer' => [[1, 1, 1], [1, 1, 1]])
  end

  def test_inner_for_over_empty_input
@@ -382,7 +354,7 @@ HERE
  end

  def test_blank_string_not_iterable
-    assert_template_result('', "{% for char in characters %}I WILL NOT BE OUTPUT{% endfor %}", { 'characters' => '' })
+    assert_template_result('', "{% for char in characters %}I WILL NOT BE OUTPUT{% endfor %}", 'characters' => '')
  end

  def test_bad_variable_naming_in_for_loop
@@ -465,4 +437,30 @@ HERE

    assert(context.registers[:for_stack].empty?)
  end
+
+  def test_instrument_for_offset_continue
+    assert_usage_increment('for_offset_continue') do
+      Template.parse('{% for item in items offset:continue %}{{item}}{% endfor %}')
+    end
+
+    assert_usage_increment('for_offset_continue', times: 0) do
+      Template.parse('{% for item in items offset:2 %}{{item}}{% endfor %}')
+    end
+  end
+
+  def test_instrument_forloop_drop_name
+    assigns = { 'items' => [1, 2, 3, 4, 5] }
+
+    assert_usage_increment('forloop_drop_name', times: 5) do
+      Template.parse('{% for item in items %}{{forloop.name}}{% endfor %}').render!(assigns)
+    end
+
+    assert_usage_increment('forloop_drop_name', times: 0) do
+      Template.parse('{% for item in items %}{{forloop.index}}{% endfor %}').render!(assigns)
+    end
+
+    assert_usage_increment('forloop_drop_name', times: 0) do
+      Template.parse('{% for item in items %}{{item}}{% endfor %}').render!(assigns)
+    end
+  end
 end
@@ -7,10 +7,8 @@ class IfElseTagTest < Minitest::Test

  def test_if
    assert_template_result('  ', ' {% if false %} this text should not go into the output {% endif %} ')
-    assert_template_result(
-      '  this text should go into the output  ',
-      ' {% if true %} this text should go into the output {% endif %} ',
-    )
+    assert_template_result('  this text should go into the output  ',
+      ' {% if true %} this text should go into the output {% endif %} ')
    assert_template_result('  you rock ?', '{% if false %} you suck {% endif %} {% if true %} you rock {% endif %}?')
  end

@@ -26,23 +24,23 @@ class IfElseTagTest < Minitest::Test
  end

  def test_if_boolean
-    assert_template_result(' YES ', '{% if var %} YES {% endif %}', { 'var' => true })
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => true)
  end

  def test_if_or
-    assert_template_result(' YES ', '{% if a or b %} YES {% endif %}', { 'a' => true, 'b' => true })
-    assert_template_result(' YES ', '{% if a or b %} YES {% endif %}', { 'a' => true, 'b' => false })
-    assert_template_result(' YES ', '{% if a or b %} YES {% endif %}', { 'a' => false, 'b' => true })
-    assert_template_result('',      '{% if a or b %} YES {% endif %}', { 'a' => false, 'b' => false })
+    assert_template_result(' YES ', '{% if a or b %} YES {% endif %}', 'a' => true, 'b' => true)
+    assert_template_result(' YES ', '{% if a or b %} YES {% endif %}', 'a' => true, 'b' => false)
+    assert_template_result(' YES ', '{% if a or b %} YES {% endif %}', 'a' => false, 'b' => true)
+    assert_template_result('',      '{% if a or b %} YES {% endif %}', 'a' => false, 'b' => false)

-    assert_template_result(' YES ', '{% if a or b or c %} YES {% endif %}', { 'a' => false, 'b' => false, 'c' => true })
-    assert_template_result('',      '{% if a or b or c %} YES {% endif %}', { 'a' => false, 'b' => false, 'c' => false })
+    assert_template_result(' YES ', '{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => true)
+    assert_template_result('',      '{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => false)
  end

  def test_if_or_with_operators
-    assert_template_result(' YES ', '{% if a == true or b == true %} YES {% endif %}', { 'a' => true, 'b' => true })
-    assert_template_result(' YES ', '{% if a == true or b == false %} YES {% endif %}', { 'a' => true, 'b' => true })
-    assert_template_result('', '{% if a == false or b == false %} YES {% endif %}', { 'a' => true, 'b' => true })
+    assert_template_result(' YES ', '{% if a == true or b == true %} YES {% endif %}', 'a' => true, 'b' => true)
+    assert_template_result(' YES ', '{% if a == true or b == false %} YES {% endif %}', 'a' => true, 'b' => true)
+    assert_template_result('', '{% if a == false or b == false %} YES {% endif %}', 'a' => true, 'b' => true)
  end

  def test_comparison_of_strings_containing_and_or_or
@@ -53,59 +51,55 @@ class IfElseTagTest < Minitest::Test

  def test_comparison_of_expressions_starting_with_and_or_or
    assigns = { 'order' => { 'items_count' => 0 }, 'android' => { 'name' => 'Roy' } }
-    assert_template_result(
-      "YES",
+    assert_template_result("YES",
      "{% if android.name == 'Roy' %}YES{% endif %}",
-      assigns,
-    )
-    assert_template_result(
-      "YES",
+      assigns)
+    assert_template_result("YES",
      "{% if order.items_count == 0 %}YES{% endif %}",
-      assigns,
-    )
+      assigns)
  end

  def test_if_and
    assert_template_result(' YES ', '{% if true and true %} YES {% endif %}')
    assert_template_result('', '{% if false and true %} YES {% endif %}')
-    assert_template_result('', '{% if true and false %} YES {% endif %}')
+    assert_template_result('', '{% if false and true %} YES {% endif %}')
  end

  def test_hash_miss_generates_false
-    assert_template_result('', '{% if foo.bar %} NO {% endif %}', { 'foo' => {} })
+    assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => {})
  end

  def test_if_from_variable
-    assert_template_result('', '{% if var %} NO {% endif %}', { 'var' => false })
-    assert_template_result('', '{% if var %} NO {% endif %}', { 'var' => nil })
-    assert_template_result('', '{% if foo.bar %} NO {% endif %}', { 'foo' => { 'bar' => false } })
-    assert_template_result('', '{% if foo.bar %} NO {% endif %}', { 'foo' => {} })
-    assert_template_result('', '{% if foo.bar %} NO {% endif %}', { 'foo' => nil })
-    assert_template_result('', '{% if foo.bar %} NO {% endif %}', { 'foo' => true })
+    assert_template_result('', '{% if var %} NO {% endif %}', 'var' => false)
+    assert_template_result('', '{% if var %} NO {% endif %}', 'var' => nil)
+    assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => { 'bar' => false })
+    assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => {})
+    assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => nil)
+    assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => true)

-    assert_template_result(' YES ', '{% if var %} YES {% endif %}', { 'var' => "text" })
-    assert_template_result(' YES ', '{% if var %} YES {% endif %}', { 'var' => true })
-    assert_template_result(' YES ', '{% if var %} YES {% endif %}', { 'var' => 1 })
-    assert_template_result(' YES ', '{% if var %} YES {% endif %}', { 'var' => {} })
-    assert_template_result(' YES ', '{% if var %} YES {% endif %}', { 'var' => [] })
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => "text")
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => true)
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => 1)
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => {})
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => [])
    assert_template_result(' YES ', '{% if "foo" %} YES {% endif %}')
-    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', { 'foo' => { 'bar' => true } })
-    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', { 'foo' => { 'bar' => "text" } })
-    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', { 'foo' => { 'bar' => 1 } })
-    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', { 'foo' => { 'bar' => {} } })
-    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', { 'foo' => { 'bar' => [] } })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => true })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => "text" })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => 1 })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => {} })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => [] })

-    assert_template_result(' YES ', '{% if var %} NO {% else %} YES {% endif %}', { 'var' => false })
-    assert_template_result(' YES ', '{% if var %} NO {% else %} YES {% endif %}', { 'var' => nil })
-    assert_template_result(' YES ', '{% if var %} YES {% else %} NO {% endif %}', { 'var' => true })
-    assert_template_result(' YES ', '{% if "foo" %} YES {% else %} NO {% endif %}', { 'var' => "text" })
+    assert_template_result(' YES ', '{% if var %} NO {% else %} YES {% endif %}', 'var' => false)
+    assert_template_result(' YES ', '{% if var %} NO {% else %} YES {% endif %}', 'var' => nil)
+    assert_template_result(' YES ', '{% if var %} YES {% else %} NO {% endif %}', 'var' => true)
+    assert_template_result(' YES ', '{% if "foo" %} YES {% else %} NO {% endif %}', 'var' => "text")

-    assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', { 'foo' => { 'bar' => false } })
-    assert_template_result(' YES ', '{% if foo.bar %} YES {% else %} NO {% endif %}', { 'foo' => { 'bar' => true } })
-    assert_template_result(' YES ', '{% if foo.bar %} YES {% else %} NO {% endif %}', { 'foo' => { 'bar' => "text" } })
-    assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', { 'foo' => { 'notbar' => true } })
-    assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', { 'foo' => {} })
-    assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', { 'notfoo' => { 'bar' => true } })
+    assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => { 'bar' => false })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% else %} NO {% endif %}', 'foo' => { 'bar' => true })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% else %} NO {% endif %}', 'foo' => { 'bar' => "text" })
+    assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => { 'notbar' => true })
+    assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => {})
+    assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', 'notfoo' => { 'bar' => true })
  end

  def test_nested_if
@@ -161,10 +155,8 @@ class IfElseTagTest < Minitest::Test
    original_op = Condition.operators['contains']
    Condition.operators['contains'] = :[]

-    assert_template_result(
-      'yes',
-      %({% if 'gnomeslab-and-or-liquid' contains 'gnomeslab-and-or-liquid' %}yes{% endif %}),
-    )
+    assert_template_result('yes',
+      %({% if 'gnomeslab-and-or-liquid' contains 'gnomeslab-and-or-liquid' %}yes{% endif %}))
  ensure
    Condition.operators['contains'] = original_op
  end
@@ -192,7 +184,7 @@ class IfElseTagTest < Minitest::Test
    tests.each do |vals, expected|
      a, b, c = vals
      assigns = { 'a' => a, 'b' => b, 'c' => c }
-      assert_template_result(expected.to_s, tpl, assigns, message: assigns.to_s)
+      assert_template_result(expected.to_s, tpl, assigns, assigns.to_s)
    end
  end
 end
@@ -3,13 +3,44 @@
 require 'test_helper'

 class TestFileSystem
-  PARTIALS = {
-    "nested_template" => "{% include 'header' %} {% include 'body' %} {% include 'footer' %}",
-    "body" => "body {% include 'body_detail' %}",
-  }
-
  def read_template_file(template_path)
-    PARTIALS[template_path] || template_path
+    case template_path
+    when "product"
+      "Product: {{ product.title }} "
+
+    when "product_alias"
+      "Product: {{ product.title }} "
+
+    when "locale_variables"
+      "Locale: {{echo1}} {{echo2}}"
+
+    when "variant"
+      "Variant: {{ variant.title }}"
+
+    when "nested_template"
+      "{% include 'header' %} {% include 'body' %} {% include 'footer' %}"
+
+    when "body"
+      "body {% include 'body_detail' %}"
+
+    when "nested_product_template"
+      "Product: {{ nested_product_template.title }} {%include 'details'%} "
+
+    when "recursively_nested_template"
+      "-{% include 'recursively_nested_template' %}"
+
+    when "pick_a_source"
+      "from TestFileSystem"
+
+    when 'assignments'
+      "{% assign foo = 'bar' %}"
+
+    when 'break'
+      "{% break %}"
+
+    else
+      template_path
+    end
  end
 end

@@ -50,129 +81,70 @@ class IncludeTagTest < Minitest::Test
  include Liquid

  def setup
-    @default_file_system = Liquid::Template.file_system
-  end
-
-  def teardown
-    Liquid::Template.file_system = @default_file_system
+    Liquid::Template.file_system = TestFileSystem.new
  end

  def test_include_tag_looks_for_file_system_in_registers_first
-    assert_equal(
-      'from OtherFileSystem',
-      Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: OtherFileSystem.new }),
-    )
+    assert_equal('from OtherFileSystem',
+      Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: OtherFileSystem.new }))
  end

  def test_include_tag_with
-    assert_template_result(
-      "Product: Draft 151cm ",
-      "{% include 'product' with products[0] %}",
-      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] },
-      partials: { "product" => "Product: {{ product.title }} " },
-    )
+    assert_template_result("Product: Draft 151cm ",
+      "{% include 'product' with products[0] %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
  end

  def test_include_tag_with_alias
-    assert_template_result(
-      "Product: Draft 151cm ",
-      "{% include 'product_alias' with products[0] as product %}",
-      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] },
-      partials: { "product_alias" => "Product: {{ product.title }} " },
-    )
+    assert_template_result("Product: Draft 151cm ",
+      "{% include 'product_alias' with products[0] as product %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
  end

  def test_include_tag_for_alias
-    assert_template_result(
-      "Product: Draft 151cm Product: Element 155cm ",
-      "{% include 'product_alias' for products as product %}",
-      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] },
-      partials: { "product_alias" => "Product: {{ product.title }} " },
-    )
+    assert_template_result("Product: Draft 151cm Product: Element 155cm ",
+      "{% include 'product_alias' for products as product %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
  end

  def test_include_tag_with_default_name
-    assert_template_result(
-      "Product: Draft 151cm ",
-      "{% include 'product' %}",
-      { "product" => { 'title' => 'Draft 151cm' } },
-      partials: { "product" => "Product: {{ product.title }} " },
-    )
+    assert_template_result("Product: Draft 151cm ",
+      "{% include 'product' %}", "product" => { 'title' => 'Draft 151cm' })
  end

  def test_include_tag_for
-    assert_template_result(
-      "Product: Draft 151cm Product: Element 155cm ",
-      "{% include 'product' for products %}",
-      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] },
-      partials: { "product" => "Product: {{ product.title }} " },
-    )
+    assert_template_result("Product: Draft 151cm Product: Element 155cm ",
+      "{% include 'product' for products %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
  end

  def test_include_tag_with_local_variables
-    assert_template_result(
-      "Locale: test123 ",
-      "{% include 'locale_variables' echo1: 'test123' %}",
-      partials: { "locale_variables" => "Locale: {{echo1}} {{echo2}}" },
-    )
+    assert_template_result("Locale: test123 ", "{% include 'locale_variables' echo1: 'test123' %}")
  end

  def test_include_tag_with_multiple_local_variables
-    assert_template_result(
-      "Locale: test123 test321",
-      "{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}",
-      partials: { "locale_variables" => "Locale: {{echo1}} {{echo2}}" },
-    )
+    assert_template_result("Locale: test123 test321",
+      "{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}")
  end

  def test_include_tag_with_multiple_local_variables_from_context
-    assert_template_result(
-      "Locale: test123 test321",
+    assert_template_result("Locale: test123 test321",
      "{% include 'locale_variables' echo1: echo1, echo2: more_echos.echo2 %}",
-      { 'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321' } },
-      partials: { "locale_variables" => "Locale: {{echo1}} {{echo2}}" },
-    )
+      'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321' })
  end

  def test_included_templates_assigns_variables
-    assert_template_result(
-      "bar",
-      "{% include 'assignments' %}{{ foo }}",
-      partials: { 'assignments' => "{% assign foo = 'bar' %}" },
-    )
+    assert_template_result("bar", "{% include 'assignments' %}{{ foo }}")
  end

  def test_nested_include_tag
-    partials = { "body" => "body {% include 'body_detail' %}", "body_detail" => "body_detail" }
-    assert_template_result("body body_detail", "{% include 'body' %}", partials: partials)
+    assert_template_result("body body_detail", "{% include 'body' %}")

-    partials = partials.merge({
-      "nested_template" => "{% include 'header' %} {% include 'body' %} {% include 'footer' %}",
-      "header" => "header",
-      "footer" => "footer",
-    })
-    assert_template_result("header body body_detail footer", "{% include 'nested_template' %}", partials: partials)
+    assert_template_result("header body body_detail footer", "{% include 'nested_template' %}")
  end

  def test_nested_include_with_variable
-    partials = {
-      "nested_product_template" => "Product: {{ nested_product_template.title }} {%include 'details'%} ",
-      "details" => "details",
-    }
+    assert_template_result("Product: Draft 151cm details ",
+      "{% include 'nested_product_template' with product %}", "product" => { "title" => 'Draft 151cm' })

-    assert_template_result(
-      "Product: Draft 151cm details ",
-      "{% include 'nested_product_template' with product %}",
-      { "product" => { "title" => 'Draft 151cm' } },
-      partials: partials,
-    )
-
-    assert_template_result(
-      "Product: Draft 151cm details Product: Element 155cm details ",
-      "{% include 'nested_product_template' for products %}",
-      { "products" => [{ "title" => 'Draft 151cm' }, { "title" => 'Element 155cm' }] },
-      partials: partials,
-    )
+    assert_template_result("Product: Draft 151cm details Product: Element 155cm details ",
+      "{% include 'nested_product_template' for products %}", "products" => [{ "title" => 'Draft 151cm' }, { "title" => 'Element 155cm' }])
  end

  def test_recursively_included_template_does_not_produce_endless_loop
@@ -190,68 +162,41 @@ class IncludeTagTest < Minitest::Test
  end

  def test_dynamically_choosen_template
-    assert_template_result(
-      "Test123",
-      "{% include template %}",
-      { "template" => 'Test123' },
-      partials: { "Test123" => "Test123" },
-    )
+    assert_template_result("Test123", "{% include template %}", "template" => 'Test123')
+    assert_template_result("Test321", "{% include template %}", "template" => 'Test321')

-    assert_template_result(
-      "Test321",
-      "{% include template %}",
-      { "template" => 'Test321' },
-      partials: { "Test321" => "Test321" },
-    )
-
-    assert_template_result(
-      "Product: Draft 151cm ",
-      "{% include template for product %}",
-      { "template" => 'product', 'product' => { 'title' => 'Draft 151cm' } },
-      partials: { "product" => "Product: {{ product.title }} " },
-    )
+    assert_template_result("Product: Draft 151cm ", "{% include template for product %}",
+      "template" => 'product', 'product' => { 'title' => 'Draft 151cm' })
  end

  def test_include_tag_caches_second_read_of_same_partial
    file_system = CountingFileSystem.new
-    assert_equal(
-      'from CountingFileSystemfrom CountingFileSystem',
-      Template.parse("{% include 'pick_a_source' %}{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system }),
-    )
+    assert_equal('from CountingFileSystemfrom CountingFileSystem',
+      Template.parse("{% include 'pick_a_source' %}{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system }))
    assert_equal(1, file_system.count)
  end

  def test_include_tag_doesnt_cache_partials_across_renders
    file_system = CountingFileSystem.new
-    assert_equal(
-      'from CountingFileSystem',
-      Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system }),
-    )
+    assert_equal('from CountingFileSystem',
+      Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system }))
    assert_equal(1, file_system.count)

-    assert_equal(
-      'from CountingFileSystem',
-      Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system }),
-    )
+    assert_equal('from CountingFileSystem',
+      Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system }))
    assert_equal(2, file_system.count)
  end

  def test_include_tag_within_if_statement
-    assert_template_result(
-      "foo_if_true",
-      "{% if true %}{% include 'foo_if_true' %}{% endif %}",
-      partials: { "foo_if_true" => "foo_if_true" },
-    )
+    assert_template_result("foo_if_true", "{% if true %}{% include 'foo_if_true' %}{% endif %}")
  end

  def test_custom_include_tag
    original_tag = Liquid::Template.tags['include']
    Liquid::Template.tags['include'] = CustomInclude
    begin
-      assert_equal(
-        "custom_foo",
-        Template.parse("{% include 'custom_foo' %}").render!,
-      )
+      assert_equal("custom_foo",
+        Template.parse("{% include 'custom_foo' %}").render!)
    ensure
      Liquid::Template.tags['include'] = original_tag
    end
@@ -261,10 +206,8 @@ class IncludeTagTest < Minitest::Test
    original_tag = Liquid::Template.tags['include']
    Liquid::Template.tags['include'] = CustomInclude
    begin
-      assert_equal(
-        "custom_foo_if_true",
-        Template.parse("{% if true %}{% include 'custom_foo_if_true' %}{% endif %}").render!,
-      )
+      assert_equal("custom_foo_if_true",
+        Template.parse("{% if true %}{% include 'custom_foo_if_true' %}{% endif %}").render!)
    ensure
      Liquid::Template.tags['include'] = original_tag
    end
@@ -279,7 +222,6 @@ class IncludeTagTest < Minitest::Test
  end

  def test_passing_options_to_included_templates
-    Liquid::Template.file_system = TestFileSystem.new
    assert_raises(Liquid::SyntaxError) do
      Template.parse("{% include template %}", error_mode: :strict).render!("template" => '{{ "X" || downcase }}')
    end
@@ -295,53 +237,25 @@ class IncludeTagTest < Minitest::Test
  end

  def test_render_raise_argument_error_when_template_is_undefined
-    assert_template_result(
-      "Liquid error (line 1): Argument error in tag 'include' - Illegal template name",
-      "{% include undefined_variable %}",
-      render_errors: true,
-    )
-
-    assert_template_result(
-      "Liquid error (line 1): Argument error in tag 'include' - Illegal template name",
-      "{% include nil %}",
-      render_errors: true,
-    )
-  end
-
-  def test_render_raise_argument_error_when_template_is_not_a_string
-    assert_template_result(
-      "Liquid error (line 1): Argument error in tag 'include' - Illegal template name",
-      "{% include 123 %}",
-      render_errors: true,
-    )
+    assert_raises(Liquid::ArgumentError) do
+      template = Liquid::Template.parse('{% include undefined_variable %}')
+      template.render!
+    end
+    assert_raises(Liquid::ArgumentError) do
+      template = Liquid::Template.parse('{% include nil %}')
+      template.render!
+    end
  end

  def test_including_via_variable_value
-    assert_template_result(
-      "from TestFileSystem",
-      "{% assign page = 'pick_a_source' %}{% include page %}",
-      partials: { "pick_a_source" => "from TestFileSystem" },
-    )
+    assert_template_result("from TestFileSystem", "{% assign page = 'pick_a_source' %}{% include page %}")

-    partials = { "product" => "Product: {{ product.title }} " }
+    assert_template_result("Product: Draft 151cm ", "{% assign page = 'product' %}{% include page %}", "product" => { 'title' => 'Draft 151cm' })

-    assert_template_result(
-      "Product: Draft 151cm ",
-      "{% assign page = 'product' %}{% include page %}",
-      { "product" => { 'title' => 'Draft 151cm' } },
-      partials: partials,
-    )
-
-    assert_template_result(
-      "Product: Draft 151cm ",
-      "{% assign page = 'product' %}{% include page for foo %}",
-      { "foo" => { 'title' => 'Draft 151cm' } },
-      partials: partials,
-    )
+    assert_template_result("Product: Draft 151cm ", "{% assign page = 'product' %}{% include page for foo %}", "foo" => { 'title' => 'Draft 151cm' })
  end

  def test_including_with_strict_variables
-    Liquid::Template.file_system = StubFileSystem.new({ "simple" => "simple" })
    template = Liquid::Template.parse("{% include 'simple' %}", error_mode: :warn)
    template.render(nil, strict_variables: true)

@@ -350,31 +264,6 @@ class IncludeTagTest < Minitest::Test

  def test_break_through_include
    assert_template_result("1", "{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}")
-    assert_template_result(
-      "1",
-      "{% for i in (1..3) %}{{ i }}{% include 'break' %}{{ i }}{% endfor %}",
-      partials: { 'break' => "{% break %}" },
-    )
-  end
-
-  def test_render_tag_renders_error_with_template_name
-    assert_template_result(
-      'Liquid error (foo line 1): standard error',
-      "{% include 'foo' with errors %}",
-      { 'errors' => ErrorDrop.new },
-      partials: { 'foo' => '{{ foo.standard_error }}' },
-      render_errors: true,
-    )
-  end
-
-  def test_render_tag_renders_error_with_template_name_from_template_factory
-    assert_template_result(
-      'Liquid error (some/path/foo line 1): standard error',
-      "{% include 'foo' with errors %}",
-      { 'errors' => ErrorDrop.new },
-      partials: { 'foo' => '{{ foo.standard_error }}' },
-      template_factory: StubTemplateFactory.new,
-      render_errors: true,
-    )
+    assert_template_result("1", "{% for i in (1..3) %}{{ i }}{% include 'break' %}{{ i }}{% endfor %}")
  end
 end # IncludeTagTest
@@ -6,25 +6,20 @@ class IncrementTagTest < Minitest::Test
  include Liquid

  def test_inc
-    assert_template_result('0 1', '{%increment port %} {{ port }}')
-    assert_template_result(' 0 1 2', '{{port}} {%increment port %} {%increment port%} {{port}}')
-    assert_template_result(
-      '0 0 1 2 1',
+    assert_template_result('0', '{%increment port %}', {})
+    assert_template_result('0 1', '{%increment port %} {%increment port%}', {})
+    assert_template_result('0 0 1 2 1',
      '{%increment port %} {%increment starboard%} ' \
      '{%increment port %} {%increment port%} ' \
-      '{%increment starboard %}',
-    )
+      '{%increment starboard %}', {})
  end

  def test_dec
-    assert_template_result('-1 -1', '{%decrement port %} {{ port }}', { 'port' => 10 })
-    assert_template_result(' -1 -2 -2', '{{port}} {%decrement port %} {%decrement port%} {{port}}')
-    assert_template_result(
-      '0 1 2 0 3 1 1 3',
-      '{%increment starboard %} {%increment starboard%} {%increment starboard%} ' \
+    assert_template_result('9', '{%decrement port %}', 'port' => 10)
+    assert_template_result('-1 -2', '{%decrement port %} {%decrement port%}', {})
+    assert_template_result('1 5 2 2 5',
      '{%increment port %} {%increment starboard%} ' \
      '{%increment port %} {%decrement port%} ' \
-      '{%decrement starboard %}',
-    )
+      '{%decrement starboard %}', 'port' => 1, 'starboard' => 5)
  end
 end
@@ -6,13 +6,13 @@ class LiquidTagTest < Minitest::Test
  include Liquid

  def test_liquid_tag
-    assert_template_result('1 2 3', <<~LIQUID, { 'array' => [1, 2, 3] })
+    assert_template_result('1 2 3', <<~LIQUID, 'array' => [1, 2, 3])
      {%- liquid
        echo array | join: " "
      -%}
    LIQUID

-    assert_template_result('1 2 3', <<~LIQUID, { 'array' => [1, 2, 3] })
+    assert_template_result('1 2 3', <<~LIQUID, 'array' => [1, 2, 3])
      {%- liquid
        for value in array
          echo value
@@ -23,7 +23,7 @@ class LiquidTagTest < Minitest::Test
      -%}
    LIQUID

-    assert_template_result('4 8 12 6', <<~LIQUID, { 'array' => [1, 2, 3] })
+    assert_template_result('4 8 12 6', <<~LIQUID, 'array' => [1, 2, 3])
      {%- liquid
        for value in array
          assign double_value = value | times: 2
@@ -6,15 +6,12 @@ class RawTagTest < Minitest::Test
  include Liquid

  def test_tag_in_raw
-    assert_template_result(
-      '{% comment %} test {% endcomment %}',
-      '{% raw %}{% comment %} test {% endcomment %}{% endraw %}',
-    )
+    assert_template_result('{% comment %} test {% endcomment %}',
+      '{% raw %}{% comment %} test {% endcomment %}{% endraw %}')
  end

  def test_output_in_raw
-    # assert_template_result('{{ test }}', '{% raw %}{{ test }}{% endraw %}')
-    assert_template_result('>{{ test }}<', '> {%- raw -%}{{ test }}{%- endraw -%} <')
+    assert_template_result('{{ test }}', '{% raw %}{{ test }}{% endraw %}')
  end

  def test_open_tag_in_raw
@@ -6,79 +6,53 @@ class RenderTagTest < Minitest::Test
  include Liquid

  def test_render_with_no_arguments
-    assert_template_result(
-      'rendered content',
-      '{% render "source" %}',
-      partials: { 'source' => 'rendered content' },
-    )
+    Liquid::Template.file_system = StubFileSystem.new('source' => 'rendered content')
+    assert_template_result('rendered content', '{% render "source" %}')
  end

  def test_render_tag_looks_for_file_system_in_registers_first
-    assert_template_result(
-      'from register file system',
-      '{% render "pick_a_source" %}',
-      partials: { 'pick_a_source' => 'from register file system' },
-    )
+    file_system = StubFileSystem.new('pick_a_source' => 'from register file system')
+    assert_equal('from register file system',
+      Template.parse('{% render "pick_a_source" %}').render!({}, registers: { file_system: file_system }))
  end

  def test_render_passes_named_arguments_into_inner_scope
-    assert_template_result(
-      'My Product',
-      '{% render "product", inner_product: outer_product %}',
-      { 'outer_product' => { 'title' => 'My Product' } },
-      partials: { 'product' => '{{ inner_product.title }}' },
-    )
+    Liquid::Template.file_system = StubFileSystem.new('product' => '{{ inner_product.title }}')
+    assert_template_result('My Product', '{% render "product", inner_product: outer_product %}',
+      'outer_product' => { 'title' => 'My Product' })
  end

  def test_render_accepts_literals_as_arguments
-    assert_template_result(
-      '123',
-      '{% render "snippet", price: 123 %}',
-      partials: { 'snippet' => '{{ price }}' },
-    )
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ price }}')
+    assert_template_result('123', '{% render "snippet", price: 123 %}')
  end

  def test_render_accepts_multiple_named_arguments
-    assert_template_result(
-      '1 2',
-      '{% render "snippet", one: 1, two: 2 %}',
-      partials: { 'snippet' => '{{ one }} {{ two }}' },
-    )
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ one }} {{ two }}')
+    assert_template_result('1 2', '{% render "snippet", one: 1, two: 2 %}')
  end

  def test_render_does_not_inherit_parent_scope_variables
-    assert_template_result(
-      '',
-      '{% assign outer_variable = "should not be visible" %}{% render "snippet" %}',
-      partials: { 'snippet' => '{{ outer_variable }}' },
-    )
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ outer_variable }}')
+    assert_template_result('', '{% assign outer_variable = "should not be visible" %}{% render "snippet" %}')
  end

  def test_render_does_not_inherit_variable_with_same_name_as_snippet
-    assert_template_result(
-      '',
-      "{% assign snippet = 'should not be visible' %}{% render 'snippet' %}",
-      partials: { 'snippet' => '{{ snippet }}' },
-    )
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ snippet }}')
+    assert_template_result('', "{% assign snippet = 'should not be visible' %}{% render 'snippet' %}")
  end

  def test_render_does_not_mutate_parent_scope
-    assert_template_result(
-      '',
-      "{% render 'snippet' %}{{ inner }}",
-      partials: { 'snippet' => '{% assign inner = 1 %}' },
-    )
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{% assign inner = 1 %}')
+    assert_template_result('', "{% render 'snippet' %}{{ inner }}")
  end

  def test_nested_render_tag
-    assert_template_result(
-      'one two',
-      "{% render 'one' %}",
-      partials: {
-        'one' => "one {% render 'two' %}",
-        'two' => 'two',
-      },
+    Liquid::Template.file_system = StubFileSystem.new(
+      'one' => "one {% render 'two' %}",
+      'two' => 'two'
    )
+    assert_template_result('one two', "{% render 'one' %}")
  end

  def test_recursively_rendered_template_does_not_produce_endless_loop
@@ -99,190 +73,141 @@ class RenderTagTest < Minitest::Test
  end

  def test_dynamically_choosen_templates_are_not_allowed
-    assert_syntax_error("{% assign name = 'snippet' %}{% render name %}")
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => 'should not be rendered')
+
+    assert_raises(Liquid::SyntaxError) do
+      Liquid::Template.parse("{% assign name = 'snippet' %}{% render name %}")
+    end
  end

  def test_include_tag_caches_second_read_of_same_partial
    file_system = StubFileSystem.new('snippet' => 'echo')
-    assert_equal(
-      'echoecho',
+    assert_equal('echoecho',
      Template.parse('{% render "snippet" %}{% render "snippet" %}')
-      .render!({}, registers: { file_system: file_system }),
-    )
+      .render!({}, registers: { file_system: file_system }))
    assert_equal(1, file_system.file_read_count)
  end

  def test_render_tag_doesnt_cache_partials_across_renders
    file_system = StubFileSystem.new('snippet' => 'my message')

-    assert_equal(
-      'my message',
-      Template.parse('{% include "snippet" %}').render!({}, registers: { file_system: file_system }),
-    )
+    assert_equal('my message',
+      Template.parse('{% include "snippet" %}').render!({}, registers: { file_system: file_system }))
    assert_equal(1, file_system.file_read_count)

-    assert_equal(
-      'my message',
-      Template.parse('{% include "snippet" %}').render!({}, registers: { file_system: file_system }),
-    )
+    assert_equal('my message',
+      Template.parse('{% include "snippet" %}').render!({}, registers: { file_system: file_system }))
    assert_equal(2, file_system.file_read_count)
  end

  def test_render_tag_within_if_statement
-    assert_template_result(
-      'my message',
-      '{% if true %}{% render "snippet" %}{% endif %}',
-      partials: { 'snippet' => 'my message' },
-    )
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => 'my message')
+    assert_template_result('my message', '{% if true %}{% render "snippet" %}{% endif %}')
  end

  def test_break_through_render
-    options = { partials: { 'break' => '{% break %}' } }
-    assert_template_result('1', '{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}', **options)
-    assert_template_result('112233', '{% for i in (1..3) %}{{ i }}{% render "break" %}{{ i }}{% endfor %}', **options)
+    Liquid::Template.file_system = StubFileSystem.new('break' => '{% break %}')
+    assert_template_result('1', '{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}')
+    assert_template_result('112233', '{% for i in (1..3) %}{{ i }}{% render "break" %}{{ i }}{% endfor %}')
  end

  def test_increment_is_isolated_between_renders
-    assert_template_result(
-      '010',
-      '{% increment %}{% increment %}{% render "incr" %}',
-      partials: { 'incr' => '{% increment %}' },
-    )
+    Liquid::Template.file_system = StubFileSystem.new('incr' => '{% increment %}')
+    assert_template_result('010', '{% increment %}{% increment %}{% render "incr" %}')
  end

  def test_decrement_is_isolated_between_renders
-    assert_template_result(
-      '-1-2-1',
-      '{% decrement %}{% decrement %}{% render "decr" %}',
-      partials: { 'decr' => '{% decrement %}' },
-    )
+    Liquid::Template.file_system = StubFileSystem.new('decr' => '{% decrement %}')
+    assert_template_result('-1-2-1', '{% decrement %}{% decrement %}{% render "decr" %}')
  end

  def test_includes_will_not_render_inside_render_tag
-    assert_template_result(
-      'Liquid error (test_include line 1): include usage is not allowed in this context',
-      '{% render "test_include" %}',
-      render_errors: true,
-      partials: {
-        'foo' => 'bar',
-        'test_include' => '{% include "foo" %}',
-      },
+    Liquid::Template.file_system = StubFileSystem.new(
+      'foo' => 'bar',
+      'test_include' => '{% include "foo" %}'
    )
+
+    exc = assert_raises(Liquid::DisabledError) do
+      Liquid::Template.parse('{% render "test_include" %}').render!
+    end
+    assert_equal('Liquid error: include usage is not allowed in this context', exc.message)
  end

  def test_includes_will_not_render_inside_nested_sibling_tags
-    assert_template_result(
-      "Liquid error (test_include line 1): include usage is not allowed in this context" \
-        "Liquid error (nested_render_with_sibling_include line 1): include usage is not allowed in this context",
-      '{% render "nested_render_with_sibling_include" %}',
-      partials: {
-        'foo' => 'bar',
-        'nested_render_with_sibling_include' => '{% render "test_include" %}{% include "foo" %}',
-        'test_include' => '{% include "foo" %}',
-      },
-      render_errors: true,
+    Liquid::Template.file_system = StubFileSystem.new(
+      'foo' => 'bar',
+      'nested_render_with_sibling_include' => '{% render "test_include" %}{% include "foo" %}',
+      'test_include' => '{% include "foo" %}'
    )
+
+    output = Liquid::Template.parse('{% render "nested_render_with_sibling_include" %}').render
+    assert_equal('Liquid error: include usage is not allowed in this contextLiquid error: include usage is not allowed in this context', output)
  end

  def test_render_tag_with
-    assert_template_result(
-      "Product: Draft 151cm ",
-      "{% render 'product' with products[0] %}",
-      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] },
-      partials: {
-        'product' => "Product: {{ product.title }} ",
-        'product_alias' => "Product: {{ product.title }} ",
-      },
+    Liquid::Template.file_system = StubFileSystem.new(
+      'product' => "Product: {{ product.title }} ",
+      'product_alias' => "Product: {{ product.title }} ",
    )
+
+    assert_template_result("Product: Draft 151cm ",
+      "{% render 'product' with products[0] %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
  end

  def test_render_tag_with_alias
-    assert_template_result(
-      "Product: Draft 151cm ",
-      "{% render 'product_alias' with products[0] as product %}",
-      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] },
-      partials: {
-        'product' => "Product: {{ product.title }} ",
-        'product_alias' => "Product: {{ product.title }} ",
-      },
+    Liquid::Template.file_system = StubFileSystem.new(
+      'product' => "Product: {{ product.title }} ",
+      'product_alias' => "Product: {{ product.title }} ",
    )
+
+    assert_template_result("Product: Draft 151cm ",
+      "{% render 'product_alias' with products[0] as product %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
  end

  def test_render_tag_for_alias
-    assert_template_result(
-      "Product: Draft 151cm Product: Element 155cm ",
-      "{% render 'product_alias' for products as product %}",
-      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] },
-      partials: {
-        'product' => "Product: {{ product.title }} ",
-        'product_alias' => "Product: {{ product.title }} ",
-      },
+    Liquid::Template.file_system = StubFileSystem.new(
+      'product' => "Product: {{ product.title }} ",
+      'product_alias' => "Product: {{ product.title }} ",
    )
+
+    assert_template_result("Product: Draft 151cm Product: Element 155cm ",
+      "{% render 'product_alias' for products as product %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
  end

  def test_render_tag_for
-    assert_template_result(
-      "Product: Draft 151cm Product: Element 155cm ",
-      "{% render 'product' for products %}",
-      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] },
-      partials: {
-        'product' => "Product: {{ product.title }} ",
-        'product_alias' => "Product: {{ product.title }} ",
-      },
+    Liquid::Template.file_system = StubFileSystem.new(
+      'product' => "Product: {{ product.title }} ",
+      'product_alias' => "Product: {{ product.title }} ",
    )
+
+    assert_template_result("Product: Draft 151cm Product: Element 155cm ",
+      "{% render 'product' for products %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
  end

  def test_render_tag_forloop
-    assert_template_result(
-      "Product: Draft 151cm first  index:1 Product: Element 155cm  last index:2 ",
-      "{% render 'product' for products %}",
-      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] },
-      partials: {
-        'product' => "Product: {{ product.title }} {% if forloop.first %}first{% endif %} {% if forloop.last %}last{% endif %} index:{{ forloop.index }} ",
-      },
+    Liquid::Template.file_system = StubFileSystem.new(
+      'product' => "Product: {{ product.title }} {% if forloop.first %}first{% endif %} {% if forloop.last %}last{% endif %} index:{{ forloop.index }} ",
    )
+
+    assert_template_result("Product: Draft 151cm first  index:1 Product: Element 155cm  last index:2 ",
+      "{% render 'product' for products %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
  end

  def test_render_tag_for_drop
-    assert_template_result(
-      "123",
-      "{% render 'loop' for loop as value %}",
-      { "loop" => TestEnumerable.new },
-      partials: {
-        'loop' => "{{ value.foo }}",
-      },
+    Liquid::Template.file_system = StubFileSystem.new(
+      'loop' => "{{ value.foo }}",
    )
+
+    assert_template_result("123",
+      "{% render 'loop' for loop as value %}", "loop" => TestEnumerable.new)
  end

  def test_render_tag_with_drop
-    assert_template_result(
-      "TestEnumerable",
-      "{% render 'loop' with loop as value %}",
-      { "loop" => TestEnumerable.new },
-      partials: {
-        'loop' => "{{ value }}",
-      },
+    Liquid::Template.file_system = StubFileSystem.new(
+      'loop' => "{{ value }}",
    )
-  end

-  def test_render_tag_renders_error_with_template_name
-    assert_template_result(
-      'Liquid error (foo line 1): standard error',
-      "{% render 'foo' with errors %}",
-      { 'errors' => ErrorDrop.new },
-      partials: { 'foo' => '{{ foo.standard_error }}' },
-      render_errors: true,
-    )
-  end
-
-  def test_render_tag_renders_error_with_template_name_from_template_factory
-    assert_template_result(
-      'Liquid error (some/path/foo line 1): standard error',
-      "{% render 'foo' with errors %}",
-      { 'errors' => ErrorDrop.new },
-      partials: { 'foo' => '{{ foo.standard_error }}' },
-      template_factory: StubTemplateFactory.new,
-      render_errors: true,
-    )
+    assert_template_result("TestEnumerable",
+      "{% render 'loop' with loop as value %}", "loop" => TestEnumerable.new)
  end
 end
@@ -6,10 +6,8 @@ class StandardTagTest < Minitest::Test
  include Liquid

  def test_no_transform
-    assert_template_result(
-      'this text should come out of the template without change...',
-      'this text should come out of the template without change...',
-    )
+    assert_template_result('this text should come out of the template without change...',
+      'this text should come out of the template without change...')

    assert_template_result('blah', 'blah')
    assert_template_result('<blah>', '<blah>')
@@ -22,10 +20,8 @@ class StandardTagTest < Minitest::Test
  end

  def test_has_a_block_which_does_nothing
-    assert_template_result(
-      %(the comment block should be removed  .. right?),
-      %(the comment block should be removed {%comment%} be gone.. {%endcomment%} .. right?),
-    )
+    assert_template_result(%(the comment block should be removed  .. right?),
+      %(the comment block should be removed {%comment%} be gone.. {%endcomment%} .. right?))

    assert_template_result('', '{%comment%}{%endcomment%}')
    assert_template_result('', '{%comment%}{% endcomment %}')
@@ -40,8 +36,6 @@ class StandardTagTest < Minitest::Test
    assert_template_result('', '{%comment%}{% endif %}{%endcomment%}')
    assert_template_result('', '{% comment %}{% endwhatever %}{% endcomment %}')
    assert_template_result('', '{% comment %}{% raw %} {{%%%%}}  }} { {% endcomment %} {% comment {% endraw %} {% endcomment %}')
-    assert_template_result('', '{% comment %}{% " %}{% endcomment %}')
-    assert_template_result('', '{% comment %}{%%}{% endcomment %}')

    assert_template_result('foobar', 'foo{%comment%}comment{%endcomment%}bar')
    assert_template_result('foobar', 'foo{% comment %}comment{% endcomment %}bar')
@@ -68,199 +62,160 @@ class StandardTagTest < Minitest::Test

  def test_capture
    assigns = { 'var' => 'content' }
-    assert_template_result(
-      'content foo content foo ',
+    assert_template_result('content foo content foo ',
      '{{ var2 }}{% capture var2 %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
-      assigns,
-    )
+      assigns)
  end

  def test_capture_detects_bad_syntax
    assert_raises(SyntaxError) do
-      assert_template_result(
-        'content foo content foo ',
+      assert_template_result('content foo content foo ',
        '{{ var2 }}{% capture %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
-        { 'var' => 'content' },
-      )
+        'var' => 'content')
    end
  end

  def test_case
    assigns = { 'condition' => 2 }
-    assert_template_result(
-      ' its 2 ',
+    assert_template_result(' its 2 ',
      '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
-      assigns,
-    )
+      assigns)

    assigns = { 'condition' => 1 }
-    assert_template_result(
-      ' its 1 ',
+    assert_template_result(' its 1 ',
      '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
-      assigns,
-    )
+      assigns)

    assigns = { 'condition' => 3 }
-    assert_template_result(
-      '',
+    assert_template_result('',
      '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
-      assigns,
-    )
+      assigns)

    assigns = { 'condition' => "string here" }
-    assert_template_result(
-      ' hit ',
+    assert_template_result(' hit ',
      '{% case condition %}{% when "string here" %} hit {% endcase %}',
-      assigns,
-    )
+      assigns)

    assigns = { 'condition' => "bad string here" }
-    assert_template_result(
-      '',
+    assert_template_result('',
      '{% case condition %}{% when "string here" %} hit {% endcase %}',\
-      assigns,
-    )
+      assigns)
  end

  def test_case_with_else
    assigns = { 'condition' => 5 }
-    assert_template_result(
-      ' hit ',
+    assert_template_result(' hit ',
      '{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}',
-      assigns,
-    )
+      assigns)

    assigns = { 'condition' => 6 }
-    assert_template_result(
-      ' else ',
+    assert_template_result(' else ',
      '{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}',
-      assigns,
-    )
+      assigns)

    assigns = { 'condition' => 6 }
-    assert_template_result(
-      ' else ',
+    assert_template_result(' else ',
      '{% case condition %} {% when 5 %} hit {% else %} else {% endcase %}',
-      assigns,
-    )
+      assigns)
  end

  def test_case_on_size
-    assert_template_result('',  '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', { 'a' => [] })
-    assert_template_result('1', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', { 'a' => [1] })
-    assert_template_result('2', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', { 'a' => [1, 1] })
-    assert_template_result('',  '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', { 'a' => [1, 1, 1] })
-    assert_template_result('',  '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', { 'a' => [1, 1, 1, 1] })
-    assert_template_result('',  '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', { 'a' => [1, 1, 1, 1, 1] })
+    assert_template_result('',  '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [])
+    assert_template_result('1', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1])
+    assert_template_result('2', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1])
+    assert_template_result('',  '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1, 1])
+    assert_template_result('',  '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1, 1, 1])
+    assert_template_result('',  '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1, 1, 1, 1])
  end

  def test_case_on_size_with_else
-    assert_template_result(
-      'else',
+    assert_template_result('else',
      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
-      { 'a' => [] },
-    )
+      'a' => [])

-    assert_template_result(
-      '1',
+    assert_template_result('1',
      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
-      { 'a' => [1] },
-    )
+      'a' => [1])

-    assert_template_result(
-      '2',
+    assert_template_result('2',
      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
-      { 'a' => [1, 1] },
-    )
+      'a' => [1, 1])

-    assert_template_result(
-      'else',
+    assert_template_result('else',
      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
-      { 'a' => [1, 1, 1] },
-    )
+      'a' => [1, 1, 1])

-    assert_template_result(
-      'else',
+    assert_template_result('else',
      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
-      { 'a' => [1, 1, 1, 1] },
-    )
+      'a' => [1, 1, 1, 1])

-    assert_template_result(
-      'else',
+    assert_template_result('else',
      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
-      { 'a' => [1, 1, 1, 1, 1] },
-    )
+      'a' => [1, 1, 1, 1, 1])
  end

  def test_case_on_length_with_else
-    assert_template_result(
-      'else',
+    assert_template_result('else',
      '{% case a.empty? %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
-      {},
-    )
+      {})

-    assert_template_result(
-      'false',
+    assert_template_result('false',
      '{% case false %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
-      {},
-    )
+      {})

-    assert_template_result(
-      'true',
+    assert_template_result('true',
      '{% case true %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
-      {},
-    )
+      {})

-    assert_template_result(
-      'else',
+    assert_template_result('else',
      '{% case NULL %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
-      {},
-    )
+      {})
  end

  def test_assign_from_case
    # Example from the shopify forums
-    code = "{% case collection.handle %}{% when 'menswear-jackets' %}{% assign ptitle = 'menswear' %}{% when 'menswear-t-shirts' %}{% assign ptitle = 'menswear' %}{% else %}{% assign ptitle = 'womenswear' %}{% endcase %}{{ ptitle }}"
-    assert_template_result("menswear",   code, { "collection" => { 'handle' => 'menswear-jackets' } })
-    assert_template_result("menswear",   code, { "collection" => { 'handle' => 'menswear-t-shirts' } })
-    assert_template_result("womenswear", code, { "collection" => { 'handle' => 'x' } })
-    assert_template_result("womenswear", code, { "collection" => { 'handle' => 'y' } })
-    assert_template_result("womenswear", code, { "collection" => { 'handle' => 'z' } })
+    code     = "{% case collection.handle %}{% when 'menswear-jackets' %}{% assign ptitle = 'menswear' %}{% when 'menswear-t-shirts' %}{% assign ptitle = 'menswear' %}{% else %}{% assign ptitle = 'womenswear' %}{% endcase %}{{ ptitle }}"
+    template = Liquid::Template.parse(code)
+    assert_equal("menswear",   template.render!("collection" => { 'handle' => 'menswear-jackets' }))
+    assert_equal("menswear",   template.render!("collection" => { 'handle' => 'menswear-t-shirts' }))
+    assert_equal("womenswear", template.render!("collection" => { 'handle' => 'x' }))
+    assert_equal("womenswear", template.render!("collection" => { 'handle' => 'y' }))
+    assert_equal("womenswear", template.render!("collection" => { 'handle' => 'z' }))
  end

  def test_case_when_or
    code = '{% case condition %}{% when 1 or 2 or 3 %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
-    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
-    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 2 })
-    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 3 })
-    assert_template_result(' its 4 ', code, { 'condition' => 4 })
-    assert_template_result('', code, { 'condition' => 5 })
+    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 1)
+    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 2)
+    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 3)
+    assert_template_result(' its 4 ', code, 'condition' => 4)
+    assert_template_result('', code, 'condition' => 5)

    code = '{% case condition %}{% when 1 or "string" or null %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
-    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
-    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 'string' })
-    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => nil })
-    assert_template_result('', code, { 'condition' => 'something else' })
+    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 1)
+    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 'string')
+    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => nil)
+    assert_template_result('', code, 'condition' => 'something else')
  end

  def test_case_when_comma
    code = '{% case condition %}{% when 1, 2, 3 %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
-    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
-    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 2 })
-    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 3 })
-    assert_template_result(' its 4 ', code, { 'condition' => 4 })
-    assert_template_result('', code, { 'condition' => 5 })
+    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 1)
+    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 2)
+    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 3)
+    assert_template_result(' its 4 ', code, 'condition' => 4)
+    assert_template_result('', code, 'condition' => 5)

    code = '{% case condition %}{% when 1, "string", null %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
-    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
-    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 'string' })
-    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => nil })
-    assert_template_result('', code, { 'condition' => 'something else' })
+    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 1)
+    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 'string')
+    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => nil)
+    assert_template_result('', code, 'condition' => 'something else')
  end

  def test_case_when_comma_and_blank_body
    code = '{% case condition %}{% when 1, 2 %} {% assign r = "result" %} {% endcase %}{{ r }}'
-    assert_template_result('result', code, { 'condition' => 2 })
+    assert_template_result('result', code, 'condition' => 2)
  end

  def test_assign
@@ -297,33 +252,24 @@ class StandardTagTest < Minitest::Test

    assert_template_result('one two one', '{%cycle "one", "two"%} {%cycle "one", "two"%} {%cycle "one", "two"%}')

-    assert_template_result(
-      'text-align: left text-align: right',
-      '{%cycle "text-align: left", "text-align: right" %} {%cycle "text-align: left", "text-align: right"%}',
-    )
+    assert_template_result('text-align: left text-align: right',
+      '{%cycle "text-align: left", "text-align: right" %} {%cycle "text-align: left", "text-align: right"%}')
  end

  def test_multiple_cycles
-    assert_template_result(
-      '1 2 1 1 2 3 1',
-      '{%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%}',
-    )
+    assert_template_result('1 2 1 1 2 3 1',
+      '{%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%}')
  end

  def test_multiple_named_cycles
-    assert_template_result(
-      'one one two two one one',
-      '{%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %}',
-    )
+    assert_template_result('one one two two one one',
+      '{%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %}')
  end

  def test_multiple_named_cycles_with_names_from_context
    assigns = { "var1" => 1, "var2" => 2 }
-    assert_template_result(
-      'one one two two one one',
-      '{%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %}',
-      assigns,
-    )
+    assert_template_result('one one two two one one',
+      '{%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %}', assigns)
  end

  def test_size_of_array
@@ -60,22 +60,22 @@ class StatementsTest < Minitest::Test

  def test_var_strings_equal
    text = ' {% if var == "hello there!" %} true {% else %} false {% endif %} '
-    assert_template_result('  true  ', text, { 'var' => 'hello there!' })
+    assert_template_result('  true  ', text, 'var' => 'hello there!')
  end

  def test_var_strings_are_not_equal
    text = ' {% if "hello there!" == var %} true {% else %} false {% endif %} '
-    assert_template_result('  true  ', text, { 'var' => 'hello there!' })
+    assert_template_result('  true  ', text, 'var' => 'hello there!')
  end

  def test_var_and_long_string_are_equal
    text = " {% if var == 'hello there!' %} true {% else %} false {% endif %} "
-    assert_template_result('  true  ', text, { 'var' => 'hello there!' })
+    assert_template_result('  true  ', text, 'var' => 'hello there!')
  end

  def test_var_and_long_string_are_equal_backwards
    text = " {% if 'hello there!' == var %} true {% else %} false {% endif %} "
-    assert_template_result('  true  ', text, { 'var' => 'hello there!' })
+    assert_template_result('  true  ', text, 'var' => 'hello there!')
  end

  # def test_is_nil
@@ -87,27 +87,27 @@ class StatementsTest < Minitest::Test

  def test_is_collection_empty
    text = ' {% if array == empty %} true {% else %} false {% endif %} '
-    assert_template_result('  true  ', text, { 'array' => [] })
+    assert_template_result('  true  ', text, 'array' => [])
  end

  def test_is_not_collection_empty
    text = ' {% if array == empty %} true {% else %} false {% endif %} '
-    assert_template_result('  false  ', text, { 'array' => [1, 2, 3] })
+    assert_template_result('  false  ', text, 'array' => [1, 2, 3])
  end

  def test_nil
    text = ' {% if var == nil %} true {% else %} false {% endif %} '
-    assert_template_result('  true  ', text, { 'var' => nil })
+    assert_template_result('  true  ', text, 'var' => nil)

    text = ' {% if var == null %} true {% else %} false {% endif %} '
-    assert_template_result('  true  ', text, { 'var' => nil })
+    assert_template_result('  true  ', text, 'var' => nil)
  end

  def test_not_nil
    text = ' {% if var != nil %} true {% else %} false {% endif %} '
-    assert_template_result('  true  ', text, { 'var' => 1 })
+    assert_template_result('  true  ', text, 'var' => 1)

    text = ' {% if var != null %} true {% else %} false {% endif %} '
-    assert_template_result('  true  ', text, { 'var' => 1 })
+    assert_template_result('  true  ', text, 'var' => 1)
  end
 end # StatementsTest
@@ -18,193 +18,49 @@ class TableRowTest < Minitest::Test
  end

  def test_table_row
-    assert_template_result(
-      "<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
+    assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
      '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
-      { 'numbers' => [1, 2, 3, 4, 5, 6] },
-    )
+      'numbers' => [1, 2, 3, 4, 5, 6])

-    assert_template_result(
-      "<tr class=\"row1\">\n</tr>\n",
+    assert_template_result("<tr class=\"row1\">\n</tr>\n",
      '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
-      { 'numbers' => [] },
-    )
+      'numbers' => [])
  end

  def test_table_row_with_different_cols
-    assert_template_result(
-      "<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td><td class=\"col4\"> 4 </td><td class=\"col5\"> 5 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 6 </td></tr>\n",
+    assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td><td class=\"col4\"> 4 </td><td class=\"col5\"> 5 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 6 </td></tr>\n",
      '{% tablerow n in numbers cols:5%} {{n}} {% endtablerow %}',
-      { 'numbers' => [1, 2, 3, 4, 5, 6] },
-    )
+      'numbers' => [1, 2, 3, 4, 5, 6])
  end

  def test_table_col_counter
-    assert_template_result(
-      "<tr class=\"row1\">\n<td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n<tr class=\"row2\"><td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n<tr class=\"row3\"><td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n",
+    assert_template_result("<tr class=\"row1\">\n<td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n<tr class=\"row2\"><td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n<tr class=\"row3\"><td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n",
      '{% tablerow n in numbers cols:2%}{{tablerowloop.col}}{% endtablerow %}',
-      { 'numbers' => [1, 2, 3, 4, 5, 6] },
-    )
+      'numbers' => [1, 2, 3, 4, 5, 6])
  end

  def test_quoted_fragment
-    assert_template_result(
-      "<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
+    assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
      "{% tablerow n in collections.frontpage cols:3%} {{n}} {% endtablerow %}",
-      { 'collections' => { 'frontpage' => [1, 2, 3, 4, 5, 6] } },
-    )
-    assert_template_result(
-      "<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
+      'collections' => { 'frontpage' => [1, 2, 3, 4, 5, 6] })
+    assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
      "{% tablerow n in collections['frontpage'] cols:3%} {{n}} {% endtablerow %}",
-      { 'collections' => { 'frontpage' => [1, 2, 3, 4, 5, 6] } },
-    )
+      'collections' => { 'frontpage' => [1, 2, 3, 4, 5, 6] })
  end

  def test_enumerable_drop
-    assert_template_result(
-      "<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
+    assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
      '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
-      { 'numbers' => ArrayDrop.new([1, 2, 3, 4, 5, 6]) },
-    )
+      'numbers' => ArrayDrop.new([1, 2, 3, 4, 5, 6]))
  end

  def test_offset_and_limit
-    assert_template_result(
-      "<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
+    assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
      '{% tablerow n in numbers cols:3 offset:1 limit:6%} {{n}} {% endtablerow %}',
-      { 'numbers' => [0, 1, 2, 3, 4, 5, 6, 7] },
-    )
+      'numbers' => [0, 1, 2, 3, 4, 5, 6, 7])
  end

  def test_blank_string_not_iterable
-    assert_template_result(
-      "<tr class=\"row1\">\n</tr>\n",
-      "{% tablerow char in characters cols:3 %}I WILL NOT BE OUTPUT{% endtablerow %}",
-      { 'characters' => '' },
-    )
-  end
-
-  def test_cols_nil_constant_same_as_evaluated_nil_expression
-    expect = "<tr class=\"row1\">\n" \
-      "<td class=\"col1\">false</td>" \
-      "<td class=\"col2\">false</td>" \
-      "</tr>\n"
-
-    assert_template_result(
-      expect,
-      "{% tablerow i in (1..2) cols:nil %}{{ tablerowloop.col_last }}{% endtablerow %}",
-    )
-
-    assert_template_result(
-      expect,
-      "{% tablerow i in (1..2) cols:var %}{{ tablerowloop.col_last }}{% endtablerow %}",
-      { "var" => nil },
-    )
-  end
-
-  def test_nil_limit_is_treated_as_zero
-    expect = "<tr class=\"row1\">\n" \
-      "</tr>\n"
-
-    assert_template_result(
-      expect,
-      "{% tablerow i in (1..2) limit:nil %}{{ i }}{% endtablerow %}",
-    )
-
-    assert_template_result(
-      expect,
-      "{% tablerow i in (1..2) limit:var %}{{ i }}{% endtablerow %}",
-      { "var" => nil },
-    )
-  end
-
-  def test_nil_offset_is_treated_as_zero
-    expect = "<tr class=\"row1\">\n" \
-      "<td class=\"col1\">1:false</td>" \
-      "<td class=\"col2\">2:true</td>" \
-      "</tr>\n"
-
-    assert_template_result(
-      expect,
-      "{% tablerow i in (1..2) offset:nil %}{{ i }}:{{ tablerowloop.col_last }}{% endtablerow %}",
-    )
-
-    assert_template_result(
-      expect,
-      "{% tablerow i in (1..2) offset:var %}{{ i }}:{{ tablerowloop.col_last }}{% endtablerow %}",
-      { "var" => nil },
-    )
-  end
-
-  def test_tablerow_loop_drop_attributes
-    template = <<~LIQUID.chomp
-      {% tablerow i in (1...2) %}
-      col: {{ tablerowloop.col }}
-      col0: {{ tablerowloop.col0 }}
-      col_first: {{ tablerowloop.col_first }}
-      col_last: {{ tablerowloop.col_last }}
-      first: {{ tablerowloop.first }}
-      index: {{ tablerowloop.index }}
-      index0: {{ tablerowloop.index0 }}
-      last: {{ tablerowloop.last }}
-      length: {{ tablerowloop.length }}
-      rindex: {{ tablerowloop.rindex }}
-      rindex0: {{ tablerowloop.rindex0 }}
-      row: {{ tablerowloop.row }}
-      {% endtablerow %}
-    LIQUID
-
-    expected_output = <<~OUTPUT
-      <tr class="row1">
-      <td class="col1">
-      col: 1
-      col0: 0
-      col_first: true
-      col_last: false
-      first: true
-      index: 1
-      index0: 0
-      last: false
-      length: 2
-      rindex: 2
-      rindex0: 1
-      row: 1
-      </td><td class="col2">
-      col: 2
-      col0: 1
-      col_first: false
-      col_last: true
-      first: false
-      index: 2
-      index0: 1
-      last: true
-      length: 2
-      rindex: 1
-      rindex0: 0
-      row: 1
-      </td></tr>
-    OUTPUT
-
-    assert_template_result(expected_output, template)
-  end
-
-  def test_table_row_renders_correct_error_message_for_invalid_parameters
-    assert_template_result(
-      "Liquid error (line 1): invalid integer",
-      '{% tablerow n in (1...10) limit:true %} {{n}} {% endtablerow %}',
-      render_errors: true,
-    )
-
-    assert_template_result(
-      "Liquid error (line 1): invalid integer",
-      '{% tablerow n in (1...10) offset:true %} {{n}} {% endtablerow %}',
-      render_errors: true,
-    )
-
-    assert_template_result(
-      "Liquid error (line 1): invalid integer",
-      '{% tablerow n in (1...10) cols:true %} {{n}} {% endtablerow %}',
-      render_errors: true,
-    )
+    assert_template_result("<tr class=\"row1\">\n</tr>\n", "{% tablerow char in characters cols:3 %}I WILL NOT BE OUTPUT{% endtablerow %}", 'characters' => '')
  end
 end
@@ -7,10 +7,8 @@ class UnlessElseTagTest < Minitest::Test

  def test_unless
    assert_template_result('  ', ' {% unless true %} this text should not go into the output {% endunless %} ')
-    assert_template_result(
-      '  this text should go into the output  ',
-      ' {% unless false %} this text should go into the output {% endunless %} ',
-    )
+    assert_template_result('  this text should go into the output  ',
+      ' {% unless false %} this text should go into the output {% endunless %} ')
    assert_template_result('  you rock ?', '{% unless true %} you suck {% endunless %} {% unless false %} you rock {% endunless %}?')
  end

@@ -21,10 +19,10 @@ class UnlessElseTagTest < Minitest::Test
  end

  def test_unless_in_loop
-    assert_template_result('23', '{% for i in choices %}{% unless i %}{{ forloop.index }}{% endunless %}{% endfor %}', { 'choices' => [1, nil, false] })
+    assert_template_result('23', '{% for i in choices %}{% unless i %}{{ forloop.index }}{% endunless %}{% endfor %}', 'choices' => [1, nil, false])
  end

  def test_unless_else_in_loop
-    assert_template_result(' TRUE  2  3 ', '{% for i in choices %}{% unless i %} {{ forloop.index }} {% else %} TRUE {% endunless %}{% endfor %}', { 'choices' => [1, nil, false] })
+    assert_template_result(' TRUE  2  3 ', '{% for i in choices %}{% unless i %} {{ forloop.index }} {% else %} TRUE {% endunless %}{% endfor %}', 'choices' => [1, nil, false])
  end
 end # UnlessElseTest
@@ -93,12 +93,10 @@ class TemplateTest < Minitest::Test

  def test_lambda_is_called_once_from_custom_assigns_over_multiple_parses_and_renders
    t = Template.new
-    assigns = {
-      'number' => -> {
-        @global ||= 0
-        @global += 1
-      },
-    }
+    assigns = { 'number' => -> {
+                              @global ||= 0
+                              @global  += 1
+                            } }
    assert_equal('1', t.parse("{{number}}").render!(assigns))
    assert_equal('1', t.parse("{{number}}").render!(assigns))
    assert_equal('1', t.render!(assigns))
@@ -317,11 +315,13 @@ class TemplateTest < Minitest::Test
  end

  def test_using_range_literal_works_as_expected
-    source = "{% assign foo = (x..y) %}{{ foo }}"
-    assert_template_result("1..5", source, { "x" => 1, "y" => 5 })
+    t = Template.parse("{% assign foo = (x..y) %}{{ foo }}")
+    result = t.render('x' => 1, 'y' => 5)
+    assert_equal('1..5', result)

-    source = "{% assign nums = (x..y) %}{% for num in nums %}{{ num }}{% endfor %}"
-    assert_template_result("12345", source, { "x" => 1, "y" => 5 })
+    t = Template.parse("{% assign nums = (x..y) %}{% for num in nums %}{{ num }}{% endfor %}")
+    result = t.render('x' => 1, 'y' => 5)
+    assert_equal('12345', result)
  end

  def test_source_string_subclass
@@ -530,9 +530,14 @@ class TrimModeTest < Minitest::Test
  end

  def test_pre_trim_blank_preceding_text
-    assert_template_result("", "\n{%- raw %}{% endraw %}")
-    assert_template_result("", "\n{%- if true %}{% endif %}")
-    assert_template_result("BC", "{{ 'B' }} \n{%- if true %}C{% endif %}")
+    template = Liquid::Template.parse("\n{%- raw %}{% endraw %}")
+    assert_equal("", template.render)
+
+    template = Liquid::Template.parse("\n{%- if true %}{% endif %}")
+    assert_equal("", template.render)
+
+    template = Liquid::Template.parse("{{ 'B' }} \n{%- if true %}C{% endif %}")
+    assert_equal("BC", template.render)
  end

  def test_bug_compatible_pre_trim
@@ -1,87 +1,86 @@
 # frozen_string_literal: true

 require 'test_helper'
-require 'timeout'

 class VariableTest < Minitest::Test
  include Liquid

  def test_simple_variable
-    assert_template_result('worked', "{{test}}", { 'test' => 'worked' })
-    assert_template_result('worked wonderfully', "{{test}}", { 'test' => 'worked wonderfully' })
+    template = Template.parse(%({{test}}))
+    assert_equal('worked', template.render!('test' => 'worked'))
+    assert_equal('worked wonderfully', template.render!('test' => 'worked wonderfully'))
  end

  def test_variable_render_calls_to_liquid
-    assert_template_result('foobar', '{{ foo }}', { 'foo' => ThingWithToLiquid.new })
+    assert_template_result('foobar', '{{ foo }}', 'foo' => ThingWithToLiquid.new)
  end

  def test_variable_lookup_calls_to_liquid_value
-    assert_template_result('1', '{{ foo }}', { 'foo' => IntegerDrop.new('1') })
-    assert_template_result('2', '{{ list[foo] }}', { 'foo' => IntegerDrop.new('1'), 'list' => [1, 2, 3] })
-    assert_template_result('one', '{{ list[foo] }}', { 'foo' => IntegerDrop.new('1'), 'list' => { 1 => 'one' } })
-    assert_template_result('Yay', '{{ foo }}', { 'foo' => BooleanDrop.new(true) })
-    assert_template_result('YAY', '{{ foo | upcase }}', { 'foo' => BooleanDrop.new(true) })
+    assert_template_result('1', '{{ foo }}', 'foo' => IntegerDrop.new('1'))
+    assert_template_result('2', '{{ list[foo] }}', 'foo' => IntegerDrop.new('1'), 'list' => [1, 2, 3])
+    assert_template_result('one', '{{ list[foo] }}', 'foo' => IntegerDrop.new('1'), 'list' => { 1 => 'one' })
+    assert_template_result('Yay', '{{ foo }}', 'foo' => BooleanDrop.new(true))
+    assert_template_result('YAY', '{{ foo | upcase }}', 'foo' => BooleanDrop.new(true))
  end

  def test_if_tag_calls_to_liquid_value
-    assert_template_result('one', '{% if foo == 1 %}one{% endif %}', { 'foo' => IntegerDrop.new('1') })
-    assert_template_result('one', '{% if foo == eqv %}one{% endif %}', { 'foo' => IntegerDrop.new(1), 'eqv' => IntegerDrop.new(1) })
-    assert_template_result('one', '{% if 0 < foo %}one{% endif %}', { 'foo' => IntegerDrop.new('1') })
-    assert_template_result('one', '{% if foo > 0 %}one{% endif %}', { 'foo' => IntegerDrop.new('1') })
-    assert_template_result('one', '{% if b > a %}one{% endif %}', { 'b' => IntegerDrop.new(1), 'a' => IntegerDrop.new(0) })
-    assert_template_result('true', '{% if foo == true %}true{% endif %}', { 'foo' => BooleanDrop.new(true) })
-    assert_template_result('true', '{% if foo %}true{% endif %}', { 'foo' => BooleanDrop.new(true) })
+    assert_template_result('one', '{% if foo == 1 %}one{% endif %}', 'foo' => IntegerDrop.new('1'))
+    assert_template_result('one', '{% if 0 < foo %}one{% endif %}', 'foo' => IntegerDrop.new('1'))
+    assert_template_result('one', '{% if foo > 0 %}one{% endif %}', 'foo' => IntegerDrop.new('1'))
+    assert_template_result('true', '{% if foo == true %}true{% endif %}', 'foo' => BooleanDrop.new(true))
+    assert_template_result('true', '{% if foo %}true{% endif %}', 'foo' => BooleanDrop.new(true))

-    assert_template_result('', '{% if foo %}true{% endif %}', { 'foo' => BooleanDrop.new(false) })
-    assert_template_result('', '{% if foo == true %}True{% endif %}', { 'foo' => BooleanDrop.new(false) })
-
-    assert_template_result('one', '{% if a contains x %}one{% endif %}', { 'a' => [1], 'x' => IntegerDrop.new(1) })
+    assert_template_result('', '{% if foo %}true{% endif %}', 'foo' => BooleanDrop.new(false))
+    assert_template_result('', '{% if foo == true %}True{% endif %}', 'foo' => BooleanDrop.new(false))
  end

  def test_unless_tag_calls_to_liquid_value
-    assert_template_result('', '{% unless foo %}true{% endunless %}', { 'foo' => BooleanDrop.new(true) })
-    assert_template_result('true', '{% unless foo %}true{% endunless %}', { 'foo' => BooleanDrop.new(false) })
+    assert_template_result('', '{% unless foo %}true{% endunless %}', 'foo' => BooleanDrop.new(true))
  end

  def test_case_tag_calls_to_liquid_value
-    assert_template_result('One', '{% case foo %}{% when 1 %}One{% endcase %}', { 'foo' => IntegerDrop.new('1') })
+    assert_template_result('One', '{% case foo %}{% when 1 %}One{% endcase %}', 'foo' => IntegerDrop.new('1'))
  end

  def test_simple_with_whitespaces
-    assert_template_result("  worked  ", "  {{ test }}  ", { "test" => "worked" })
-    assert_template_result("  worked wonderfully  ", "  {{ test }}  ", { "test" => "worked wonderfully" })
+    template = Template.parse(%(  {{ test }}  ))
+    assert_equal('  worked  ', template.render!('test' => 'worked'))
+    assert_equal('  worked wonderfully  ', template.render!('test' => 'worked wonderfully'))
  end

  def test_expression_with_whitespace_in_square_brackets
-    assert_template_result('result', "{{ a[ 'b' ] }}", { 'a' => { 'b' => 'result' } })
-    assert_template_result('result', "{{ a[ [ 'b' ] ] }}", { 'b' => 'c', 'a' => { 'c' => 'result' } })
+    assert_template_result('result', "{{ a[ 'b' ] }}", 'a' => { 'b' => 'result' })
+    assert_template_result('result', "{{ a[ [ 'b' ] ] }}", 'b' => 'c', 'a' => { 'c' => 'result' })
  end

  def test_ignore_unknown
-    assert_template_result("", "{{ test }}")
+    template = Template.parse(%({{ test }}))
+    assert_equal('', template.render!)
  end

  def test_using_blank_as_variable_name
-    assert_template_result("", "{% assign foo = blank %}{{ foo }}")
+    template = Template.parse("{% assign foo = blank %}{{ foo }}")
+    assert_equal('', template.render!)
  end

  def test_using_empty_as_variable_name
-    assert_template_result("", "{% assign foo = empty %}{{ foo }}")
+    template = Template.parse("{% assign foo = empty %}{{ foo }}")
+    assert_equal('', template.render!)
  end

  def test_hash_scoping
-    assert_template_result('worked', "{{ test.test }}", { 'test' => { 'test' => 'worked' } })
-    assert_template_result('worked', "{{ test . test }}", { 'test' => { 'test' => 'worked' } })
+    assert_template_result('worked', "{{ test.test }}", 'test' => { 'test' => 'worked' })
+    assert_template_result('worked', "{{ test . test }}", 'test' => { 'test' => 'worked' })
  end

  def test_false_renders_as_false
-    assert_template_result("false", "{{ foo }}", { 'foo' => false })
-    assert_template_result("false", "{{ false }}")
+    assert_equal('false', Template.parse("{{ foo }}").render!('foo' => false))
+    assert_equal('false', Template.parse("{{ false }}").render!)
  end

  def test_nil_renders_as_empty_string
-    assert_template_result("", "{{ nil }}")
-    assert_template_result("cat", "{{ nil | append: 'cat' }}")
+    assert_equal('', Template.parse("{{ nil }}").render!)
+    assert_equal('cat', Template.parse("{{ nil | append: 'cat' }}").render!)
  end

  def test_preset_assigns
@@ -122,86 +121,18 @@ class VariableTest < Minitest::Test
  end

  def test_multiline_variable
-    assert_template_result("worked", "{{\ntest\n}}", { "test" => "worked" })
+    assert_equal('worked', Template.parse("{{\ntest\n}}").render!('test' => 'worked'))
  end

  def test_render_symbol
-    assert_template_result('bar', '{{ foo }}', { 'foo' => :bar })
+    assert_template_result('bar', '{{ foo }}', 'foo' => :bar)
  end

  def test_dynamic_find_var
-    assert_template_result('bar', '{{ [key] }}', { 'key' => 'foo', 'foo' => 'bar' })
+    assert_template_result('bar', '{{ [key] }}', 'key' => 'foo', 'foo' => 'bar')
  end

  def test_raw_value_variable
-    assert_template_result('bar', '{{ [key] }}', { 'key' => 'foo', 'foo' => 'bar' })
-  end
-
-  def test_dynamic_find_var_with_drop
-    assert_template_result(
-      'bar',
-      '{{ [list[settings.zero]] }}',
-      {
-        'list' => ['foo'],
-        'settings' => SettingsDrop.new("zero" => 0),
-        'foo' => 'bar',
-      },
-    )
-
-    assert_template_result(
-      'foo',
-      '{{ [list[settings.zero]["foo"]] }}',
-      {
-        'list' => [{ 'foo' => 'bar' }],
-        'settings' => SettingsDrop.new("zero" => 0),
-        'bar' => 'foo',
-      },
-    )
-  end
-
-  def test_double_nested_variable_lookup
-    assert_template_result(
-      'bar',
-      '{{ list[list[settings.zero]]["foo"] }}',
-      {
-        'list' => [1, { 'foo' => 'bar' }],
-        'settings' => SettingsDrop.new("zero" => 0),
-        'bar' => 'foo',
-      },
-    )
-  end
-
-  def test_variable_lookup_should_not_hang_with_invalid_syntax
-    Timeout.timeout(1) do
-      assert_template_result(
-        'bar',
-        "{{['foo'}}",
-        {
-          'foo' => 'bar',
-        },
-        error_mode: :lax,
-      )
-    end
-
-    very_long_key = "1234567890" * 100
-
-    template_list = [
-      "{{['#{very_long_key}']}}", # valid
-      "{{['#{very_long_key}'}}", # missing closing bracket
-      "{{[['#{very_long_key}']}}", # extra open bracket
-    ]
-
-    template_list.each do |template|
-      Timeout.timeout(1) do
-        assert_template_result(
-          'bar',
-          template,
-          {
-            very_long_key => 'bar',
-          },
-          error_mode: :lax,
-        )
-      end
-    end
+    assert_template_result('bar', '{{ [key] }}', 'key' => 'foo', 'foo' => 'bar')
  end
 end
@@ -37,30 +37,23 @@ module Minitest
  module Assertions
    include Liquid

-    def assert_template_result(
-      expected, template, assigns = {},
-      message: nil, partials: nil, error_mode: nil, render_errors: false,
-      template_factory: nil
-    )
-      template = Liquid::Template.parse(template, line_numbers: true, error_mode: error_mode&.to_sym)
-      file_system = StubFileSystem.new(partials || {})
-      registers = Liquid::Registers.new(file_system: file_system, template_factory: template_factory)
-      context = Liquid::Context.build(static_environments: assigns, rethrow_errors: !render_errors, registers: registers)
-      output = template.render(context)
-      assert_equal(expected, output, message)
+    def assert_template_result(expected, template, assigns = {}, message = nil)
+      assert_equal(expected, Template.parse(template, line_numbers: true).render!(assigns), message)
    end

-    def assert_match_syntax_error(match, template, error_mode: nil)
+    def assert_template_result_matches(expected, template, assigns = {}, message = nil)
+      return assert_template_result(expected, template, assigns, message) unless expected.is_a?(Regexp)
+
+      assert_match(expected, Template.parse(template, line_numbers: true).render!(assigns), message)
+    end
+
+    def assert_match_syntax_error(match, template, assigns = {})
      exception = assert_raises(Liquid::SyntaxError) do
-        Template.parse(template, line_numbers: true, error_mode: error_mode&.to_sym).render
+        Template.parse(template, line_numbers: true).render(assigns)
      end
      assert_match(match, exception.message)
    end

-    def assert_syntax_error(template, error_mode: nil)
-      assert_match_syntax_error("", template, error_mode: error_mode)
-    end
-
    def assert_usage_increment(name, times: 1)
      old_method = Liquid::Usage.method(:increment)
      calls = 0
@@ -126,23 +119,16 @@ class ThingWithToLiquid
  end
 end

-class SettingsDrop < Liquid::Drop
-  def initialize(settings)
-    super()
-    @settings = settings
-  end
-
-  def liquid_method_missing(key)
-    @settings[key]
-  end
-end
-
 class IntegerDrop < Liquid::Drop
  def initialize(value)
    super()
    @value = value.to_i
  end

+  def ==(other)
+    @value == other
+  end
+
  def to_s
    @value.to_s
  end
@@ -158,6 +144,10 @@ class BooleanDrop < Liquid::Drop
    @value = value
  end

+  def ==(other)
+    @value == other
+  end
+
  def to_liquid_value
    @value
  end
@@ -210,10 +200,8 @@ class StubTemplateFactory
    @count = 0
  end

-  def for(template_name)
+  def for(_template_name)
    @count += 1
-    template = Liquid::Template.new
-    template.name = "some/path/" + template_name
-    template
+    Liquid::Template.new
  end
 end
@@ -35,10 +35,8 @@ class BlockUnitTest < Minitest::Test
  def test_variable_many_embedded_fragments
    template = Liquid::Template.parse("  {{funk}} {{so}} {{brother}} ")
    assert_equal(7, template.root.nodelist.size)
-    assert_equal(
-      [String, Variable, String, Variable, String, Variable, String],
-      block_types(template.root.nodelist),
-    )
+    assert_equal([String, Variable, String, Variable, String, Variable, String],
+      block_types(template.root.nodelist))
  end

  def test_with_block
@@ -164,17 +164,13 @@ class ConditionUnitTest < Minitest::Test
  private

  def assert_evaluates_true(left, op, right)
-    assert(
-      Condition.new(left, op, right).evaluate(@context),
-      "Evaluated false: #{left} #{op} #{right}",
-    )
+    assert(Condition.new(left, op, right).evaluate(@context),
+      "Evaluated false: #{left} #{op} #{right}")
  end

  def assert_evaluates_false(left, op, right)
-    assert(
-      !Condition.new(left, op, right).evaluate(@context),
-      "Evaluated true: #{left} #{op} #{right}",
-    )
+    assert(!Condition.new(left, op, right).evaluate(@context),
+      "Evaluated true: #{left} #{op} #{right}")
  end

  def assert_evaluates_argument_error(left, op, right)
@@ -8,245 +8,245 @@ class ParseTreeVisitorTest < Minitest::Test
  def test_variable
    assert_equal(
      ["test"],
-      visit(%({{ test }})),
+      visit(%({{ test }}))
    )
  end

  def test_varible_with_filter
    assert_equal(
      ["test", "infilter"],
-      visit(%({{ test | split: infilter }})),
+      visit(%({{ test | split: infilter }}))
    )
  end

  def test_dynamic_variable
    assert_equal(
      ["test", "inlookup"],
-      visit(%({{ test[inlookup] }})),
+      visit(%({{ test[inlookup] }}))
    )
  end

  def test_echo
    assert_equal(
      ["test"],
-      visit(%({% echo test %})),
+      visit(%({% echo test %}))
    )
  end

  def test_if_condition
    assert_equal(
      ["test"],
-      visit(%({% if test %}{% endif %})),
+      visit(%({% if test %}{% endif %}))
    )
  end

  def test_complex_if_condition
    assert_equal(
      ["test"],
-      visit(%({% if 1 == 1 and 2 == test %}{% endif %})),
+      visit(%({% if 1 == 1 and 2 == test %}{% endif %}))
    )
  end

  def test_if_body
    assert_equal(
      ["test"],
-      visit(%({% if 1 == 1 %}{{ test }}{% endif %})),
+      visit(%({% if 1 == 1 %}{{ test }}{% endif %}))
    )
  end

  def test_unless_condition
    assert_equal(
      ["test"],
-      visit(%({% unless test %}{% endunless %})),
+      visit(%({% unless test %}{% endunless %}))
    )
  end

  def test_complex_unless_condition
    assert_equal(
      ["test"],
-      visit(%({% unless 1 == 1 and 2 == test %}{% endunless %})),
+      visit(%({% unless 1 == 1 and 2 == test %}{% endunless %}))
    )
  end

  def test_unless_body
    assert_equal(
      ["test"],
-      visit(%({% unless 1 == 1 %}{{ test }}{% endunless %})),
+      visit(%({% unless 1 == 1 %}{{ test }}{% endunless %}))
    )
  end

  def test_elsif_condition
    assert_equal(
      ["test"],
-      visit(%({% if 1 == 1 %}{% elsif test %}{% endif %})),
+      visit(%({% if 1 == 1 %}{% elsif test %}{% endif %}))
    )
  end

  def test_complex_elsif_condition
    assert_equal(
      ["test"],
-      visit(%({% if 1 == 1 %}{% elsif 1 == 1 and 2 == test %}{% endif %})),
+      visit(%({% if 1 == 1 %}{% elsif 1 == 1 and 2 == test %}{% endif %}))
    )
  end

  def test_elsif_body
    assert_equal(
      ["test"],
-      visit(%({% if 1 == 1 %}{% elsif 2 == 2 %}{{ test }}{% endif %})),
+      visit(%({% if 1 == 1 %}{% elsif 2 == 2 %}{{ test }}{% endif %}))
    )
  end

  def test_else_body
    assert_equal(
      ["test"],
-      visit(%({% if 1 == 1 %}{% else %}{{ test }}{% endif %})),
+      visit(%({% if 1 == 1 %}{% else %}{{ test }}{% endif %}))
    )
  end

  def test_case_left
    assert_equal(
      ["test"],
-      visit(%({% case test %}{% endcase %})),
+      visit(%({% case test %}{% endcase %}))
    )
  end

  def test_case_condition
    assert_equal(
      ["test"],
-      visit(%({% case 1 %}{% when test %}{% endcase %})),
+      visit(%({% case 1 %}{% when test %}{% endcase %}))
    )
  end

  def test_case_when_body
    assert_equal(
      ["test"],
-      visit(%({% case 1 %}{% when 2 %}{{ test }}{% endcase %})),
+      visit(%({% case 1 %}{% when 2 %}{{ test }}{% endcase %}))
    )
  end

  def test_case_else_body
    assert_equal(
      ["test"],
-      visit(%({% case 1 %}{% else %}{{ test }}{% endcase %})),
+      visit(%({% case 1 %}{% else %}{{ test }}{% endcase %}))
    )
  end

  def test_for_in
    assert_equal(
      ["test"],
-      visit(%({% for x in test %}{% endfor %})),
+      visit(%({% for x in test %}{% endfor %}))
    )
  end

  def test_for_limit
    assert_equal(
      ["test"],
-      visit(%({% for x in (1..5) limit: test %}{% endfor %})),
+      visit(%({% for x in (1..5) limit: test %}{% endfor %}))
    )
  end

  def test_for_offset
    assert_equal(
      ["test"],
-      visit(%({% for x in (1..5) offset: test %}{% endfor %})),
+      visit(%({% for x in (1..5) offset: test %}{% endfor %}))
    )
  end

  def test_for_body
    assert_equal(
      ["test"],
-      visit(%({% for x in (1..5) %}{{ test }}{% endfor %})),
+      visit(%({% for x in (1..5) %}{{ test }}{% endfor %}))
    )
  end

  def test_for_range
    assert_equal(
      ["test"],
-      visit(%({% for x in (1..test) %}{% endfor %})),
+      visit(%({% for x in (1..test) %}{% endfor %}))
    )
  end

  def test_tablerow_in
    assert_equal(
      ["test"],
-      visit(%({% tablerow x in test %}{% endtablerow %})),
+      visit(%({% tablerow x in test %}{% endtablerow %}))
    )
  end

  def test_tablerow_limit
    assert_equal(
      ["test"],
-      visit(%({% tablerow x in (1..5) limit: test %}{% endtablerow %})),
+      visit(%({% tablerow x in (1..5) limit: test %}{% endtablerow %}))
    )
  end

  def test_tablerow_offset
    assert_equal(
      ["test"],
-      visit(%({% tablerow x in (1..5) offset: test %}{% endtablerow %})),
+      visit(%({% tablerow x in (1..5) offset: test %}{% endtablerow %}))
    )
  end

  def test_tablerow_body
    assert_equal(
      ["test"],
-      visit(%({% tablerow x in (1..5) %}{{ test }}{% endtablerow %})),
+      visit(%({% tablerow x in (1..5) %}{{ test }}{% endtablerow %}))
    )
  end

  def test_cycle
    assert_equal(
      ["test"],
-      visit(%({% cycle test %})),
+      visit(%({% cycle test %}))
    )
  end

  def test_assign
    assert_equal(
      ["test"],
-      visit(%({% assign x = test %})),
+      visit(%({% assign x = test %}))
    )
  end

  def test_capture
    assert_equal(
      ["test"],
-      visit(%({% capture x %}{{ test }}{% endcapture %})),
+      visit(%({% capture x %}{{ test }}{% endcapture %}))
    )
  end

  def test_include
    assert_equal(
      ["test"],
-      visit(%({% include test %})),
+      visit(%({% include test %}))
    )
  end

  def test_include_with
    assert_equal(
      ["test"],
-      visit(%({% include "hai" with test %})),
+      visit(%({% include "hai" with test %}))
    )
  end

  def test_include_for
    assert_equal(
      ["test"],
-      visit(%({% include "hai" for test %})),
+      visit(%({% include "hai" for test %}))
    )
  end

  def test_render_with
    assert_equal(
      ["test"],
-      visit(%({% render "hai" with test %})),
+      visit(%({% render "hai" with test %}))
    )
  end

  def test_render_for
    assert_equal(
      ["test"],
-      visit(%({% render "hai" for test %})),
+      visit(%({% render "hai" for test %}))
    )
  end

@@ -257,7 +257,7 @@ class ParseTreeVisitorTest < Minitest::Test
        ["test", []],
        ["xs", []],
      ]]],
-      traversal(%({% for x in xs offset: test %}{{ other }}{% endfor %})).visit,
+      traversal(%({% for x in xs offset: test %}{{ other }}{% endfor %})).visit
    )
  end

@@ -7,13 +7,13 @@ class PartialCacheUnitTest < Minitest::Test
    context = Liquid::Context.build(
      registers: {
        file_system: StubFileSystem.new('my_partial' => 'my partial body'),
-      },
+      }
    )

    partial = Liquid::PartialCache.load(
      'my_partial',
      context: context,
-      parse_context: Liquid::ParseContext.new,
+      parse_context: Liquid::ParseContext.new
    )

    assert_equal('my partial body', partial.render)
@@ -22,14 +22,14 @@ class PartialCacheUnitTest < Minitest::Test
  def test_reads_from_the_file_system_only_once_per_file
    file_system = StubFileSystem.new('my_partial' => 'some partial body')
    context     = Liquid::Context.build(
-      registers: { file_system: file_system },
+      registers: { file_system: file_system }
    )

    2.times do
      Liquid::PartialCache.load(
        'my_partial',
        context: context,
-        parse_context: Liquid::ParseContext.new,
+        parse_context: Liquid::ParseContext.new
      )
    end

@@ -39,31 +39,31 @@ class PartialCacheUnitTest < Minitest::Test
  def test_cache_state_is_stored_per_context
    parse_context      = Liquid::ParseContext.new
    shared_file_system = StubFileSystem.new(
-      'my_partial' => 'my shared value',
+      'my_partial' => 'my shared value'
    )
    context_one = Liquid::Context.build(
      registers: {
        file_system: shared_file_system,
-      },
+      }
    )
    context_two = Liquid::Context.build(
      registers: {
        file_system: shared_file_system,
-      },
+      }
    )

    2.times do
      Liquid::PartialCache.load(
        'my_partial',
        context: context_one,
-        parse_context: parse_context,
+        parse_context: parse_context
      )
    end

    Liquid::PartialCache.load(
      'my_partial',
      context: context_two,
-      parse_context: parse_context,
+      parse_context: parse_context
    )

    assert_equal(2, shared_file_system.file_read_count)
@@ -72,18 +72,18 @@ class PartialCacheUnitTest < Minitest::Test
  def test_cache_is_not_broken_when_a_different_parse_context_is_used
    file_system = StubFileSystem.new('my_partial' => 'some partial body')
    context     = Liquid::Context.build(
-      registers: { file_system: file_system },
+      registers: { file_system: file_system }
    )

    Liquid::PartialCache.load(
      'my_partial',
      context: context,
-      parse_context: Liquid::ParseContext.new(my_key: 'value one'),
+      parse_context: Liquid::ParseContext.new(my_key: 'value one')
    )
    Liquid::PartialCache.load(
      'my_partial',
      context: context,
-      parse_context: Liquid::ParseContext.new(my_key: 'value two'),
+      parse_context: Liquid::ParseContext.new(my_key: 'value two')
    )

    # Technically what we care about is that the file was parsed twice,
@@ -95,13 +95,13 @@ class PartialCacheUnitTest < Minitest::Test
    context = Liquid::Context.build(
      registers: {
        file_system: StubFileSystem.new('my_partial' => 'my partial body'),
-      },
+      }
    )

    partial = Liquid::PartialCache.load(
      'my_partial',
      context: context,
-      parse_context: Liquid::ParseContext.new,
+      parse_context: Liquid::ParseContext.new
    )

    assert_equal('my partial body', partial.render)
@@ -113,13 +113,13 @@ class PartialCacheUnitTest < Minitest::Test
      registers: {
        file_system: StubFileSystem.new('my_partial' => 'my partial body'),
        template_factory: template_factory,
-      },
+      }
    )

    partial = Liquid::PartialCache.load(
      'my_partial',
      context: context,
-      parse_context: Liquid::ParseContext.new,
+      parse_context: Liquid::ParseContext.new
    )

    assert_equal('my partial body', partial.render)
@@ -129,12 +129,12 @@ class PartialCacheUnitTest < Minitest::Test
  def test_cache_state_is_shared_for_subcontexts
    parse_context      = Liquid::ParseContext.new
    shared_file_system = StubFileSystem.new(
-      'my_partial' => 'my shared value',
+      'my_partial' => 'my shared value'
    )
    context = Liquid::Context.build(
      registers: Liquid::Registers.new(
        file_system: shared_file_system,
-      ),
+      )
    )
    subcontext = context.new_isolated_subcontext

@@ -144,34 +144,16 @@ class PartialCacheUnitTest < Minitest::Test
      Liquid::PartialCache.load(
        'my_partial',
        context: context,
-        parse_context: parse_context,
+        parse_context: parse_context
      )

      Liquid::PartialCache.load(
        'my_partial',
        context: subcontext,
-        parse_context: parse_context,
+        parse_context: parse_context
      )
    end

    assert_equal(1, shared_file_system.file_read_count)
  end
-
-  def test_uses_template_name_from_template_factory
-    template_factory = StubTemplateFactory.new
-    context = Liquid::Context.build(
-      registers: {
-        file_system: StubFileSystem.new('my_partial' => 'my partial body'),
-        template_factory: template_factory,
-      },
-    )
-
-    partial = Liquid::PartialCache.load(
-      'my_partial',
-      context: context,
-      parse_context: Liquid::ParseContext.new,
-    )
-
-    assert_equal('some/path/my_partial', partial.name)
-  end
 end
@@ -1,7 +1,6 @@
 # frozen_string_literal: true

 require 'test_helper'
-require 'timeout'

 class RegexpUnitTest < Minitest::Test
  include Liquid
@@ -38,22 +37,10 @@ class RegexpUnitTest < Minitest::Test

  def test_variable_parser
    assert_equal(['var'],                               'var'.scan(VariableParser))
-    assert_equal(['[var]'],                             '[var]'.scan(VariableParser))
    assert_equal(['var', 'method'],                     'var.method'.scan(VariableParser))
    assert_equal(['var', '[method]'],                   'var[method]'.scan(VariableParser))
    assert_equal(['var', '[method]', '[0]'],            'var[method][0]'.scan(VariableParser))
    assert_equal(['var', '["method"]', '[0]'],          'var["method"][0]'.scan(VariableParser))
    assert_equal(['var', '[method]', '[0]', 'method'],  'var[method][0].method'.scan(VariableParser))
  end
-
-  def test_variable_parser_with_large_input
-    Timeout.timeout(1) { assert_equal(['[var]'], '[var]'.scan(VariableParser)) }
-
-    very_long_string = "foo" * 1000
-
-    # valid dynamic lookup
-    Timeout.timeout(1) { assert_equal(["[#{very_long_string}]"], "[#{very_long_string}]".scan(VariableParser)) }
-    # invalid dynamic lookup with missing closing bracket
-    Timeout.timeout(1) { assert_equal([very_long_string], "[#{very_long_string}".scan(VariableParser)) }
-  end
 end # RegexpTest
@@ -50,7 +50,7 @@ class StrainerFactoryUnitTest < Minitest::Test

    assert_match(
      /\ALiquid error: wrong number of arguments \((1 for 0|given 1, expected 0)\)\z/,
-      exception.message,
+      exception.message
    )
    source = AccessScopeFilters.instance_method(:public_filter).source_location
    assert_equal(source.map(&:to_s), exception.backtrace[0].split(':')[0..1])
@@ -60,7 +60,7 @@ class StrainerTemplateUnitTest < Minitest::Test
    with_global_filter do
      strainer = Context.new.strainer
      strainer.class.add_filter(PublicMethodOverrideFilter)
-      assert(strainer.class.send(:filter_methods).include?('public_filter'))
+      assert(strainer.class.filter_method_names.include?('public_filter'))
    end
  end