golden_liquid.yaml

version: 0.23.0
test_groups:
- name: liquid.golden.abs_filter
  tests:
  - name: negative float
    template: '{{ -5.4 | abs }}'
    want: '5.4'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: negative integer
    template: '{{ -5 | abs }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: negative string float
    template: '{{ ''-5.1'' | abs }}'
    want: '5.1'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: negative string integer
    template: '{{ ''-5'' | abs }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string, int or float
    template: '{{ a | abs }}'
    want: '0'
    context:
      a: {}
    partials: {}
    error: false
    strict: false
  - name: positive float
    template: '{{ 5.4 | abs }}'
    want: '5.4'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive integer
    template: '{{ 5 | abs }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive string float
    template: '{{ ''5.1'' | abs }}'
    want: '5.1'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive string integer
    template: '{{ ''5'' | abs }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string not a number
    template: '{{ ''hello'' | abs }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | abs }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ -3 | abs: 1 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: zero
    template: '{{ 0 | abs }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.append_filter
  tests:
  - name: argument not a string
    template: '{{ "hello" | append: 5 }}'
    want: hello5
    context: {}
    partials: {}
    error: false
    strict: false
  - name: concat
    template: '{{ "hello" | append: "there" }}'
    want: hellothere
    context: {}
    partials: {}
    error: false
    strict: false
  - name: missing argument
    template: '{{ "hello" | append }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: not a string
    template: '{{ 5 | append: ''there'' }}'
    want: 5there
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ "hello" | append: "how", "are", "you" }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined argument
    template: '{{ "hi" | append: nosuchthing }}'
    want: hi
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | append: "hi" }}'
    want: hi
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.assign_tag
  tests:
  - name: assign a filtered literal
    template: '{% assign foo = ''foo'' | upcase %}{{ foo }}'
    want: FOO
    context: {}
    partials: {}
    error: false
    strict: false
  - name: assign a range literal
    template: '{% assign foo = (1..3) %}{{ foo | join: ''#'' }}'
    want: 1#2#3
    context: {}
    partials: {}
    error: false
    strict: false
  - name: assign an existing array
    template: '{% assign foo = bar %}{{ foo[0] }}/{{ foo[1] }}'
    want: a/b
    context:
      bar:
      - a
      - b
      - c
    partials: {}
    error: false
    strict: false
  - name: assign an item from an existing object with quoted notation
    template: '{% assign foo = bar[''baz''] %}{{ foo }}'
    want: hello
    context:
      bar:
        baz: hello
    partials: {}
    error: false
    strict: false
  - name: assign to variable with a hyphen
    template: '{% assign some-thing = ''foo'' %}{{ some-thing }}'
    want: foo
    context: {}
    partials: {}
    error: false
    strict: false
  - name: assign with quoted notation and extra whitespace
    template: '{% assign foo = bar[ ''baz''  ] %}{{ foo }}'
    want: hello
    context:
      bar:
        baz: hello
    partials: {}
    error: false
    strict: false
  - name: local variables shadow global variables
    template: '{{ foo }}{% assign foo = ''foo'' | upcase %}{{ foo }}'
    want: barFOO
    context:
      foo: bar
    partials: {}
    error: false
    strict: false
- name: liquid.golden.at_least_filter
  tests:
  - name: argument string not a number
    template: '{{ -1 | at_least: "abc" }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: left value not a number
    template: '{{ "abc" | at_least: 2 }}'
    want: '2'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: left value not a number negative argument
    template: '{{ "abc" | at_least: -2 }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: missing arg
    template: '{{ 5 | at_least }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: negative integer < arg
    template: '{{ -8 | at_least: 5 }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive float < arg
    template: '{{ 5.4 | at_least: 8.9 }}'
    want: '8.9'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive float > arg
    template: '{{ 8.4 | at_least: 5.9 }}'
    want: '8.4'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive integer < arg
    template: '{{ 5 | at_least: 8 }}'
    want: '8'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive integer == arg
    template: '{{ 5 | at_least: 5 }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive integer > arg
    template: '{{ 8 | at_least: 5 }}'
    want: '8'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive string > arg
    template: '{{ "9" | at_least: 8 }}'
    want: '9'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many args
    template: '{{ 5 | at_least: 1, 2}}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined argument
    template: '{{ 5 | at_least: nosuchthing }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | at_least: 5 }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.at_most_filter
  tests:
  - name: left value not a number
    template: '{{ "abc" | at_most: -2 }}'
    want: '-2'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: missing arg
    template: '{{ 5 | at_most }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: negative integer < arg
    template: '{{ -8 | at_most: 5 }}'
    want: '-8'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive float < arg
    template: '{{ 5.4 | at_most: 8.9 }}'
    want: '5.4'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive float > arg
    template: '{{ 8.4 | at_most: 5.9 }}'
    want: '5.9'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive integer < arg
    template: '{{ 5 | at_most: 8 }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive integer == arg
    template: '{{ 5 | at_most: 5 }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive integer > arg
    template: '{{ 8 | at_most: 5 }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive string > arg
    template: '{{ "9" | at_most: 8 }}'
    want: '8'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many args
    template: '{{ 5 | at_most: 1, 2}}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined argument
    template: '{{ 5 | at_most: nosuchthing }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | at_most: 5 }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.base64_decode_filter
  tests:
  - name: from string
    template: '{{ "XyMvLg==" | base64_decode }}'
    want: _#/.
    context: {}
    partials: {}
    error: false
    strict: false
  - name: from string with URL unsafe
    template: '{{ a | base64_decode }}'
    want: abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 !@#$%^&*()-=_+/?.:;[]{}\|
    context:
      a: YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXogQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVogMTIzNDU2Nzg5MCAhQCMkJV4mKigpLT1fKy8/Ljo7W117fVx8
    partials: {}
    error: false
    strict: false
  - name: not a string
    template: '{{ 5 | base64_decode }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | base64_decode }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "hello" | base64_decode: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.base64_encode_filter
  tests:
  - name: from string
    template: '{{ "_#/." | base64_encode }}'
    want: XyMvLg==
    context: {}
    partials: {}
    error: false
    strict: false
  - name: from string with URL unsafe
    template: '{{ a | base64_encode }}'
    want: YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXogQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVogMTIzNDU2Nzg5MCAhQCMkJV4mKigpLT1fKy8/Ljo7W117fVx8
    context:
      a: abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 !@#$%^&*()-=_+/?.:;[]{}\|
    partials: {}
    error: false
    strict: false
  - name: not a string
    template: '{{ 5 | base64_encode }}'
    want: NQ==
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | base64_encode }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "hello" | base64_encode: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.base64_url_safe_decode_filter
  tests:
  - name: from string
    template: '{{ "XyMvLg==" | base64_url_safe_decode }}'
    want: _#/.
    context: {}
    partials: {}
    error: false
    strict: false
  - name: from string with URL unsafe
    template: '{{ a | base64_url_safe_decode }}'
    want: abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 !@#$%^&*()-=_+/?.:;[]{}\|
    context:
      a: YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXogQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVogMTIzNDU2Nzg5MCAhQCMkJV4mKigpLT1fKy8_Ljo7W117fVx8
    partials: {}
    error: false
    strict: false
  - name: not a string
    template: '{{ 5 | base64_url_safe_decode }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | base64_url_safe_decode }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "hello" | base64_url_safe_decode: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.base64_url_safe_encode_filter
  tests:
  - name: from string
    template: '{{ "_#/." | base64_url_safe_encode }}'
    want: XyMvLg==
    context: {}
    partials: {}
    error: false
    strict: false
  - name: from string with URL unsafe
    template: '{{ a | base64_url_safe_encode }}'
    want: YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXogQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVogMTIzNDU2Nzg5MCAhQCMkJV4mKigpLT1fKy8_Ljo7W117fVx8
    context:
      a: abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 !@#$%^&*()-=_+/?.:;[]{}\|
    partials: {}
    error: false
    strict: false
  - name: not a string
    template: '{{ 5 | base64_url_safe_encode }}'
    want: NQ==
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | base64_url_safe_encode }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "hello" | base64_url_safe_encode: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.capitalize_filter
  tests:
  - name: already capitalized string
    template: '{{ "Hello" | capitalize }}'
    want: Hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: lower case string
    template: '{{ "hello" | capitalize }}'
    want: Hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | capitalize }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "hello" | capitalize: 2 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.capture_tag
  tests:
  - name: assign to a variable from a captured variable
    template: '{% capture some %}hello{% endcapture %}{% assign other = some %}{{
      some }}-{{ other }}'
    want: hello-hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: capture into a variable with a hyphen
    template: '{% capture this-thing %}Hello, {{ customer.first_name }}.{% endcapture
      %}{{ this-thing }}'
    want: Hello, Holly.
    context:
      customer:
        first_name: Holly
    partials: {}
    error: false
    strict: false
  - name: capture template literal and global variable
    template: '{% capture greeting %}Hello, {{ customer.first_name }}.{% endcapture
      %}{{ greeting }}'
    want: Hello, Holly.
    context:
      customer:
        first_name: Holly
    partials: {}
    error: false
    strict: false
- name: liquid.golden.case_tag
  tests:
  - name: '''when'' expression using an identifier'
    template: '{% case title %}{% when other %}foo{% when ''goodbye'' %}bar{% endcase
      %}'
    want: foo
    context:
      title: Hello
      other: Hello
    partials: {}
    error: false
    strict: false
  - name: '''when'' expression using an out of scope identifier'
    template: '{% case title %}{% when nosuchthing %}foo{% when ''Hello'' %}bar{%
      endcase %}'
    want: bar
    context:
      title: Hello
    partials: {}
    error: false
    strict: false
  - name: comma separated when expression
    template: '{% case title %}{% when ''foo'' %}foo{% when ''bar'', ''Hello'' %}bar{%
      endcase %}'
    want: bar
    context:
      title: Hello
    partials: {}
    error: false
    strict: false
  - name: comma string literal
    template: '{% case foo %}{% when ''foo'' %}bar{% when '','' %}comma{% endcase
      %}'
    want: comma
    context:
      foo: ','
    partials: {}
    error: false
    strict: false
  - name: empty when tag
    template: '{% case foo %}{% when %}bar{% endcase %}'
    want: ''
    context:
      foo: bar
    partials: {}
    error: true
    strict: false
  - name: evaluate multiple matching blocks
    template: '{% case title %}{% when ''Hello'' %}foo{% when a, ''Hello'' %}bar{%
      endcase %}'
    want: foobarbar
    context:
      title: Hello
      a: Hello
    partials: {}
    error: false
    strict: false
  - name: falsy when before and truthy when after else
    template: '{% case ''x'' %}{% when ''y'' %}foo{% else %}bar{% when ''x'' %}baz{%
      endcase %}'
    want: barbaz
    context: {}
    partials: {}
    error: false
    strict: false
  - name: falsy when before and truthy when after multiple else blocks
    template: '{% case ''x'' %}{% when ''y'' %}foo{% else %}bar{% else %}baz{% when
      ''x'' %}qux{% endcase %}'
    want: barbazqux
    context: {}
    partials: {}
    error: false
    strict: false
  - name: mix or and comma separated when expression
    template: '{% case title %}{% when ''foo'' %}foo{% when ''bar'' or ''Hello'',
      ''Hello'' %}bar{% endcase %}'
    want: barbar
    context:
      title: Hello
    partials: {}
    error: false
    strict: false
  - name: multiple else blocks
    template: '{% case ''x'' %}{% when ''y'' %}foo{% else %}bar{% else %}baz{% endcase
      %}'
    want: barbaz
    context: {}
    partials: {}
    error: false
    strict: false
  - name: name not in scope
    template: '{% case nosuchthing %}{% when ''foo'' %}foo{% when ''bar'' %}bar{%
      endcase %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: no match and no default
    template: '{% case title %}{% when ''foo'' %}foo{% when ''bar'' %}bar{% endcase
      %}'
    want: ''
    context:
      title: Hello
    partials: {}
    error: false
    strict: false
  - name: no whens
    template: '{% case title %}{% else %}bar{% endcase %}'
    want: bar
    context:
      title: Hello
    partials: {}
    error: false
    strict: false
  - name: no whens or default
    template: '{% case title %}{% endcase %}'
    want: ''
    context:
      title: Hello
    partials: {}
    error: false
    strict: false
  - name: or separated when expression
    template: '{% case title %}{% when ''foo'' %}foo{% when ''bar'' or ''Hello'' %}bar{%
      endcase %}'
    want: bar
    context:
      title: Hello
    partials: {}
    error: false
    strict: false
  - name: simple case/when
    template: '{% case title %}{% when ''foo'' %}foo{% when ''Hello'' %}bar{% endcase
      %}'
    want: bar
    context:
      title: Hello
    partials: {}
    error: false
    strict: false
  - name: switch on array
    template: '{% case x %}{% when y %}foo{% endcase %}'
    want: foo
    context:
      x:
      - a
      - b
      - c
      y:
      - a
      - b
      - c
    partials: {}
    error: false
    strict: false
  - name: tags inside when block
    template: '{% case title %}{% when other %}{% if true %}foo{% endif %}{% when
      ''goodbye'' %}bar{% endcase %}'
    want: foo
    context:
      title: Hello
      other: Hello
    partials: {}
    error: false
    strict: false
  - name: truthy and empty when block before else
    template: '{% case ''x'' %}{% when ''x'' %}{% else %}bar{% endcase %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: truthy when before and after else
    template: '{% case ''x'' %}{% when ''x'' %}foo{% else %}bar{% when ''x'' %}baz{%
      endcase %}'
    want: foobaz
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected when token
    template: '{% case title %}{% when ''foo'' %}foo{% when ''bar'' and ''Hello'',
      ''Hello'' %}bar{% endcase %}'
    want: ''
    context:
      title: Hello
    partials: {}
    error: false
    strict: false
  - name: whitespace
    template: "{% case title %}  \n\t{% when 'foo' %}foo\n{% when 'Hello' %}bar{%\
      \ endcase %}"
    want: bar
    context:
      title: Hello
    partials: {}
    error: false
    strict: false
  - name: with default
    template: '{% case title %}{% when ''foo'' %}foo{% else %}bar{% endcase %}'
    want: bar
    context:
      title: Hello
    partials: {}
    error: false
    strict: false
- name: liquid.golden.ceil_filter
  tests:
  - name: negative float
    template: '{{ -5.4 | ceil }}'
    want: '-5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: negative integer
    template: '{{ -5 | ceil }}'
    want: '-5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: negative string float
    template: '{{ "-5.1" | ceil }}'
    want: '-5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string, int or float
    template: '{{ a | ceil }}'
    want: '0'
    context:
      a: {}
    partials: {}
    error: false
    strict: false
  - name: positive float
    template: '{{ 5.4 | ceil }}'
    want: '6'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive integer
    template: '{{ 5 | ceil }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive string float
    template: '{{ "5.1" | ceil }}'
    want: '6'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string not a number
    template: '{{ "hello" | ceil }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | ceil }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ -3.1 | ceil: 1 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: zero
    template: '{{ 0 | ceil }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.comment_tag
  tests:
  - name: don't render comments
    template: '{% comment %}foo{% endcomment %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: don't render comments with tags
    template: '{% comment %}{% if true %}{{ title }}{% endif %}{% endcomment %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: respect whitespace control in comments
    template: "\n{%- comment %}foo{% endcomment -%}\t \r"
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.compact_filter
  tests:
  - name: array of objects with key property
    template: '{% assign x = a | compact: ''title'' %}{% for obj in x %}{% for i in
      obj %}({{ i[0] }},{{ i[1] }}){% endfor %}{% endfor %}'
    want: (title,foo)(name,a)(title,bar)(name,c)
    context:
      a:
      - title: foo
        name: a
      - title: null
        name: b
      - title: bar
        name: c
    partials: {}
    error: false
    strict: false
  - name: array with a nil
    template: '{{ a | compact | join: ''#'' }}'
    want: b#a#A
    context:
      a:
      - b
      - a
      - null
      - A
    partials: {}
    error: false
    strict: false
  - name: empty array
    template: '{{ a | compact | join: ''#'' }}'
    want: ''
    context:
      a: []
    partials: {}
    error: false
    strict: false
  - name: left value is not an array
    template: '{{ a | compact | first }}'
    want: '123'
    context:
      a: 123
    partials: {}
    error: false
    strict: false
  - name: left value is undefined
    template: '{{ nosuchthing | compact }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ a | compact: ''foo'', ''bar'' }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.concat_filter
  tests:
  - name: left value contains non string
    template: '{{ a | concat: b | join: ''#'' }}'
    want: a#b#5#c#d
    context:
      a:
      - a
      - b
      - 5
      b:
      - c
      - d
    partials: {}
    error: false
    strict: false
  - name: left value is not array-like
    template: '{{ a | concat: b | join: ''#'' }}'
    want: ab#c#d
    context:
      a: ab
      b:
      - c
      - d
    partials: {}
    error: false
    strict: false
  - name: missing argument is an error
    template: '{{ a | concat | join: ''#'' }}'
    want: a#b
    context:
      a:
      - a
      - b
    partials: {}
    error: true
    strict: false
  - name: nested left value gets flattened
    template: '{{ a | concat: b | join: ''#'' }}'
    want: a#x#b#y#z#c#d
    context:
      a:
      - - a
        - x
      - - b
        - - y
          - - z
      b:
      - c
      - d
    partials: {}
    error: false
    strict: false
  - name: non array-like argument is an error
    template: '{{ a | concat: b | join: ''#'' }}'
    want: ''
    context:
      a:
      - a
      - b
      b: 5
    partials: {}
    error: true
    strict: false
  - name: range literal concat filter left value
    template: '{{ (1..3) | concat: foo | join: ''#'' }}'
    want: 1#2#3#5#6#7
    context:
      foo:
      - 5
      - 6
      - 7
    partials: {}
    error: false
    strict: false
  - name: two arrays of strings
    template: '{{ a | concat: b | join: ''#'' }}'
    want: a#b#c#d
    context:
      a:
      - a
      - b
      b:
      - c
      - d
    partials: {}
    error: false
    strict: false
  - name: undefined argument is an error
    template: '{{ a | concat: nosuchthing | join: ''#'' }}'
    want: ''
    context:
      a:
      - a
      - b
    partials: {}
    error: true
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | concat: b | join: ''#'' }}'
    want: c#d
    context:
      b:
      - c
      - d
    partials: {}
    error: false
    strict: false
