liquid 3.0.6 → 5.4.0

data/test/integration/tags/statements_test.rb

@@ -1,113 +0,0 @@
-require 'test_helper'
-
-class StatementsTest < Minitest::Test
-  include Liquid
-
-  def test_true_eql_true
-    text = ' {% if true == true %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text
-  end
-
-  def test_true_not_eql_true
-    text = ' {% if true != true %} true {% else %} false {% endif %} '
-    assert_template_result '  false  ', text
-  end
-
-  def test_true_lq_true
-    text = ' {% if 0 > 0 %} true {% else %} false {% endif %} '
-    assert_template_result '  false  ', text
-  end
-
-  def test_one_lq_zero
-    text = ' {% if 1 > 0 %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text
-  end
-
-  def test_zero_lq_one
-    text = ' {% if 0 < 1 %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text
-  end
-
-  def test_zero_lq_or_equal_one
-    text = ' {% if 0 <= 0 %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text
-  end
-
-  def test_zero_lq_or_equal_one_involving_nil
-    text = ' {% if null <= 0 %} true {% else %} false {% endif %} '
-    assert_template_result '  false  ', text
-
-
-    text = ' {% if 0 <= null %} true {% else %} false {% endif %} '
-    assert_template_result '  false  ', text
-  end
-
-  def test_zero_lqq_or_equal_one
-    text = ' {% if 0 >= 0 %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text
-  end
-
-  def test_strings
-    text = " {% if 'test' == 'test' %} true {% else %} false {% endif %} "
-    assert_template_result '  true  ', text
-  end
-
-  def test_strings_not_equal
-    text = " {% if 'test' != 'test' %} true {% else %} false {% endif %} "
-    assert_template_result '  false  ', text
-  end
-
-  def test_var_strings_equal
-    text = ' {% if var == "hello there!" %} true {% else %} false {% endif %} '
-    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!'
-  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!'
-  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!'
-  end
-
-  #def test_is_nil
-  #  text = %| {% if var != nil %} true {% else %} false {% end %} |
-  #  @template.assigns = { 'var' => 'hello there!'}
-  #  expected = %|  true  |
-  #  assert_equal expected, @template.parse(text)
-  #end
-
-  def test_is_collection_empty
-    text = ' {% if array == empty %} true {% else %} false {% endif %} '
-    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]
-  end
-
-  def test_nil
-    text = ' {% if var == nil %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text, 'var' => nil
-
-    text = ' {% if var == null %} true {% else %} false {% endif %} '
-    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
-
-    text = ' {% if var != null %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text, 'var' => 1
-  end
-end # StatementsTest

data/test/integration/tags/table_row_test.rb

@@ -1,63 +0,0 @@
-require 'test_helper'
-
-class TableRowTest < Minitest::Test
-  include Liquid
-
-  class ArrayDrop < Liquid::Drop
-    include Enumerable
-
-    def initialize(array)
-      @array = array
-    end
-
-    def each(&block)
-      @array.each(&block)
-    end
-  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",
-                           '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
-                           'numbers' => [1,2,3,4,5,6])
-
-    assert_template_result("<tr class=\"row1\">\n</tr>\n",
-                           '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
-                           '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",
-                           '{% tablerow n in numbers cols:5%} {{n}} {% endtablerow %}',
-                           '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",
-                           '{% tablerow n in numbers cols:2%}{{tablerowloop.col}}{% endtablerow %}',
-                           '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",
-                           "{% 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",
-                           "{% tablerow n in collections['frontpage'] cols:3%} {{n}} {% endtablerow %}",
-                           '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",
-                           '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
-                           '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",
-                           '{% tablerow n in numbers cols:3 offset:1 limit:6%} {{n}} {% endtablerow %}',
-                           'numbers' => [0,1,2,3,4,5,6,7])
-  end
-end

data/test/integration/tags/unless_else_tag_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-class UnlessElseTagTest < Minitest::Test
-  include Liquid
-
-  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('  you rock ?','{% unless true %} you suck {% endunless %} {% unless false %} you rock {% endunless %}?')
-  end
-
-  def test_unless_else
-    assert_template_result(' YES ','{% unless true %} NO {% else %} YES {% endunless %}')
-    assert_template_result(' YES ','{% unless false %} YES {% else %} NO {% endunless %}')
-    assert_template_result(' YES ','{% unless "foo" %} NO {% else %} YES {% endunless %}')
-  end
-
-  def test_unless_in_loop
-    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]
-  end
-end # UnlessElseTest

data/test/integration/template_test.rb

