+ {% for item in items limit:page_size offset:start %}
+
{{ item }}
+ {% endfor %}
+
+
+
+ LIQUID
+
+ template = Liquid::Template.parse(source)
+ data = {
+ "items" => %w[A B C D E F G H I],
+ "current_page" => 2,
+ }
+
+ output = template.render!(data)
+ assert_includes(output, "
D
")
+ assert_includes(output, "
E
")
+ assert_includes(output, "
F
")
+ assert_includes(output, "Previous")
+ assert_includes(output, "Next")
+ end
+
+ #-----------------------------------------------------------------------------
+ # Forloop Variables
+ #-----------------------------------------------------------------------------
+
+ def test_forloop_all_variables
+ source = <<~LIQUID
+ {% for item in items %}
+ index: {{ forloop.index }}
+ index0: {{ forloop.index0 }}
+ rindex: {{ forloop.rindex }}
+ rindex0: {{ forloop.rindex0 }}
+ first: {{ forloop.first }}
+ last: {{ forloop.last }}
+ length: {{ forloop.length }}
+ ---
+ {% endfor %}
+ LIQUID
+
+ template = Liquid::Template.parse(source)
+ output = template.render!({ "items" => %w[a b c] })
+
+ # First item
+ assert_includes(output, "index: 1")
+ assert_includes(output, "index0: 0")
+ assert_includes(output, "first: true")
+
+ # Last item
+ assert_includes(output, "index: 3")
+ assert_includes(output, "last: true")
+ assert_includes(output, "rindex: 1")
+ assert_includes(output, "rindex0: 0")
+
+ # Length
+ assert_includes(output, "length: 3")
+ end
+
+ def test_nested_forloop_with_parentloop
+ source = <<~LIQUID
+ {% for outer in (1..2) %}
+ outer.index: {{ forloop.index }}
+ {% for inner in (1..2) %}
+ inner.index: {{ forloop.index }}
+ parentloop.index: {{ forloop.parentloop.index }}
+ {% endfor %}
+ {% endfor %}
+ LIQUID
+
+ template = Liquid::Template.parse(source)
+ output = template.render!
+
+ assert_includes(output, "outer.index: 1")
+ assert_includes(output, "outer.index: 2")
+ assert_includes(output, "inner.index: 1")
+ assert_includes(output, "parentloop.index: 1")
+ assert_includes(output, "parentloop.index: 2")
+ end
+
+ #-----------------------------------------------------------------------------
+ # Edge Cases
+ #-----------------------------------------------------------------------------
+
+ def test_empty_blocks_render_correctly
+ source = <<~LIQUID
+ {% if true %}{% endif %}{% for i in (1..0) %}{% endfor %}{% case x %}{% endcase %}
+ LIQUID
+ template = Liquid::Template.parse(source)
+ assert_equal("", template.render!.strip)
+ end
+
+ def test_mixed_content_and_tags
+ source = "Hello {% if true %}beautiful{% endif %} world{{ '!' }}"
+ template = Liquid::Template.parse(source)
+ assert_equal("Hello beautiful world!", template.render!)
+ end
+
+ def test_unicode_in_templates
+ source = <<~LIQUID
+ {% assign greeting = "Hallo" %}
+ {{ greeting }}, {{ name }}! Today is {{ day }}.
+ LIQUID
+
+ template = Liquid::Template.parse(source)
+ output = template.render!({ "name" => "Muller", "day" => "Montag" })
+ assert_includes(output, "Hallo")
+ assert_includes(output, "Muller")
+ end
+
+ def test_special_characters_in_strings
+ # Liquid doesn't support escape sequences in strings, so we use single quotes
+ source = "{% assign msg = '<>&' %}{{ msg | escape }}"
+ template = Liquid::Template.parse(source)
+ output = template.render!
+ assert_includes(output, "<")
+ assert_includes(output, ">")
+ assert_includes(output, "&")
+ end
+end
diff --git a/test/unit/template_parser_test.rb b/test/unit/template_parser_test.rb
new file mode 100644
index 00000000..0280a896
--- /dev/null
+++ b/test/unit/template_parser_test.rb
@@ -0,0 +1,411 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Tests for the C template parser implementation
+# This file tests parsing of all Liquid control flow tags
+class TemplateParserTest < Minitest::Test
+ #-----------------------------------------------------------------------------
+ # If/Elsif/Else Tag Tests
+ #-----------------------------------------------------------------------------
+
+ def test_parse_simple_if
+ template = Liquid::Template.parse("{% if true %}yes{% endif %}")
+ assert_equal("yes", template.render!)
+ end
+
+ def test_parse_if_else
+ template = Liquid::Template.parse("{% if false %}yes{% else %}no{% endif %}")
+ assert_equal("no", template.render!)
+ end
+
+ def test_parse_if_elsif_else
+ source = <<~LIQUID
+ {% if x == 1 %}one{% elsif x == 2 %}two{% else %}other{% endif %}
+ LIQUID
+ template = Liquid::Template.parse(source.strip)
+
+ assert_equal("one", template.render!({ "x" => 1 }))
+ assert_equal("two", template.render!({ "x" => 2 }))
+ assert_equal("other", template.render!({ "x" => 3 }))
+ end
+
+ def test_parse_if_with_and_or_operators
+ template = Liquid::Template.parse("{% if a and b %}both{% endif %}")
+ assert_equal("both", template.render!({ "a" => true, "b" => true }))
+ assert_equal("", template.render!({ "a" => true, "b" => false }))
+
+ template = Liquid::Template.parse("{% if a or b %}either{% endif %}")
+ assert_equal("either", template.render!({ "a" => false, "b" => true }))
+ assert_equal("", template.render!({ "a" => false, "b" => false }))
+ end
+
+ def test_parse_if_with_comparison_operators
+ operators = {
+ "==" => [1, 1, true],
+ "!=" => [1, 2, true],
+ "<" => [1, 2, true],
+ ">" => [2, 1, true],
+ "<=" => [1, 1, true],
+ ">=" => [2, 1, true],
+ "contains" => ["hello world", "world", true],
+ }
+
+ operators.each do |op, (a, b, expected_true)|
+ template = Liquid::Template.parse("{% if a #{op} b %}yes{% endif %}")
+ result = template.render!({ "a" => a, "b" => b })
+ if expected_true
+ assert_equal("yes", result, "Operator #{op} failed")
+ else
+ assert_equal("", result, "Operator #{op} failed")
+ end
+ end
+ end
+
+ def test_parse_nested_if
+ source = <<~LIQUID
+ {% if outer %}{% if inner %}both{% else %}outer_only{% endif %}{% endif %}
+ LIQUID
+ template = Liquid::Template.parse(source.strip)
+
+ assert_equal("both", template.render!({ "outer" => true, "inner" => true }))
+ assert_equal("outer_only", template.render!({ "outer" => true, "inner" => false }))
+ assert_equal("", template.render!({ "outer" => false, "inner" => true }))
+ end
+
+ #-----------------------------------------------------------------------------
+ # Unless Tag Tests
+ #-----------------------------------------------------------------------------
+
+ def test_parse_simple_unless
+ template = Liquid::Template.parse("{% unless false %}yes{% endunless %}")
+ assert_equal("yes", template.render!)
+ end
+
+ def test_parse_unless_else
+ template = Liquid::Template.parse("{% unless true %}no{% else %}yes{% endunless %}")
+ assert_equal("yes", template.render!)
+ end
+
+ #-----------------------------------------------------------------------------
+ # Case/When Tag Tests
+ #-----------------------------------------------------------------------------
+
+ def test_parse_simple_case
+ source = <<~LIQUID
+ {% case x %}{% when 1 %}one{% when 2 %}two{% endcase %}
+ LIQUID
+ template = Liquid::Template.parse(source.strip)
+
+ assert_equal("one", template.render!({ "x" => 1 }))
+ assert_equal("two", template.render!({ "x" => 2 }))
+ assert_equal("", template.render!({ "x" => 3 }))
+ end
+
+ def test_parse_case_with_else
+ source = <<~LIQUID
+ {% case x %}{% when 1 %}one{% else %}other{% endcase %}
+ LIQUID
+ template = Liquid::Template.parse(source.strip)
+
+ assert_equal("one", template.render!({ "x" => 1 }))
+ assert_equal("other", template.render!({ "x" => 2 }))
+ end
+
+ def test_parse_case_with_multiple_values
+ source = <<~LIQUID
+ {% case x %}{% when 1, 2, 3 %}small{% when 4, 5 %}medium{% endcase %}
+ LIQUID
+ template = Liquid::Template.parse(source.strip)
+
+ assert_equal("small", template.render!({ "x" => 2 }))
+ assert_equal("medium", template.render!({ "x" => 4 }))
+ end
+
+ #-----------------------------------------------------------------------------
+ # For Loop Tag Tests
+ #-----------------------------------------------------------------------------
+
+ def test_parse_simple_for
+ template = Liquid::Template.parse("{% for i in (1..3) %}{{ i }}{% endfor %}")
+ assert_equal("123", template.render!)
+ end
+
+ def test_parse_for_with_array
+ template = Liquid::Template.parse("{% for item in items %}{{ item }},{% endfor %}")
+ assert_equal("a,b,c,", template.render!({ "items" => %w[a b c] }))
+ end
+
+ def test_parse_for_with_limit
+ template = Liquid::Template.parse("{% for i in (1..5) limit:2 %}{{ i }}{% endfor %}")
+ assert_equal("12", template.render!)
+ end
+
+ def test_parse_for_with_offset
+ template = Liquid::Template.parse("{% for i in (1..5) offset:2 %}{{ i }}{% endfor %}")
+ assert_equal("345", template.render!)
+ end
+
+ def test_parse_for_with_reversed
+ template = Liquid::Template.parse("{% for i in (1..3) reversed %}{{ i }}{% endfor %}")
+ assert_equal("321", template.render!)
+ end
+
+ def test_parse_for_with_else
+ template = Liquid::Template.parse("{% for item in items %}{{ item }}{% else %}empty{% endfor %}")
+ assert_equal("empty", template.render!({ "items" => [] }))
+ end
+
+ def test_parse_for_forloop_variables
+ source = <<~LIQUID
+ {% for i in (1..3) %}{{ forloop.index }}-{{ forloop.first }}-{{ forloop.last }},{% endfor %}
+ LIQUID
+ template = Liquid::Template.parse(source.strip)
+ assert_equal("1-true-false,2-false-false,3-false-true,", template.render!)
+ end
+
+ def test_parse_nested_for
+ source = <<~LIQUID
+ {% for i in (1..2) %}{% for j in (1..2) %}({{ i }},{{ j }}){% endfor %}{% endfor %}
+ LIQUID
+ template = Liquid::Template.parse(source.strip)
+ assert_equal("(1,1)(1,2)(2,1)(2,2)", template.render!)
+ end
+
+ def test_parse_for_with_break
+ template = Liquid::Template.parse("{% for i in (1..5) %}{% if i == 3 %}{% break %}{% endif %}{{ i }}{% endfor %}")
+ assert_equal("12", template.render!)
+ end
+
+ def test_parse_for_with_continue
+ template = Liquid::Template.parse("{% for i in (1..5) %}{% if i == 3 %}{% continue %}{% endif %}{{ i }}{% endfor %}")
+ assert_equal("1245", template.render!)
+ end
+
+ #-----------------------------------------------------------------------------
+ # Tablerow Tag Tests
+ #-----------------------------------------------------------------------------
+
+ def test_parse_tablerow
+ template = Liquid::Template.parse("{% tablerow i in (1..3) %}{{ i }}{% endtablerow %}")
+ output = template.render!
+ assert_includes(output, " [
+ {
+ "name" => "Electronics",
+ "products" => [
+ { "name" => "Phone", "price" => 999, "in_stock" => true },
+ { "name" => "Laptop", "price" => 1999, "in_stock" => false },
+ ],
+ },
+ {
+ "name" => "Books",
+ "products" => [
+ { "name" => "Ruby Guide", "price" => 49, "in_stock" => true },
+ ],
+ },
+ ],
+ }
+
+ output = template.render!(data)
+ assert_includes(output, "Electronics")
+ assert_includes(output, "Phone")
+ assert_includes(output, "$999")
+ refute_includes(output, "Laptop") # out of stock
+ assert_includes(output, "Ruby Guide")
+ end
+
+ def test_parse_deeply_nested_if
+ source = <<~LIQUID
+ {% if a %}
+ {% if b %}
+ {% if c %}
+ {% if d %}
+ deep
+ {% endif %}
+ {% endif %}
+ {% endif %}
+ {% endif %}
+ LIQUID
+ template = Liquid::Template.parse(source)
+
+ assert_includes(template.render!({ "a" => true, "b" => true, "c" => true, "d" => true }), "deep")
+ refute_includes(template.render!({ "a" => true, "b" => true, "c" => true, "d" => false }), "deep")
+ end
+
+ def test_parse_mixed_control_flow
+ source = <<~LIQUID
+ {% case type %}
+ {% when 'list' %}
+ {% for item in items %}
+ {% if item.visible %}{{ item.name }}{% endif %}
+ {% endfor %}
+ {% when 'count' %}
+ {{ items | size }}
+ {% else %}
+ unknown
+ {% endcase %}
+ LIQUID
+ template = Liquid::Template.parse(source)
+
+ list_data = {
+ "type" => "list",
+ "items" => [
+ { "name" => "A", "visible" => true },
+ { "name" => "B", "visible" => false },
+ { "name" => "C", "visible" => true },
+ ],
+ }
+ output = template.render!(list_data)
+ assert_includes(output, "A")
+ assert_includes(output, "C")
+ refute_includes(output, "B")
+
+ count_data = { "type" => "count", "items" => [1, 2, 3] }
+ assert_includes(template.render!(count_data), "3")
+
+ assert_includes(template.render!({ "type" => "other" }), "unknown")
+ end
+end
diff --git a/test/unit/template_parser_vm_opcodes_test.rb b/test/unit/template_parser_vm_opcodes_test.rb
new file mode 100644
index 00000000..43e9287c
--- /dev/null
+++ b/test/unit/template_parser_vm_opcodes_test.rb
@@ -0,0 +1,410 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Tests for new VM opcodes added for the C template parser
+# Based on parser_design.md opcode specifications
+class TemplateParserVmOpcodesTest < Minitest::Test
+ #-----------------------------------------------------------------------------
+ # Comparison Opcodes (OP_CMP_*)
+ #-----------------------------------------------------------------------------
+
+ def test_comparison_equal
+ template = Liquid::Template.parse("{% if a == b %}yes{% endif %}")
+ assert_equal("yes", template.render!({ "a" => 1, "b" => 1 }))
+ assert_equal("", template.render!({ "a" => 1, "b" => 2 }))
+ end
+
+ def test_comparison_not_equal
+ template = Liquid::Template.parse("{% if a != b %}yes{% endif %}")
+ assert_equal("yes", template.render!({ "a" => 1, "b" => 2 }))
+ assert_equal("", template.render!({ "a" => 1, "b" => 1 }))
+ end
+
+ def test_comparison_less_than
+ template = Liquid::Template.parse("{% if a < b %}yes{% endif %}")
+ assert_equal("yes", template.render!({ "a" => 1, "b" => 2 }))
+ assert_equal("", template.render!({ "a" => 2, "b" => 1 }))
+ assert_equal("", template.render!({ "a" => 1, "b" => 1 }))
+ end
+
+ def test_comparison_greater_than
+ template = Liquid::Template.parse("{% if a > b %}yes{% endif %}")
+ assert_equal("yes", template.render!({ "a" => 2, "b" => 1 }))
+ assert_equal("", template.render!({ "a" => 1, "b" => 2 }))
+ assert_equal("", template.render!({ "a" => 1, "b" => 1 }))
+ end
+
+ def test_comparison_less_than_or_equal
+ template = Liquid::Template.parse("{% if a <= b %}yes{% endif %}")
+ assert_equal("yes", template.render!({ "a" => 1, "b" => 2 }))
+ assert_equal("yes", template.render!({ "a" => 1, "b" => 1 }))
+ assert_equal("", template.render!({ "a" => 2, "b" => 1 }))
+ end
+
+ def test_comparison_greater_than_or_equal
+ template = Liquid::Template.parse("{% if a >= b %}yes{% endif %}")
+ assert_equal("yes", template.render!({ "a" => 2, "b" => 1 }))
+ assert_equal("yes", template.render!({ "a" => 1, "b" => 1 }))
+ assert_equal("", template.render!({ "a" => 1, "b" => 2 }))
+ end
+
+ def test_comparison_contains
+ template = Liquid::Template.parse("{% if a contains b %}yes{% endif %}")
+ assert_equal("yes", template.render!({ "a" => "hello world", "b" => "world" }))
+ assert_equal("", template.render!({ "a" => "hello world", "b" => "foo" }))
+ # Array contains
+ assert_equal("yes", template.render!({ "a" => [1, 2, 3], "b" => 2 }))
+ assert_equal("", template.render!({ "a" => [1, 2, 3], "b" => 4 }))
+ end
+
+ #-----------------------------------------------------------------------------
+ # Liquid Truthiness (OP_TRUTHY, OP_NOT)
+ #-----------------------------------------------------------------------------
+
+ def test_liquid_truthiness_nil_is_falsy
+ template = Liquid::Template.parse("{% if x %}yes{% else %}no{% endif %}")
+ assert_equal("no", template.render!({ "x" => nil }))
+ end
+
+ def test_liquid_truthiness_false_is_falsy
+ template = Liquid::Template.parse("{% if x %}yes{% else %}no{% endif %}")
+ assert_equal("no", template.render!({ "x" => false }))
+ end
+
+ def test_liquid_truthiness_zero_is_truthy
+ template = Liquid::Template.parse("{% if x %}yes{% else %}no{% endif %}")
+ assert_equal("yes", template.render!({ "x" => 0 }))
+ end
+
+ def test_liquid_truthiness_empty_string_is_truthy
+ template = Liquid::Template.parse("{% if x %}yes{% else %}no{% endif %}")
+ assert_equal("yes", template.render!({ "x" => "" }))
+ end
+
+ def test_liquid_truthiness_empty_array_is_truthy
+ template = Liquid::Template.parse("{% if x %}yes{% else %}no{% endif %}")
+ assert_equal("yes", template.render!({ "x" => [] }))
+ end
+
+ #-----------------------------------------------------------------------------
+ # Logical Operators (and/or)
+ #-----------------------------------------------------------------------------
+
+ def test_logical_and
+ template = Liquid::Template.parse("{% if a and b %}yes{% endif %}")
+ assert_equal("yes", template.render!({ "a" => true, "b" => true }))
+ assert_equal("", template.render!({ "a" => true, "b" => false }))
+ assert_equal("", template.render!({ "a" => false, "b" => true }))
+ assert_equal("", template.render!({ "a" => false, "b" => false }))
+ end
+
+ def test_logical_or
+ template = Liquid::Template.parse("{% if a or b %}yes{% endif %}")
+ assert_equal("yes", template.render!({ "a" => true, "b" => true }))
+ assert_equal("yes", template.render!({ "a" => true, "b" => false }))
+ assert_equal("yes", template.render!({ "a" => false, "b" => true }))
+ assert_equal("", template.render!({ "a" => false, "b" => false }))
+ end
+
+ def test_logical_chained_and
+ template = Liquid::Template.parse("{% if a and b and c %}yes{% endif %}")
+ assert_equal("yes", template.render!({ "a" => true, "b" => true, "c" => true }))
+ assert_equal("", template.render!({ "a" => true, "b" => true, "c" => false }))
+ end
+
+ def test_logical_chained_or
+ template = Liquid::Template.parse("{% if a or b or c %}yes{% endif %}")
+ assert_equal("", template.render!({ "a" => false, "b" => false, "c" => false }))
+ assert_equal("yes", template.render!({ "a" => false, "b" => false, "c" => true }))
+ end
+
+ def test_logical_mixed_and_or
+ # Liquid evaluates left to right, no precedence
+ # a or b and c => a or (b and c) in terms of short-circuit evaluation
+ template = Liquid::Template.parse("{% if a or b and c %}yes{% endif %}")
+ # If 'a' is true, short-circuits to true
+ assert_equal("yes", template.render!({ "a" => true, "b" => false, "c" => true }))
+ assert_equal("yes", template.render!({ "a" => true, "b" => false, "c" => false }))
+ # If 'a' is false, evaluates 'b and c'
+ assert_equal("yes", template.render!({ "a" => false, "b" => true, "c" => true }))
+ assert_equal("", template.render!({ "a" => false, "b" => true, "c" => false }))
+ end
+
+ #-----------------------------------------------------------------------------
+ # Jump Opcodes (OP_JUMP, OP_JUMP_IF_FALSE, OP_JUMP_IF_TRUE)
+ #-----------------------------------------------------------------------------
+
+ def test_jump_forward_in_if
+ # Tests that the parser generates correct forward jumps
+ template = Liquid::Template.parse("{% if false %}skip{% endif %}after")
+ assert_equal("after", template.render!)
+ end
+
+ def test_jump_to_else
+ template = Liquid::Template.parse("{% if false %}then{% else %}else{% endif %}after")
+ assert_equal("elseafter", template.render!)
+ end
+
+ def test_jump_in_elsif_chain
+ source = "{% if x == 1 %}one{% elsif x == 2 %}two{% elsif x == 3 %}three{% else %}other{% endif %}"
+ template = Liquid::Template.parse(source)
+ assert_equal("one", template.render!({ "x" => 1 }))
+ assert_equal("two", template.render!({ "x" => 2 }))
+ assert_equal("three", template.render!({ "x" => 3 }))
+ assert_equal("other", template.render!({ "x" => 4 }))
+ end
+
+ def test_wide_jump_for_large_template
+ # Generate a template large enough to require wide jumps (>256 bytes)
+ large_content = "x" * 300
+ template = Liquid::Template.parse("{% if false %}#{large_content}{% endif %}after")
+ assert_equal("after", template.render!)
+ end
+
+ #-----------------------------------------------------------------------------
+ # For Loop Opcodes (OP_FOR_INIT, OP_FOR_NEXT, OP_FOR_CLEANUP)
+ #-----------------------------------------------------------------------------
+
+ def test_for_loop_basic_iteration
+ template = Liquid::Template.parse("{% for i in items %}{{ i }}{% endfor %}")
+ assert_equal("abc", template.render!({ "items" => %w[a b c] }))
+ end
+
+ def test_for_loop_with_range
+ template = Liquid::Template.parse("{% for i in (1..3) %}{{ i }}{% endfor %}")
+ assert_equal("123", template.render!)
+ end
+
+ def test_for_loop_empty_collection
+ template = Liquid::Template.parse("{% for i in items %}{{ i }}{% else %}empty{% endfor %}")
+ assert_equal("empty", template.render!({ "items" => [] }))
+ end
+
+ def test_for_loop_with_limit
+ template = Liquid::Template.parse("{% for i in items limit:2 %}{{ i }}{% endfor %}")
+ assert_equal("ab", template.render!({ "items" => %w[a b c d] }))
+ end
+
+ def test_for_loop_with_offset
+ template = Liquid::Template.parse("{% for i in items offset:2 %}{{ i }}{% endfor %}")
+ assert_equal("cd", template.render!({ "items" => %w[a b c d] }))
+ end
+
+ def test_for_loop_with_limit_and_offset
+ template = Liquid::Template.parse("{% for i in items limit:2 offset:1 %}{{ i }}{% endfor %}")
+ assert_equal("bc", template.render!({ "items" => %w[a b c d e] }))
+ end
+
+ def test_for_loop_reversed
+ template = Liquid::Template.parse("{% for i in items reversed %}{{ i }}{% endfor %}")
+ assert_equal("cba", template.render!({ "items" => %w[a b c] }))
+ end
+
+ def test_for_loop_forloop_index
+ template = Liquid::Template.parse("{% for i in items %}{{ forloop.index }}{% endfor %}")
+ assert_equal("123", template.render!({ "items" => %w[a b c] }))
+ end
+
+ def test_for_loop_forloop_index0
+ template = Liquid::Template.parse("{% for i in items %}{{ forloop.index0 }}{% endfor %}")
+ assert_equal("012", template.render!({ "items" => %w[a b c] }))
+ end
+
+ def test_for_loop_forloop_rindex
+ template = Liquid::Template.parse("{% for i in items %}{{ forloop.rindex }}{% endfor %}")
+ assert_equal("321", template.render!({ "items" => %w[a b c] }))
+ end
+
+ def test_for_loop_forloop_rindex0
+ template = Liquid::Template.parse("{% for i in items %}{{ forloop.rindex0 }}{% endfor %}")
+ assert_equal("210", template.render!({ "items" => %w[a b c] }))
+ end
+
+ def test_for_loop_forloop_first
+ template = Liquid::Template.parse("{% for i in items %}{{ forloop.first }}{% endfor %}")
+ assert_equal("truefalsefalse", template.render!({ "items" => %w[a b c] }))
+ end
+
+ def test_for_loop_forloop_last
+ template = Liquid::Template.parse("{% for i in items %}{{ forloop.last }}{% endfor %}")
+ assert_equal("falsefalsetrue", template.render!({ "items" => %w[a b c] }))
+ end
+
+ def test_for_loop_forloop_length
+ template = Liquid::Template.parse("{% for i in items %}{{ forloop.length }}{% endfor %}")
+ assert_equal("333", template.render!({ "items" => %w[a b c] }))
+ end
+
+ #-----------------------------------------------------------------------------
+ # Break and Continue Opcodes (OP_BREAK, OP_CONTINUE)
+ #-----------------------------------------------------------------------------
+
+ def test_break_in_loop
+ template = Liquid::Template.parse("{% for i in (1..5) %}{% if i == 3 %}{% break %}{% endif %}{{ i }}{% endfor %}")
+ assert_equal("12", template.render!)
+ end
+
+ def test_continue_in_loop
+ template = Liquid::Template.parse("{% for i in (1..5) %}{% if i == 3 %}{% continue %}{% endif %}{{ i }}{% endfor %}")
+ assert_equal("1245", template.render!)
+ end
+
+ def test_break_in_nested_loop
+ source = <<~LIQUID
+ {% for i in (1..3) %}{% for j in (1..3) %}{% if j == 2 %}{% break %}{% endif %}{{ j }}{% endfor %}|{% endfor %}
+ LIQUID
+ template = Liquid::Template.parse(source.strip)
+ assert_equal("1|1|1|", template.render!)
+ end
+
+ def test_continue_in_nested_loop
+ source = <<~LIQUID
+ {% for i in (1..2) %}{% for j in (1..3) %}{% if j == 2 %}{% continue %}{% endif %}{{ j }}{% endfor %}|{% endfor %}
+ LIQUID
+ template = Liquid::Template.parse(source.strip)
+ assert_equal("13|13|", template.render!)
+ end
+
+ #-----------------------------------------------------------------------------
+ # Variable Opcodes (OP_ASSIGN, OP_CAPTURE_START, OP_CAPTURE_END)
+ #-----------------------------------------------------------------------------
+
+ def test_assign_simple
+ template = Liquid::Template.parse("{% assign x = 42 %}{{ x }}")
+ assert_equal("42", template.render!)
+ end
+
+ def test_assign_with_expression
+ template = Liquid::Template.parse("{% assign x = a | plus: b %}{{ x }}")
+ assert_equal("5", template.render!({ "a" => 2, "b" => 3 }))
+ end
+
+ def test_assign_overwrites
+ template = Liquid::Template.parse("{% assign x = 1 %}{% assign x = 2 %}{{ x }}")
+ assert_equal("2", template.render!)
+ end
+
+ def test_capture_simple
+ template = Liquid::Template.parse("{% capture x %}hello{% endcapture %}{{ x }}")
+ assert_equal("hello", template.render!)
+ end
+
+ def test_capture_with_expressions
+ template = Liquid::Template.parse("{% capture x %}{{ a }} and {{ b }}{% endcapture %}{{ x }}")
+ assert_equal("1 and 2", template.render!({ "a" => 1, "b" => 2 }))
+ end
+
+ def test_capture_with_control_flow
+ source = "{% capture x %}{% for i in (1..3) %}{{ i }}{% endfor %}{% endcapture %}{{ x }}"
+ template = Liquid::Template.parse(source)
+ assert_equal("123", template.render!)
+ end
+
+ #-----------------------------------------------------------------------------
+ # Counter Opcodes (OP_INCREMENT, OP_DECREMENT)
+ #-----------------------------------------------------------------------------
+
+ def test_increment_basic
+ template = Liquid::Template.parse("{% increment x %}{% increment x %}{% increment x %}")
+ assert_equal("012", template.render!)
+ end
+
+ def test_decrement_basic
+ template = Liquid::Template.parse("{% decrement x %}{% decrement x %}{% decrement x %}")
+ assert_equal("-1-2-3", template.render!)
+ end
+
+ def test_increment_independent_of_assign
+ template = Liquid::Template.parse("{% assign x = 10 %}{% increment x %}{{ x }}")
+ assert_equal("010", template.render!)
+ end
+
+ def test_decrement_independent_of_assign
+ template = Liquid::Template.parse("{% assign x = 10 %}{% decrement x %}{{ x }}")
+ assert_equal("-110", template.render!)
+ end
+
+ #-----------------------------------------------------------------------------
+ # Cycle Opcode (OP_CYCLE)
+ #-----------------------------------------------------------------------------
+
+ def test_cycle_basic
+ template = Liquid::Template.parse("{% for i in (1..5) %}{% cycle 'a', 'b', 'c' %}{% endfor %}")
+ assert_equal("abcab", template.render!)
+ end
+
+ def test_cycle_with_group
+ source = <<~LIQUID
+ {% for i in (1..4) %}{% cycle 'g1': 'a', 'b' %}{% cycle 'g2': 'x', 'y' %}{% endfor %}
+ LIQUID
+ template = Liquid::Template.parse(source.strip)
+ # Each named group cycles independently through its values
+ assert_equal("axbyaxby", template.render!)
+ end
+
+ def test_cycle_persists_across_loops
+ source = <<~LIQUID
+ {% for i in (1..2) %}{% cycle 'a', 'b', 'c' %}{% endfor %}|{% for i in (1..2) %}{% cycle 'a', 'b', 'c' %}{% endfor %}
+ LIQUID
+ template = Liquid::Template.parse(source.strip)
+ assert_equal("ab|ca", template.render!)
+ end
+
+ #-----------------------------------------------------------------------------
+ # Case Opcode (OP_CASE_EQ)
+ #-----------------------------------------------------------------------------
+
+ def test_case_basic
+ source = "{% case x %}{% when 1 %}one{% when 2 %}two{% else %}other{% endcase %}"
+ template = Liquid::Template.parse(source)
+ assert_equal("one", template.render!({ "x" => 1 }))
+ assert_equal("two", template.render!({ "x" => 2 }))
+ assert_equal("other", template.render!({ "x" => 3 }))
+ end
+
+ def test_case_with_strings
+ source = '{% case x %}{% when "a" %}A{% when "b" %}B{% endcase %}'
+ template = Liquid::Template.parse(source)
+ assert_equal("A", template.render!({ "x" => "a" }))
+ assert_equal("B", template.render!({ "x" => "b" }))
+ end
+
+ def test_case_with_multiple_when_values
+ source = "{% case x %}{% when 1, 2, 3 %}small{% when 4, 5 %}medium{% endcase %}"
+ template = Liquid::Template.parse(source)
+ assert_equal("small", template.render!({ "x" => 1 }))
+ assert_equal("small", template.render!({ "x" => 2 }))
+ assert_equal("medium", template.render!({ "x" => 4 }))
+ assert_equal("", template.render!({ "x" => 6 }))
+ end
+
+ #-----------------------------------------------------------------------------
+ # Tablerow Opcodes (OP_TABLEROW_*)
+ #-----------------------------------------------------------------------------
+
+ def test_tablerow_basic
+ template = Liquid::Template.parse("{% tablerow i in (1..3) %}{{ i }}{% endtablerow %}")
+ output = template.render!
+ assert_includes(output, "")
+ assert_includes(output, "")
+ end
+
+ def test_tablerow_with_cols
+ template = Liquid::Template.parse("{% tablerow i in (1..6) cols:3 %}{{ i }}{% endtablerow %}")
+ output = template.render!
+ # Should have 2 rows
+ assert_equal(2, output.scan(" %w[a b c d e] })
+ assert_includes(output, "b")
+ assert_includes(output, "c")
+ refute_includes(output, ">a<")
+ refute_includes(output, ">d<")
+ end
+end