- name: liquid.golden.cycle_tag
  tests:
  - name: changing variable name
    template: '{% cycle a: 1, 2, 3 %}{% assign a = ''bar'' %}{% cycle a: 1, 2, 3 %}{%
      cycle a: 1, 2, 3 %}'
    want: '112'
    context:
      a: foo
    partials: {}
    error: false
    strict: false
  - name: different items
    template: '{% cycle ''1'', ''2'', ''3'' %}{% cycle ''1'', ''2'' %}{% cycle ''1'',
      ''2'', ''3'' %}'
    want: '112'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: integers
    template: '{% cycle 1, 2, 3 %}{% cycle 1, 2, 3 %}{% cycle 1, 2, 3 %}'
    want: '123'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: multiple undefined variable names
    template: '{% cycle a: 1, 2, 3 %}{% cycle b: 1, 2, 3 %}{% cycle a: 1, 2, 3 %}'
    want: '123'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: named with different items
    template: '{% cycle ''a'': 1, 2, 3 %}{% cycle ''a'': 7, 8, 9 %}{% cycle ''a'':
      1, 2, 3 %}'
    want: '183'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: named with different number of arguments
    template: '{% cycle a: ''1'', ''2'' %}{% cycle a: ''1'', ''2'', ''3'' %}{% cycle
      a: ''1'' %}'
    want: '12'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: named with growing number of arguments
    template: '{% cycle a: ''1'' %}{% cycle a: ''1'', ''2'' %}{% cycle a: ''1'', ''2'',
      ''3'' %}'
    want: '112'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: named with shrinking number of arguments
    template: '{% cycle a: ''1'', ''2'', ''3'' %}{% cycle a: ''1'', ''2'' %}{% cycle
      a: ''1'' %}'
    want: '121'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: no identifier
    template: '{% cycle ''some'', ''other'' %}{% cycle ''some'', ''other'' %}{% cycle
      ''some'', ''other'' %}'
    want: someothersome
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined variable names mixed with no name
    template: '{% cycle a: 1, 2, 3 %}{% cycle b: 1, 2, 3 %}{% cycle 1, 2, 3 %}'
    want: '121'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: variable name
    template: '{% cycle a: 1, 2, 3 %}{% cycle a: 1, 2, 3 %}{% cycle a: 1, 2, 3 %}'
    want: '123'
    context:
      a: foo
    partials: {}
    error: false
    strict: false
  - name: with identifier
    template: '{% cycle ''foo'': ''some'', ''other'' %}{% cycle ''some'', ''other''
      %}{% cycle ''foo'': ''some'', ''other'' %}'
    want: somesomeother
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.date_filter
  tests:
  - name: literal percent
    template: '{{ ''March 14, 2016'' | date: ''%%%b %d, %y'' }}'
    want: '%Mar 14, 16'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: missing argument
    template: '{{ ''March 14, 2016'' | date }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: negative timestamp string
    template: '{{ ''-1152098955'' | date: ''%m/%d/%Y'' }}'
    want: '-1152098955'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: seconds since epoch format directive
    template: '{{ ''March 14, 2016'' | date: ''%s'' }}'
    want: '1457913600'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: timestamp integer
    template: '{{ 1152098955 | date: ''%m/%d/%Y'' }}'
    want: 07/05/2006
    context: {}
    partials: {}
    error: false
    strict: false
  - name: timestamp string
    template: '{{ ''1152098955'' | date: ''%m/%d/%Y'' }}'
    want: 07/05/2006
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ ''March 14, 2016'' | date: ''%b %d, %y'', ''foo'' }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined argument
    template: '{{ ''March 14, 2016'' | date: nosuchthing }}'
    want: March 14, 2016
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | date: ''%b %d, %y'' }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: well formed string
    template: '{{ ''March 14, 2016'' | date: ''%b %d, %y'' }}'
    want: Mar 14, 16
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.decrement_tag
  tests:
  - name: increment and decrement named counter
    template: '{% decrement foo %} {% decrement foo %} {% increment foo %}'
    want: -1 -2 -2
    context: {}
    partials: {}
    error: false
    strict: false
  - name: named counter
    template: '{% decrement foo %}{{ foo }} {% decrement foo %}{{ foo }}'
    want: -1-1 -2-2
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.default_filter
  tests:
  - name: 0.0 is not falsy
    template: '{{ 0.0 | default: "bar" }}'
    want: '0.0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: allow false
    template: '{{ false | default: ''bar'', allow_false:true }}'
    want: 'false'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: allow false from context
    template: '{{ false | default: ''bar'', allow_false:foo }}'
    want: 'false'
    context:
      foo: true
    partials: {}
    error: false
    strict: false
  - name: empty
    template: '{{ empty | default: bar }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: empty array
    template: '{{ a | default: ''foo'' }}'
    want: foo
    context:
      a: []
    partials: {}
    error: false
    strict: false
  - name: empty object
    template: '{{ a | default: ''foo'' }}'
    want: foo
    context:
      a: {}
    partials: {}
    error: false
    strict: false
  - name: empty string
    template: '{{ "" | default: "foo" }}'
    want: foo
    context: {}
    partials: {}
    error: false
    strict: false
  - name: 'false'
    template: '{{ False | default: ''foo'' }}'
    want: foo
    context: {}
    partials: {}
    error: false
    strict: false
  - name: false keyword argument before positional
    template: '{{ false | default: allow_false: false, "bar" }}'
    want: bar
    context: {}
    partials: {}
    error: false
    strict: false
  - name: missing argument
    template: '{{ false | default }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: nil
    template: '{{ nil | default: ''foo'' }}'
    want: foo
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not empty list
    template: '{{ a | default: "foo" | join: "#" }}'
    want: hello#world
    context:
      a:
      - hello
      - world
    partials: {}
    error: false
    strict: false
  - name: not empty object
    template: '{% assign b = a | default: foo %}{% for item in b %}({{ item[0] }},{{
      item[1] }}){% endfor %}'
    want: (greeting,hello)
    context:
      a:
        greeting: hello
      foo:
        greeting: goodbye
    partials: {}
    error: false
    strict: false
  - name: not empty string
    template: '{{ "hello" | default: "foo" }}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ None | default: ''foo'', ''bar'', ''baz'' }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: true keyword argument before positional
    template: '{{ false | default: allow_false: true, "bar" }}'
    want: 'false'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | default: "bar" }}'
    want: bar
    context: {}
    partials: {}
    error: false
    strict: false
  - name: zero is not falsy
    template: '{{ 0 | default: "bar" }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: zero is not falsy with allow_false
    template: '{{ 0 | default: "bar", allow_false: true }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.divided_by_filter
  tests:
  - name: arg string not a number
    template: '{{ "10" | divided_by: "foo" }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: divied by zero
    template: '{{ 10 | divided_by: 0 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: float division
    template: '{{ 20 | divided_by: 7.0 }}'
    want: '2.857142857142857'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: float value and integer arg
    template: '{{ 9.0 | divided_by: 2 }}'
    want: '4.5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: integer division
    template: '{{ 9 | divided_by: 2 }}'
    want: '4'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: integer value and float arg
    template: '{{ 10 | divided_by: 2.0 }}'
    want: '5.0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: integer value and integer arg
    template: '{{ 10 | divided_by: 2 }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: issue
    template: '{{ 5 | divided_by: 3 }}'
    want: '1'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: left value is an empty string
    template: '{{ '''' | divided_by: 2 }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string, int or float
    template: '{{ a | divided_by: 1 }}'
    want: '0'
    context:
      a: {}
    partials: {}
    error: false
    strict: false
  - name: render
    template: '{{ 5.0 }} {{ 5 }}'
    want: 5.0 5
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string not a number
    template: '{{ "foo" | divided_by: "2" }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string value and argument
    template: '{{ "10" | divided_by: "2" }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many args
    template: '{{ 5 | divided_by: 1, ''5'' }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined argument
    template: '{{ 10 | divided_by: nosuchthing }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | divided_by: 2 }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: zero divided by float
    template: '{{ 0 | divided_by: 1.1 }}'
    want: '0.0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: zero divided by integer
    template: '{{ 0 | divided_by: 1 }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.downcase_filter
  tests:
  - name: make lower case
    template: '{{ "HELLO" | downcase }}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string
    template: '{{ 5 | downcase }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | downcase }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "HELLO" | downcase: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.echo_tag
  tests:
  - name: access an array item by index
    template: '{% echo product.tags[1] %}'
    want: garden
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: access an array item by negative index
    template: '{% echo product.tags[-2] %}'
    want: sports
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: access an undefined variable by index
    template: '{% echo nosuchthing[0] %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: access array item by index stored in a local variable
    template: '{% assign i = 1 %}{% echo product.tags[i] %}'
    want: garden
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: assign a variable the value of an existing variable
    template: '{% capture some %}hello{% endcapture %}{% assign other = some %}{%
      assign some = ''foo'' %}{% echo some %}-{% echo other %}'
    want: foo-hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: dump an array from the global context
    template: '{% echo product.tags %}'
    want: sportsgarden
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: nothing to echo
    template: '{% echo %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render a float literal
    template: '{% echo 1.23 %}'
    want: '1.23'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render a global identifier with a filter
    template: '{% echo product.title | upcase %}'
    want: FOO
    context:
      product:
        title: foo
    partials: {}
    error: false
    strict: false
  - name: render a string literal
    template: '{% echo ''hello'' %}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render a variable from the global namespace
    template: '{% echo product.title %}'
    want: foo
    context:
      product:
        title: foo
    partials: {}
    error: false
    strict: false
  - name: render a variable from the local namespace
    template: '{% assign name = ''Brian'' %}{% echo name %}'
    want: Brian
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render an integer literal
    template: '{% echo 123 %}'
    want: '123'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render an undefined property
    template: '{% echo product.age %}'
    want: ''
    context:
      product:
        title: foo
    partials: {}
    error: false
    strict: false
  - name: render an undefined variable
    template: '{% echo age %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: traverse variables with bracketed identifiers
    template: '{% echo site.data.menu[include.menu][include.locale] %}'
    want: it works!
    context:
      site:
        data:
          menu:
            foo:
              bar: it works!
      include:
        menu: foo
        locale: bar
    partials: {}
    error: false
    strict: false
- name: liquid.golden.escape_filter
  tests:
  - name: make HTML-safe
    template: '{{ "<p>test</p>" | escape }}'
    want: '&lt;p&gt;test&lt;/p&gt;'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string
    template: '{{ 5 | escape }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | escape }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "HELLO" | escape: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.escape_once_filter
  tests:
  - name: make HTML-safe
    template: '{{ "&lt;p&gt;test&lt;/p&gt;" | escape_once }}'
    want: '&lt;p&gt;test&lt;/p&gt;'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: make HTML-safe from mixed safe and markup.
    template: '{{ "&lt;p&gt;test&lt;/p&gt;<p>test</p>" | escape_once }}'
    want: '&lt;p&gt;test&lt;/p&gt;&lt;p&gt;test&lt;/p&gt;'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string
    template: '{{ 5 | escape_once }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | escape_once }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "HELLO" | escape_once: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.first_filter
  tests:
  - name: array of strings
    template: '{{ arr | first }}'
    want: a
    context:
      arr:
      - a
      - b
    partials: {}
    error: false
    strict: false
  - name: array of things
    template: '{{ arr | first }}'
    want: a
    context:
      arr:
      - a
      - b
      - 1
      - []
      - {}
    partials: {}
    error: false
    strict: false
  - name: empty left value
    template: '{{ arr | first }}'
    want: ''
    context:
      arr: []
    partials: {}
    error: false
    strict: false
  - name: first of a hash
    template: '{% assign x = a | first %}({{ x[0] }},{{ x[1] }})'
    want: (b,1)
    context:
      a:
        b: 1
        c: 2
    partials: {}
    error: false
    strict: false
  - name: first of a string
    template: '{{ ''hello'' | first }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: left value is not an array
    template: '{{ arr | first }}'
    want: ''
    context:
      arr: 12
    partials: {}
    error: false
    strict: false
  - name: left value is undefined
    template: '{{ nosuchthing | first }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: range literal first filter left value
    template: '{{ (1..3) | first }}'
    want: '1'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.floor_filter
  tests:
  - name: negative float
    template: '{{ -5.4 | floor }}'
    want: '-6'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: negative integer
    template: '{{ -5 | floor }}'
    want: '-5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: negative string float
    template: '{{ "-5.1" | floor }}'
    want: '-6'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string, int or float
    template: '{{ a | floor }}'
    want: '0'
    context:
      a: {}
    partials: {}
    error: false
    strict: false
  - name: positive float
    template: '{{ 5.4 | floor }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive integer
    template: '{{ 5 | floor }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: positive string float
    template: '{{ "5.1" | floor }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string not a number
    template: '{{ "hello" | floor }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | floor }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ -3.1 | floor: 1 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: zero
    template: '{{ 0 | floor }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.for_tag
  tests:
  - name: access parentloop
    template: '{% for i in (1..2)%}{% for j in (1..2) %}{{ i }} {{j}} {{ forloop.parentloop.index
      }} {{ forloop.index }} {% endfor %}{% endfor %}'
    want: '1 1 1 1 1 2 1 2 2 1 2 1 2 2 2 2 '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: assign inside loop
    template: '{% for tag in product.tags %}{% assign x = tag %}{% endfor %}{{ x }}'
    want: garden
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: blank empty loops
    template: '{% for i in (0..10) %}  {% endfor %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: break
    template: '{% for tag in product.tags %}{% if tag == ''sports'' %}{% break %}{%
      else %}{{ tag }} {% endif %}{% else %}no images{% endfor %}'
    want: ''
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: comma separated arguments
    template: '{% for i in (1..6), limit: 4, offset: 2 %}{{ i }} {% endfor %}'
    want: '3 4 5 6 '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: continue
    template: '{% for tag in product.tags %}{% if tag == ''sports'' %}{% continue
      %}{% else %}{{ tag }} {% endif %}{% else %}no images{% endfor %}'
    want: 'garden '
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: continue a loop
    template: '{% for item in array limit: 3 %}a{{ item }} {% endfor %}{% for item
      in array offset: continue %}b{{ item }} {% endfor %}'
    want: 'a1 a2 a3 b4 b5 b6 '
    context:
      array:
      - 1
      - 2
      - 3
      - 4
      - 5
      - 6
    partials: {}
    error: false
    strict: false
  - name: continue a loop over a changing array
    template: '{% assign foo = ''1,2,3,4,5,6'' | split: '','' %}{% for item in foo
      limit: 3 %}{{ item }} {% endfor %}{% assign foo = ''u,v,w,x,y,z'' | split: '',''
      %}{% for item in foo offset: continue %}{{ item }} {% endfor %}'
    want: '1 2 3 x y z '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: continue a loop over an assigned range
    template: '{% assign nums = (1..5) %}{% for item in nums limit: 3 %}a{{ item }}
      {% endfor %}{% for item in nums offset: continue %}b{{ item }} {% endfor %}'
    want: 'a1 a2 a3 b4 b5 '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: continue from a limit that is greater than length
    template: '{% for item in array limit: 99 %}a{{ item }} {% endfor %}{% for item
      in array offset: continue %}b{{ item }} {% endfor %}'
    want: 'a1 a2 a3 a4 a5 a6 '
    context:
      array:
      - 1
      - 2
      - 3
      - 4
      - 5
      - 6
    partials: {}
    error: false
    strict: false
  - name: continue from a range expression
    template: '{% for item in (1..6) limit: 3 %}a{{ item }} {% endfor %}{% for item
      in (1..6) offset: continue %}b{{ item }} {% endfor %}'
    want: 'a1 a2 a3 b4 b5 b6 '
    context:
      array:
      - 1
      - 2
      - 3
      - 4
      - 5
      - 6
    partials: {}
    error: false
    strict: false
  - name: continue with changing loop var
    template: '{% for foo in array limit: 3 %}{{ foo }} {% endfor %}{% for bar in
      array offset: continue %}{{ bar }} {% endfor %}'
    want: '1 2 3 1 2 3 4 5 6 '
    context:
      array:
      - 1
      - 2
      - 3
      - 4
      - 5
      - 6
    partials: {}
    error: false
    strict: false
  - name: empty array with default
    template: '{% for img in emptythings.array %}{{ img.url }} {% else %}no images{%
      endfor %}'
    want: no images
    context:
      emptythings:
        array: []
        map: {}
        string: ''
    partials: {}
    error: false
    strict: false
  - name: first and last with an offset and limit
    template: '{% for tag in tags limit: 2 offset: 1 %}{{ tag }} {{ forloop.first
      }} {{ forloop.last }} {% endfor %}'
    want: 'garden true false home false true '
    context:
      tags:
      - sports
      - garden
      - home
      - diy
      - motoring
      - fashion
    partials: {}
    error: false
    strict: false
  - name: first and last with offset continue
    template: '{% for tag in product.tags limit: 1 %}{% endfor %}{% for tag in product.tags
      offset: continue %}{{ forloop.first }} {{ forloop.last }} {% endfor %}'
    want: 'true false false false false false false false false true '
    context:
      product:
        tags:
        - sports
        - garden
        - home
        - diy
        - motoring
        - fashion
    partials: {}
    error: false
    strict: false
  - name: forloop goes out of scope
    template: '{% for tag in product.tags %}{{ forloop.length }} {% endfor %}{{ forloop.length
      }}'
    want: '2 2 '
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: forloop length
    template: '{% for tag in product.tags %}{{ forloop.length }} {% endfor %}'
    want: '2 2 '
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: forloop length with limit
    template: '{% for tag in tags limit:3 %}{{ forloop.length }} {% endfor %}'
    want: '3 3 3 '
    context:
      tags:
      - sports
      - garden
      - home
      - diy
      - motoring
      - fashion
    partials: {}
    error: false
    strict: false
  - name: forloop length with offset
    template: '{% for tag in tags offset:3 %}{{ forloop.length }} {% endfor %}'
    want: '3 3 3 '
    context:
      tags:
      - sports
      - garden
      - home
      - diy
      - motoring
      - fashion
    partials: {}
    error: false
    strict: false
  - name: forloop name
    template: '{% for tag in product.tags limit:1 %}{{ forloop.name }}{% endfor %}'
    want: tag-product.tags
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: forloop name of a range
    template: '{% for i in (1..3) limit:1 %}{{ forloop.name }}{% endfor %}'
    want: i-(1..3)
    context: {}
    partials: {}
    error: false
    strict: false
  - name: forloop no such attribute
    template: '{% for tag in product.tags %}{{ forloop.nosuchthing }}{% endfor %}'
    want: ''
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: forloop.first
    template: '{% for tag in product.tags %}{{ forloop.first }} {% endfor %}'
    want: 'true false '
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: forloop.index
    template: '{% for tag in product.tags %}{{ forloop.index }} {% endfor %}'
    want: '1 2 '
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: forloop.index0
    template: '{% for tag in product.tags %}{{ forloop.index0 }} {% endfor %}'
    want: '0 1 '
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: forloop.last
    template: '{% for tag in product.tags %}{{ forloop.last }} {% endfor %}'
    want: 'false true '
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: forloop.rindex
    template: '{% for tag in product.tags %}{{ forloop.rindex }} {% endfor %}'
    want: '2 1 '
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: forloop.rindex0
    template: '{% for tag in product.tags %}{{ forloop.rindex0 }} {% endfor %}'
    want: '1 0 '
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: iterate an empty array
    template: '{% for item in emptythings.array %}{{ item }}{% endfor %}'
    want: ''
    context:
      emptythings:
        array: []
        map: {}
        string: ''
    partials: {}
    error: false
    strict: false
  - name: iterate an empty array with default
    template: '{% for item in emptythings.array %}{{ item }}{% else %}foo{% endfor
      %}'
    want: foo
    context:
      emptythings:
        array: []
        map: {}
        string: ''
    partials: {}
    error: false
    strict: false
  - name: limit
    template: '{% for tag in product.tags limit:1 %}{{ tag }} {% endfor %}'
    want: 'sports '
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: limit is a non-number string
    template: '{% for i in (1..4) limit: ''foo'' %}{{ i }} {% endfor %}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: limit is a string
    template: '{% for i in (1..4) limit: ''2'' %}{{ i }} {% endfor %}'
    want: '1 2 '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: limit is not a string or number
    template: '{% for i in (1..4) limit: foo %}{{ i }} {% endfor %}'
    want: ''
    context:
      foo:
      - 1
      - 2
      - 3
    partials: {}
    error: true
    strict: false
  - name: lookup a filter from an outer context
    template: '{% for tag in product.tags %}{{ tag | upcase }} {% endfor %}'
    want: 'SPORTS GARDEN '
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: loop over a string literal
    template: '{% for i in ''hello'' %}{{ i }} {% endfor %}'
    want: 'hello '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: loop over a string variable
    template: '{% for i in foo %}{{ i }} {% endfor %}'
    want: 'hello '
    context:
      foo: hello
    partials: {}
    error: false
    strict: false
  - name: loop over an array in reverse
    template: '{% for tag in product.tags reversed %}{{ tag }} {% endfor %}'
    want: 'garden sports '
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: loop over an existing range object
    template: '{% assign foo = (1..3) %}{{ foo | join: ''#'' }}{% for i in foo %}{{
      i }}{% endfor %}{% for i in foo %}{{ i }}{% endfor %}'
    want: 1#2#3123123
    context: {}
    partials: {}
    error: false
    strict: false
  - name: loop over nested and chained object from context with trailing identifier
    template: '{% for link in linklists[section.settings.menu].links %}{{ link }}
      {% endfor %}'
    want: '1 2 '
    context:
      linklists:
        main:
          links:
          - '1'
          - '2'
      section:
        settings:
          menu: main
    partials: {}
    error: false
    strict: false
  - name: loop over range with float start
    template: '{% assign x = (2.4..5) %}{% for i in x %}{{ i }}{% endfor %}'
    want: '2345'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: loop over undefined
    template: '{% for tag in nosuchthing %}{{ tag }}{% endfor %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: nothing to continue from
    template: '{% for item in array %}a{{ item }} {% endfor %}{% for item in array
      offset: continue %}b{{ item }} {% endfor %}'
    want: 'a1 a2 a3 a4 a5 a6 '
    context:
      array:
      - 1
      - 2
      - 3
      - 4
      - 5
      - 6
    partials: {}
    error: false
    strict: false
  - name: offset
    template: '{% for tag in product.tags offset:1 %}{{ tag }} {% endfor %}'
    want: 'garden '
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: offset and limit
    template: '{% for tag in tags limit: 3 offset: 1 %}{{ tag }} {% endfor %}'
    want: 'garden home diy '
    context:
      tags:
      - sports
      - garden
      - home
      - diy
      - motoring
      - fashion
    partials: {}
    error: false
    strict: false
  - name: offset continue forloop length
    template: '{% for item in (1..6) limit: 2 %}a{{ item }} - {{ forloop.length }},
      {% endfor %}{% for item in (1..6) offset: continue %}b{{ item }} - {{ forloop.length
      }}, {% endfor %}'
    want: 'a1 - 2, a2 - 2, b3 - 4, b4 - 4, b5 - 4, b6 - 4, '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: offset continue from a broken loop
    template: '{% for item in (1..6) limit: 4 %}{% if item == 3 %}{% break %}{% endif
      %}a{{ item }} {% endfor %}{% for item in (1..6) offset: continue %}b{{ item
      }} {% endfor %}'
    want: 'a1 a2 b5 b6 '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: offset continue from a broken loop with preceding limit
    template: '{% for item in (1..6) limit: 3 %}a{{ item }} {% endfor %}{% for item
      in (1..6) %}{% if item == 3 %}{% break %}{% endif %}b{{ item }} {% endfor %}{%
      for item in (1..6) offset: continue %}c{{ item }} {% endfor %}'
    want: 'a1 a2 a3 b1 b2 '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: offset continue twice with changing limit
    template: '{% for item in (1..6) limit: 2 %}a{{ item }} {% endfor %}{% for item
      in (1..6) limit: 3 offset: continue %}b{{ item }} {% endfor %}{% for item in
      (1..6) offset: continue %}c{{ item }} {% endfor %}'
    want: 'a1 a2 b3 b4 b5 c6 '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: offset continue twice with limit
    template: '{% for item in (1..6) limit: 2 %}a{{ item }} {% endfor %}{% for item
      in (1..6) limit: 2 offset: continue %}b{{ item }} {% endfor %}{% for item in
      (1..6) offset: continue %}c{{ item }} {% endfor %}'
    want: 'a1 a2 b3 b4 c5 c6 '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: offset continue twice with no second limit
    template: '{% for item in (1..6) limit: 2 %}a{{ item }} {% endfor %}{% for item
      in (1..6) offset: continue %}b{{ item }} {% endfor %}{% for item in (1..6) offset:
      continue %}c{{ item }} {% endfor %}'
    want: 'a1 a2 b3 b4 b5 b6 '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: offset continue without preceding loop
    template: '{% for item in array offset: continue %}{{ item }} {% endfor %}'
    want: '1 2 3 4 5 6 '
    context:
      array:
      - 1
      - 2
      - 3
      - 4
      - 5
      - 6
    partials: {}
    error: false
    strict: false
  - name: offset is a non-number string
    template: '{% for i in (1..4) offset: ''foo'' %}{{ i }} {% endfor %}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: offset is a string
    template: '{% for i in (1..4) offset: ''2'' %}{{ i }} {% endfor %}'
    want: '3 4 '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: offset is not a string or number
    template: '{% for i in (1..4) offset: foo %}{{ i }} {% endfor %}'
    want: ''
    context:
      foo:
      - 1
      - 2
      - 3
    partials: {}
    error: true
    strict: false
  - name: parent's parentloop
    template: '{% for i in (1..2) %}{% for j in (1..2) %}{% for k in (1..2) %}i={{
      forloop.parentloop.parentloop.index }} j={{ forloop.parentloop.index }} k={{
      forloop.index }} {% endfor %}{% endfor %}{% endfor %}'
    want: 'i=1 j=1 k=1 i=1 j=1 k=2 i=1 j=2 k=1 i=1 j=2 k=2 i=2 j=1 k=1 i=2 j=1 k=2
      i=2 j=2 k=1 i=2 j=2 k=2 '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: parentloop goes out of scope
    template: '{% for i in (1..2)%}{% for j in (1..2) %}{{ i }} {{ j }} {% endfor
      %}{{ forloop.parentloop.index }}{% endfor %}'
    want: '1 1 1 2 2 1 2 2 '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: parentloop is normally undefined
    template: '{% for i in (1..2)%}{{ forloop.parentloop.index }}{% endfor %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: range loop using identifier
    template: '{% for i in (0..product.end_range) %}{{ i }} - {{ product.tags[i] }}
      {% endfor %}'
    want: '0 - sports 1 - garden '
    context:
      product:
        tags:
        - sports
        - garden
        end_range: 1
    partials: {}
    error: false
    strict: false
  - name: range start and stop are the same
    template: '{% for i in (1..1) %}{{ i }} {% endfor %}'
    want: '1 '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: range start and stop are zero
    template: '{% for i in (0..0) %}{{ i }} {% endfor %}'
    want: '0 '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: share outer scope
    template: '{% assign foo = ''hello'' %}{% for x in (1..3) %}{% assign foo = x
      %}{% endfor %}{{ foo }}'
    want: '3'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: simple array loop
    template: '{% for tag in product.tags %}{{ tag }} {% endfor %}'
    want: 'sports garden '
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: simple hash loop
    template: '{% for c in collection %}{{ c[0] }} {{ c[1] }} {% endfor %}'
    want: 'title foo description bar '
    context:
      collection:
        title: foo
        description: bar
    partials: {}
    error: false
    strict: false
  - name: simple range loop
    template: '{% for i in (0..3) %}{{ i }} {% endfor %}'
    want: '0 1 2 3 '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: some comma separated arguments
    template: '{% for i in (1..6) limit: 4, offset: 2, %}{{ i }} {% endfor %}'
    want: '3 4 5 6 '
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.identifiers
  tests:
  - name: ascii lowercase
    template: '{% assign foo = ''hello'' %}{{ foo }} {{ bar }}'
    want: hello goodbye
    context:
      bar: goodbye
    partials: {}
    error: false
    strict: true
  - name: ascii uppercase
    template: '{% assign FOO = ''hello'' %}{{ FOO }} {{ BAR }}'
    want: hello goodbye
    context:
      BAR: goodbye
    partials: {}
    error: false
    strict: true
  - name: at sign
    template: '{{ @foo }}'
    want: hello
    context:
      '@foo': hello
    partials: {}
    error: true
    strict: true
  - name: capture ascii lowercase
    template: '{% capture foo %}hello{% endcapture %}{{ foo }}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: true
  - name: capture ascii uppercase
    template: '{% capture FOO %}hello{% endcapture %}{{ FOO }}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: true
  - name: capture digits
    template: '{% capture foo1 %}hello{% endcapture %}{{ foo1 }}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: true
  - name: capture hyphens
    template: '{% capture foo-a %}hello {{ bar-b }}{% endcapture %}{{ foo-a }}'
    want: hello goodbye
    context:
      bar-b: goodbye
    partials: {}
    error: false
    strict: true
  - name: capture leading hyphen
    template: '{% capture -foo %}hello {{ -bar }}{% endcapture %}{{ -foo }}'
    want: hello goodbye
    context:
      -bar: goodbye
    partials: {}
    error: true
    strict: true
  - name: capture leading underscore
    template: '{% capture _foo %}hello {{ _bar }}{% endcapture %}{{ _foo }}'
    want: hello goodbye
    context:
      _bar: goodbye
    partials: {}
    error: false
    strict: true
  - name: capture only digits
    template: '{% capture 123 %}hello{% endcapture %}{{ 123 }}'
    want: '123'
    context: {}
    partials: {}
    error: false
    strict: true
  - name: capture only underscore
    template: '{% capture _ %}hello {{ __ }}{% endcapture %}{{ _ }}'
    want: hello goodbye
    context:
      __: goodbye
    partials: {}
    error: false
    strict: true
  - name: capture underscore
    template: '{% capture foo_a %}hello {{ bar_b }}{% endcapture %}{{ foo_a }}'
    want: hello goodbye
    context:
      bar_b: goodbye
    partials: {}
    error: false
    strict: true
  - name: decrement with a hyphen
    template: '{% decrement f-oo %}{% decrement f-oo %}'
    want: -1-2
    context: {}
    partials: {}
    error: false
    strict: true
  - name: digits
    template: '{% assign foo1 = ''hello'' %}{{ foo1 }} {{ bar2 }}'
    want: hello goodbye
    context:
      bar2: goodbye
    partials: {}
    error: false
    strict: true
  - name: hyphen in for loop target
    template: '{% for x in f-oo %}{{ x }}{% endfor %}'
    want: '123'
    context:
      f-oo:
      - 1
      - 2
      - 3
    partials: {}
    error: false
    strict: true
  - name: hyphen in for loop variable
    template: '{% for x-y in foo %}{{ x-y }}{% endfor %}'
    want: '123'
    context:
      foo:
      - 1
      - 2
      - 3
    partials: {}
    error: false
    strict: true
  - name: hyphens
    template: '{% assign foo-a = ''hello'' %}{{ foo-a }} {{ bar-b }}'
    want: hello goodbye
    context:
      bar-b: goodbye
    partials: {}
    error: false
    strict: true
  - name: increment with a hyphen
    template: '{% increment f-oo %}{% increment f-oo %}'
    want: '01'
    context: {}
    partials: {}
    error: false
    strict: true
  - name: leading hyphen
    template: '{% assign -foo = ''hello'' %}{{ -foo }} {{ -bar }}'
    want: hello goodbye
    context:
      -bar: goodbye
    partials: {}
    error: true
    strict: true
  - name: leading hyphen in for loop target
    template: '{% for x in -foo %}{{ x }}{% endfor %}'
    want: '123'
    context:
      -foo:
      - 1
      - 2
      - 3
    partials: {}
    error: true
    strict: true
  - name: leading underscore
    template: '{% assign _foo = ''hello'' %}{{ _foo }} {{ _bar }}'
    want: hello goodbye
    context:
      _bar: goodbye
    partials: {}
    error: false
    strict: true
  - name: only digits
    template: '{% assign 123 = ''hello'' %}{{ 123 }} {{ 456 }}'
    want: 123 456
    context:
      '456': goodbye
    partials: {}
    error: false
    strict: true
  - name: only underscore
    template: '{% assign _ = ''hello'' %}{{ _ }} {{ __ }}'
    want: hello goodbye
    context:
      __: goodbye
    partials: {}
    error: false
    strict: true
  - name: trailing question mark assign
    template: '{% assign foo? = ''hello'' %}{{ foo? }}'
    want: hello
    context: {}
    partials: {}
    error: true
    strict: true
  - name: trailing question mark in for loop target
    template: '{% for x in foo? %}{{ x }}{% endfor %}'
    want: '123'
    context:
      foo?:
      - 1
      - 2
      - 3
    partials: {}
    error: false
    strict: true
  - name: trailing question mark in for loop variable
    template: '{% for x? in foo %}{{ x? }}{% endfor %}'
    want: '123'
    context:
      foo:
      - 1
      - 2
      - 3
    partials: {}
    error: false
    strict: true
  - name: trailing question mark output
    template: '{{ bar? }}'
    want: goodbye
    context:
      bar?: goodbye
    partials: {}
    error: false
    strict: true
  - name: underscore
    template: '{% assign foo_a = ''hello'' %}{{ foo_a }} {{ bar_b }}'
    want: hello goodbye
    context:
      bar_b: goodbye
    partials: {}
    error: false
    strict: true
- name: liquid.golden.if_tag
  tests:
  - name: 0.0 is truthy
    template: '{% if 0.0 %}Hello{% else %}Goodbye{% endif %}'
    want: Hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: alternate not equal condition
    template: '{% if product.title <> ''foo'' %}baz{% endif %}'
    want: ''
    context:
      product:
        title: foo
    partials: {}
    error: false
    strict: false
  - name: array is equal to array
    template: '{% assign x = ''a,b,c'' | split: '','' %}{% assign y = ''a,b,c'' |
      split: '','' %}{% if x == y %}true{% else %}false{% endif %}'
    want: 'true'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: array is equal to array from context
    template: '{% assign y = ''a,b,c'' | split: '','' %}{% if x == y %}true{% else
      %}false{% endif %}'
    want: 'true'
    context:
      x:
      - a
      - b
      - c
    partials: {}
    error: false
    strict: false
  - name: blocks that contain only whitespace and comments are not rendered
    template: '{% if true %} {% comment %} this is blank {% endcomment %} {% endif
      %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: blocks that contain only whitespace are not rendered
    template: '{% if true %}  {% elsif false %} {% else %} {% endif %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: condition with conditional alternative
    template: '{% if product.title == ''hello'' %}foo{% elsif product.title == ''foo''
      %}bar{% endif %}'
    want: bar
    context:
      product:
        title: foo
    partials: {}
    error: false
    strict: false
  - name: condition with conditional alternative and final alternative
    template: '{% if product.title == ''hello'' %}foo{% elsif product.title == ''goodbye''
      %}bar{% else %}baz{% endif %}'
    want: baz
    context:
      product:
        title: foo
    partials: {}
    error: false
    strict: false
  - name: condition with literal consequence
    template: '{% if product.title == ''foo'' %}bar{% endif %}'
    want: bar
    context:
      product:
        title: foo
    partials: {}
    error: false
    strict: false
  - name: condition with literal consequence and literal alternative
    template: '{% if product.title == ''hello'' %}bar{% else %}baz{% endif %}'
    want: baz
    context:
      product:
        title: foo
    partials: {}
    error: false
    strict: false
  - name: conditional alternative with default
    template: '{% if false %}foo{% elsif false %}bar{% else %}hello{% endif %}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: contains condition
    template: '{% if product.tags contains ''garden'' %}baz{% endif %}'
    want: baz
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: context string contains string from context
    template: '{% if t contains s %}TRUE{% else %}FALSE{% endif %}'
    want: 'TRUE'
    context:
      s: llo
      t: hello
    partials: {}
    error: false
    strict: false
  - name: else tag expressions are ignored
    template: '{% if false %}1{% else nonsense %}2{% endif %}'
    want: '2'
    context: {}
    partials: {}
    error: false
    strict: true
  - name: empty array equals special empty
    template: '{% if x == empty %}TRUE{% else %}FALSE{% endif %}'
    want: 'TRUE'
    context:
      x: []
    partials: {}
    error: false
    strict: false
  - name: empty array is truthy
    template: '{% if x %}TRUE{% else %}FALSE{% endif %}'
    want: 'TRUE'
    context:
      x: []
    partials: {}
    error: false
    strict: false
  - name: empty object equals special empty
    template: '{% if x == empty %}TRUE{% else %}FALSE{% endif %}'
    want: 'TRUE'
    context:
      x: {}
    partials: {}
    error: false
    strict: false
  - name: empty object is truthy
    template: '{% if x %}TRUE{% else %}FALSE{% endif %}'
    want: 'TRUE'
    context:
      x: {}
    partials: {}
    error: false
    strict: false
  - name: empty string is truthy
    template: '{% if '''' %}TRUE{% else %}FALSE{% endif %}'
    want: 'TRUE'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: extra else blocks are ignored
    template: '{% if false %}1{% else %}2{% else %}3{% endif %}'
    want: '2'
    context: {}
    partials: {}
    error: false
    strict: true
  - name: extra elsif blocks are ignored
    template: '{% if false %}1{% else %}2{% elsif true %}3{% endif %}'
    want: '2'
    context: {}
    partials: {}
    error: false
    strict: true
  - name: int does not equal string
    template: '{% if 1 == ''1'' %}true{% else %}false{% endif %}'
    want: 'false'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: int equals float
    template: '{% if 1 == 1.0 %}true{% else %}false{% endif %}'
    want: 'true'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: literal false condition
    template: '{% if false %}{% endif %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: literal nil is falsy
    template: '{% if nil %}bar{% else %}foo{% endif %}'
    want: foo
    context: {}
    partials: {}
    error: false
    strict: false
  - name: logical operators are right associative
    template: '{% if true and false and false or true %}hello{% endif %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: nested condition in the consequence block
    template: '{% if product %}{% if title == ''Hello'' %}baz{% endif %}{% endif %}'
    want: baz
    context:
      product:
        title: foo
      title: Hello
    partials: {}
    error: false
    strict: false
  - name: nested condition, alternative in the consequence block
    template: '{% if product %}{% if title == ''goodbye'' %}baz{% else %}hello{% endif
      %}{% endif %}'
    want: hello
    context:
      product:
        title: foo
      title: Hello
    partials: {}
    error: false
    strict: false
  - name: non-empty hash is truthy
    template: '{% if product %}bar{% else %}foo{% endif %}'
    want: bar
    context:
      product:
        title: foo
    partials: {}
    error: false
    strict: false
  - name: not equal condition
    template: '{% if product.title != ''foo'' %}baz{% endif %}'
    want: ''
    context:
      product:
        title: foo
    partials: {}
    error: false
    strict: false
  - name: one is not equal to true
    template: '{% if 1 == true %}Hello{% else %}Goodbye{% endif %}'
    want: Goodbye
    context: {}
    partials: {}
    error: false
    strict: false
  - name: range equals range
    template: '{% assign foo = (1..3) %}{% if foo == (1..3) %}true{% else %}false{%
      endif %}'
    want: 'true'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string contains int
    template: '{% if ''hel9lo'' contains 9 %}TRUE{% else %}FALSE{% endif %}'
    want: 'TRUE'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string contains string
    template: '{% if ''hello'' contains ''llo'' %}TRUE{% else %}FALSE{% endif %}'
    want: 'TRUE'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string contains string from context
    template: '{% if ''hello'' contains s %}TRUE{% else %}FALSE{% endif %}'
    want: 'TRUE'
    context:
      s: llo
    partials: {}
    error: false
    strict: false
  - name: string does not equal int
    template: '{% if ''1'' == 1 %}true{% else %}false{% endif %}'
    want: 'false'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string greater than int
    template: '{% if ''2'' > 1 %}true{% else %}false{% endif %}'
    want: 'false'
    context: {}
    partials: {}
    error: true
    strict: false
  - name: string is greater than or equal to string
    template: '{% if ''abc'' >= ''acb'' %}true{% else %}false{% endif %}'
    want: 'false'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string is greater than string
    template: '{% if ''abc'' > ''acb'' %}true{% else %}false{% endif %}'
    want: 'false'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string is less than or equal to string
    template: '{% if ''abc'' <= ''acb'' %}true{% else %}false{% endif %}'
    want: 'true'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string is less than string
    template: '{% if ''abc'' < ''acb'' %}true{% else %}false{% endif %}'
    want: 'true'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string is not greater than or equal to string
    template: '{% if ''bbb'' >= ''aaa'' %}true{% else %}false{% endif %}'
    want: 'true'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string is not greater than string
    template: '{% if ''bbb'' > ''aaa'' %}true{% else %}false{% endif %}'
    want: 'true'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string is not less than or equal to string
    template: '{% if ''bbb'' <= ''aaa'' %}true{% else %}false{% endif %}'
    want: 'false'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string is not less than string
    template: '{% if ''bbb'' < ''aaa'' %}true{% else %}false{% endif %}'
    want: 'false'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined is equal to nil
    template: '{% if nosuchthing == nil %}TRUE{% else %}FALSE{% endif %}'
    want: 'TRUE'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined is equal to null
    template: '{% if nosuchthing == null %}TRUE{% else %}FALSE{% endif %}'
    want: 'TRUE'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined variables are falsy
    template: '{% if nosuchthing %}bar{% else %}foo{% endif %}'
    want: foo
    context: {}
    partials: {}
    error: false
    strict: false
  - name: zero is not equal to false
    template: '{% if 0 == false %}Hello{% else %}Goodbye{% endif %}'
    want: Goodbye
    context: {}
    partials: {}
    error: false
    strict: false
  - name: zero is truthy
    template: '{% if 0 %}Hello{% else %}Goodbye{% endif %}'
    want: Hello
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.ifchanged_tag
  tests:
  - name: change from assign
    template: '{% assign foo = ''hello'' %}{% ifchanged %}{{ foo }}{% endifchanged
      %}{% ifchanged %}{{ foo }}{% endifchanged %}{% assign foo = ''goodbye'' %}{%
      ifchanged %}{{ foo }}{% endifchanged %}'
    want: hellogoodbye
    context: {}
    partials: {}
    error: false
    strict: false
  - name: changed from initial state
    template: '{% ifchanged %}hello{% endifchanged %}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: no change from assign
    template: '{% assign foo = ''hello'' %}{% ifchanged %}{{ foo }}{% endifchanged
      %}{% ifchanged %}{{ foo }}{% endifchanged %}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not changed from initial state
    template: '{% ifchanged %}{% endifchanged %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: within for loop
    template: '{% assign list = "1,3,2,1,3,1,2" | split: "," | sort %}{% for item
      in list -%}{%- ifchanged %} {{ item }}{% endifchanged -%}{%- endfor %}'
    want: ' 1 2 3'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.illegal
  tests:
  - name: no addition operator
    template: '{% assign x = 1 + 2 %}{{ x }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: true
  - name: no multiplication operator
    template: '{% assign x = 2 %}{{ x * 3 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: true
  - name: no subtraction operator
    template: '{% assign x = 1 - 2 %}{{ x }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: true
  - name: unknown tag
    template: '{% nosuchthing %}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: true