@@ -1,182 +0,0 @@
-require 'test_helper'
-
-class TemplateContextDrop < Liquid::Drop
-  def before_method(method)
-    method
-  end
-
-  def foo
-    'fizzbuzz'
-  end
-
-  def baz
-    @context.registers['lulz']
-  end
-end
-
-class SomethingWithLength
-  def length
-    nil
-  end
-
-  liquid_methods :length
-end
-
-class ErroneousDrop < Liquid::Drop
-  def bad_method
-    raise 'ruby error in drop'
-  end
-end
-
-class TemplateTest < Minitest::Test
-  include Liquid
-
-  def test_instance_assigns_persist_on_same_template_object_between_parses
-    t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
-    assert_equal 'from instance assigns', t.parse("{{ foo }}").render!
-  end
-
-  def test_instance_assigns_persist_on_same_template_parsing_between_renders
-    t = Template.new.parse("{{ foo }}{% assign foo = 'foo' %}{{ foo }}")
-    assert_equal 'foo', t.render!
-    assert_equal 'foofoo', t.render!
-  end
-
-  def test_custom_assigns_do_not_persist_on_same_template
-    t = Template.new
-    assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns')
-    assert_equal '', t.parse("{{ foo }}").render!
-  end
-
-  def test_custom_assigns_squash_instance_assigns
-    t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
-    assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns')
-  end
-
-  def test_persistent_assigns_squash_instance_assigns
-    t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
-    t.assigns['foo'] = 'from persistent assigns'
-    assert_equal 'from persistent assigns', t.parse("{{ foo }}").render!
-  end
-
-  def test_lambda_is_called_once_from_persistent_assigns_over_multiple_parses_and_renders
-    t = Template.new
-    t.assigns['number'] = lambda { @global ||= 0; @global += 1 }
-    assert_equal '1', t.parse("{{number}}").render!
-    assert_equal '1', t.parse("{{number}}").render!
-    assert_equal '1', t.render!
-    @global = nil
-  end
-
-  def test_lambda_is_called_once_from_custom_assigns_over_multiple_parses_and_renders
-    t = Template.new
-    assigns = {'number' => lambda { @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)
-    @global = nil
-  end
-
-  def test_resource_limits_works_with_custom_length_method
-    t = Template.parse("{% assign foo = bar %}")
-    t.resource_limits = { :render_length_limit => 42 }
-    assert_equal "", t.render!("bar" => SomethingWithLength.new)
-  end
-
-  def test_resource_limits_render_length
-    t = Template.parse("0123456789")
-    t.resource_limits = { :render_length_limit => 5 }
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
-    assert t.resource_limits[:reached]
-    t.resource_limits = { :render_length_limit => 10 }
-    assert_equal "0123456789", t.render!()
-    refute_nil t.resource_limits[:render_length_current]
-  end
-
-  def test_resource_limits_render_score
-    t = Template.parse("{% for a in (1..10) %} {% for a in (1..10) %} foo {% endfor %} {% endfor %}")
-    t.resource_limits = { :render_score_limit => 50 }
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
-    assert t.resource_limits[:reached]
-    t = Template.parse("{% for a in (1..100) %} foo {% endfor %}")
-    t.resource_limits = { :render_score_limit => 50 }
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
-    assert t.resource_limits[:reached]
-    t.resource_limits = { :render_score_limit => 200 }
-    assert_equal (" foo " * 100), t.render!()
-    refute_nil t.resource_limits[:render_score_current]
-  end
-
-  def test_resource_limits_assign_score
-    t = Template.parse("{% assign foo = 42 %}{% assign bar = 23 %}")
-    t.resource_limits = { :assign_score_limit => 1 }
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
-    assert t.resource_limits[:reached]
-    t.resource_limits = { :assign_score_limit => 2 }
-    assert_equal "", t.render!()
-    refute_nil t.resource_limits[:assign_score_current]
-  end
-
-  def test_resource_limits_aborts_rendering_after_first_error
-    t = Template.parse("{% for a in (1..100) %} foo1 {% endfor %} bar {% for a in (1..100) %} foo2 {% endfor %}")
-    t.resource_limits = { :render_score_limit => 50 }
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
-    assert t.resource_limits[:reached]
-  end
-
-  def test_resource_limits_hash_in_template_gets_updated_even_if_no_limits_are_set
-    t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
-    t.render!()
-    assert t.resource_limits[:assign_score_current] > 0
-    assert t.resource_limits[:render_score_current] > 0
-    assert t.resource_limits[:render_length_current] > 0
-  end
-
-  def test_default_resource_limits_unaffected_by_render_with_context
-    context = Context.new
-    t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
-    t.render!(context)
-    assert context.resource_limits[:assign_score_current] > 0
-    assert context.resource_limits[:render_score_current] > 0
-    assert context.resource_limits[:render_length_current] > 0
-    refute Template.default_resource_limits.key?(:assign_score_current)
-    refute Template.default_resource_limits.key?(:render_score_current)
-    refute Template.default_resource_limits.key?(:render_length_current)
-  end
-
-  def test_can_use_drop_as_context
-    t = Template.new
-    t.registers['lulz'] = 'haha'
-    drop = TemplateContextDrop.new
-    assert_equal 'fizzbuzz', t.parse('{{foo}}').render!(drop)
-    assert_equal 'bar', t.parse('{{bar}}').render!(drop)
-    assert_equal 'haha', t.parse("{{baz}}").render!(drop)
-  end
-
-  def test_render_bang_force_rethrow_errors_on_passed_context
-    context = Context.new({'drop' => ErroneousDrop.new})
-    t = Template.new.parse('{{ drop.bad_method }}')
-
-    e = assert_raises RuntimeError do
-      t.render!(context)
-    end
-    assert_equal 'ruby error in drop', e.message
-  end
-
-  def test_exception_handler_doesnt_reraise_if_it_returns_false
-    exception = nil
-    Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_handler: ->(e) { exception = e; false })
-    assert exception.is_a?(ZeroDivisionError)
-  end
-
-  def test_exception_handler_does_reraise_if_it_returns_true
-    exception = nil
-    assert_raises(ZeroDivisionError) do
-      Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_handler: ->(e) { exception = e; true })
-    end
-    assert exception.is_a?(ZeroDivisionError)
-  end
-end