- name: liquid.golden.include_tag
  tests:
  - name: assign persists in outer scope
    template: '{% include ''assign-outer-scope'' %} {{ last_name }}'
    want: Hello, Holly Smith
    context:
      customer:
        first_name: Holly
    partials:
      assign-outer-scope: Hello, {{ customer.first_name }}{% assign last_name = 'Smith'
        %}
    error: false
    strict: false
  - name: assign to a keyword argument
    template: '{% include ''product-args'', foo: ''hello'' %} {{ foo }}'
    want: hello hello goodbye
    context: {}
    partials:
      product-args: '{{ foo }}{% assign foo = ''goodbye'' %} {{ foo }}'
    error: false
    strict: false
  - name: bound array variable
    template: '{% include ''prod'' for collection.products %}'
    want: bikecar
    context:
      collection:
        products:
        - title: bike
        - title: car
    partials:
      prod: '{{ prod.title }}'
    error: false
    strict: false
  - name: bound variable
    template: '{% include ''product-title'' with collection.products[1] %}'
    want: car
    context:
      collection:
        products:
        - title: bike
        - title: car
    partials:
      product-title: '{{ product-title.title }}'
    error: false
    strict: false
  - name: bound variable does not exist
    template: '{% include ''product-title'' with no.such.thing %}'
    want: ''
    context: {}
    partials:
      product-title: '{{ product-title.title }}'
    error: false
    strict: false
  - name: bound variable with alias
    template: '{% include ''product-alias'' with collection.products[1] as product
      %}'
    want: car
    context:
      collection:
        products:
        - title: bike
        - title: car
    partials:
      product-alias: '{{ product.title }}'
    error: false
    strict: false
  - name: break from include
    template: '{% for tag in product.tags %}{% include ''tag-break'' %}{% endfor %}'
    want: SPORTS
    context:
      product:
        tags:
        - sports
        - garden
    partials:
      tag-break: '{{ tag | upcase }}{% break %}'
    error: false
    strict: false
  - name: break from nested include
    template: '{% for tag in product.tags %}{% include ''tag'' %}{% endfor %}'
    want: SPORTS break!
    context:
      product:
        tags:
        - sports
        - garden
    partials:
      tag: '{{ tag | upcase }}{% include ''break'' %}'
      break: ' break!{% break %}'
    error: false
    strict: false
  - name: counter from outer scope
    template: '{% increment foo %} {% include ''increment-outer-scope'' %} {% increment
      foo %}'
    want: 0 1 2
    context: {}
    partials:
      increment-outer-scope: '{% increment foo %}'
    error: false
    strict: false
  - name: keyword arguments go out of scope
    template: '{% include ''product-args'', foo: ''hello'', bar: ''there'' %}{{ foo
      }}'
    want: hello there
    context: {}
    partials:
      product-args: '{{ foo }} {{ bar }}'
    error: false
    strict: false
  - name: name from identifier
    template: '{% include snippet %}'
    want: 'foo

      - sports

      - garden

      '
    context:
      snippet: product-hero
      product:
        title: foo
        tags:
        - sports
        - garden
    partials:
      product-hero: '{{ product.title }}

        {% for tag in product.tags %}- {{ tag }}

        {% endfor %}'
    error: false
    strict: false
  - name: some keyword arguments
    template: '{% include ''product-args'', foo: ''hello'', bar: ''there'' %}'
    want: hello there
    context: {}
    partials:
      product-args: '{{ foo }} {{ bar }}'
    error: false
    strict: false
  - name: some keyword arguments with float literals
    template: '{% include ''product-args'' foo: 1.1, bar: ''there'' %}'
    want: 1.1 there
    context: {}
    partials:
      product-args: '{{ foo }} {{ bar }}'
    error: false
    strict: false
  - name: some keyword arguments with range literal
    template: '{% include ''product-args'' foo: (1..3), bar: ''there'' %}'
    want: 1#2#3 there
    context: {}
    partials:
      product-args: '{{ foo | join: ''#'' }} {{ bar }}'
    error: false
    strict: false
  - name: some keyword arguments without leading comma
    template: '{% include ''product-args'' foo: ''hello'', bar: ''there'' %}'
    want: hello there
    context: {}
    partials:
      product-args: '{{ foo }} {{ bar }}'
    error: false
    strict: false
  - name: string literal name
    template: '{% include ''product-hero'' %}'
    want: 'foo

      - sports

      - garden

      '
    context:
      product:
        title: foo
        tags:
        - sports
        - garden
    partials:
      product-hero: '{{ product.title }}

        {% for tag in product.tags %}- {{ tag }}

        {% endfor %}'
    error: false
    strict: false
  - name: use globals from outer scope
    template: '{% include ''outer-scope'' %}'
    want: Hello, Holly
    context:
      customer:
        first_name: Holly
    partials:
      outer-scope: Hello, {{ customer.first_name }}
    error: false
    strict: false
- name: liquid.golden.increment_tag
  tests:
  - name: assign and increment
    template: '{% assign foo = 5 %}{{ foo }} {% increment foo %} {% increment foo
      %} {{ foo }}'
    want: 5 0 1 5
    context: {}
    partials: {}
    error: false
    strict: false
  - name: incrementing counter renders before incrementing
    template: '{% increment foo %} {{ foo }}'
    want: 0 1
    context: {}
    partials: {}
    error: false
    strict: false
  - name: multiple named counters
    template: '{% increment foo %} {% increment bar %} {% increment foo %} {% increment
      bar %}'
    want: 0 0 1 1
    context: {}
    partials: {}
    error: false
    strict: false
  - name: named counter
    template: '{% increment foo %} {% increment foo %} {% increment foo %}'
    want: 0 1 2
    context: {}
    partials: {}
    error: false
    strict: false
  - name: named counters are in scope for subsequent expressions
    template: '{% increment foo %} {% increment foo %} {% if foo > 0 %}{{ foo }}{%
      endif %}'
    want: 0 1 2
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.inline_comment_tag
  tests:
  - name: can't comment tags
    template: '{%- # {% echo ''hello world'' %} -%}'
    want: ' -%}'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: comment with double quote
    template: '{%# some "comment %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: comment with double quoted string
    template: '{%# some "comment" %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: comment with single quote
    template: '{%# some ''comment %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: comment with single quoted string
    template: '{%# some ''comment'' %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: comment with u2018
    template: "{%# some \u2018comment %}"
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: comment with u201C
    template: "{%# some \u201Ccomment %}"
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: empty
    template: '{%#%}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: enforce leading hash
    template: "{%-\n  # spread inline comments\n  over multiple lines\n-%}"
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: liquid tag
    template: "{% liquid \n  # first comment line\n  # second comment line\n\n  #\
      \ another comment line\n  echo 'Hello '\n\n  # more comments\n  echo 'goodbye'\n\
      -%}"
    want: Hello goodbye
    context: {}
    partials: {}
    error: false
    strict: false
  - name: lots of hashes in a liquid tag
    template: "{% liquid\n  ##########################\n  # spread inline comments\
      \ #\n  ##########################\n-%}"
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: multiple lines
    template: "{%-\n  # spread inline comments\n  # over multiple lines\n-%}"
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: no padding after the hash
    template: '{%#some comment %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: no whitespace control no padding
    template: '{%# some comment %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: no whitespace control with padding
    template: '{% # some comment %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: with whitespace control and padding
    template: '{%- # some comment -%}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: with whitespace control no padding
    template: '{%-# some comment -%}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.join_filter
  tests:
  - name: argument is not a string
    template: '{{ arr | join: 5 }}'
    want: a5b
    context:
      arr:
      - a
      - b
    partials: {}
    error: false
    strict: false
  - name: join an array of integers
    template: '{{ arr | join: ''#'' }}'
    want: 1#2
    context:
      arr:
      - 1
      - 2
    partials: {}
    error: false
    strict: false
  - name: join an array of strings
    template: '{{ arr | join: ''#'' }}'
    want: a#b
    context:
      arr:
      - a
      - b
    partials: {}
    error: false
    strict: false
  - name: joining a string is a noop
    template: '{{ ''a,b'' | join: ''#'' }}'
    want: a,b
    context: {}
    partials: {}
    error: false
    strict: false
  - name: joining an int is a noop
    template: '{{ 123 | join: ''#'' }}'
    want: '123'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: left value contains non string
    template: '{{ arr | join: ''#'' }}'
    want: a#b#1
    context:
      arr:
      - a
      - b
      - 1
    partials: {}
    error: false
    strict: false
  - name: missing argument defaults to a space
    template: '{{ arr | join }}'
    want: a b
    context:
      arr:
      - a
      - b
    partials: {}
    error: false
    strict: false
  - name: range literal join filter left value
    template: '{{ (1..3) | join: ''#'' }}'
    want: 1#2#3
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ arr | join: ''#'', 42 }}'
    want: ''
    context:
      arr:
      - a
      - b
    partials: {}
    error: true
    strict: false
  - name: undefined argument
    template: '{{ arr | join: nosuchthing }}'
    want: ab
    context:
      arr:
      - a
      - b
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | join: ''#'' }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.last_filter
  tests:
  - name: array of strings
    template: '{{ arr | last }}'
    want: b
    context:
      arr:
      - a
      - b
    partials: {}
    error: false
    strict: false
  - name: array of things
    template: '{{ arr | last }}'
    want: '{}'
    context:
      arr:
      - a
      - b
      - 1
      - []
      - {}
    partials: {}
    error: false
    strict: false
  - name: empty array
    template: '{{ arr | last }}'
    want: ''
    context:
      arr: []
    partials: {}
    error: false
    strict: false
  - name: last of a hash
    template: '{{ a | last }}'
    want: ''
    context:
      a:
        b: 1
        c: 2
    partials: {}
    error: false
    strict: false
  - name: last of a string
    template: '{{ ''hello'' | last }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: left value is undefined
    template: '{{ nosuchthing | last }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: left value not an array
    template: '{{ arr | last }}'
    want: ''
    context:
      arr: 12
    partials: {}
    error: false
    strict: false
  - name: range literal last filter left value
    template: '{{ (1..3) | last }}'
    want: '3'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.liquid_tag
  tests:
  - name: bare liquid tag in liquid tag
    template: "{%- liquid\n  liquid\n  echo \"foo\"\n-%}"
    want: foo
    context: {}
    partials: {}
    error: false
    strict: false
  - name: can't close nested blocks
    template: '{%- if true -%}

      42

      {%- liquid endif -%}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: carriage return and newline terminated tags
    template: "{% liquid\r\nif product.title\r\n   echo product.title | upcase\r\n\
      else\r\n   echo 'product-1' | upcase \r\nendif\r\n\r\nfor i in (0..5)\r\n  \
      \ echo i\r\nendfor %}"
    want: FOO012345
    context:
      product:
        title: foo
    partials: {}
    error: false
    strict: false
  - name: carriage return terminated tags
    template: "{% liquid\rif product.title\r   echo product.title | upcase\relse\r\
      \   echo 'product-1' | upcase \rendif\r\rfor i in (0..5)\r   echo i\rendfor\
      \ %}"
    want: ''
    context:
      product:
        title: foo
    partials: {}
    error: true
    strict: false
  - name: empty liquid tag
    template: '{% liquid %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: liquid tag in liquid tag
    template: "{%- liquid\n  liquid echo 'bar'\n  echo \"foo\"\n-%}"
    want: barfoo
    context: {}
    partials: {}
    error: false
    strict: false
  - name: multi-line comment tag
    template: '{% liquid

      comment this is a comment

      split over two lines

      endcomment

      %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: nested liquid
    template: "{%- if true %}\n  {%- liquid\n    echo \"good\"\n  %}\n{%- endif -%}"
    want: good
    context: {}
    partials: {}
    error: false
    strict: false
  - name: nested liquid in liquid tag
    template: '{%- liquid liquid liquid echo "foo" -%}'
    want: foo
    context: {}
    partials: {}
    error: false
    strict: false
  - name: newline terminated tags
    template: "{% liquid\nif product.title\n   echo product.title | upcase\nelse\n\
      \   echo 'product-1' | upcase \nendif\n\nfor i in (0..5)\n   echo i\nendfor\
      \ %}"
    want: FOO012345
    context:
      product:
        title: foo
    partials: {}
    error: false
    strict: false
  - name: only whitespace
    template: "{% liquid\n   \n\n   \t \n\t\n  %}"
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: 'reference test #2'
    template: "{%- liquid\n  for value in array\n    echo value\n    unless forloop.last\n\
      \      echo '#'\n    endunless\n  endfor\n-%}"
    want: 1#2#3
    context:
      array:
      - 1
      - 2
      - 3
    partials: {}
    error: false
    strict: false
  - name: 'reference test #3'
    template: "{%- liquid\n  for value in array\n    assign double_value = value |\
      \ times: 2\n    echo double_value | times: 2\n    unless forloop.last\n    \
      \  echo '#'\n    endunless\n  endfor\n\n  echo '#'\n  echo double_value\n-%}"
    want: 4#8#12#6
    context:
      array:
      - 1
      - 2
      - 3
    partials: {}
    error: false
    strict: false
  - name: 'reference test #4'
    template: '{%- liquid echo ''a'' -%}

      b

      {%- liquid echo ''c'' -%}'
    want: abc
    context: {}
    partials: {}
    error: false
    strict: false
  - name: single line comment tag
    template: '{% liquid

      comment this is a comment

      endcomment

      %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: whitespace control
    template: "Hello,     \n{%- liquid\n  echo ' World! '\n-%}\n   Goodbye."
    want: Hello, World! Goodbye.
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.lstrip_filter
  tests:
  - name: left and right padded
    template: "{{ \" \t\r\n  hello  \t\r\n \" | lstrip }}"
    want: "hello  \t\r\n "
    context: {}
    partials: {}
    error: false
    strict: false
  - name: left padded
    template: "{{ \" \t\r\n  hello\" | lstrip }}"
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string
    template: '{{ 5 | lstrip }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: right padded
    template: "{{ \"hello \t\r\n  \" | lstrip }}"
    want: "hello \t\r\n  "
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | lstrip }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "hello" | lstrip: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.map_filter
  tests:
  - name: array containing a non object
    template: '{{ a | map: ''title'' | join: ''#'' }}'
    want: ''
    context:
      a:
      - title: foo
      - title: bar
      - 5
      - []
    partials: {}
    error: true
    strict: false
  - name: array of objects
    template: '{{ a | map: ''title'' | join: ''#'' }}'
    want: foo#bar#baz
    context:
      a:
      - title: foo
      - title: bar
      - title: baz
    partials: {}
    error: false
    strict: false
  - name: input is a hash
    template: '{{ a | map: ''title'' | join: ''#'' }}'
    want: foo
    context:
      a:
        title: foo
        some: thing
    partials: {}
    error: false
    strict: false
  - name: left value not an array
    template: '{{ a | map: ''title'' | join: ''#'' }}'
    want: ''
    context:
      a: 123
    partials: {}
    error: true
    strict: false
  - name: missing property
    template: '{{ a | map: ''title'' | join: ''#'' }}'
    want: foo#bar#
    context:
      a:
      - title: foo
      - title: bar
      - heading: baz
    partials: {}
    error: false
    strict: false
  - name: nested arrays get flattened
    template: '{{ a | map: ''title'' | join: ''#'' }}'
    want: foo#bar#baz
    context:
      a:
      - title: foo
      - - title: bar
        - title: baz
    partials: {}
    error: false
    strict: false
  - name: undefined argument
    template: '{{ a | map: nosuchthing | join: ''#'' }}'
    want: '#'
    context:
      a:
      - title: foo
      - title: bar
    partials: {}
    error: false
    strict: false