data/test/integration/variable_test.rb

@@ -1,82 +0,0 @@
-require 'test_helper'
-
-class VariableTest < Minitest::Test
-  include Liquid
-
-  def test_simple_variable
-    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
-  end
-
-  def test_simple_with_whitespaces
-    template = Template.parse(%|  {{ test }}  |)
-    assert_equal '  worked  ', template.render!('test' => 'worked')
-    assert_equal '  worked wonderfully  ', template.render!('test' => 'worked wonderfully')
-  end
-
-  def test_ignore_unknown
-    template = Template.parse(%|{{ test }}|)
-    assert_equal '', template.render!
-  end
-
-  def test_hash_scoping
-    template = Template.parse(%|{{ test.test }}|)
-    assert_equal 'worked', template.render!('test' => {'test' => 'worked'})
-  end
-
-  def test_false_renders_as_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_equal '', Template.parse("{{ nil }}").render!
-    assert_equal 'cat', Template.parse("{{ nil | append: 'cat' }}").render!
-  end
-
-  def test_preset_assigns
-    template = Template.parse(%|{{ test }}|)
-    template.assigns['test'] = 'worked'
-    assert_equal 'worked', template.render!
-  end
-
-  def test_reuse_parsed_template
-    template = Template.parse(%|{{ greeting }} {{ name }}|)
-    template.assigns['greeting'] = 'Goodbye'
-    assert_equal 'Hello Tobi', template.render!('greeting' => 'Hello', 'name' => 'Tobi')
-    assert_equal 'Hello ', template.render!('greeting' => 'Hello', 'unknown' => 'Tobi')
-    assert_equal 'Hello Brian', template.render!('greeting' => 'Hello', 'name' => 'Brian')
-    assert_equal 'Goodbye Brian', template.render!('name' => 'Brian')
-    assert_equal({'greeting'=>'Goodbye'}, template.assigns)
-  end
-
-  def test_assigns_not_polluted_from_template
-    template = Template.parse(%|{{ test }}{% assign test = 'bar' %}{{ test }}|)
-    template.assigns['test'] = 'baz'
-    assert_equal 'bazbar', template.render!
-    assert_equal 'bazbar', template.render!
-    assert_equal 'foobar', template.render!('test' => 'foo')
-    assert_equal 'bazbar', template.render!
-  end
-
-  def test_hash_with_default_proc
-    template = Template.parse(%|Hello {{ test }}|)
-    assigns = Hash.new { |h,k| raise "Unknown variable '#{k}'" }
-    assigns['test'] = 'Tobi'
-    assert_equal 'Hello Tobi', template.render!(assigns)
-    assigns.delete('test')
-    e = assert_raises(RuntimeError) {
-      template.render!(assigns)
-    }
-    assert_equal "Unknown variable 'test'", e.message
-  end
-
-  def test_multiline_variable
-    assert_equal 'worked', Template.parse("{{\ntest\n}}").render!('test' => 'worked')
-  end
-end