- name: liquid.golden.minus_filter
  tests:
  - name: arg string not a number
    template: '{{ "10" | minus: "foo" }}'
    want: '10'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: float value and float arg
    template: '{{ 10.1 | minus: 2.2 }}'
    want: '7.9'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: integer value and float arg
    template: '{{ 10 | minus: 2.0 }}'
    want: '8.0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: integer value and integer arg
    template: '{{ 10 | minus: 2 }}'
    want: '8'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string, int or float
    template: '{{ a | minus: 1 }}'
    want: '-1'
    context:
      a: {}
    partials: {}
    error: false
    strict: false
  - name: string not a number
    template: '{{ "foo" | minus: "2.0" }}'
    want: '-2.0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string value and string arg
    template: '{{ "10.1" | minus: "2.2" }}'
    want: '7.9'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many args
    template: '{{ 5 | minus: 1, ''5'' }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined argument
    template: '{{ 10 | minus: nosuchthing }}'
    want: '10'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | minus: 2 }}'
    want: '-2'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.modulo_filter
  tests:
  - name: arg string not a number
    template: '{{ "10" | modulo: "foo" }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: float value and float arg
    template: '{{ 10.1 | modulo: 7.0 }}'
    want: '3.1'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: integer value and float arg
    template: '{{ 10 | modulo: 2.0 }}'
    want: '0.0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: integer value and integer arg
    template: '{{ 10 | modulo: 2 }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string, int or float
    template: '{{ a | modulo: 1 }}'
    want: '0'
    context:
      a: {}
    partials: {}
    error: false
    strict: false
  - name: string not a number
    template: '{{ "foo" | modulo: "2.0" }}'
    want: '0.0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string value and argument
    template: '{{ "10" | modulo: "2.0" }}'
    want: '0.0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many args
    template: '{{ 5 | modulo: 1, ''5'' }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined argument
    template: '{{ 5 | modulo: nosuchthing }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | modulo: 2 }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.newline_to_br_filter
  tests:
  - name: not a string
    template: '{{ 5 | newline_to_br }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: reference implementation test 1
    template: '{{ "a

      b

      c" | newline_to_br }}'
    want: 'a<br />

      b<br />

      c'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: reference implementation test 2
    template: "{{ \"a\r\nb\nc\" | newline_to_br }}"
    want: 'a<br />

      b<br />

      c'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string with newlines
    template: '{{ "- apples

      - oranges

      " | newline_to_br }}'
    want: '- apples<br />

      - oranges<br />

      '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | newline_to_br }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "hello" | newline_to_br: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.not_liquid
  tests:
  - name: css text gets passed through unchanged
    template: ' div { font-weight: bold; } '
    want: ' div { font-weight: bold; } '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: plain text gets passed through unchanged
    template: a literal string
    want: a literal string
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.output_statement
  tests:
  - name: access an array item by index
    template: '{{ product.tags[1] }}'
    want: garden
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: access an array item by negative index
    template: '{{ product.tags[-2] }}'
    want: sports
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: access an undefined variable by index
    template: '{{ nosuchthing[0] }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: access array item by index stored in a local variable
    template: '{% assign i = 1 %}{{ product.tags[i] }}'
    want: garden
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: assign a variable the value of an existing variable
    template: '{% capture some %}hello{% endcapture %}{% assign other = some %}{%
      assign some = ''foo'' %}{{ some }}-{{ other }}'
    want: foo-hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: bracketed variable resolves to a string
    template: '{{ foo[something] }}'
    want: goodbye
    context:
      foo:
        hello: goodbye
      something: hello
    partials: {}
    error: false
    strict: false
  - name: bracketed variable resolves to a string without leading identifier
    template: '{{ [something] }}'
    want: goodbye
    context:
      something: hello
      hello: goodbye
    partials: {}
    error: false
    strict: false
  - name: chained bracketed identifier index
    template: '{{ products[0].title }}'
    want: shoe
    context:
      products:
      - title: shoe
      - title: hat
    partials: {}
    error: false
    strict: false
  - name: chained bracketed identifier index no dot
    template: '{{ products[0]title }}'
    want: shoe
    context:
      products:
      - title: shoe
      - title: hat
    partials: {}
    error: false
    strict: false
  - name: chained identifier dot separated index
    template: '{{ products.0.title }}'
    want: ''
    context:
      products:
      - title: shoe
      - title: hat
    partials: {}
    error: true
    strict: true
  - name: dump an array from the global context
    template: '{{ product.tags | join: ''#'' }}'
    want: sports#garden
    context:
      product:
        tags:
        - sports
        - garden
    partials: {}
    error: false
    strict: false
  - name: nested bracketed variable resolving to a string
    template: '{{ [list[settings.zero]] }}'
    want: bar
    context:
      list:
      - foo
      settings:
        zero: 0
      foo: bar
    partials: {}
    error: false
    strict: false
  - name: quoted, bracketed variable name
    template: '{{ foo[''bar''] }}'
    want: '42'
    context:
      foo:
        bar: 42
    partials: {}
    error: false
    strict: false
  - name: quoted, bracketed variable name with whitespace
    template: '{{ foo[''bar baz''] }}'
    want: '42'
    context:
      foo:
        bar baz: 42
    partials: {}
    error: false
    strict: false
  - name: render a default given a literal false
    template: '{{ false | default: ''bar'' }}'
    want: bar
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render a default given a literal false with 'allow false' equal to false
    template: '{{ false | default: ''bar'', allow_false: false }}'
    want: bar
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render a default given a literal false with 'allow false' equal to true
    template: '{{ false | default: ''bar'', allow_false: true }}'
    want: 'false'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render a float literal
    template: '{{ 1.23 }}'
    want: '1.23'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render a global variable with a filter
    template: '{{ product.title | upcase }}'
    want: FOO
    context:
      product:
        title: foo
    partials: {}
    error: false
    strict: false
  - name: render a negative integer literal
    template: '{{ -123 }}'
    want: '-123'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render a range object
    template: '{{ (1..5) | join: ''#'' }}'
    want: 1#2#3#4#5
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render a range object that uses a float
    template: '{{ (1.4..5) | join: ''#'' }}'
    want: 1#2#3#4#5
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render a range object that uses an identifier
    template: '{{ (foo..5) | join: ''#'' }}'
    want: 2#3#4#5
    context:
      foo: 2
    partials: {}
    error: false
    strict: false
  - name: render a string literal
    template: '{{ ''hello'' }}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render a variable from the global namespace
    template: '{{ product.title }}'
    want: foo
    context:
      product:
        title: foo
    partials: {}
    error: false
    strict: false
  - name: render a variable from the local namespace
    template: '{% assign name = ''Brian'' %}{{ name }}'
    want: Brian
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render an integer literal
    template: '{{ 123 }}'
    want: '123'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render an output start sequence as a string literal
    template: '{{ ''{{'' }}'
    want: '{{'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render an undefined property
    template: '{{ product.age }}'
    want: ''
    context:
      product:
        title: foo
    partials: {}
    error: false
    strict: false
  - name: render an undefined variable
    template: '{{ age }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: render nil
    template: '{{ nil }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: reverse a range
    template: '{{ (foo..5) | reverse | join: ''#'' }}'
    want: 5#4#3#2
    context:
      foo: 2
    partials: {}
    error: false
    strict: false
  - name: top-level quoted, bracketed variable name with whitespace
    template: '{{ [''bar baz''] }}'
    want: '42'
    context:
      bar baz: 42
    partials: {}
    error: false
    strict: false
  - name: top-level quoted, bracketed variable name with whitespace followed by dot
      notation
    template: '{{ [''bar baz''].qux }}'
    want: '42'
    context:
      bar baz:
        qux: 42
    partials: {}
    error: false
    strict: false
  - name: traverse variables with bracketed identifiers
    template: '{{ site.data.menu[include.menu][include.locale] }}'
    want: it works!
    context:
      site:
        data:
          menu:
            foo:
              bar: it works!
      include:
        menu: foo
        locale: bar
    partials: {}
    error: false
    strict: false
  - name: unexpected left value for the `join` filter passes through
    template: '{{ 12 | join: ''#'' }}'
    want: '12'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.plus_filter
  tests:
  - name: arg string not a number
    template: '{{ "10" | plus: "foo" }}'
    want: '10'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: float value and float arg
    template: '{{ 10.1 | plus: 2.2 }}'
    want: '12.3'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: integer value and float arg
    template: '{{ 10 | plus: 2.0 }}'
    want: '12.0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: integer value and integer arg
    template: '{{ 10 | plus: 2 }}'
    want: '12'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: integer value and negative integer arg
    template: '{{ 10 | plus: -2 }}'
    want: '8'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string, int or float
    template: '{{ a | plus: 1 }}'
    want: '1'
    context:
      a: {}
    partials: {}
    error: false
    strict: false
  - name: string not a number
    template: '{{ "foo" | plus: "2.0" }}'
    want: '2.0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string value and string arg
    template: '{{ "10.1" | plus: "2.2" }}'
    want: '12.3'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many args
    template: '{{ 5 | plus: 1, ''5'' }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined argument
    template: '{{ 10 | plus: nosuchthing }}'
    want: '10'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | plus: 2 }}'
    want: '2'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.prepend_filter
  tests:
  - name: argument not a string
    template: '{{ "hello" | prepend: 5 }}'
    want: 5hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: concat
    template: '{{ "hello" | prepend: "there" }}'
    want: therehello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: missing argument
    template: '{{ "hello" | prepend }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: not a string
    template: '{{ 5 | prepend: ''there'' }}'
    want: there5
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ "hello" | prepend: "how", "are", "you" }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined argument
    template: '{{ "hi" | prepend: nosuchthing }}'
    want: hi
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | prepend: "hi" }}'
    want: hi
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.range_objects
  tests:
  - name: end is less than start
    template: '{{ (start..end) | join: ''#'' }}'
    want: ''
    context:
      start: 5
      end: 1
    partials: {}
    error: false
    strict: false
  - name: end is not a number
    template: '{{ (start..end) | join: ''#'' }}'
    want: ''
    context:
      start: '1'
      end: foo
    partials: {}
    error: false
    strict: false
  - name: start and end are negative
    template: '{{ (start..end) | join: ''#'' }}'
    want: -5#-4#-3#-2
    context:
      start: -5
      end: -2
    partials: {}
    error: false
    strict: false
  - name: start is negative
    template: '{{ (start..end) | join: ''#'' }}'
    want: -5#-4#-3#-2#-1#0#1
    context:
      start: -5
      end: 1
    partials: {}
    error: false
    strict: false
  - name: start is not a number
    template: '{{ (start..end) | join: ''#'' }}'
    want: 0#1#2#3#4#5
    context:
      start: foo
      end: 5
    partials: {}
    error: false
    strict: false
- name: liquid.golden.raw_tag
  tests:
  - name: continue after raw
    template: '{% raw %} {% some raw content %} {% endraw %}a literal'
    want: ' {% some raw content %} a literal'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: literal
    template: '{% raw %}foo{% endraw %}'
    want: foo
    context: {}
    partials: {}
    error: false
    strict: false
  - name: partial tag
    template: '{% raw %} %} {% }} {{ {% endraw %}'
    want: ' %} {% }} {{ '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: statement
    template: '{% raw %}{{ foo }}{% endraw %}'
    want: '{{ foo }}'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: tag
    template: '{% raw %}{% assign x = 1 %}{% endraw %}'
    want: '{% assign x = 1 %}'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.remove_filter
  tests:
  - name: argument not a string
    template: '{{ "hello" | remove: 5 }}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: missing argument
    template: '{{ "hello" | remove }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: not a string
    template: '{{ 5 | remove: ''there'' }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: remove substrings
    template: '{{ "I strained to see the train through the rain" | remove: "rain"
      }}'
    want: 'I sted to see the t through the '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ "hello" | remove: "how", "are", "you" }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined argument
    template: '{{ "hello" | remove: nosuchthing }}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | remove: "rain" }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.remove_first_filter
  tests:
  - name: argument not a string
    template: '{{ "hello" | remove_first: 5 }}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: missing argument
    template: '{{ "hello" | remove_first }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: not a string
    template: '{{ 5 | remove_first: ''rain'' }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: remove substrings
    template: '{{ "I strained to see the train through the rain" | remove_first: "rain"
      }}'
    want: I sted to see the train through the rain
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ "hello" | remove_first: "how", "are", "you" }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined argument
    template: '{{ "hello" | remove_first: nosuchthing }}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | remove_first: "rain" }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.remove_last_filter
  tests:
  - name: argument not a string
    template: '{{ "hello" | remove_last: 5 }}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: missing argument
    template: '{{ "hello" | remove_last }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: not a string
    template: '{{ 5 | remove_last: ''rain'' }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: remove substrings
    template: '{{ "I strained to see the train through the rain" | remove_last: "rain"
      }}'
    want: 'I strained to see the train through the '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ "hello" | remove_last: "how", "are", "you" }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined argument
    template: '{{ "hello" | remove_last: nosuchthing }}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | remove_last: "rain" }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.render_tag
  tests:
  - name: assign to keyword argument
    template: '{% render ''product-args'', foo: ''hello'' %}{{ foo }}'
    want: hello goodbye
    context: {}
    partials:
      product-args: '{{ foo }}{% assign foo=''goodbye'' %} {{ foo }}'
    error: false
    strict: false
  - name: assigned variables do not leak into outer scope
    template: '{% render ''assign-outer-scope'', customer: customer %} {{ last_name
      }}'
    want: 'Hello, Holly '
    context:
      customer:
        first_name: Holly
    partials:
      assign-outer-scope: Hello, {{ customer.first_name }}{% assign last_name = 'Smith'
        %}
    error: false
    strict: false
  - name: bound array variable
    template: '{% render ''prod'' for collection.products %}'
    want: bikecar
    context:
      collection:
        products:
        - title: bike
        - title: car
    partials:
      prod: '{{ prod.title }}'
    error: false
    strict: false
  - name: bound variable
    template: '{% render ''product-title'' with collection.products[1] %}'
    want: car
    context:
      collection:
        products:
        - title: bike
        - title: car
    partials:
      product-title: '{{ product-title.title }}'
    error: false
    strict: false
  - name: bound variable does not exist
    template: '{% render ''product-title'' with no.such.thing %}'
    want: ''
    context: {}
    partials:
      product-title: '{{ product-title.title }}'
    error: false
    strict: false
  - name: bound variable with alias
    template: '{% render ''product-alias'' with collection.products[1] as product
      %}'
    want: car
    context:
      collection:
        products:
        - title: bike
        - title: car
    partials:
      product-alias: '{{ product.title }}'
    error: false
    strict: false
  - name: decrement is isolated between renders
    template: '{% decrement foo %} {% render ''decrement'' %} {% decrement foo %}'
    want: -1 -1 -2
    context: {}
    partials:
      decrement: '{% decrement foo %}'
    error: false
    strict: false
  - name: for loop variables go out of scope
    template: '{% for i in (1..3) %}{{ i }}{% render ''loop-scope'' %}{{ i }}{% endfor
      %}{{ i }}'
    want: '112233'
    context: {}
    partials:
      loop-scope: '{{ i }}'
    error: false
    strict: false
  - name: forloop helper
    template: '{% render ''product'' for collection.products %}'
    want: 'Product: bike first index:1 Product: car last index:2 '
    context:
      collection:
        products:
        - title: bike
        - title: car
    partials:
      product: 'Product: {{ product.title }} {% if forloop.first %}first{% endif %}{%
        if forloop.last %}last{% endif %} index:{{ forloop.index }} '
    error: false
    strict: false
  - name: increment is isolated between renders
    template: '{% increment foo %} {% render ''increment'' %} {% increment foo %}'
    want: 0 0 1
    context: {}
    partials:
      increment: '{% increment foo %}'
    error: false
    strict: false
  - name: parent variables go out of scope
    template: '{% assign greeting = ''good morning'' %}{{ greeting }} {% render ''outer-scope''
      %}{{ greeting }}'
    want: good morning good morning
    context: {}
    partials:
      outer-scope: '{{ greeting }}'
    error: false
    strict: false
  - name: render loops can't access parentloop
    template: '{% for x in (1..3) %}{% render ''product'' for collection.products
      %}{% endfor %}'
    want: 'bike-0 car-1 bike-0 car-1 bike-0 car-1 '
    context:
      collection:
        products:
        - title: bike
        - title: car
    partials:
      product: '{{ product.title }}-{{ forloop.index0 }} {{ forloop.parentloop.index0
        }}'
    error: false
    strict: false
  - name: render loops don't add parentloop
    template: '{% render ''product'' for collection.products %}'
    want: 'bike-0 0 1 2 car-1 0 1 2 '
    context:
      collection:
        products:
        - title: bike
        - title: car
    partials:
      product: '{{ product.title }}-{{ forloop.index0 }} {% for x in (1..3) %}{{ forloop.index0
        }}{{ forloop.parentloop.index0 }} {% endfor %}'
    error: false
    strict: false
  - name: some keyword arguments
    template: '{% render ''product-args'', foo: ''hello'', bar: ''there'' %}'
    want: hello there
    context: {}
    partials:
      product-args: '{{ foo }} {{ bar }}'
    error: false
    strict: false
  - name: some keyword arguments including a range literal
    template: '{% render ''product-args'', foo: (1..3), bar: ''there'' %}'
    want: 1#2#3 there
    context: {}
    partials:
      product-args: '{{ foo | join: ''#'' }} {{ bar }}'
    error: false
    strict: false
  - name: some keyword arguments no leading coma
    template: '{% render ''product-args'' foo: ''hello'', bar: ''there'' %}'
    want: hello there
    context: {}
    partials:
      product-args: '{{ foo }} {{ bar }}'
    error: false
    strict: false
  - name: string literal name
    template: '{% render ''product-hero'', product: product %}'
    want: 'foo

      - sports - garden '
    context:
      product:
        title: foo
        tags:
        - sports
        - garden
    partials:
      product-hero: '{{ product.title }}

        {% for tag in product.tags %}- {{ tag }} {% endfor %}'
    error: false
    strict: false
- name: liquid.golden.replace_filter
  tests:
  - name: argument not a string
    template: '{{ "hello" | replace: 5, "your" }}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: left value is an object
    template: '{{ a | replace: ''{'', ''!'' }}'
    want: '!}'
    context:
      a: {}
    partials: {}
    error: false
    strict: false
  - name: missing argument
    template: '{{ "hello" | replace: "ll" }}'
    want: heo
    context: {}
    partials: {}
    error: false
    strict: false
  - name: missing arguments
    template: '{{ "hello" | replace }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: not a string
    template: '{{ 5 | replace: ''rain'', ''foo'' }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: replace substrings
    template: '{{ "Take my protein pills and put my helmet on" | replace: "my", "your"
      }}'
    want: Take your protein pills and put your helmet on
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ "hello" | replace: "how", "are", "you" }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined first argument
    template: '{{ "Take my protein" | replace: nosuchthing, "#" }}'
    want: '#T#a#k#e# #m#y# #p#r#o#t#e#i#n#'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | replace: "my", "your" }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined second argument
    template: '{{ "Take my protein pills and put my helmet on" | replace: "my", nosuchthing
      }}'
    want: Take  protein pills and put  helmet on
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.replace_first_filter
  tests:
  - name: argument not a string
    template: '{{ "hello5" | replace_first: 5, "your" }}'
    want: helloyour
    context: {}
    partials: {}
    error: false
    strict: false
  - name: missing argument
    template: '{{ "hello" | replace_first: "ll" }}'
    want: heo
    context: {}
    partials: {}
    error: false
    strict: false
  - name: missing arguments
    template: '{{ "hello" | replace_first }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: not a string
    template: '{{ 5 | replace_first: ''rain'', ''foo'' }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: replace substrings
    template: '{{ "Take my protein pills and put my helmet on" | replace_first: "my",
      "your" }}'
    want: Take your protein pills and put my helmet on
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ "hello" | replace_first: "how", "are", "you" }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined first argument
    template: '{{ "Take my protein" | replace_first: nosuchthing, "#" }}'
    want: '#Take my protein'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | replace_first: "my", "your" }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined second argument
    template: '{{ "Take my protein pills and put my helmet on" | replace_first: "my",
      nosuchthing }}'
    want: Take  protein pills and put my helmet on
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.replace_last_filter
  tests:
  - name: argument not a string
    template: '{{ "hello5" | replace_last: 5, "your" }}'
    want: helloyour
    context: {}
    partials: {}
    error: false
    strict: false
  - name: missing argument
    template: '{{ "hello" | replace_last: "ll" }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: missing arguments
    template: '{{ "hello" | replace_last }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: not a string
    template: '{{ 5 | replace_last: ''rain'', ''foo'' }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: replace substrings
    template: '{{ "Take my protein pills and put my helmet on" | replace_last: "my",
      "your" }}'
    want: Take my protein pills and put your helmet on
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ "hello" | replace_last: "how", "are", "you" }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined first argument
    template: '{{ "Take my protein" | replace_last: nosuchthing, "#" }}'
    want: Take my protein#
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | replace_last: "my", "your" }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined second argument
    template: '{{ "Take my protein pills and put my helmet on" | replace_last: "my",
      nosuchthing }}'
    want: Take my protein pills and put  helmet on
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.reverse_filter
  tests:
  - name: array of strings
    template: '{{ a | reverse | join: ''#'' }}'
    want: A#B#a#b
    context:
      a:
      - b
      - a
      - B
      - A
    partials: {}
    error: false
    strict: false
  - name: array of things
    template: '{{ a | reverse | join: ''#'' }}'
    want: '{}#1#b#a'
    context:
      a:
      - a
      - b
      - 1
      - []
      - {}
    partials: {}
    error: false
    strict: false
  - name: empty array
    template: '{{ a | reverse | join: ''#'' }}'
    want: ''
    context:
      a: []
    partials: {}
    error: false
    strict: false
  - name: left value is undefined
    template: '{{ nosuchthing | reverse | join: ''#'' }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: left value not an array
    template: '{{ a | reverse | join: ''#'' }}'
    want: '123'
    context:
      a: 123
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ a | reverse: 0 | join: ''#'' }}'
    want: ''
    context:
      a: []
    partials: {}
    error: true
    strict: false
- name: liquid.golden.round_filter
  tests:
  - name: argument is a float
    template: '{{ 5.666 | round: 1.2 }}'
    want: '5.7'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: argument is a negative
    template: '{{ 5.666 | round: -2 }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: argument is a string
    template: '{{ 5.666 | round: ''foo'' }}'
    want: '6'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: argument is a string representation of an integer
    template: '{{ 5.666 | round: ''1'' }}'
    want: '5.7'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: argument is a string representation of zero
    template: '{{ 5.666 | round: ''1'' }}'
    want: '5.7'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: argument is a zero
    template: '{{ 5.666 | round: 0 }}'
    want: '6'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: decimal places
    template: '{{ "5.666666" | round: 2 }}'
    want: '5.67'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: float as a string
    template: '{{ "5.6" | round }}'
    want: '6'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: float round down
    template: '{{ 5.1 | round }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: float round up
    template: '{{ 5.6 | round }}'
    want: '6'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: integer
    template: '{{ 5 | round }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string argument
    template: '{{ 5.666 | round: "1" }}'
    want: '5.7'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many args
    template: '{{ 5 | round: 1, 2 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined argument
    template: '{{ 5.666 | round: nosuchthing }}'
    want: '6'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | round: 2 }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.rstrip_filter
  tests:
  - name: left and right padded
    template: "{{ \" \t\r\n  hello  \t\r\n \" | rstrip }}"
    want: " \t\r\n  hello"
    context: {}
    partials: {}
    error: false
    strict: false
  - name: left padded
    template: "{{ \" \t\r\n  hello\" | rstrip }}"
    want: " \t\r\n  hello"
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string
    template: '{{ 5 | rstrip }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: right padded
    template: "{{ \"hello \t\r\n  \" | rstrip }}"
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | rstrip }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "hello" | rstrip: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.size_filter
  tests:
  - name: size of a hash
    template: '{{ a | size }}'
    want: '2'
    context:
      a:
        a: 1
        b: 2
    partials: {}
    error: false
    strict: false
  - name: size of a string
    template: '{{ a | size }}'
    want: '3'
    context:
      a: abc
    partials: {}
    error: false
    strict: false
  - name: size of an array
    template: '{{ a | size }}'
    want: '3'
    context:
      a:
      - a
      - b
      - c
    partials: {}
    error: false
    strict: false
  - name: size of an empty array
    template: '{{ a | size }}'
    want: '0'
    context:
      a: []
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | size }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ a | size: ''foo'' }}'
    want: ''
    context:
      a:
      - 1
      - 2
      - 3
    partials: {}
    error: true
    strict: false
- name: liquid.golden.slice_filter
  tests:
  - name: first argument is a float
    template: '{{ ''Liquid'' | slice: 2.2 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: first argument is a string
    template: '{{ "hello" | slice: "2" }}'
    want: l
    context: {}
    partials: {}
    error: false
    strict: false
  - name: first argument not an integer
    template: '{{ "hello" | slice: "foo" }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: missing arguments
    template: '{{ "hello" | slice }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: negative first argument
    template: '{{ ''Liquid'' | slice: -2 }}'
    want: i
    context: {}
    partials: {}
    error: false
    strict: false
  - name: negative first argument and length out of range
    template: '{{ ''Liquid'' | slice: -2, 99 }}'
    want: id
    context: {}
    partials: {}
    error: false
    strict: false
  - name: negative first argument and negative length
    template: '{{ ''Liquid'' | slice: -2, -1 }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: negative first argument and positive length
    template: '{{ ''Liquid'' | slice: -2, 2 }}'
    want: id
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string
    template: '{{ 5 | slice: 1 }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: one
    template: '{{ "hello" | slice: 1 }}'
    want: e
    context: {}
    partials: {}
    error: false
    strict: false
  - name: one length three
    template: '{{ "hello" | slice: 1, 3 }}'
    want: ell
    context: {}
    partials: {}
    error: false
    strict: false
  - name: out of range
    template: '{{ "hello" | slice: 99 }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: second argument is a float
    template: '{{ ''Liquid'' | slice: 1, 2.2 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: second argument is a string
    template: '{{ "hello" | slice: 3, "2" }}'
    want: lo
    context: {}
    partials: {}
    error: false
    strict: false
  - name: second argument not an integer
    template: '{{ "hello" | slice: 5, "foo" }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: slice an array of numbers
    template: '{{ a | slice: 2, 3 | join: ''#'' }}'
    want: 3#4#5
    context:
      a:
      - 1
      - 2
      - 3
      - 4
      - 5
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ "hello" | slice: 1, 2, 3 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined first argument
    template: '{{ "hello" | slice: nosuchthing, 3 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | slice: 1, 3 }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined second argument
    template: '{{ "hello" | slice: 1, nosuchthing }}'
    want: e
    context: {}
    partials: {}
    error: false
    strict: false
  - name: zero
    template: '{{ "hello" | slice: 0 }}'
    want: h
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.sort_filter
  tests:
  - name: argument is undefined
    template: '{{ a | sort: nosuchthing | join: ''#'' }}'
    want: a#b
    context:
      a:
      - b
      - a
    partials: {}
    error: false
    strict: false
  - name: array of integers
    template: '{{ a | sort | join: ''#'' }}'
    want: 1#3#30#1000
    context:
      a:
      - 1
      - 1000
      - 3
      - 30
    partials: {}
    error: false
    strict: false
  - name: array of objects
    template: '{% assign x = a | sort: ''title'' %}{% for obj in x %}{% for i in obj
      %}({{ i[0] }},{{ i[1] }}){% endfor %}{% endfor %}'
    want: (title,Baz)(title,bar)(title,foo)
    context:
      a:
      - title: foo
      - title: Baz
      - title: bar
    partials: {}
    error: false
    strict: false
  - name: array of objects with missing key
    template: '{% assign x = a | sort: ''title'' %}{% for obj in x %}{% for i in obj
      %}({{ i[0] }},{{ i[1] }}){% endfor %}{% endfor %}'
    want: (title,bar)(title,foo)(heading,Baz)
    context:
      a:
      - title: foo
      - heading: Baz
      - title: bar
    partials: {}
    error: false
    strict: false
  - name: array of strings
    template: '{{ a | sort | join: ''#'' }}'
    want: A#B#C#a#b
    context:
      a:
      - b
      - a
      - C
      - B
      - A
    partials: {}
    error: false
    strict: false
  - name: empty array
    template: '{{ a | sort | join: ''#'' }}'
    want: ''
    context:
      a: []
    partials: {}
    error: false
    strict: false
  - name: incompatible types
    template: '{{ a | sort }}'
    want: ''
    context:
      a:
      - []
      - {}
      - 1
      - '4'
    partials: {}
    error: true
    strict: false
  - name: left value is not an array
    template: '{{ a | sort | join: ''#'' }}'
    want: '123'
    context:
      a: 123
    partials: {}
    error: false
    strict: false
  - name: left value is undefined
    template: '{{ nosuchthing | sort | join: ''#'' }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: sort a string
    template: '{{ ''BzAa4'' | sort | join: ''#'' }}'
    want: BzAa4
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ a | sort: ''title'', ''foo'' | join: ''#'' }}'
    want: ''
    context:
      a:
      - b
      - a
    partials: {}
    error: true
    strict: false