data/test/test_helper.rb

@@ -1,89 +0,0 @@
-#!/usr/bin/env ruby
-
-ENV["MT_NO_EXPECTATIONS"] = "1"
-require 'minitest/autorun'
-require 'spy/integration'
-
-$:.unshift(File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib'))
-require 'liquid.rb'
-
-mode = :strict
-if env_mode = ENV['LIQUID_PARSER_MODE']
-  puts "-- #{env_mode.upcase} ERROR MODE"
-  mode = env_mode.to_sym
-end
-Liquid::Template.error_mode = mode
-
-if Minitest.const_defined?('Test')
-  # We're on Minitest 5+. Nothing to do here.
-else
-  # Minitest 4 doesn't have Minitest::Test yet.
-  Minitest::Test = MiniTest::Unit::TestCase
-end
-
-module Minitest
-  class Test
-    def fixture(name)
-      File.join(File.expand_path(File.dirname(__FILE__)), "fixtures", name)
-    end
-  end
-
-  module Assertions
-    include Liquid
-
-    def assert_template_result(expected, template, assigns = {}, message = nil)
-      assert_equal expected, Template.parse(template).render!(assigns), message
-    end
-
-    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).render!(assigns), message
-    end
-
-    def assert_match_syntax_error(match, template, registers = {})
-      exception = assert_raises(Liquid::SyntaxError) {
-        Template.parse(template).render(assigns)
-      }
-      assert_match match, exception.message
-    end
-
-    def with_global_filter(*globals)
-      original_global_strainer = Liquid::Strainer.class_variable_get(:@@global_strainer)
-      Liquid::Strainer.class_variable_set(:@@global_strainer, Class.new(Liquid::Strainer) do
-        @filter_methods = Set.new
-      end)
-      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
-
-      globals.each do |global|
-        Liquid::Template.register_filter(global)
-      end
-      yield
-    ensure
-      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
-      Liquid::Strainer.class_variable_set(:@@global_strainer, original_global_strainer)
-    end
-
-    def with_taint_mode(mode)
-      old_mode = Liquid::Template.taint_mode
-      Liquid::Template.taint_mode = mode
-      yield
-    ensure
-      Liquid::Template.taint_mode = old_mode
-    end
-
-    def with_error_mode(mode)
-      old_mode = Liquid::Template.error_mode
-      Liquid::Template.error_mode = mode
-      yield
-    ensure
-      Liquid::Template.error_mode = old_mode
-    end
-  end
-end
-
-class ThingWithToLiquid
-  def to_liquid
-    'foobar'
-  end
-end

data/test/unit/block_unit_test.rb

@@ -1,55 +0,0 @@
-require 'test_helper'
-
-class BlockUnitTest < Minitest::Test
-  include Liquid
-
-  def test_blankspace
-    template = Liquid::Template.parse("  ")
-    assert_equal ["  "], template.root.nodelist
-  end
-
-  def test_variable_beginning
-    template = Liquid::Template.parse("{{funk}}  ")
-    assert_equal 2, template.root.nodelist.size
-    assert_equal Variable, template.root.nodelist[0].class
-    assert_equal String, template.root.nodelist[1].class
-  end
-
-  def test_variable_end
-    template = Liquid::Template.parse("  {{funk}}")
-    assert_equal 2, template.root.nodelist.size
-    assert_equal String, template.root.nodelist[0].class
-    assert_equal Variable, template.root.nodelist[1].class
-  end
-
-  def test_variable_middle
-    template = Liquid::Template.parse("  {{funk}}  ")
-    assert_equal 3, template.root.nodelist.size
-    assert_equal String, template.root.nodelist[0].class
-    assert_equal Variable, template.root.nodelist[1].class
-    assert_equal String, template.root.nodelist[2].class
-  end
-
-  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)
-  end
-
-  def test_with_block
-    template = Liquid::Template.parse("  {% comment %} {% endcomment %} ")
-    assert_equal [String, Comment, String], block_types(template.root.nodelist)
-    assert_equal 3, template.root.nodelist.size
-  end
-
-  def test_with_custom_tag
-    Liquid::Template.register_tag("testtag", Block)
-    assert Liquid::Template.parse( "{% testtag %} {% endtesttag %}")
-  end
-
-  private
-    def block_types(nodelist)
-      nodelist.collect { |node| node.class }
-    end
-end # VariableTest