- name: liquid.golden.sort_natural_filter
  tests:
  - name: argument is undefined
    template: '{% assign x = a | sort_natural: nosuchthing %}{% for obj in x %}{%
      for i in obj %}({{ i[0] }},{{ i[1] }}){% endfor %}{% endfor %}'
    want: (title,bar)(title,Baz)(title,foo)
    context:
      a:
      - title: foo
      - title: bar
      - title: Baz
    partials: {}
    error: false
    strict: false
  - name: array of objects with a key
    template: '{% assign x = a | sort_natural: ''title'' %}{% for obj in x %}{% for
      i in obj %}({{ i[0] }},{{ i[1] }}){% endfor %}{% endfor %}'
    want: (title,bar)(title,Baz)(title,foo)
    context:
      a:
      - title: foo
      - title: bar
      - title: Baz
    partials: {}
    error: false
    strict: false
  - name: array of objects with a key gets stringified
    template: '{% assign x = a | sort_natural: ''title'' %}{% for obj in x %}{% for
      i in obj %}({{ i[0] }},{{ i[1] }}){% endfor %}{% endfor %}'
    want: (title,1111)(title,87)(title,9)
    context:
      a:
      - title: 9
      - title: 1111
      - title: 87
    partials: {}
    error: false
    strict: false
  - name: array of objects with a missing key
    template: '{% assign x = a | sort_natural: ''title'' %}{% for obj in x %}{% for
      i in obj %}({{ i[0] }},{{ i[1] }}){% endfor %}{% endfor %}'
    want: (title,bar)(title,foo)(heading,Baz)
    context:
      a:
      - title: foo
      - title: bar
      - heading: Baz
    partials: {}
    error: false
    strict: false
  - name: array of strings
    template: '{{ a | sort_natural | join: ''#'' }}'
    want: a#A#b#B#C
    context:
      a:
      - b
      - a
      - C
      - B
      - A
    partials: {}
    error: false
    strict: false
  - name: array of strings with a nul
    template: '{% assign x = a | sort_natural %}{% for i in x %}{{ i }}{% unless forloop.last
      %}#{% endunless %}{% endfor %}'
    want: a#A#b#B#C#
    context:
      a:
      - b
      - a
      - null
      - C
      - B
      - A
    partials: {}
    error: false
    strict: false
  - name: empty array
    template: '{% assign x = a | sort_natural %}{% for i in x %}{{ i }}{% unless forloop.last
      %}#{% endunless %}{% endfor %}'
    want: ''
    context:
      a: []
    partials: {}
    error: false
    strict: false
  - name: incompatible types
    template: '{{ a | sort_natural }}'
    want: 14{}
    context:
      a:
      - {}
      - 1
      - '4'
    partials: {}
    error: false
    strict: false
  - name: left value is not an array
    template: '{{ a | sort_natural }}'
    want: '123'
    context:
      a: 123
    partials: {}
    error: false
    strict: false
  - name: left value is undefined
    template: '{{ nosuchthing | sort_natural }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.special
  tests:
  - name: first of a string
    template: '{{ s.first }}'
    want: ''
    context:
      s: hello
    partials: {}
    error: false
    strict: false
  - name: first of an array
    template: '{{ a.first }}'
    want: '3'
    context:
      a:
      - 3
      - 2
      - 1
    partials: {}
    error: false
    strict: false
  - name: first of an empty object
    template: '{{ obj.first | join: ''#'' }}'
    want: ''
    context:
      obj: {}
    partials: {}
    error: false
    strict: false
  - name: first of an object
    template: '{{ obj.first | join: ''#'' }}'
    want: a#1
    context:
      obj:
        a: 1
        b: 2
    partials: {}
    error: false
    strict: false
  - name: first of an object with a first property
    template: '{{ obj.first }}'
    want: '99'
    context:
      obj:
        a: 1
        first: 99
    partials: {}
    error: false
    strict: false
  - name: last of a object
    template: '{{ obj.last }}'
    want: ''
    context:
      obj:
        a: 1
        b: 2
    partials: {}
    error: false
    strict: false
  - name: last of a string
    template: '{{ s.last }}'
    want: ''
    context:
      s: hello
    partials: {}
    error: false
    strict: false
  - name: last of an array
    template: '{{ a.last }}'
    want: '1'
    context:
      a:
      - 3
      - 2
      - 1
    partials: {}
    error: false
    strict: false
  - name: last of an object with a last property
    template: '{{ obj.last }}'
    want: '99'
    context:
      obj:
        a: 1
        last: 99
        b: 42
    partials: {}
    error: false
    strict: false
  - name: size of a string
    template: '{{ s.size }}'
    want: '5'
    context:
      s: hello
    partials: {}
    error: false
    strict: false
  - name: size of an array
    template: '{{ a.size }}'
    want: '3'
    context:
      a:
      - 3
      - 2
      - 1
    partials: {}
    error: false
    strict: false
  - name: size of an object with a size property
    template: '{{ obj.size }}'
    want: '99'
    context:
      obj:
        size: 99
    partials: {}
    error: false
    strict: false
  - name: size of undefined
    template: '{{ nosuchthing.last }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.split_filter
  tests:
  - name: argument does not appear in string
    template: '{% assign a = "abc" | split: "," %}{% for i in a %}#{{ forloop.index0
      }}{{ i }}{% endfor %}'
    want: '#0abc'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: argument not a string
    template: '{{ "hello th1ere" | split: 1 | join: "#" }}'
    want: hello th#ere
    context: {}
    partials: {}
    error: false
    strict: false
  - name: empty string and empty argument
    template: '{% assign a = "" | split: "" %}{% for i in a %}{{ forloop.index0 }}{{
      i }}{% endfor %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: empty string and single char argument
    template: '{% assign a = "" | split: "," %}{% for i in a %}{{ forloop.index0 }}{{
      i }}{% endfor %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: empty string argument
    template: '{% assign a = "abc" | split: "" %}{% for i in a %}#{{ forloop.index0
      }}{{ i }}{% endfor %}'
    want: '#0a#1b#2c'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: left matches argument
    template: '{% assign a = "," | split: "," %}{% for i in a %}{{ forloop.index0
      }}{{ i }}{% endfor %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: left matches string repr of argument
    template: '{% assign a = "1" | split: 1 %}{% for i in a %}{{ forloop.index0 }}{{
      i }}{% endfor %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: missing argument
    template: '{{ "hello there" | split }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: not a string
    template: '{{ 56 | split: '' '' | first }}'
    want: '56'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: split string
    template: '{{ "Hi, how are you today?" | split: " " | join: "#" }}'
    want: Hi,#how#are#you#today?
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ "hello there" | split: " ", "," }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined argument
    template: '{{ "Hello there" | split: nosuchthing | join: "#" }}'
    want: 'H#e#l#l#o# #t#h#e#r#e'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | split: " " }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.strip_filter
  tests:
  - name: left and right padded
    template: "{{ \" \t\r\n  hello  \t\r\n \" | strip }}"
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: left padded
    template: "{{ \" \t\r\n  hello\" | strip }}"
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string
    template: '{{ 5 | strip }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: right padded
    template: "{{ \"hello \t\r\n  \" | strip }}"
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | strip }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "hello" | strip: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.strip_html_filter
  tests:
  - name: html block
    template: '{{ s | strip_html }}'
    want: test
    context:
      s: <div>test</div>
    partials: {}
    error: false
    strict: false
  - name: html block with id
    template: '{{ s | strip_html }}'
    want: test
    context:
      s: <div id='test'>test</div>
    partials: {}
    error: false
    strict: false
  - name: html block with newline
    template: '{{ s | strip_html }}'
    want: test
    context:
      s: '<div

        class=''multiline''>test</div>'
    partials: {}
    error: false
    strict: false
  - name: html comment with newline
    template: '{{ s | strip_html }}'
    want: test
    context:
      s: "<!-- foo bar \n test -->test"
    partials: {}
    error: false
    strict: false
  - name: not a string
    template: '{{ 5 | strip_html }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: script block
    template: '{{ s | strip_html }}'
    want: ''
    context:
      s: <script type='text/javascript'>document.write('some stuff');</script>
    partials: {}
    error: false
    strict: false
  - name: some HTML markup
    template: '{{ s | strip_html }}'
    want: Have you read Ulysses &amp; &#20;?
    context:
      s: Have <em>you</em> read <strong>Ulysses</strong> &amp; &#20;?
    partials: {}
    error: false
    strict: false
  - name: some HTML markup with HTML comment
    template: '{{ s | strip_html }}'
    want: you read Ulysses &amp; &#20;?
    context:
      s: <!-- Have --><em>you</em> read <strong>Ulysses</strong> &amp; &#20;?
    partials: {}
    error: false
    strict: false
  - name: style block
    template: '{{ s | strip_html }}'
    want: ''
    context:
      s: <style type='text/css'>foo bar</style>
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | strip_html }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "hello" | strip_html: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.strip_newlines_filter
  tests:
  - name: newline and other whitespace
    template: '{{ "hello there

      you" | strip_newlines }}'
    want: hello thereyou
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string
    template: '{{ 5 | strip_newlines }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: reference implementation test 1
    template: '{{ "a

      b

      c" | strip_newlines }}'
    want: abc
    context: {}
    partials: {}
    error: false
    strict: false
  - name: reference implementation test 2
    template: "{{ \"a\r\nb\nc\" | strip_newlines }}"
    want: abc
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | strip_newlines }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "hello" | strip_newlines: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.sum_filter
  tests:
  - name: empty sequence
    template: '{{ a | sum }}'
    want: '0'
    context:
      a: []
    partials: {}
    error: false
    strict: false
  - name: hashes with numeric strings and property argument
    template: '{{ a | sum: ''k'' }}'
    want: '6'
    context:
      a:
      - k: '1'
      - k: '2'
      - k: '3'
    partials: {}
    error: false
    strict: false
  - name: hashes with property argument
    template: '{{ a | sum: ''k'' }}'
    want: '6'
    context:
      a:
      - k: 1
      - k: 2
      - k: 3
    partials: {}
    error: false
    strict: false
  - name: hashes with some missing properties
    template: '{{ a | sum: ''k'' }}'
    want: '3'
    context:
      a:
      - k: 1
      - k: 2
      - x: 3
    partials: {}
    error: false
    strict: false
  - name: hashes without property argument
    template: '{{ a | sum }}'
    want: '0'
    context:
      a:
      - k: 1
      - k: 2
      - k: 3
    partials: {}
    error: false
    strict: false
  - name: ints
    template: '{{ a | sum }}'
    want: '6'
    context:
      a:
      - 1
      - 2
      - 3
    partials: {}
    error: false
    strict: false
  - name: negative ints
    template: '{{ a | sum }}'
    want: '-6'
    context:
      a:
      - -1
      - -2
      - -3
    partials: {}
    error: false
    strict: false
  - name: negative strings
    template: '{{ a | sum }}'
    want: '-6'
    context:
      a:
      - '-1'
      - '-2'
      - '-3'
    partials: {}
    error: false
    strict: false
  - name: nested ints
    template: '{{ a | sum }}'
    want: '6'
    context:
      a:
      - 1
      - - 2
        - - 3
    partials: {}
    error: false
    strict: false
  - name: only zeros
    template: '{{ a | sum }}'
    want: '0'
    context:
      a:
      - 0
      - 0
      - 0
    partials: {}
    error: false
    strict: false
  - name: positive and negative ints
    template: '{{ a | sum }}'
    want: '5'
    context:
      a:
      - -2
      - -3
      - 10
    partials: {}
    error: false
    strict: false
  - name: properties arguments with non-hash items
    template: '{{ a | sum: ''k'' }}'
    want: '3'
    context:
      a:
      - 1
      - 2
      - 3
    partials: {}
    error: true
    strict: false
- name: liquid.golden.tablerow_tag
  tests:
  - name: break from a tablerow loop
    template: '{% tablerow n in (1..3) cols:2 %}{{n}}{% break %}{{n}}{% endtablerow
      %}'
    want: '<tr class="row1">

      <td class="col1">1</td></tr>

      '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: break from a tablerow loop inside a for loop
    template: '{% for i in (1..2) -%}\n{% for j in (1..2) -%}\n{% tablerow k in (1..3)
      %}{% break %}{% endtablerow -%}\nloop j={{ j }}\n{% endfor -%}\nloop i={{ i
      }}\n{% endfor -%}\nafter loop\n'
    want: '\n\n<tr class="row1">

      <td class="col1"></td></tr>

      \nloop j=1\n\n<tr class="row1">

      <td class="col1"></td></tr>

      \nloop j=2\n\nloop i=1\n\n\n<tr class="row1">

      <td class="col1"></td></tr>

      \nloop j=1\n\n<tr class="row1">

      <td class="col1"></td></tr>

      \nloop j=2\n\nloop i=2\n\nafter loop\n'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: cols is a float
    template: '{% tablerow i in (1..4) cols:2.6 %}{{ i }} {{ tablerowloop.col_first
      }}{% endtablerow %}'
    want: '<tr class="row1">

      <td class="col1">1 true</td><td class="col2">2 false</td></tr>

      <tr class="row2"><td class="col1">3 true</td><td class="col2">4 false</td></tr>

      '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: cols is a string
    template: '{% tablerow i in (1..4) cols:''2'' %}{{ i }} {{ tablerowloop.col_first
      }}{% endtablerow %}'
    want: '<tr class="row1">

      <td class="col1">1 true</td><td class="col2">2 false</td></tr>

      <tr class="row2"><td class="col1">3 true</td><td class="col2">4 false</td></tr>

      '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: continue from a tablerow loop
    template: '{% tablerow n in (1..3) cols:2 %}{{n}}{% continue %}{{n}}{% endtablerow
      %}'
    want: '<tr class="row1">

      <td class="col1">1</td><td class="col2">2</td></tr>

      <tr class="row2"><td class="col1">3</td></tr>

      '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: limit is a string
    template: '{% tablerow i in (1..4) limit:''2'' %}{{ i }} {{ tablerowloop.col_first
      }}{% endtablerow %}'
    want: '<tr class="row1">

      <td class="col1">1 true</td><td class="col2">2 false</td></tr>

      '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: no cols param
    template: '{% 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 %}'
    want: '<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>

      '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: offset is a string
    template: '{% tablerow i in (1..4) offset:''2'' %}{{ i }} {{ tablerowloop.col_first
      }}{% endtablerow %}'
    want: '<tr class="row1">

      <td class="col1">3 true</td><td class="col2">4 false</td></tr>

      '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: one row
    template: '{% tablerow tag in collection.tags %}{{ tag }}{% endtablerow %}'
    want: '<tr class="row1">

      <td class="col1">tag1</td><td class="col2">tag2</td><td class="col3">tag3</td><td
      class="col4">tag4</td></tr>

      '
    context:
      collection:
        tags:
        - tag1
        - tag2
        - tag3
        - tag4
    partials: {}
    error: false
    strict: false
  - name: one row with limit
    template: '{% tablerow tag in collection.tags limit: 2 %}{{ tag }}{% endtablerow
      %}'
    want: '<tr class="row1">

      <td class="col1">tag1</td><td class="col2">tag2</td></tr>

      '
    context:
      collection:
        tags:
        - tag1
        - tag2
        - tag3
        - tag4
    partials: {}
    error: false
    strict: false
  - name: one row with offset
    template: '{% tablerow tag in collection.tags offset: 2 %}{{ tag }}{% endtablerow
      %}'
    want: '<tr class="row1">

      <td class="col1">tag3</td><td class="col2">tag4</td></tr>

      '
    context:
      collection:
        tags:
        - tag1
        - tag2
        - tag3
        - tag4
    partials: {}
    error: false
    strict: false
  - name: two column odd range
    template: '{% tablerow i in (1..5) cols:2 %}{{ i }} {{ tablerowloop.col_first
      }}{% endtablerow %}'
    want: '<tr class="row1">

      <td class="col1">1 true</td><td class="col2">2 false</td></tr>

      <tr class="row2"><td class="col1">3 true</td><td class="col2">4 false</td></tr>

      <tr class="row3"><td class="col1">5 true</td></tr>

      '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: two column odd range row numbers
    template: '{% tablerow i in (1..5) cols:2 %}{{ i }} {{ tablerowloop.row }}{% endtablerow
      %}'
    want: '<tr class="row1">

      <td class="col1">1 1</td><td class="col2">2 1</td></tr>

      <tr class="row2"><td class="col1">3 2</td><td class="col2">4 2</td></tr>

      <tr class="row3"><td class="col1">5 3</td></tr>

      '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: two column range
    template: '{% tablerow i in (1..4) cols:2 %}{{ i }} {{ tablerowloop.col_first
      }}{% endtablerow %}'
    want: '<tr class="row1">

      <td class="col1">1 true</td><td class="col2">2 false</td></tr>

      <tr class="row2"><td class="col1">3 true</td><td class="col2">4 false</td></tr>

      '
    context: {}
    partials: {}
    error: false
    strict: false
  - name: two columns
    template: '{% tablerow tag in collection.tags cols:2 %}{{ tag }}{% endtablerow
      %}'
    want: '<tr class="row1">

      <td class="col1">tag1</td><td class="col2">tag2</td></tr>

      <tr class="row2"><td class="col1">tag3</td><td class="col2">tag4</td></tr>

      '
    context:
      collection:
        tags:
        - tag1
        - tag2
        - tag3
        - tag4
    partials: {}
    error: false
    strict: false
- name: liquid.golden.times_filter
  tests:
  - name: float times float
    template: '{{ 5.0 | times: 2.1 }}'
    want: '10.5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: int times float
    template: '{{ 5 | times: 2.1 }}'
    want: '10.5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: int times int
    template: '{{ 5 | times: 2 }}'
    want: '10'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: missing arg
    template: '{{ 5 | times }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: negative multiplication
    template: '{{ -5 | times: 2 }}'
    want: '-10'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string times string
    template: '{{ "5.0" | times: "2.1" }}'
    want: '10.5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many args
    template: '{{ 5 | times: 1, 2 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined argument
    template: '{{ 5 | times: nosuchthing }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | times: 2 }}'
    want: '0'
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.truncate_filter
  tests:
  - name: custom end
    template: '{{ "Ground control to Major Tom." | truncate: 25, ", and so on" }}'
    want: Ground control, and so on
    context: {}
    partials: {}
    error: false
    strict: false
  - name: default end
    template: '{{ "Ground control to Major Tom." | truncate: 20 }}'
    want: Ground control to...
    context: {}
    partials: {}
    error: false
    strict: false
  - name: default length is 50
    template: '{{ "Ground control to Major Tom. Ground control to Major Tom." | truncate
      }}'
    want: Ground control to Major Tom. Ground control to ...
    context: {}
    partials: {}
    error: false
    strict: false
  - name: no end
    template: '{{ "Ground control to Major Tom." | truncate: 20, "" }}'
    want: Ground control to Ma
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string
    template: '{{ 5 | truncate: 10 }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: string is shorter than length
    template: '{{ "Ground control" | truncate: 20 }}'
    want: Ground control
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ "hello" | truncate: 5, "foo", "bar" }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined first argument
    template: '{{ "Ground control to Major Tom." | truncate: nosuchthing }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | truncate: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined second argument
    template: '{{ "Ground control to Major Tom." | truncate: 20, nosuchthing }}'
    want: Ground control to Ma
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.truncatewords_filter
  tests:
  - name: all whitespace is clobbered
    template: '{{ "    one    two three    four  " | truncatewords: 2 }}'
    want: one two...
    context: {}
    partials: {}
    error: false
    strict: false
  - name: custom end
    template: '{{ "Ground control to Major Tom." | truncatewords: 3, "--" }}'
    want: Ground control to--
    context: {}
    partials: {}
    error: false
    strict: false
  - name: default end
    template: '{{ "Ground control to Major Tom." | truncatewords: 3 }}'
    want: Ground control to...
    context: {}
    partials: {}
    error: false
    strict: false
  - name: fewer words than word count
    template: '{{ "Ground control" | truncatewords: 3 }}'
    want: Ground control
    context: {}
    partials: {}
    error: false
    strict: false
  - name: no end
    template: '{{ "Ground control to Major Tom." | truncatewords: 3, "" }}'
    want: Ground control to
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string
    template: '{{ 5 | truncatewords: 10 }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: number of words defaults to 15
    template: '{{ "a b c d e f g h i j k l m n o p q" | truncatewords }}'
    want: a b c d e f g h i j k l m n o...
    context: {}
    partials: {}
    error: false
    strict: false
  - name: reference implementation test 1
    template: "{{ \"\u6D4B\u8BD5\u6D4B\u8BD5\u6D4B\u8BD5\u6D4B\u8BD5\" | truncatewords:\
      \ 5 }}"
    want: "\u6D4B\u8BD5\u6D4B\u8BD5\u6D4B\u8BD5\u6D4B\u8BD5"
    context: {}
    partials: {}
    error: false
    strict: false
  - name: reference implementation test 2
    template: '{{ "one two three" | truncatewords: 2, 1 }}'
    want: one two1
    context: {}
    partials: {}
    error: false
    strict: false
  - name: reference implementation test 3
    template: "{{ \"one  two\tthree\nfour\" | truncatewords: 3 }}"
    want: one two three...
    context: {}
    partials: {}
    error: false
    strict: false
  - name: reference implementation test 4
    template: '{{ "one two three four" | truncatewords: 2 }}'
    want: one two...
    context: {}
    partials: {}
    error: false
    strict: false
  - name: reference implementation test 5
    template: '{{ "one two three four" | truncatewords: 0 }}'
    want: one...
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ "hello" | truncatewords: 5, "foo", "bar" }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined first argument
    template: '{{ "one two three four" | truncatewords: nosuchthing }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | truncatewords: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined second argument
    template: '{{ "one two three four" | truncatewords: 2, nosuchthing }}'
    want: one two
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.uniq_filter
  tests:
  - name: array of objects with key property
    template: '{% assign x = a | uniq: ''title'' %}{% for obj in x %}{% for i in obj
      %}({{ i[0] }},{{ i[1] }}){% endfor %}{% endfor %}'
    want: (title,foo)(name,a)(title,bar)(name,c)
    context:
      a:
      - title: foo
        name: a
      - title: foo
        name: b
      - title: bar
        name: c
    partials: {}
    error: false
    strict: false
  - name: array of objects with missing key property
    template: '{% assign x = a | uniq: ''title'' %}{% for obj in x %}{% for i in obj
      %}({{ i[0] }},{{ i[1] }}){% endfor %}{% endfor %}'
    want: (title,foo)(name,a)(title,bar)(name,c)(heading,bar)(name,c)
    context:
      a:
      - title: foo
        name: a
      - title: foo
        name: b
      - title: bar
        name: c
      - heading: bar
        name: c
      - heading: baz
        name: d
    partials: {}
    error: false
    strict: false
  - name: array of strings
    template: '{{ a | uniq | join: ''#'' }}'
    want: a#b
    context:
      a:
      - a
      - b
      - b
      - a
    partials: {}
    error: false
    strict: false
  - name: array of things
    template: '{{ a | uniq | join: ''#'' }}'
    want: a#b#1
    context:
      a:
      - a
      - b
      - 1
      - 1
    partials: {}
    error: false
    strict: false
  - name: empty array
    template: '{{ a | uniq | join: ''#'' }}'
    want: ''
    context:
      a: []
    partials: {}
    error: false
    strict: false
  - name: left value is not an array
    template: '{{ a | uniq | join: ''#'' }}'
    want: '123'
    context:
      a: 123
    partials: {}
    error: false
    strict: false
  - name: left value is undefined
    template: '{{ nosuchthing | uniq | join: ''#'' }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ nosuchthing | uniq: ''foo'', ''bar'' }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
  - name: unhashable items
    template: '{{ a | uniq | join: ''#'' }}'
    want: a#b#{}
    context:
      a:
      - a
      - b
      - []
      - {}
      - {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.unless_tag
  tests:
  - name: alternative block
    template: '{% unless true %}foo{% else %}bar{% endunless %}'
    want: bar
    context: {}
    partials: {}
    error: false
    strict: false
  - name: array is equal to array
    template: '{% assign x = ''a,b,c'' | split: '','' %}{% assign y = ''a,b,c'' |
      split: '','' %}{% unless x == y %}true{% else %}false{% endunless %}'
    want: 'false'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: array is equal to array from context
    template: '{% assign y = ''a,b,c'' | split: '','' %}{% unless x == y %}true{%
      else %}false{% endunless %}'
    want: 'false'
    context:
      x:
      - a
      - b
      - c
    partials: {}
    error: false
    strict: false
  - name: blocks that contain only whitespace are not rendered
    template: '{% unless false %}  {% endunless %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: conditional alternative block
    template: '{% unless true %}foo{% elsif true %}bar{% endunless %}'
    want: bar
    context: {}
    partials: {}
    error: false
    strict: false
  - name: conditional alternative block with default
    template: '{% unless true %}foo{% elsif false %}bar{% else %}hello{% endunless
      %}'
    want: hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: else tag expressions are ignored
    template: '{% unless true %}1{% else nonsense %}2{% endunless %}'
    want: '2'
    context: {}
    partials: {}
    error: false
    strict: true
  - name: extra else blocks are ignored
    template: '{% unless true %}1{% else %}2{% else %}3{% endunless %}'
    want: '2'
    context: {}
    partials: {}
    error: false
    strict: true
  - name: extra elsif blocks are ignored
    template: '{% unless true %}1{% else %}2{% elsif true %}3{% endunless %}'
    want: '2'
    context: {}
    partials: {}
    error: false
    strict: true
  - name: literal false condition
    template: '{% unless false %}foo{% endunless %}'
    want: foo
    context: {}
    partials: {}
    error: false
    strict: false
  - name: literal true condition
    template: '{% unless true %}foo{% endunless %}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: one is not equal to true
    template: '{% unless 1 == true %}Hello{% else %}Goodbye{% endunless %}'
    want: Hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: zero is not equal to false
    template: '{% unless 0 == false %}Hello{% else %}Goodbye{% endunless %}'
    want: Hello
    context: {}
    partials: {}
    error: false
    strict: false
  - name: zero is truthy
    template: '{% unless 0 %}Hello{% else %}Goodbye{% endunless %}'
    want: Goodbye
    context: {}
    partials: {}
    error: false
    strict: false
- name: liquid.golden.upcase_filter
  tests:
  - name: make lower case
    template: '{{ "hello" | upcase }}'
    want: HELLO
    context: {}
    partials: {}
    error: false
    strict: false
  - name: not a string
    template: '{{ 5 | upcase }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | upcase }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "hello" | upcase: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.url_decode_filter
  tests:
  - name: not a string
    template: '{{ 5 | url_decode }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: some special URL characters
    template: '{{ "email+address+is+bob%40example.com%21" | url_decode }}'
    want: email address is bob@example.com!
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | url_decode }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "hello" | url_decode: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.url_encode_filter
  tests:
  - name: not a string
    template: '{{ 5 | url_encode }}'
    want: '5'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: some special URL characters
    template: '{{ "email address is bob@example.com!" | url_encode }}'
    want: email+address+is+bob%40example.com%21
    context: {}
    partials: {}
    error: false
    strict: false
  - name: undefined left value
    template: '{{ nosuchthing | url_encode }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: unexpected argument
    template: '{{ "hello" | url_encode: 5 }}'
    want: ''
    context: {}
    partials: {}
    error: true
    strict: false
- name: liquid.golden.where_filter
  tests:
  - name: array of hashes
    template: '{% assign x = a | where: ''title'' %}{% for obj in x %}{% for i in
      obj %}({{ i[0] }},{{ i[1] }}){% endfor %}{% endfor %}'
    want: (title,foo)(title,bar)
    context:
      a:
      - title: foo
      - title: bar
      - title: null
    partials: {}
    error: false
    strict: false
  - name: array of hashes with a missing key
    template: '{% assign x = a | where: ''title'', ''bar'' %}{% for obj in x %}{%
      for i in obj %}({{ i[0] }},{{ i[1] }}){% endfor %}{% endfor %}'
    want: (title,bar)
    context:
      a:
      - heading: foo
      - title: bar
      - title: null
    partials: {}
    error: false
    strict: false
  - name: array of hashes with equality test
    template: '{% assign x = a | where: ''title'', ''bar'' %}{% for obj in x %}{%
      for i in obj %}({{ i[0] }},{{ i[1] }}){% endfor %}{% endfor %}'
    want: (title,bar)
    context:
      a:
      - title: foo
      - title: bar
      - title: null
    partials: {}
    error: false
    strict: false
  - name: both arguments are undefined
    template: '{{ a | where: nosuchthing, nothing }}'
    want: ''
    context:
      a:
      - title: foo
      - title: bar
      - title: null
    partials: {}
    error: false
    strict: false
  - name: first argument is undefined
    template: '{{ a | where: nosuchthing }}'
    want: ''
    context:
      a:
      - title: foo
      - title: bar
      - title: null
    partials: {}
    error: false
    strict: false
  - name: left value is not an array
    template: '{{ a | where: ''title'' }}'
    want: ''
    context:
      a: 123
    partials: {}
    error: true
    strict: false
  - name: left value is undefined
    template: '{{ nosuchthing | where: ''title'' }}'
    want: ''
    context: {}
    partials: {}
    error: false
    strict: false
  - name: missing argument
    template: '{{ a | where }}'
    want: ''
    context:
      a:
      - title: foo
      - title: bar
      - title: null
    partials: {}
    error: true
    strict: false
  - name: second argument is undefined
    template: '{% assign x = a | where: ''title'', nosuchthing %}{% for obj in x %}{%
      for i in obj %}({{ i[0] }},{{ i[1] }}){% endfor %}{% endfor %}'
    want: (title,foo)(title,bar)
    context:
      a:
      - title: foo
      - title: bar
      - title: null
    partials: {}
    error: false
    strict: false
  - name: too many arguments
    template: '{{ a | where: ''title'', ''foo'', ''bar'' }}'
    want: ''
    context:
      a:
      - title: foo
      - title: bar
      - title: null
    partials: {}
    error: true
    strict: false
  - name: value is explicit nil
    template: '{% assign x =  a | where: ''b'', nil %}{% for obj in x %}{% for i in
      obj %}({{ i[0] }},{{ i[1] }}){% endfor %}{% endfor %}'
    want: (b,bar)
    context:
      a:
      - b: false
      - b: bar
      - b: null
    partials: {}
    error: false
    strict: false
  - name: value is false
    template: '{% assign x =  a | where: ''b'', false %}{% for obj in x %}{% for i
      in obj %}({{ i[0] }},{{ i[1] }}){% endfor %}{% endfor %}'
    want: (b,false)
    context:
      a:
      - b: false
      - b: bar
      - b: null
    partials: {}
    error: false
    strict: false
- name: liquid.golden.whitespace_control
  tests:
  - name: don't suppress whitespace only blocks containing echo
    template: "!{% if true %}\n\n{% assign bar = 'foo' %}\n    {% echo '' %}\n\n \
      \   {% assign foo = 'bar' %}\n\n\n\n{% endif %}!"
    want: "!\n\n\n    \n\n    \n\n\n\n!"
    context: {}
    partials: {}
    error: false
    strict: false
  - name: don't suppress whitespace only blocks containing output
    template: "!{% if true %}\n\n{% assign bar = 'foo' %}\n    {{ '' }}\n\n    {%\
      \ assign foo = 'bar' %}\n\n\n\n{% endif %}!"
    want: "!\n\n\n    \n\n    \n\n\n\n!"
    context: {}
    partials: {}
    error: false
    strict: false
  - name: don't suppress whitespace only blocks containing output in nested block
    template: "!{% if 1 %}\n\n{% assign bar = 'foo' %}\n{% if 2 %}\n    {{ '' }}\n\
      \n    {% assign foo = 'bar' %}\n\n{% endif %}\n\n\n{% endif %}!"
    want: "!\n\n\n\n    \n\n    \n\n\n\n\n!"
    context: {}
    partials: {}
    error: false
    strict: false
  - name: don't suppress whitespace only blocks containing output in unreachable blocks
    template: "!{% if 1 %}\n\n{% assign bar = 'foo' %}\n{% if true %}\n\n    {% assign\
      \ foo = 'bar' %}\n\n{% else %}\n    {{ '' }}\n{% endif %}\n\n\n{% endif %}!"
    want: "!\n\n\n\n\n    \n\n\n\n\n!"
    context: {}
    partials: {}
    error: false
    strict: false
  - name: don't suppress whitespace only case blocks containing output
    template: "!{% assign x = 1 %}{% case x %}\n\n  {% when 1 %}\n    {% assign foo\
      \ = 'bar' %}\n\n  {% when 2 %}\n    {{ '' }}\n\n{% endcase %}!"
    want: "!\n    \n\n  !"
    context: {}
    partials: {}
    error: false
    strict: false
  - name: don't suppress whitespace only unless blocks containing output in nested
      blocks
    template: "!{% unless false %}\n\n{% assign bar = 'foo' %}\n{% unless false %}\n\
      \    {{ '' }}\n\n    {% assign foo = 'bar' %}\n\n{% endunless %}\n\n\n{% endunless\
      \ %}!"
    want: "!\n\n\n\n    \n\n    \n\n\n\n\n!"
    context: {}
    partials: {}
    error: false
    strict: false
  - name: suppress whitespace only case blocks
    template: "!{% assign x = 1 %}{% case x %}\n\n  {% when 1 %}\n    {% assign foo\
      \ = 'bar' %}\n\n\n{% endcase %}!"
    want: '!!'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: suppress whitespace only if blocks
    template: "!{% if true %}\n\n{% assign bar = 'foo' %}\n{% if true %}\n\n\n   \
      \ {% assign foo = 'bar' %}\n\n{% endif %}\n\n\n{% endif %}!"
    want: '!!'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: suppress whitespace only unless blocks
    template: "!{% unless false %}\n\n{% assign bar = 'foo' %}\n{% unless false %}\n\
      \n\n    {% assign foo = 'bar' %}\n\n{% endunless %}\n\n\n{% endunless %}!"
    want: '!!'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: suppress whitespace surrounding a capture block
    template: '!{% if true %}


      {% capture foo %}

      {{ '''' }}

      {% endcapture %}


      {% endif %}!'
    want: '!!'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: suppress whitespace surrounding an empty capture block
    template: '!{% if true %}


      {% capture foo %}{% endcapture %}


      {% endif %}!'
    want: '!!'
    context: {}
    partials: {}
    error: false
    strict: false
  - name: white space control with  carriage return, newline and spaces
    template: "\r\n{% if customer -%}\r\nWelcome back,  {{ customer.first_name -}}\
      \ !\r\n {%- endif -%}"
    want: "\r\nWelcome back,  Holly!"
    context:
      customer:
        first_name: Holly
    partials: {}
    error: false
    strict: false
  - name: white space control with carriage return and spaces
    template: "\r{% if customer -%}\rWelcome back,  {{ customer.first_name -}} !\r\
      \ {%- endif -%}"
    want: "\rWelcome back,  Holly!"
    context:
      customer:
        first_name: Holly
    partials: {}
    error: false
    strict: false
  - name: white space control with newlines and spaces
    template: "\n{% if customer -%}\nWelcome back,  {{ customer.first_name -}} !\n\
      \ {%- endif -%}"
    want: '

      Welcome back,  Holly!'
    context:
      customer:
        first_name: Holly
    partials: {}
    error: false
    strict: false
  - name: white space control with newlines, tabs and spaces
    template: "\n\t{% if customer -%}\t\nWelcome back,  {{ customer.first_name -}}\t\
      \ !\r\n {%- endif -%}"
    want: "\n\tWelcome back,  Holly!"
    context:
      customer:
        first_name: Holly
    partials: {}
    error: false
    strict: false
  - name: white space control with raw tags
    template: '! {% raw %}{{ hello }}{% endraw %} !

      ! {%- raw -%}{{ hello }}{%- endraw -%} !'
    want: '! {{ hello }} !

      !{{ hello }}!'
    context: {}
    partials: {}
    error: false
    strict: false